diff --git a/asm/macros/scrcmd.inc b/asm/macros/scrcmd.inc index a7a892f076..065afd4922 100644 --- a/asm/macros/scrcmd.inc +++ b/asm/macros/scrcmd.inc @@ -2503,9 +2503,9 @@ .short \arg0 .endm - .macro ScrCmd_1B5 listIndex + .macro StartRankingsMachine machineID .short 437 - .short \listIndex + .short \machineID .endm .macro GetTimeOfDay destVarID diff --git a/generated/game_records.txt b/generated/game_records.txt index a0c6708444..17c5e624e7 100644 --- a/generated/game_records.txt +++ b/generated/game_records.txt @@ -13,7 +13,7 @@ RECORD_EGGS_HATCHED RECORD_POKEMON_EVOLVED RECORD_UNK_013 RECORD_UNK_014 -RECORD_UNK_015 +RECORD_BATTLE_TOWER_CHALLENGES RECORD_UNK_016 RECORD_UNK_017 RECORD_UNK_018 @@ -27,7 +27,7 @@ RECORD_UNK_025 RECORD_WIFI_BATTLE_WINS RECORD_WIFI_BATTLE_LOSSES RECORD_UNK_028 -RECORD_UNK_029 +RECORD_BATTLE_TOWER_VICTORIES RECORD_UNK_030 RECORD_UNK_031 RECORD_UNK_032 @@ -88,11 +88,11 @@ RECORD_UNK_086 RECORD_UNK_087 RECORD_UNK_088 RECORD_UNK_089 -RECORD_UNK_090 -RECORD_UNK_091 +RECORD_SUPER_CONTEST_PARTICIPATIONS +RECORD_LINK_CONTEST_PARTICIPATIONS RECORD_SUPER_CONTEST_WINS RECORD_LINK_CONTEST_WINS -RECORD_UNK_094 +RECORD_RIBBONS_WON RECORD_USED_INEFFECTIVE_MOVE RECORD_FAINTED_ENEMY_MON RECORD_ATTACKED_ALLY diff --git a/generated/text_banks.txt b/generated/text_banks.txt index d4fcb91c76..90b7494c09 100644 --- a/generated/text_banks.txt +++ b/generated/text_banks.txt @@ -530,7 +530,7 @@ TEXT_BANK_ROUTE_228_GATE_TO_ROUTE_226 TEXT_BANK_ROUTE_228_NORTH_HOUSE TEXT_BANK_ROUTE_228_SOUTH_HOUSE TEXT_BANK_ROUTE_229 -TEXT_BANK_UNK_0532 +TEXT_BANK_RANKINGS_MACHINE TEXT_BANK_UNK_0533 TEXT_BANK_SAVE_INFO_WINDOW TEXT_BANK_RIBBON_NAMES diff --git a/include/constants/heap.h b/include/constants/heap.h index 435f91f443..61ec8f0145 100644 --- a/include/constants/heap.h +++ b/include/constants/heap.h @@ -82,7 +82,7 @@ enum HeapID { HEAP_ID_GAME_START, HEAP_ID_MIGRATE_FROM_GBA, HEAP_ID_79, - HEAP_ID_80, + HEAP_ID_RANKINGS_MACHINE, HEAP_ID_MAIN_MENU, HEAP_ID_ROWAN_INTRO, HEAP_ID_ROWAN_INTRO_TV, @@ -160,6 +160,7 @@ enum HeapSize { HEAP_SIZE_BOAT_CUTSCENE = 0x20000, HEAP_SIZE_EVOLUTION = 0x30000, HEAP_SIZE_GAME_START = 0x20000, + HEAP_SIZE_RECORD_LIST = 0x6000, HEAP_SIZE_MAIN_MENU = 0x40000, HEAP_SIZE_MIGRATE_FROM_GBA = 0x38000, HEAP_SIZE_WONDER_CARDS_APP = 0x30000, diff --git a/include/rankings.h b/include/rankings.h new file mode 100644 index 0000000000..67f4d30586 --- /dev/null +++ b/include/rankings.h @@ -0,0 +1,54 @@ +#ifndef POKEPLATINUM_RANKINGS_H +#define POKEPLATINUM_RANKINGS_H + +#include "constants/heap.h" +#include "constants/string.h" + +#include "savedata.h" +#include "string_gf.h" + +#define MAX_RANKINGS_ENTRIES 6 + +#define RECORDS_WITH_RANKINGS_COUNT 13 + +typedef struct RankingEntry { + u32 seed; + u32 recordValue; + u16 playerName[TRAINER_NAME_LEN + 1]; +} RankingEntry; + +typedef struct RankingList { + RankingEntry entries[MAX_RANKINGS_ENTRIES]; +} RankingList; + +typedef struct Rankings { + RankingList lists[RECORDS_WITH_RANKINGS_COUNT * 2]; +} Rankings; + +typedef struct RankingPlayerInfo { + u32 seed; + u32 recordValue; + String *playerName; +} RankingPlayerInfo; + +typedef struct RecordPlayersInfo { + int count; + RankingPlayerInfo players[MAX_RANKINGS_ENTRIES]; +} RecordPlayersInfo; + +u8 GetRecordsListLength(int listID); +u8 GetRecordsListFirstRecord(int listID); +void sub_0202E858(RankingEntry *entry); +BOOL sub_0202E870(RankingEntry *entry); +int Rankings_SaveSize(void); +void Rankings_Init(Rankings *rankings); +Rankings *SaveData_GetRankings(SaveData *saveData); +void Rankings_RemoveEntry(Rankings *rankings, int listID, u8 entryID); +int RankingsEntries_Size(void); +void *sub_0202E9FC(SaveData *saveData, enum HeapID heapID); +void sub_0202ED0C(SaveData *saveData, int param1, u8 param2, const void **inRankingsEntries, enum HeapID heapID); +RecordPlayersInfo *Rankings_GetCurrentPlayerInfo(SaveData *saveData, int listID, enum HeapID heapID); +RecordPlayersInfo *Rankings_GetConnectedPlayersInfo(Rankings *rankings, int listID, enum HeapID heapID); +void RecordPlayersInfo_Free(RecordPlayersInfo *entry); + +#endif // POKEPLATINUM_RANKINGS_H diff --git a/include/rankings_machine.h b/include/rankings_machine.h new file mode 100644 index 0000000000..32b66baaf9 --- /dev/null +++ b/include/rankings_machine.h @@ -0,0 +1,8 @@ +#ifndef POKEPLATINUM_RANKINGS_MACHINE_H +#define POKEPLATINUM_RANKINGS_MACHINE_H + +#include "field_task.h" + +void RankingsMachine_InitFieldTask(FieldTask *task, u16 machineID); + +#endif // POKEPLATINUM_RANKINGS_MACHINE_H diff --git a/include/struct_decls/struct_0202E858_decl.h b/include/struct_decls/struct_0202E858_decl.h deleted file mode 100644 index 1acb52b56a..0000000000 --- a/include/struct_decls/struct_0202E858_decl.h +++ /dev/null @@ -1,6 +0,0 @@ -#ifndef POKEPLATINUM_STRUCT_0202E858_DECL_H -#define POKEPLATINUM_STRUCT_0202E858_DECL_H - -typedef struct UnkStruct_0202E858_t UnkStruct_0202E858; - -#endif // POKEPLATINUM_STRUCT_0202E858_DECL_H diff --git a/include/struct_decls/struct_0202E8C0_decl.h b/include/struct_decls/struct_0202E8C0_decl.h deleted file mode 100644 index 21b98a13ed..0000000000 --- a/include/struct_decls/struct_0202E8C0_decl.h +++ /dev/null @@ -1,6 +0,0 @@ -#ifndef POKEPLATINUM_STRUCT_0202E8C0_DECL_H -#define POKEPLATINUM_STRUCT_0202E8C0_DECL_H - -typedef struct UnkStruct_0202E8C0_t UnkStruct_0202E8C0; - -#endif // POKEPLATINUM_STRUCT_0202E8C0_DECL_H diff --git a/include/struct_decls/struct_0202E91C_decl.h b/include/struct_decls/struct_0202E91C_decl.h deleted file mode 100644 index d693481d86..0000000000 --- a/include/struct_decls/struct_0202E91C_decl.h +++ /dev/null @@ -1,6 +0,0 @@ -#ifndef POKEPLATINUM_STRUCT_0202E91C_DECL_H -#define POKEPLATINUM_STRUCT_0202E91C_DECL_H - -typedef struct UnkStruct_0202E91C_t UnkStruct_0202E91C; - -#endif // POKEPLATINUM_STRUCT_0202E91C_DECL_H diff --git a/include/struct_decls/struct_0202EA80_decl.h b/include/struct_decls/struct_0202EA80_decl.h deleted file mode 100644 index 0d25e29627..0000000000 --- a/include/struct_decls/struct_0202EA80_decl.h +++ /dev/null @@ -1,6 +0,0 @@ -#ifndef POKEPLATINUM_STRUCT_0202EA80_DECL_H -#define POKEPLATINUM_STRUCT_0202EA80_DECL_H - -typedef struct UnkStruct_0202EA80_t UnkStruct_0202EA80; - -#endif // POKEPLATINUM_STRUCT_0202EA80_DECL_H diff --git a/include/struct_defs/struct_0202E858.h b/include/struct_defs/struct_0202E858.h deleted file mode 100644 index 1c438b95af..0000000000 --- a/include/struct_defs/struct_0202E858.h +++ /dev/null @@ -1,10 +0,0 @@ -#ifndef POKEPLATINUM_STRUCT_0202E858_H -#define POKEPLATINUM_STRUCT_0202E858_H - -typedef struct UnkStruct_0202E858_t { - u32 unk_00; - u32 unk_04; - u16 unk_08[8]; -} UnkStruct_0202E858; - -#endif // POKEPLATINUM_STRUCT_0202E858_H diff --git a/include/struct_defs/struct_0202E8C0.h b/include/struct_defs/struct_0202E8C0.h deleted file mode 100644 index c3def6e89e..0000000000 --- a/include/struct_defs/struct_0202E8C0.h +++ /dev/null @@ -1,10 +0,0 @@ -#ifndef POKEPLATINUM_STRUCT_0202E8C0_H -#define POKEPLATINUM_STRUCT_0202E8C0_H - -#include "struct_defs/struct_0202EA80.h" - -typedef struct UnkStruct_0202E8C0_t { - UnkStruct_0202EA80 unk_00[26]; -} UnkStruct_0202E8C0; - -#endif // POKEPLATINUM_STRUCT_0202E8C0_H diff --git a/include/struct_defs/struct_0202E91C.h b/include/struct_defs/struct_0202E91C.h deleted file mode 100644 index 966047a349..0000000000 --- a/include/struct_defs/struct_0202E91C.h +++ /dev/null @@ -1,10 +0,0 @@ -#ifndef POKEPLATINUM_STRUCT_0202E91C_H -#define POKEPLATINUM_STRUCT_0202E91C_H - -#include "struct_defs/struct_0202E858.h" - -typedef struct UnkStruct_0202E91C_t { - UnkStruct_0202E858 unk_00[13]; -} UnkStruct_0202E91C; - -#endif // POKEPLATINUM_STRUCT_0202E91C_H diff --git a/include/struct_defs/struct_0202EA80.h b/include/struct_defs/struct_0202EA80.h deleted file mode 100644 index cf70c556ad..0000000000 --- a/include/struct_defs/struct_0202EA80.h +++ /dev/null @@ -1,10 +0,0 @@ -#ifndef POKEPLATINUM_STRUCT_0202EA80_H -#define POKEPLATINUM_STRUCT_0202EA80_H - -#include "struct_defs/struct_0202E858.h" - -typedef struct UnkStruct_0202EA80_t { - UnkStruct_0202E858 unk_00[6]; -} UnkStruct_0202EA80; - -#endif // POKEPLATINUM_STRUCT_0202EA80_H diff --git a/include/struct_defs/struct_0202EE10.h b/include/struct_defs/struct_0202EE10.h deleted file mode 100644 index 6a2eb95016..0000000000 --- a/include/struct_defs/struct_0202EE10.h +++ /dev/null @@ -1,11 +0,0 @@ -#ifndef POKEPLATINUM_STRUCT_0202EE10_H -#define POKEPLATINUM_STRUCT_0202EE10_H - -#include "struct_defs/struct_0202EE10_sub1.h" - -typedef struct { - int unk_00; - UnkStruct_0202EE10_sub1 unk_04[6]; -} UnkStruct_0202EE10; - -#endif // POKEPLATINUM_STRUCT_0202EE10_H diff --git a/include/struct_defs/struct_0202EE10_sub1.h b/include/struct_defs/struct_0202EE10_sub1.h deleted file mode 100644 index 8e49d359c0..0000000000 --- a/include/struct_defs/struct_0202EE10_sub1.h +++ /dev/null @@ -1,12 +0,0 @@ -#ifndef POKEPLATINUM_STRUCT_0202EE10_SUB1_H -#define POKEPLATINUM_STRUCT_0202EE10_SUB1_H - -#include "string_gf.h" - -typedef struct { - u32 unk_00; - u32 unk_04; - String *unk_08; -} UnkStruct_0202EE10_sub1; - -#endif // POKEPLATINUM_STRUCT_0202EE10_SUB1_H diff --git a/include/unk_0202E840.h b/include/unk_0202E840.h deleted file mode 100644 index 260d247a45..0000000000 --- a/include/unk_0202E840.h +++ /dev/null @@ -1,27 +0,0 @@ -#ifndef POKEPLATINUM_UNK_0202E840_H -#define POKEPLATINUM_UNK_0202E840_H - -#include "constants/heap.h" - -#include "struct_decls/struct_0202E858_decl.h" -#include "struct_decls/struct_0202E8C0_decl.h" -#include "struct_defs/struct_0202EE10.h" - -#include "savedata.h" - -u8 sub_0202E840(int param0); -u8 sub_0202E84C(int param0); -void sub_0202E858(UnkStruct_0202E858 *param0); -BOOL sub_0202E870(UnkStruct_0202E858 *param0); -int Rankings_SaveSize(void); -void Rankings_Init(UnkStruct_0202E8C0 *param0); -UnkStruct_0202E8C0 *sub_0202E8C0(SaveData *saveData); -void sub_0202E8D4(UnkStruct_0202E8C0 *param0, int param1, u8 param2); -int sub_0202E91C(void); -void *sub_0202E9FC(SaveData *saveData, enum HeapID heapID); -void sub_0202ED0C(SaveData *saveData, int param1, u8 param2, const void **param3, enum HeapID heapID); -UnkStruct_0202EE10 *sub_0202ED8C(SaveData *saveData, int param1, enum HeapID heapID); -UnkStruct_0202EE10 *sub_0202EE10(UnkStruct_0202E8C0 *param0, int param1, enum HeapID heapID); -void sub_0202EE8C(UnkStruct_0202EE10 *param0); - -#endif // POKEPLATINUM_UNK_0202E840_H diff --git a/include/unk_0206F314.h b/include/unk_0206F314.h deleted file mode 100644 index 9be8a39a18..0000000000 --- a/include/unk_0206F314.h +++ /dev/null @@ -1,8 +0,0 @@ -#ifndef POKEPLATINUM_UNK_0206F314_H -#define POKEPLATINUM_UNK_0206F314_H - -#include "field_task.h" - -void sub_020703FC(FieldTask *param0, u16 param1); - -#endif // POKEPLATINUM_UNK_0206F314_H diff --git a/platinum.us/main.lsf b/platinum.us/main.lsf index d18ff2fa89..9839eba30c 100644 --- a/platinum.us/main.lsf +++ b/platinum.us/main.lsf @@ -137,7 +137,7 @@ Static main Object main.nef.p/src_mystery_gift.c.o Object main.nef.p/src_hall_of_fame_entries.c.o Object main.nef.p/src_unk_0202E2CC.c.o - Object main.nef.p/src_unk_0202E840.c.o + Object main.nef.p/src_rankings.c.o Object main.nef.p/src_unk_0202EEC0.c.o Object main.nef.p/src_link_contest_records.c.o Object main.nef.p/src_unk_0202F180.c.o @@ -273,7 +273,7 @@ Static main Object main.nef.p/src_unk_0206C660.c.o Object main.nef.p/src_cutscenes_boat_cutscene_boat_cutscene.c.o Object main.nef.p/src_tv_episode_segment.c.o - Object main.nef.p/src_unk_0206F314.c.o + Object main.nef.p/src_rankings_machine.c.o Object main.nef.p/src_unk_02070428.c.o Object main.nef.p/src_field_move_tasks.c.o Object main.nef.p/src_unk_020711C8.c.o diff --git a/res/field/scripts/scripts_jubilife_tv_3f_global_ranking_room.s b/res/field/scripts/scripts_jubilife_tv_3f_global_ranking_room.s index d1a90e3d46..174fc55779 100644 --- a/res/field/scripts/scripts_jubilife_tv_3f_global_ranking_room.s +++ b/res/field/scripts/scripts_jubilife_tv_3f_global_ranking_room.s @@ -14,21 +14,21 @@ JubilifeTV3FGlobalRankingRoom_RecordMachinePokemon: PlayFanfare SEQ_SE_CONFIRM LockAll - ScrCmd_1B5 0 + StartRankingsMachine 0 ReleaseAll End JubilifeTV3FGlobalRankingRoom_RecordMachineBattles: PlayFanfare SEQ_SE_CONFIRM LockAll - ScrCmd_1B5 1 + StartRankingsMachine 1 ReleaseAll End JubilifeTV3FGlobalRankingRoom_RecordMachineContests: PlayFanfare SEQ_SE_CONFIRM LockAll - ScrCmd_1B5 2 + StartRankingsMachine 2 ReleaseAll End diff --git a/res/field/scripts/scripts_jubilife_tv_3f_group_ranking_room.s b/res/field/scripts/scripts_jubilife_tv_3f_group_ranking_room.s index 51dbc9c65a..c72ffcd912 100644 --- a/res/field/scripts/scripts_jubilife_tv_3f_group_ranking_room.s +++ b/res/field/scripts/scripts_jubilife_tv_3f_group_ranking_room.s @@ -13,21 +13,21 @@ JubilifeTV3FGroupRankingRoom_RecordMachinePokemon: PlayFanfare SEQ_SE_CONFIRM LockAll - ScrCmd_1B5 3 + StartRankingsMachine 3 ReleaseAll End JubilifeTV3FGroupRankingRoom_RecordMachineBattles: PlayFanfare SEQ_SE_CONFIRM LockAll - ScrCmd_1B5 4 + StartRankingsMachine 4 ReleaseAll End JubilifeTV3FGroupRankingRoom_RecordMachineContests: PlayFanfare SEQ_SE_CONFIRM LockAll - ScrCmd_1B5 5 + StartRankingsMachine 5 ReleaseAll End diff --git a/res/text/unk_0532.json b/res/text/rankings_machine.json similarity index 53% rename from res/text/unk_0532.json rename to res/text/rankings_machine.json index 978410f5e2..3f1e66aea9 100644 --- a/res/text/unk_0532.json +++ b/res/text/rankings_machine.json @@ -2,196 +2,196 @@ "key": 40969, "messages": [ { - "id": "pl_msg_00000532_00000", + "id": "RankingsMachine_Text_SingleBattlesRecordTitle", "en_US": "SINGLE BATTLES" }, { - "id": "pl_msg_00000532_00001", + "id": "RankingsMachine_Text_DoubleBattlesRecordTitle", "en_US": "DOUBLE BATTLES" }, { - "id": "pl_msg_00000532_00002", + "id": "RankingsMachine_Text_MultiBattlesRecordTitle", "en_US": "MULTI BATTLES" }, { - "id": "pl_msg_00000532_00003", + "id": "RankingsMachine_Text_LinkMultiBattlesRecordTitle", "en_US": "LINK MULTI BATTLES" }, { - "id": "pl_msg_00000532_00004", + "id": "RankingsMachine_Text_WiFiBattleRoomRecordTitle", "en_US": "WI-FI BATTLE ROOM" }, { - "id": "pl_msg_00000532_00005", + "id": "RankingsMachine_Text_AvgWinStreakRecordTitle", "en_US": "AVG WIN STREAK" }, { - "id": "pl_msg_00000532_00006", + "id": "RankingsMachine_Text_PokemonDefeatedRecordTitle", "en_US": "POKéMON DEFEATED" }, { - "id": "pl_msg_00000532_00007", + "id": "RankingsMachine_Text_PokemonCaughtRecordTitle", "en_US": "POKéMON CAUGHT" }, { - "id": "pl_msg_00000532_00008", + "id": "RankingsMachine_Text_PokemonEggsRecordTitle", "en_US": "POKéMON EGGS" }, { - "id": "pl_msg_00000532_00009", + "id": "RankingsMachine_Text_EncounteredWhileFishingRecordTitle", "en_US": "ENCOUNTERED WHILE FISHING" }, { - "id": "pl_msg_00000532_00010", + "id": "RankingsMachine_Text_ContestWinsRecordTitle", "en_US": "CONTEST WINS" }, { - "id": "pl_msg_00000532_00011", + "id": "RankingsMachine_Text_ContestWinPercentRecordTitle", "en_US": "CONTEST WIN %" }, { - "id": "pl_msg_00000532_00012", + "id": "RankingsMachine_Text_RibbonsRecordTitle", "en_US": "RIBBONS" }, { - "id": "pl_msg_00000532_00013", + "id": "RankingsMachine_Text_Exit", "en_US": "EXIT" }, { - "id": "pl_msg_00000532_00014", + "id": "RankingsMachine_Text_RecordEntryInfo", "en_US": "{STRVAR_1 50, 0, 0}. {STRVAR_1 3, 1, 0}" }, { - "id": "pl_msg_00000532_00015", + "id": "RankingsMachine_Text_BattleWinsValue", "en_US": "{STRVAR_1 53, 0, 0} wins" }, { - "id": "pl_msg_00000532_00016", + "id": "RankingsMachine_Text_AvgWinStreakValue", "en_US": "{STRVAR_1 50, 0, 0} wins" }, { - "id": "pl_msg_00000532_00017", + "id": "RankingsMachine_Text_RibbonsValue", "en_US": "{STRVAR_1 54, 0, 0}" }, { - "id": "pl_msg_00000532_00018", + "id": "RankingsMachine_Text_PokemonHatchedValue", "en_US": "{STRVAR_1 55, 0, 0}" }, { - "id": "pl_msg_00000532_00019", + "id": "RankingsMachine_Text_PokemonCaughtValue", "en_US": "{STRVAR_1 55, 0, 0}" }, { - "id": "pl_msg_00000532_00020", + "id": "RankingsMachine_Text_ContestWinPercentValue", "en_US": "{STRVAR_1 52, 0, 0}%" }, { - "id": "pl_msg_00000532_00021", + "id": "RankingsMachine_Text_ContestWinsValue", "en_US": "{STRVAR_1 53, 0, 0}" }, { - "id": "pl_msg_00000532_00022", + "id": "RankingsMachine_Text_WhichRecordWouldYouLikeToSee", "en_US": "Which record would you like to see?" }, { - "id": "pl_msg_00000532_00023", + "id": "RankingsMachine_Text_SingleBattlesRecordExplanation", "en_US": [ "The Battle Tower’s win-streak record\n", "in Single Battles." ] }, { - "id": "pl_msg_00000532_00024", + "id": "RankingsMachine_Text_DoubleBattlesRecordExplanation", "en_US": [ "The Battle Tower’s win-streak record\n", "in Double Battles." ] }, { - "id": "pl_msg_00000532_00025", + "id": "RankingsMachine_Text_MultiBattlesRecordExplanation", "en_US": [ "The Battle Tower’s win-streak record\n", "in Multi Battles." ] }, { - "id": "pl_msg_00000532_00026", + "id": "RankingsMachine_Text_LinkMultiBattlesRecordExplanation", "en_US": [ "The Battle Tower’s win-streak record\n", "in Link Multi Battles." ] }, { - "id": "pl_msg_00000532_00027", + "id": "RankingsMachine_Text_WiFiBattlesRecordExplanation", "en_US": [ "The Battle Tower’s win-streak record\n", "in Wi-Fi Battles." ] }, { - "id": "pl_msg_00000532_00028", + "id": "RankingsMachine_Text_AvgWinStreakRecordExplanation", "en_US": [ "The average win-streak record\n", "at the Battle Tower." ] }, { - "id": "pl_msg_00000532_00029", + "id": "RankingsMachine_Text_PokemonDefeatedRecordExplanation", "en_US": "The number of Pokémon defeated." }, { - "id": "pl_msg_00000532_00030", + "id": "RankingsMachine_Text_PokemonCaughtRecordExplanation", "en_US": [ "The number of Pokémon caught using\n", "Poké Balls." ] }, { - "id": "pl_msg_00000532_00031", + "id": "RankingsMachine_Text_PokemonEggsRecordExplanation", "en_US": [ "The number of Pokémon that were\n", "hatched from Eggs." ] }, { - "id": "pl_msg_00000532_00032", + "id": "RankingsMachine_Text_EncounteredWhileFishingRecordExplanation", "en_US": [ "The number of Pokémon that were\n", "caught fishing." ] }, { - "id": "pl_msg_00000532_00033", + "id": "RankingsMachine_Text_ContestWinsRecordExplanation", "en_US": "The number of Contest wins." }, { - "id": "pl_msg_00000532_00034", + "id": "RankingsMachine_Text_ContestWinPercentRecordExplanation", "en_US": "The winning percentage of Contests." }, { - "id": "pl_msg_00000532_00035", + "id": "RankingsMachine_Text_RibbonsRecordExplanation", "en_US": [ "The number of Ribbons won in\n", "Contests." ] }, { - "id": "pl_msg_00000532_00036", + "id": "RankingsMachine_Text_DeleteRecord", "en_US": "DEL RECORD" }, { - "id": "pl_msg_00000532_00037", + "id": "RankingsMachine_Text_SelectTheRecordYouWantToDeleteThenPressA", "en_US": [ "Select the record you want to\n", "delete, then press the A Button." ] }, { - "id": "pl_msg_00000532_00038", + "id": "RankingsMachine_Text_AskDeleteThisRecord", "en_US": "Delete this record?" }, { - "id": "pl_msg_00000532_00039", + "id": "RankingsMachine_Text_YourOwnRecordCantBeDeleted", "en_US": "Your own record can’t be deleted." } ] diff --git a/src/game_records.c b/src/game_records.c index 04082f4f61..a56a290891 100644 --- a/src/game_records.c +++ b/src/game_records.c @@ -102,7 +102,7 @@ static u8 sUsesHighLimit[MAX_RECORDS] = { [RECORD_POKEMON_EVOLVED] = TRUE, [RECORD_UNK_013] = TRUE, [RECORD_UNK_014] = TRUE, - [RECORD_UNK_015] = TRUE, + [RECORD_BATTLE_TOWER_CHALLENGES] = TRUE, [RECORD_UNK_016] = TRUE, [RECORD_UNK_017] = TRUE, [RECORD_UNK_018] = TRUE, @@ -116,7 +116,7 @@ static u8 sUsesHighLimit[MAX_RECORDS] = { [RECORD_WIFI_BATTLE_WINS] = TRUE, [RECORD_WIFI_BATTLE_LOSSES] = TRUE, [RECORD_UNK_028] = TRUE, - [RECORD_UNK_029] = TRUE, + [RECORD_BATTLE_TOWER_VICTORIES] = TRUE, [RECORD_UNK_030] = TRUE, [RECORD_UNK_031] = TRUE, [RECORD_UNK_032] = TRUE, @@ -177,11 +177,11 @@ static u8 sUsesHighLimit[MAX_RECORDS] = { [RECORD_UNK_087] = FALSE, [RECORD_UNK_088] = FALSE, [RECORD_UNK_089] = FALSE, - [RECORD_UNK_090] = FALSE, - [RECORD_UNK_091] = FALSE, + [RECORD_SUPER_CONTEST_PARTICIPATIONS] = FALSE, + [RECORD_LINK_CONTEST_PARTICIPATIONS] = FALSE, [RECORD_SUPER_CONTEST_WINS] = FALSE, [RECORD_LINK_CONTEST_WINS] = FALSE, - [RECORD_UNK_094] = TRUE, + [RECORD_RIBBONS_WON] = TRUE, [RECORD_USED_INEFFECTIVE_MOVE] = FALSE, [RECORD_FAINTED_ENEMY_MON] = FALSE, [RECORD_ATTACKED_ALLY] = FALSE, diff --git a/src/meson.build b/src/meson.build index ca8ee62fa2..5ddc8c5c3b 100644 --- a/src/meson.build +++ b/src/meson.build @@ -126,7 +126,7 @@ pokeplatinum_c = files( 'mystery_gift.c', 'hall_of_fame_entries.c', 'unk_0202E2CC.c', - 'unk_0202E840.c', + 'rankings.c', 'unk_0202EEC0.c', 'link_contest_records.c', 'unk_0202F180.c', @@ -259,7 +259,7 @@ pokeplatinum_c = files( 'unk_0206C660.c', 'cutscenes/boat_cutscene/boat_cutscene.c', 'tv_episode_segment.c', - 'unk_0206F314.c', + 'rankings_machine.c', 'unk_02070428.c', 'field_move_tasks.c', 'unk_020711C8.c', diff --git a/src/overlay005/ov5_021F6454.c b/src/overlay005/ov5_021F6454.c index e7321f44a5..65f996f7e9 100644 --- a/src/overlay005/ov5_021F6454.c +++ b/src/overlay005/ov5_021F6454.c @@ -800,7 +800,7 @@ BOOL ScrCmd_30F(ScriptContext *param0) switch (v3) { case 13: - if (GameRecords_GetRecordValue(v1, RECORD_UNK_029) < 1) { + if (GameRecords_GetRecordValue(v1, RECORD_BATTLE_TOWER_VICTORIES) < 1) { *v4 = 0; } diff --git a/src/overlay059/ov59_021D2F88.c b/src/overlay059/ov59_021D2F88.c index 635e870752..8a2591d0b8 100644 --- a/src/overlay059/ov59_021D2F88.c +++ b/src/overlay059/ov59_021D2F88.c @@ -4,7 +4,6 @@ #include #include "struct_decls/struct_0202440C_decl.h" -#include "struct_decls/struct_0202E8C0_decl.h" #include "struct_defs/dress_up_photo.h" #include "struct_defs/image_clips.h" @@ -17,12 +16,12 @@ #include "communication_information.h" #include "communication_system.h" #include "heap.h" +#include "rankings.h" #include "record_mixed_rng.h" #include "savedata.h" #include "unk_020298BC.h" #include "unk_0202D05C.h" #include "unk_0202E2CC.h" -#include "unk_0202E840.h" #include "unk_02073700.h" typedef struct { @@ -115,7 +114,7 @@ static void *ov59_021D3088(SaveData *saveData, enum HeapID heapID, u32 param2) static void ov59_021D3090(const UnkStruct_ov59_021D2FBC *param0) { - UnkStruct_0202E8C0 *v0 = sub_0202E8C0(param0->saveData); + Rankings *v0 = SaveData_GetRankings(param0->saveData); sub_0202ED0C(param0->saveData, param0->unk_0C, param0->unk_08, param0->unk_10, param0->heapID); } @@ -140,7 +139,7 @@ static const UnkStruct_ov59_021D33FC Unk_ov59_021D33FC[] = { { (UnkFuncPtr_ov59_021D33FC)ov59_021D2B4C, (UnkFuncPtr_ov59_021D33FC_1)ov59_021D2C70, NULL }, { (UnkFuncPtr_ov59_021D33FC)ov59_021D2B54, (UnkFuncPtr_ov59_021D33FC_1)ov59_021D2CB4, NULL }, { (UnkFuncPtr_ov59_021D33FC)ov59_021D2B44, (UnkFuncPtr_ov59_021D33FC_1)ov59_021D2C28, NULL }, - { (UnkFuncPtr_ov59_021D33FC)sub_0202E91C, (UnkFuncPtr_ov59_021D33FC_1)ov59_021D3088, ov59_021D3090 }, + { (UnkFuncPtr_ov59_021D33FC)RankingsEntries_Size, (UnkFuncPtr_ov59_021D33FC_1)ov59_021D3088, ov59_021D3090 }, { (UnkFuncPtr_ov59_021D33FC)sub_0202D05C, (UnkFuncPtr_ov59_021D33FC_1)ov59_021D30B4, ov59_021D30DC }, { (UnkFuncPtr_ov59_021D33FC)ov59_021D2B4C, (UnkFuncPtr_ov59_021D33FC_1)ov59_021D2D3C, ov59_021D3028 }, { (UnkFuncPtr_ov59_021D33FC)ov59_021D2B54, (UnkFuncPtr_ov59_021D33FC_1)ov59_021D2D80, ov59_021D3048 }, diff --git a/src/rankings.c b/src/rankings.c new file mode 100644 index 0000000000..505f193780 --- /dev/null +++ b/src/rankings.c @@ -0,0 +1,438 @@ +#include "rankings.h" + +#include +#include + +#include "generated/game_records.h" + +#include "struct_defs/battle_frontier.h" + +#include "charcode_util.h" +#include "game_records.h" +#include "heap.h" +#include "record_mixed_rng.h" +#include "save_player.h" +#include "savedata.h" +#include "string_gf.h" +#include "trainer_info.h" +#include "unk_0203061C.h" + +#include "res/text/bank/rankings_machine.h" + +typedef struct { + int unk_00; + int unk_04; + int unk_08; + RankingEntry *unk_0C[11]; + RankingEntry *unk_38[6]; + RankingList list; +} UnkStruct_0202EABC; + +typedef struct RankingsEntries { + RankingEntry entries[RECORDS_WITH_RANKINGS_COUNT]; +} RankingsEntries; + +typedef struct RecordListInfo { + u8 length; + u8 firstRecord; +} RecordListInfo; + +static const RecordListInfo sRecordsListsInfo[] = { + { 6, 0 }, + { 4, 6 }, + { 3, 10 } +}; + +u8 GetRecordsListLength(int listID) +{ + return sRecordsListsInfo[listID].length; +} + +u8 GetRecordsListFirstRecord(int listID) +{ + return sRecordsListsInfo[listID].firstRecord; +} + +void RankingEntry_Clear(RankingEntry *entry) +{ + entry->seed = 0; + entry->recordValue = 0; + + CharCode_FillWithEOS(entry->playerName, TRAINER_NAME_LEN + 1); + SaveData_SetChecksum(SAVE_TABLE_ENTRY_RANKINGS); +} + +BOOL RankingEntry_HasPlayerName(RankingEntry *entry) +{ + return CharCode_Length(entry->playerName) != 0; +} + +int Rankings_SaveSize(void) +{ + return sizeof(Rankings); +} + +void Rankings_Init(Rankings *rankings) +{ + MI_CpuClear8(rankings, sizeof(Rankings)); + + for (int listID = 0; listID < RECORDS_WITH_RANKINGS_COUNT * 2; listID++) { + for (int entryID = 0; entryID < MAX_RANKINGS_ENTRIES; entryID++) { + RankingEntry_Clear(&(rankings->lists[listID].entries[entryID])); + } + } + + SaveData_SetChecksum(SAVE_TABLE_ENTRY_RANKINGS); +} + +Rankings *SaveData_GetRankings(SaveData *saveData) +{ + SaveData_Checksum(SAVE_TABLE_ENTRY_RANKINGS); + return SaveData_SaveTable(saveData, SAVE_TABLE_ENTRY_RANKINGS); +} + +void Rankings_RemoveEntry(Rankings *rankings, int listID, u8 entryID) +{ + if (entryID >= MAX_RANKINGS_ENTRIES) { + GF_ASSERT(entryID < MAX_RANKINGS_ENTRIES); + return; + } + + RankingList *list = &rankings->lists[listID]; + + for (int i = entryID; i < MAX_RANKINGS_ENTRIES - 1; i++) { + list->entries[i] = list->entries[i + 1]; + } + + RankingEntry_Clear(&(list->entries[MAX_RANKINGS_ENTRIES - 1])); + SaveData_SetChecksum(SAVE_TABLE_ENTRY_RANKINGS); +} + +int RankingsEntries_Size(void) +{ + return sizeof(RankingsEntries); +} + +static u32 *GetRecordValues(SaveData *saveData, enum HeapID heapID) +{ + int i; + u32 recordValue; + static const int recordIDs[] = { + 0, + 2, + 4, + 6, + 8, + RECORD_BATTLE_TOWER_VICTORIES, + RECORD_FAINTED_IN_BATTLE, + RECORD_CAUGHT_POKEMON, + RECORD_EGGS_HATCHED, + RECORD_CAUGHT_FISH, + RECORD_SUPER_CONTEST_WINS, + RECORD_SUPER_CONTEST_PARTICIPATIONS, + RECORD_RIBBONS_WON + }; + + GameRecords *gameRecords = SaveData_GetGameRecords(saveData); + BattleFrontier *frontier = SaveData_GetBattleFrontier(saveData); + u32 *recordValues = Heap_AllocAtEnd(heapID, sizeof(u32) * RECORDS_WITH_RANKINGS_COUNT); + + for (i = 0; i < RECORDS_WITH_RANKINGS_COUNT; i++) { + switch (i) { + case 5: + recordValue = GameRecords_GetRecordValue(gameRecords, RECORD_BATTLE_TOWER_CHALLENGES); + + if (recordValue > 0) { + recordValue = GameRecords_GetRecordValue(gameRecords, RECORD_BATTLE_TOWER_VICTORIES) / recordValue; + } + + recordValues[i] = recordValue; + break; + case 10: + recordValue = GameRecords_GetRecordValue(gameRecords, RECORD_SUPER_CONTEST_WINS); + recordValue += GameRecords_GetRecordValue(gameRecords, RECORD_LINK_CONTEST_WINS); + recordValues[i] = recordValue; + break; + case 11: + recordValue = GameRecords_GetRecordValue(gameRecords, RECORD_SUPER_CONTEST_PARTICIPATIONS); + recordValue += GameRecords_GetRecordValue(gameRecords, RECORD_LINK_CONTEST_PARTICIPATIONS); + + if (recordValue > 0) { + recordValue = (recordValues[10] * 100) / recordValue; + } + + recordValues[i] = recordValue; + break; + default: + if (i >= 0 && i <= 4) { + recordValues[i] = sub_02030698(frontier, recordIDs[i], 0xFF); + } else { + recordValues[i] = GameRecords_GetRecordValue(gameRecords, recordIDs[i]); + } + } + } + + SaveData_SetChecksum(SAVE_TABLE_ENTRY_RANKINGS); + + return recordValues; +} + +void *sub_0202E9FC(SaveData *saveData, enum HeapID heapID) +{ + int i; + u32 seed, unused; + RankingsEntries *rankingsEntries; + String *string; + TrainerInfo *trainerInfo = SaveData_GetTrainerInfo(saveData); + u32 *recordValues; + + rankingsEntries = Heap_AllocAtEnd(heapID, sizeof(RankingsEntries)); + MI_CpuClear8(rankingsEntries, sizeof(RankingsEntries)); + + seed = RecordMixedRNG_GetEntrySeed(SaveData_GetRecordMixedRNG(saveData), RECORD_MIXED_RNG_PLAYER_OVERRIDE); + string = TrainerInfo_NameNewString(trainerInfo, heapID); + recordValues = GetRecordValues(saveData, heapID); + + for (i = 0; i < RECORDS_WITH_RANKINGS_COUNT; i++) { + unused = 0; + + rankingsEntries->entries[i].seed = seed; + String_ToChars(string, rankingsEntries->entries[i].playerName, TRAINER_NAME_LEN + 1); + rankingsEntries->entries[i].recordValue = recordValues[i]; + } + + Heap_Free(recordValues); + String_Free(string); + SaveData_SetChecksum(SAVE_TABLE_ENTRY_RANKINGS); + + return rankingsEntries; +} + +static void RankingList_ClearEntries(RankingList *list) +{ + for (int i = 0; i < MAX_RANKINGS_ENTRIES; i++) { + RankingEntry_Clear(&list->entries[i]); + } +} + +static BOOL CompareEntriesSeedsAndNames(const RankingEntry *entry0, const RankingEntry *entry1) +{ + if (entry0->seed != entry1->seed) { + return FALSE; + } + + if (CharCode_Compare(entry0->playerName, entry1->playerName)) { + return FALSE; + } + + return TRUE; +} + +static BOOL sub_0202EABC(UnkStruct_0202EABC *param0, const RankingEntry *entry) +{ + for (int i = 0; i < param0->unk_04; i++) { + if (CompareEntriesSeedsAndNames(param0->unk_0C[i], entry)) { + return TRUE; + } + } + + return FALSE; +} + +static void sub_0202EAEC(Rankings *rankings, UnkStruct_0202EABC *param1, u32 param2, u8 param3, u8 param4, RankingsEntries **rankingsEntries, u8 param6, enum HeapID heapID) +{ + int i, v1; + RankingEntry *v2; + RankingList *list; + + MI_CpuClear8(param1, sizeof(UnkStruct_0202EABC)); + + if (param4 == 0) { + list = &(rankings->lists[param3]); + + MI_CpuCopy8(list, &(param1->list), sizeof(RankingList)); + + for (i = 0; i < param6; i++) { + param1->unk_0C[param1->unk_04++] = &(rankingsEntries[i]->entries[param3]); + } + + for (i = 0; i < MAX_RANKINGS_ENTRIES; i++) { + if (!RankingEntry_HasPlayerName(&(param1->list.entries[i]))) { + continue; + } + + if (sub_0202EABC(param1, &(param1->list.entries[i]))) { + continue; + } + + param1->unk_38[param1->unk_00++] = &(param1->list.entries[i]); + } + } else { + list = &(rankings->lists[param3 + RECORDS_WITH_RANKINGS_COUNT]); + MI_CpuCopy8(list, &(param1->list), sizeof(RankingList)); + + for (i = 0; i < param6; i++) { + if ((rankingsEntries[i]->entries[param3].seed == 0) || (rankingsEntries[i]->entries[param3].seed != param2)) { + continue; + } + + param1->unk_0C[param1->unk_04++] = &(rankingsEntries[i]->entries[param3]); + } + + for (i = 0; i < MAX_RANKINGS_ENTRIES; i++) { + if (!RankingEntry_HasPlayerName(&(param1->list.entries[i]))) { + continue; + } + + if (param1->list.entries[i].seed != param2) { + continue; + } + + if (sub_0202EABC(param1, &(param1->list.entries[i]))) { + continue; + } + + param1->unk_38[param1->unk_00++] = &(param1->list.entries[i]); + } + } + + param1->unk_08 = param1->unk_04 + param1->unk_00; + + for (i = 0; i < param1->unk_00; i++) { + param1->unk_0C[i + param1->unk_04] = param1->unk_38[i]; + } + + for (i = 0; i < (param1->unk_08 - 1); i++) { + for (v1 = (param1->unk_08 - 1); v1 > i; v1--) { + if (param1->unk_0C[i]->recordValue >= param1->unk_0C[v1]->recordValue) { + continue; + } + + v2 = param1->unk_0C[i]; + + param1->unk_0C[i] = param1->unk_0C[v1]; + param1->unk_0C[v1] = v2; + } + } + + RankingList_ClearEntries(list); + + for (i = 0; (i < MAX_RANKINGS_ENTRIES && i < param1->unk_08); i++) { + list->entries[i] = *(param1->unk_0C[i]); + } +} + +static void sub_0202ECB0(Rankings *rankings, u32 param1, u8 param2, RankingsEntries **rankingsEntries, u8 param4, enum HeapID heapID) +{ + UnkStruct_0202EABC *v2 = Heap_AllocAtEnd(heapID, sizeof(UnkStruct_0202EABC)); + + sub_0202EAEC(rankings, v2, param1, param2, 0, rankingsEntries, param4, heapID); + + if (param1 != 0) { + sub_0202EAEC(rankings, v2, param1, param2, 1, rankingsEntries, param4, heapID); + } + + Heap_Free(v2); +} + +void sub_0202ED0C(SaveData *saveData, int param1, u8 param2, const void **inRankingsEntries, enum HeapID heapID) +{ + u8 i, v1; + u32 v2; + RankingsEntries *rankingsEntries[5]; + Rankings *rankings = SaveData_GetRankings(saveData); + + v2 = RecordMixedRNG_GetEntrySeed(SaveData_GetRecordMixedRNG(saveData), RECORD_MIXED_RNG_PLAYER_OVERRIDE); + v1 = 0; + + for (i = 0; i < param2; i++) { + if (i == param1) { + continue; + } + + if (inRankingsEntries[i] == NULL) { + continue; + } + + rankingsEntries[v1++] = (RankingsEntries *)inRankingsEntries[i]; + } + + if (v1 == 0) { + return; + } + + for (i = 0; i < 13; i++) { + sub_0202ECB0(rankings, v2, i, rankingsEntries, v1, heapID); + } + + SaveData_SetChecksum(SAVE_TABLE_ENTRY_RANKINGS); + + return; +} + +RecordPlayersInfo *Rankings_GetCurrentPlayerInfo(SaveData *saveData, int listID, enum HeapID heapID) +{ + int i, firstRecordID; + u32 seed; + RecordPlayersInfo *playersInfo; + u32 *recordValues; + TrainerInfo *trainerInfo = SaveData_GetTrainerInfo(saveData); + playersInfo = Heap_Alloc(heapID, sizeof(RecordPlayersInfo)); + + MI_CpuClear8(playersInfo, sizeof(RecordPlayersInfo)); + + seed = RecordMixedRNG_GetEntrySeed(SaveData_GetRecordMixedRNG(saveData), RECORD_MIXED_RNG_PLAYER_OVERRIDE); + recordValues = GetRecordValues(saveData, heapID); + playersInfo->count = GetRecordsListLength(listID); + firstRecordID = GetRecordsListFirstRecord(listID); + + for (i = 0; i < playersInfo->count; i++) { + playersInfo->players[i].seed = seed; + playersInfo->players[i].recordValue = recordValues[i + firstRecordID]; + playersInfo->players[i].playerName = TrainerInfo_NameNewString(trainerInfo, heapID); + } + + Heap_Free(recordValues); + return playersInfo; +} + +RecordPlayersInfo *Rankings_GetConnectedPlayersInfo(Rankings *rankings, int listID, enum HeapID heapID) +{ + int i; + RecordPlayersInfo *playersInfo = Heap_Alloc(heapID, sizeof(RecordPlayersInfo)); + RankingList *list; + + MI_CpuClear8(playersInfo, sizeof(RecordPlayersInfo)); + list = &rankings->lists[listID]; + + for (i = 0; i < MAX_RANKINGS_ENTRIES; i++) { + if (!RankingEntry_HasPlayerName(&list->entries[i])) { + continue; + } + + playersInfo->players[playersInfo->count].seed = list->entries[i].seed; + playersInfo->players[playersInfo->count].recordValue = list->entries[i].recordValue; + playersInfo->players[playersInfo->count].playerName = String_Init(TRAINER_NAME_LEN + 1, heapID); + String_CopyChars(playersInfo->players[playersInfo->count].playerName, list->entries[i].playerName); + ++playersInfo->count; + } + + return playersInfo; +} + +void RecordPlayersInfo_Free(RecordPlayersInfo *playersInfo) +{ + int i; + + for (i = 0; i < MAX_RANKINGS_ENTRIES; i++) { + if (playersInfo->players[i].playerName != NULL) { + String_Free(playersInfo->players[i].playerName); + } + } + + MI_CpuClear8(playersInfo, sizeof(RecordPlayersInfo)); + + Heap_Free(playersInfo); + playersInfo = NULL; + SaveData_SetChecksum(SAVE_TABLE_ENTRY_RANKINGS); +} diff --git a/src/rankings_machine.c b/src/rankings_machine.c new file mode 100644 index 0000000000..cdb014526d --- /dev/null +++ b/src/rankings_machine.c @@ -0,0 +1,995 @@ +#include "rankings_machine.h" + +#include +#include + +#include "constants/field_base_tiles.h" +#include "constants/scrcmd.h" + +#include "field/field_system.h" +#include "overlay005/sprite_resource_manager.h" + +#include "bg_window.h" +#include "field_task.h" +#include "font.h" +#include "game_options.h" +#include "heap.h" +#include "list_menu.h" +#include "menu.h" +#include "message.h" +#include "narc.h" +#include "rankings.h" +#include "render_window.h" +#include "save_player.h" +#include "savedata.h" +#include "sound_playback.h" +#include "sprite.h" +#include "sprite_system.h" +#include "string_gf.h" +#include "string_list.h" +#include "string_template.h" +#include "system.h" +#include "text.h" + +#include "res/text/bank/rankings_machine.h" + +#define PLAYERID_OWN 0xFF + +#define VALUE_STRINGS_COUNT 7 +#define MAX_RECORDS_PER_MACHINE 6 +#define DELETE_INSTRUCTIONS_STRINGS_COUNT 3 + +#define MANAGED_SPRITE_CURSOR 0 +#define MANAGED_SPRITE_DELETE_WINDOW 1 + +#define RANKINGS_WINDOW_WIDTH 8 +#define RANKINGS_WINDOW_HEIGHT 2 +#define BASE_TILE_RANKINGS_WINDOW (BASE_TILE_STANDARD_WINDOW_FRAME - MESSAGE_WINDOW_TILE_COUNT - YES_NO_MENU_TILE_COUNT - RANKINGS_WINDOW_WIDTH * RANKINGS_WINDOW_HEIGHT) + +typedef struct RankingsMachineText { + MessageLoader *msgLoader; + StringTemplate *strTemplate; + String *strBuffer; + String *exit; + String *whichRecord; + String *deleteRecord; + String *recordEntryInfo; + String *values[VALUE_STRINGS_COUNT]; + String *titles[MAX_RECORDS_PER_MACHINE]; + String *explanations[MAX_RECORDS_PER_MACHINE]; + String *deleteInstructions[DELETE_INSTRUCTIONS_STRINGS_COUNT]; +} RankingsMachineText; + +typedef struct MachineRankingInfo { + RankingPlayerInfo *playerInfo; + u16 exists; + u8 playerID; +} MachineRankingInfo; + +typedef struct MachineRankings { + int rankingsCount; + MachineRankingInfo rankingsInfo[7]; +} MachineRankings; + +typedef struct RecordPrintingData { + u32 maxScore; + u16 maxDigits; + u16 valueString; +} RecordPrintingData; + +typedef struct RankingsMachineManager { + enum HeapID heapID; + int *unused_04; + int unused_08; + int deleteState; + u16 bgMain0Priority; + u16 bgMain1Priority; + u16 unused_14; + u8 listID; + u8 mode; + u8 recordsCount; + u8 firstRecord; + u16 textDelay; + u16 frame; + u8 printerID; + u8 selectedRecordID; + u8 unused_20; + u8 lastRankingID; + u16 startListPos; + u16 startCursorPos; + u16 unused_26; + u16 cursorPos; + RankingsMachineText text; + ListMenuTemplate listMenuTemplate; + ListMenu *listMenu; + StringList *stringList; + Menu *menu; + FieldSystem *fieldSystem; + BgConfig *bgConfig; + Window listWindow; + Window msgBoxWindow; + Window rankingsWindow; + Window unused_104[3]; + SpriteResourceManager spriteManager; + ManagedSprite *managedSprites[2]; + Rankings *rankings; + RecordPlayersInfo *recordsPlayersInfo[MAX_RECORDS_PER_MACHINE + 1]; + MachineRankings *machineRankings; + MachineRankingInfo *rankingToDelete; + u8 rankingIDs[MAX_RANKINGS_ENTRIES]; +} RankingsMachineManager; + +typedef struct RankingsMachine { + int state; + u16 id; + RankingsMachineManager *manager; +} RankingsMachine; + +static void RankingsMachine_NewRankings(RankingsMachineManager *machineMan, SaveData *saveData); +static void RankingsMachine_FreeRankings(RankingsMachineManager *machineMan); +static void RankingsMachine_InitStrings(RankingsMachineManager *machineMan); +static void RankingsMachine_FreeStrings(RankingsMachineManager *machineMan); +static void RankingsMachine_InitBg(RankingsMachineManager *machineMan); +static void RankingsMachine_FreeBg(RankingsMachineManager *machineMan); +static void RankingsMachine_InitSprites(RankingsMachineManager *machineMan); +static void RankingsMachine_FreeSprites(RankingsMachineManager *machineMan); +static void RankingsMachine_ShowRecordsList(RankingsMachineManager *machineMan, u16 startListPos, u16 startCursorPos); +static void RankingsMachine_RemoveRecordsList(RankingsMachineManager *machineMan); +static void RankingsMachine_SetCursorPos(ListMenu *listMenu, u32 unused, u8 mute); +static void RankingsMachine_PrintDeleteInstruction(RankingsMachineManager *machineMan); +static void RankingsMachine_PrepareForDeletingRecord(RankingsMachineManager *machineMan); +static void RankingsMachine_PrintRecordExplanation(RankingsMachineManager *machineMan); +static void RankingsMachine_PrintRecordRankings(RankingsMachineManager *machineMan, BOOL showDeleteScreen); +static void RankingsMachine_ShowRankingList(RankingsMachineManager *machineMan, u16 cursorPos); +static void RankingsMachine_RemoveRankingList(RankingsMachineManager *machineMan); + +enum RankingsMachineState { + STATE_INIT_MANAGER, + STATE_INIT, + STATE_PRINT_RECORD_TITLES, + STATE_HANDLE_RECORDS_LIST_INPUT, + STATE_SHOW_RANKINGS_LIST, + STATE_HANDLE_RANKINGS_LIST_INPUT, + STATE_HANDLE_DELETE_RANKINGS_INPUT, + STATE_ASK_DELETE_RANKING, + STATE_CANT_DELETE_OWN_RANKING, + STATE_UNUSED, + STATE_FREE, + STATE_FREE_MANAGER, + STATE_FREE_MACHINE, +}; + +static const ListMenuTemplate sRankingsMachineListMenuTemplate = { + .choices = NULL, + .cursorCallback = NULL, + .printCallback = NULL, + .window = NULL, + .count = 0, + .maxDisplay = 7, + .headerXOffset = 2, + .textXOffset = 8, + .cursorXOffset = 1, + .yOffset = 0, + .textColorFg = 1, + .textColorBg = 15, + .textColorShadow = 2, + .letterSpacing = 0, + .lineSpacing = 0, + .pagerMode = PAGER_MODE_LEFT_RIGHT_PAD, + .fontID = FONT_SYSTEM, + .cursorType = 1, + .parent = NULL +}; + +static const RecordPrintingData sPrintingDataBattleRecords[] = { + { + .maxScore = 9999, + .maxDigits = 4, + .valueString = RankingsMachine_Text_BattleWinsValue, + }, + { + .maxScore = 9999, + .maxDigits = 4, + .valueString = RankingsMachine_Text_BattleWinsValue, + }, + { + .maxScore = 9999, + .maxDigits = 4, + .valueString = RankingsMachine_Text_BattleWinsValue, + }, + { + .maxScore = 9999, + .maxDigits = 4, + .valueString = RankingsMachine_Text_BattleWinsValue, + }, + { + .maxScore = 9999, + .maxDigits = 4, + .valueString = RankingsMachine_Text_BattleWinsValue, + }, + { + .maxScore = 7, + .maxDigits = 1, + .valueString = RankingsMachine_Text_AvgWinStreakValue, + }, +}; + +static const RecordPrintingData sPrintingDataPokemonRecords[] = { + { + .maxScore = 999999, + .maxDigits = 6, + .valueString = RankingsMachine_Text_PokemonCaughtValue, + }, + { + .maxScore = 999999, + .maxDigits = 6, + .valueString = RankingsMachine_Text_PokemonCaughtValue, + }, + { + .maxScore = 999999, + .maxDigits = 6, + .valueString = RankingsMachine_Text_PokemonHatchedValue, + }, + { + .maxScore = 999999, + .maxDigits = 6, + .valueString = RankingsMachine_Text_PokemonCaughtValue, + }, +}; + +static const RecordPrintingData sPrintingDataContestRecords[] = { + { + .maxScore = 9999, + .maxDigits = 4, + .valueString = RankingsMachine_Text_ContestWinsValue, + }, + { + .maxScore = 100, + .maxDigits = 4, + .valueString = RankingsMachine_Text_ContestWinPercentValue, + }, + { + .maxScore = 65535, + .maxDigits = 5, + .valueString = RankingsMachine_Text_RibbonsValue, + }, +}; + +static const RecordPrintingData *const sRecordsPrintingData[] = { + sPrintingDataBattleRecords, + sPrintingDataPokemonRecords, + sPrintingDataContestRecords +}; + +static int RankingsMachine_InitManager(RankingsMachine *rankingsMachine, FieldSystem *fieldSystem, u16 machineID) +{ + RankingsMachineManager *machineMan; + SaveData *saveData = fieldSystem->saveData; + + Heap_Create(HEAP_ID_APPLICATION, HEAP_ID_RANKINGS_MACHINE, HEAP_SIZE_RECORD_LIST); + + machineMan = Heap_Alloc(HEAP_ID_RANKINGS_MACHINE, sizeof(RankingsMachineManager)); + MI_CpuClear8(machineMan, sizeof(RankingsMachineManager)); + + machineMan->heapID = HEAP_ID_RANKINGS_MACHINE; + machineMan->listID = machineID % 3; + machineMan->mode = machineID / 3; + machineMan->recordsCount = GetRecordsListLength(machineMan->listID); + machineMan->firstRecord = GetRecordsListFirstRecord(machineMan->listID); + machineMan->fieldSystem = fieldSystem; + machineMan->bgConfig = fieldSystem->bgConfig; + machineMan->rankings = SaveData_GetRankings(saveData); + machineMan->textDelay = Options_TextFrameDelay(SaveData_GetOptions(saveData)); + machineMan->frame = Options_Frame(SaveData_GetOptions(saveData)); + + rankingsMachine->manager = machineMan; + + return STATE_INIT; +} + +static int RankingsMachine_FreeManager(RankingsMachine *rankingsMachine) +{ + int recordID, rankingID, entryIDOffset, heapID; + MachineRankingInfo *rankingInfo; + RankingsMachineManager *machineMan = rankingsMachine->manager; + + for (recordID = 0; recordID < machineMan->recordsCount; recordID++) { + entryIDOffset = 0; + + for (rankingID = 0; rankingID < machineMan->machineRankings[recordID].rankingsCount; rankingID++) { + rankingInfo = &(machineMan->machineRankings[recordID].rankingsInfo[rankingID]); + + if (rankingInfo->playerID == PLAYERID_OWN || rankingInfo->exists) { + continue; + } + + Rankings_RemoveEntry(machineMan->rankings, (machineMan->mode * 13) + machineMan->firstRecord + recordID, rankingInfo->playerID - entryIDOffset); + ++entryIDOffset; + } + } + + heapID = machineMan->heapID; + + Heap_Free(machineMan); + MI_CpuClear8(machineMan, sizeof(RankingsMachineManager)); + Heap_Destroy(heapID); + + return STATE_FREE_MACHINE; +} + +static int RankingsMachine_Init(RankingsMachineManager *machineMan, SaveData *saveData) +{ + RankingsMachine_NewRankings(machineMan, saveData); + RankingsMachine_InitStrings(machineMan); + RankingsMachine_InitBg(machineMan); + RankingsMachine_InitSprites(machineMan); + + return STATE_PRINT_RECORD_TITLES; +} + +static int RankingsMachine_Free(RankingsMachineManager *machineMan) +{ + RankingsMachine_FreeSprites(machineMan); + RankingsMachine_FreeBg(machineMan); + RankingsMachine_FreeStrings(machineMan); + RankingsMachine_FreeRankings(machineMan); + + return STATE_FREE_MANAGER; +} + +static int RankingsMachine_StateShowRecordsList(RankingsMachineManager *machineMan) +{ + RankingsMachine_ShowRecordsList(machineMan, machineMan->startListPos, machineMan->startCursorPos); + return STATE_HANDLE_RECORDS_LIST_INPUT; +} + +static int RankingsMachine_HandleRecordsListInput(RankingsMachineManager *machineMan) +{ + s32 input = ListMenu_ProcessInput(machineMan->listMenu); + + if (JOY_NEW(PAD_BUTTON_B)) { + Sound_PlayEffect(SEQ_SE_CONFIRM); + RankingsMachine_RemoveRecordsList(machineMan); + return STATE_FREE; + } + + if (!(JOY_NEW(PAD_BUTTON_A))) { + return STATE_HANDLE_RECORDS_LIST_INPUT; + } + + Sound_PlayEffect(SEQ_SE_CONFIRM); + + switch (input) { + case MENU_NOTHING_CHOSEN: + case MENU_CANCEL: + case 0xFFFF: + RankingsMachine_RemoveRecordsList(machineMan); + return STATE_FREE; + default: + machineMan->selectedRecordID = input; + machineMan->cursorPos = 0; + RankingsMachine_RemoveRecordsList(machineMan); + return STATE_SHOW_RANKINGS_LIST; + } + + return STATE_HANDLE_RECORDS_LIST_INPUT; +} + +static int RankingsMachine_StateShowRankingList(RankingsMachineManager *machineMan) +{ + RankingsMachine_ShowRankingList(machineMan, machineMan->cursorPos); + return STATE_HANDLE_RANKINGS_LIST_INPUT; +} + +static int RankingsMachine_HandleRankingListInput(RankingsMachineManager *machineMan) +{ + if (JOY_NEW(PAD_BUTTON_B | PAD_BUTTON_A)) { + Sound_PlayEffect(SEQ_SE_CONFIRM); + RankingsMachine_RemoveRankingList(machineMan); + return STATE_PRINT_RECORD_TITLES; + } + + if (JOY_NEW(PAD_BUTTON_SELECT)) { + Sound_PlayEffect(SEQ_SE_CONFIRM); + RankingsMachine_PrepareForDeletingRecord(machineMan); + return STATE_HANDLE_DELETE_RANKINGS_INPUT; + } + + return STATE_HANDLE_RANKINGS_LIST_INPUT; +} + +static int RankingsMachine_HandleDeleteRankingInput(RankingsMachineManager *machineMan) +{ + if (JOY_NEW(PAD_BUTTON_B)) { + Sound_PlayEffect(SEQ_SE_CONFIRM); + RankingsMachine_PrintRecordExplanation(machineMan); + return STATE_HANDLE_RANKINGS_LIST_INPUT; + } + + if (JOY_NEW(PAD_BUTTON_A)) { + Sound_PlayEffect(SEQ_SE_CONFIRM); + machineMan->deleteState = 0; + machineMan->rankingToDelete = &(machineMan->machineRankings[machineMan->selectedRecordID].rankingsInfo[machineMan->rankingIDs[machineMan->cursorPos]]); + + if (machineMan->rankingToDelete->playerID == PLAYERID_OWN) { + return STATE_CANT_DELETE_OWN_RANKING; + } + + return STATE_ASK_DELETE_RANKING; + } + + if (JOY_NEW(PAD_KEY_UP)) { + if (machineMan->cursorPos > 0) { + Sound_PlayEffect(SEQ_SE_CONFIRM); + --machineMan->cursorPos; + ManagedSprite_SetPositionXY(machineMan->managedSprites[MANAGED_SPRITE_CURSOR], 126, 16 + 16 * machineMan->cursorPos); + } + } + + if (JOY_NEW(PAD_KEY_DOWN)) { + if (machineMan->cursorPos < machineMan->lastRankingID - 1) { + Sound_PlayEffect(SEQ_SE_CONFIRM); + ++machineMan->cursorPos; + ManagedSprite_SetPositionXY(machineMan->managedSprites[MANAGED_SPRITE_CURSOR], 126, 16 + 16 * machineMan->cursorPos); + } + } + + return STATE_HANDLE_DELETE_RANKINGS_INPUT; +} + +static void RankingsMachine_MakeYesNoMenu(RankingsMachineManager *machineMan) +{ + static const WindowTemplate yesNoWindowTemplate = { + .bgLayer = BG_LAYER_MAIN_3, + .tilemapLeft = 25, + .tilemapTop = 13, + .width = 6, + .height = 4, + .palette = PLTT_13, + .baseTile = 0x355, + }; + + machineMan->menu = Menu_MakeYesNoChoice(machineMan->bgConfig, &yesNoWindowTemplate, BASE_TILE_STANDARD_WINDOW_FRAME, 11, machineMan->heapID); +} + +static int RankingsMachine_AskDeleteRanking(RankingsMachineManager *machineMan) +{ + switch (machineMan->deleteState) { + case 0: + Window_FillTilemap(&machineMan->msgBoxWindow, PIXEL_FILL(15)); + machineMan->printerID = Text_AddPrinterWithParamsAndColor(&machineMan->msgBoxWindow, FONT_MESSAGE, machineMan->text.deleteInstructions[1], 0, 0, machineMan->textDelay, TEXT_COLOR(1, 2, 15), NULL); + ManagedSprite_SetExplicitPalette(machineMan->managedSprites[MANAGED_SPRITE_CURSOR], 2); + machineMan->deleteState++; + break; + case 1: + if (Text_IsPrinterActive(machineMan->printerID)) { + break; + } + + RankingsMachine_MakeYesNoMenu(machineMan); + machineMan->deleteState++; + break; + case 2: + switch (Menu_ProcessInputAndHandleExit(machineMan->menu, machineMan->heapID)) { + case MENU_YES: + machineMan->deleteState++; + break; + case MENU_CANCEL: + machineMan->deleteState = 0xFF; + break; + } + break; + case 3: + machineMan->rankingToDelete->exists = FALSE; + RankingsMachine_PrintRecordRankings(machineMan, TRUE); + ManagedSprite_SetExplicitPalette(machineMan->managedSprites[MANAGED_SPRITE_CURSOR], 1); + machineMan->deleteState = 0; + return STATE_HANDLE_DELETE_RANKINGS_INPUT; + case 0xFF: + RankingsMachine_PrintDeleteInstruction(machineMan); + ManagedSprite_SetExplicitPalette(machineMan->managedSprites[MANAGED_SPRITE_CURSOR], 1); + machineMan->deleteState = 0; + return STATE_HANDLE_DELETE_RANKINGS_INPUT; + } + + return STATE_ASK_DELETE_RANKING; +} + +static int RankingsMachine_CantDeleteOwnRanking(RankingsMachineManager *machineMan) +{ + switch (machineMan->deleteState) { + case 0: + Sound_PlayEffect(SEQ_SE_DP_CUSTOM06); + Window_FillTilemap(&machineMan->msgBoxWindow, PIXEL_FILL(15)); + machineMan->printerID = Text_AddPrinterWithParamsAndColor(&machineMan->msgBoxWindow, FONT_MESSAGE, machineMan->text.deleteInstructions[2], 0, 0, machineMan->textDelay, TEXT_COLOR(1, 2, 15), NULL); + ManagedSprite_SetExplicitPalette(machineMan->managedSprites[MANAGED_SPRITE_CURSOR], 2); + machineMan->deleteState++; + break; + case 1: + if (Text_IsPrinterActive(machineMan->printerID)) { + break; + } + + machineMan->deleteState++; + break; + case 2: + if (!(JOY_NEW(PAD_BUTTON_A | PAD_BUTTON_B))) { + break; + } + + Sound_PlayEffect(SEQ_SE_CONFIRM); + RankingsMachine_PrintDeleteInstruction(machineMan); + ManagedSprite_SetExplicitPalette(machineMan->managedSprites[MANAGED_SPRITE_CURSOR], 1); + machineMan->deleteState = 0; + return STATE_HANDLE_DELETE_RANKINGS_INPUT; + } + + return STATE_CANT_DELETE_OWN_RANKING; +} + +static void RankingsMachine_NewRankings(RankingsMachineManager *machineMan, SaveData *saveData) +{ + int recordID, playerID, rankingID, addedOwnPlayerID; + RecordPlayersInfo *playersInfo; + + machineMan->machineRankings = Heap_Alloc(machineMan->heapID, sizeof(MachineRankings) * machineMan->recordsCount); + MI_CpuClear8(machineMan->machineRankings, sizeof(MachineRankings) * machineMan->recordsCount); + machineMan->recordsPlayersInfo[0] = Rankings_GetCurrentPlayerInfo(saveData, machineMan->listID, machineMan->heapID); + + for (recordID = 0; recordID < machineMan->recordsCount; recordID++) { + machineMan->recordsPlayersInfo[recordID + 1] = Rankings_GetConnectedPlayersInfo(machineMan->rankings, (machineMan->mode * 13) + machineMan->firstRecord + recordID, machineMan->heapID); + + playersInfo = machineMan->recordsPlayersInfo[recordID + 1]; + rankingID = 0; + addedOwnPlayerID = FALSE; + + if (playersInfo->count == 0) { + machineMan->machineRankings[recordID].rankingsInfo[0].playerInfo = &(machineMan->recordsPlayersInfo[0]->players[recordID]); + machineMan->machineRankings[recordID].rankingsInfo[0].exists = TRUE; + machineMan->machineRankings[recordID].rankingsInfo[0].playerID = PLAYERID_OWN; + machineMan->machineRankings[recordID].rankingsCount = 1; + } else { + for (playerID = 0; playerID < playersInfo->count; playerID++) { + if (addedOwnPlayerID == FALSE && machineMan->recordsPlayersInfo[0]->players[recordID].recordValue >= playersInfo->players[playerID].recordValue) { + machineMan->machineRankings[recordID].rankingsInfo[rankingID].playerInfo = &(machineMan->recordsPlayersInfo[0]->players[recordID]); + machineMan->machineRankings[recordID].rankingsInfo[rankingID].exists = TRUE; + machineMan->machineRankings[recordID].rankingsInfo[rankingID].playerID = PLAYERID_OWN; + ++rankingID; + machineMan->machineRankings[recordID].rankingsInfo[rankingID].playerInfo = &(playersInfo->players[playerID]); + machineMan->machineRankings[recordID].rankingsInfo[rankingID].exists = TRUE; + machineMan->machineRankings[recordID].rankingsInfo[rankingID].playerID = playerID; + addedOwnPlayerID = TRUE; + } else { + machineMan->machineRankings[recordID].rankingsInfo[rankingID].playerInfo = &(playersInfo->players[playerID]); + machineMan->machineRankings[recordID].rankingsInfo[rankingID].exists = TRUE; + machineMan->machineRankings[recordID].rankingsInfo[rankingID].playerID = playerID; + } + + ++rankingID; + } + + if (!addedOwnPlayerID) { + machineMan->machineRankings[recordID].rankingsInfo[rankingID].playerInfo = &(machineMan->recordsPlayersInfo[0]->players[recordID]); + machineMan->machineRankings[recordID].rankingsInfo[rankingID].exists = TRUE; + machineMan->machineRankings[recordID].rankingsInfo[rankingID].playerID = PLAYERID_OWN; + } + + machineMan->machineRankings[recordID].rankingsCount = playersInfo->count + 1; + } + } +} + +static void RankingsMachine_FreeRankings(RankingsMachineManager *machineMan) +{ + int i; + + for (i = 0; i < machineMan->recordsCount + 1; i++) { + RecordPlayersInfo_Free(machineMan->recordsPlayersInfo[i]); + } + + Heap_Free(machineMan->machineRankings); +} + +static void RankingsMachine_InitStrings(RankingsMachineManager *machineMan) +{ + int i; + + machineMan->text.msgLoader = MessageLoader_Init(MSG_LOADER_PRELOAD_ENTIRE_BANK, NARC_INDEX_MSGDATA__PL_MSG, TEXT_BANK_RANKINGS_MACHINE, machineMan->heapID); + machineMan->text.strTemplate = StringTemplate_New(2, (38 * 2), machineMan->heapID); + machineMan->text.strBuffer = String_Init((38 * 2), machineMan->heapID); + machineMan->text.exit = MessageLoader_GetNewString(machineMan->text.msgLoader, RankingsMachine_Text_Exit); + machineMan->text.whichRecord = MessageLoader_GetNewString(machineMan->text.msgLoader, RankingsMachine_Text_WhichRecordWouldYouLikeToSee); + machineMan->text.deleteRecord = MessageLoader_GetNewString(machineMan->text.msgLoader, RankingsMachine_Text_DeleteRecord); + machineMan->text.recordEntryInfo = MessageLoader_GetNewString(machineMan->text.msgLoader, RankingsMachine_Text_RecordEntryInfo); + + for (i = 0; i < machineMan->recordsCount; i++) { + machineMan->text.titles[i] = MessageLoader_GetNewString(machineMan->text.msgLoader, RankingsMachine_Text_SingleBattlesRecordTitle + machineMan->firstRecord + i); + machineMan->text.explanations[i] = MessageLoader_GetNewString(machineMan->text.msgLoader, RankingsMachine_Text_SingleBattlesRecordExplanation + machineMan->firstRecord + i); + } + + for (i = 0; i < VALUE_STRINGS_COUNT; i++) { + machineMan->text.values[i] = MessageLoader_GetNewString(machineMan->text.msgLoader, RankingsMachine_Text_BattleWinsValue + i); + } + + for (i = 0; i < DELETE_INSTRUCTIONS_STRINGS_COUNT; i++) { + machineMan->text.deleteInstructions[i] = MessageLoader_GetNewString(machineMan->text.msgLoader, RankingsMachine_Text_SelectTheRecordYouWantToDeleteThenPressA + i); + } +} + +static void RankingsMachine_FreeStrings(RankingsMachineManager *machineMan) +{ + int i; + + for (i = 0; i < DELETE_INSTRUCTIONS_STRINGS_COUNT; i++) { + String_Free(machineMan->text.deleteInstructions[i]); + } + + for (i = 0; i < VALUE_STRINGS_COUNT; i++) { + String_Free(machineMan->text.values[i]); + } + + for (i = 0; i < machineMan->recordsCount; i++) { + String_Free(machineMan->text.titles[i]); + String_Free(machineMan->text.explanations[i]); + } + + String_Free(machineMan->text.recordEntryInfo); + String_Free(machineMan->text.deleteRecord); + String_Free(machineMan->text.whichRecord); + String_Free(machineMan->text.exit); + String_Free(machineMan->text.strBuffer); + StringTemplate_Free(machineMan->text.strTemplate); + MessageLoader_Free(machineMan->text.msgLoader); +} + +static void RankingsMachine_InitBg(RankingsMachineManager *machineMan) +{ + Bg_ClearTilesRange(BG_LAYER_MAIN_1, 32 * (24 * (12 + 2) + 9 + 1), 0, machineMan->heapID); + Bg_FillTilemapRect(machineMan->bgConfig, BG_LAYER_MAIN_1, 0, 0, 0, 32, 32, 17); + Bg_ScheduleTilemapTransfer(machineMan->bgConfig, BG_LAYER_MAIN_1); + Bg_ToggleLayer(BG_LAYER_MAIN_1, 1); + + machineMan->bgMain0Priority = Bg_GetPriority(machineMan->bgConfig, BG_LAYER_MAIN_0); + machineMan->bgMain1Priority = Bg_GetPriority(machineMan->bgConfig, BG_LAYER_MAIN_1); + + Bg_SetPriority(BG_LAYER_MAIN_0, 2); + Bg_SetPriority(BG_LAYER_MAIN_1, 1); + LoadMessageBoxGraphics(machineMan->bgConfig, BG_LAYER_MAIN_3, BASE_TILE_SCROLLING_MESSAGE_BOX, 10, machineMan->frame, machineMan->heapID); + LoadStandardWindowGraphics(machineMan->bgConfig, BG_LAYER_MAIN_3, BASE_TILE_STANDARD_WINDOW_FRAME, 11, 0, machineMan->heapID); + LoadStandardWindowGraphics(machineMan->bgConfig, BG_LAYER_MAIN_1, BASE_TILE_STANDARD_WINDOW_FRAME, 11, 0, machineMan->heapID); + Font_LoadTextPalette(0, 13 * PALETTE_SIZE_BYTES, machineMan->heapID); + Font_LoadScreenIndicatorsPalette(0, 12 * PALETTE_SIZE_BYTES, machineMan->heapID); + Window_Add(machineMan->bgConfig, &machineMan->msgBoxWindow, BG_LAYER_MAIN_3, 2, 19, 27, 4, 12, BASE_TILE_STANDARD_WINDOW_FRAME - MESSAGE_WINDOW_TILE_COUNT); + Window_FillTilemap(&machineMan->msgBoxWindow, PIXEL_FILL(15)); +} + +static void RankingsMachine_FreeBg(RankingsMachineManager *machineMan) +{ + Window_EraseMessageBox(&machineMan->msgBoxWindow, 1); + Window_ClearAndCopyToVRAM(&machineMan->msgBoxWindow); + Window_Remove(&machineMan->msgBoxWindow); + Bg_ClearTilesRange(BG_LAYER_MAIN_1, 32 * (24 * (12 + 2) + 9 + 1), 0, machineMan->heapID); + Bg_FillTilemapRect(machineMan->bgConfig, BG_LAYER_MAIN_1, 0, 0, 0, 32, 32, 17); + Bg_ScheduleTilemapTransfer(machineMan->bgConfig, BG_LAYER_MAIN_1); + Bg_ToggleLayer(BG_LAYER_MAIN_1, 0); + Bg_SetPriority(BG_LAYER_MAIN_0, machineMan->bgMain0Priority); + Bg_SetPriority(BG_LAYER_MAIN_1, machineMan->bgMain1Priority); +} + +static void RankingsMachine_InitSprites(RankingsMachineManager *machineMan) +{ + int i; + SpriteResourceCapacities capacities = { + 1, 1, 1, 1, 0, 0 + }; + static const SpriteTemplate spriteTemplates[] = { + { + .x = 126, + .y = 16, + .z = 0, + .animIdx = 0, + .priority = 0, + .plttIdx = 1, + .vramType = NNS_G2D_VRAM_TYPE_2DMAIN, + .resources = { + 0x34D8, + 0x34D8, + 0x34D8, + 0x34D8, + NULL, + NULL, + }, + .bgPriority = 1, + .vramTransfer = FALSE, + }, + { + .x = 74, + .y = 120, + .z = 0, + .animIdx = 1, + .priority = 1, + .plttIdx = 0, + .vramType = NNS_G2D_VRAM_TYPE_2DMAIN, + .resources = { + 0x34D8, + 0x34D8, + 0x34D8, + 0x34D8, + NULL, + NULL, + }, + .bgPriority = 1, + .vramTransfer = FALSE, + }, + }; + + SpriteResourceManager_SetCapacities(&machineMan->spriteManager, &capacities, 2, machineMan->heapID); + + NARC *narc = NARC_ctor(NARC_INDEX_GRAPHIC__RANKING, machineMan->heapID); + + SpriteResourceManager_LoadPalette(&machineMan->spriteManager, narc, 0, 0, 3, NNS_G2D_VRAM_TYPE_2DMAIN, 13528); + SpriteResourceManager_LoadCell(&machineMan->spriteManager, narc, 2, 0, 13528); + SpriteResourceManager_LoadAnimation(&machineMan->spriteManager, narc, 3, 0, 13528); + SpriteResourceManager_LoadTiles(&machineMan->spriteManager, narc, 1, 0, NNS_G2D_VRAM_TYPE_2DMAIN, 13528); + + NARC_dtor(narc); + + for (i = 0; i < 2; i++) { + machineMan->managedSprites[i] = SpriteResourceManager_CreateManagedSprite(&machineMan->spriteManager, &spriteTemplates[i]); + } + + ManagedSprite_SetDrawFlag(machineMan->managedSprites[MANAGED_SPRITE_DELETE_WINDOW], FALSE); +} + +static void RankingsMachine_FreeSprites(RankingsMachineManager *machineMan) +{ + int i; + + for (i = 0; i < 2; i++) { + if (machineMan->managedSprites[i] != NULL) { + Sprite_DeleteAndFreeResources(machineMan->managedSprites[i]); + } + } + + SpriteResourceManager_Cleanup(&machineMan->spriteManager); +} + +static void RankingsMachine_ShowRecordsList(RankingsMachineManager *machineMan, u16 startListPos, u16 startCursorPos) +{ + int i, listEntriesCount; + + listEntriesCount = machineMan->recordsCount + 1; + machineMan->stringList = StringList_New(listEntriesCount, machineMan->heapID); + + Window_Add(machineMan->bgConfig, &machineMan->listWindow, 1, 4, 1, 24, listEntriesCount * 2, 13, 1); + Window_FillTilemap(&machineMan->listWindow, PIXEL_FILL(15)); + + for (i = 0; i < machineMan->recordsCount; i++) { + StringList_AddFromString(machineMan->stringList, machineMan->text.titles[i], i); + } + + StringList_AddFromString(machineMan->stringList, machineMan->text.exit, 0xFFFF); + + MI_CpuCopy8((void *)&sRankingsMachineListMenuTemplate, (void *)&(machineMan->listMenuTemplate), sizeof(ListMenuTemplate)); + + machineMan->listMenuTemplate.window = &(machineMan->listWindow); + machineMan->listMenuTemplate.choices = machineMan->stringList; + machineMan->listMenuTemplate.parent = (void *)machineMan; + machineMan->listMenuTemplate.count = listEntriesCount; + machineMan->listMenuTemplate.yOffset = 0; + machineMan->listMenuTemplate.cursorCallback = RankingsMachine_SetCursorPos; + machineMan->listMenuTemplate.printCallback = NULL; + machineMan->listMenu = ListMenu_New(&(machineMan->listMenuTemplate), startListPos, startCursorPos, machineMan->heapID); + + Window_DrawStandardFrame(&machineMan->listWindow, 0, BASE_TILE_STANDARD_WINDOW_FRAME, 11); + Window_DrawMessageBoxWithScrollCursor(&machineMan->msgBoxWindow, 1, BASE_TILE_SCROLLING_MESSAGE_BOX, 10); + Window_FillTilemap(&machineMan->msgBoxWindow, PIXEL_FILL(15)); + Text_AddPrinterWithParamsAndColor(&machineMan->msgBoxWindow, FONT_MESSAGE, machineMan->text.whichRecord, 0, 0, TEXT_SPEED_INSTANT, TEXT_COLOR(1, 2, 15), NULL); + ManagedSprite_SetDrawFlag(machineMan->managedSprites[MANAGED_SPRITE_CURSOR], TRUE); + Bg_ScheduleTilemapTransfer(machineMan->bgConfig, BG_LAYER_MAIN_3); +} + +static void RankingsMachine_RemoveRecordsList(RankingsMachineManager *machineMan) +{ + ListMenu_Free(machineMan->listMenu, &(machineMan->startListPos), &(machineMan->startCursorPos)); + StringList_Free(machineMan->stringList); + Window_ClearAndCopyToVRAM(&(machineMan->listWindow)); + Window_EraseStandardFrame(&(machineMan->listWindow), 0); + Window_Remove(&(machineMan->listWindow)); + ManagedSprite_SetDrawFlag(machineMan->managedSprites[MANAGED_SPRITE_CURSOR], FALSE); + Bg_ScheduleTilemapTransfer(machineMan->bgConfig, BG_LAYER_MAIN_3); +} + +static void RankingsMachine_SetCursorPos(ListMenu *listMenu, u32 unused, u8 mute) +{ + u16 listPos, cursorPos, count; + RankingsMachineManager *machineMan = (RankingsMachineManager *)ListMenu_GetAttribute(listMenu, LIST_MENU_PARENT); + + if (mute == 0) { + Sound_PlayEffect(SEQ_SE_CONFIRM); + } + + ListMenu_GetListAndCursorPos(listMenu, &listPos, &cursorPos); + count = ListMenu_GetAttribute(listMenu, LIST_MENU_COUNT); + + ManagedSprite_SetPositionXY(machineMan->managedSprites[MANAGED_SPRITE_CURSOR], 126, 16 + 16 * (cursorPos + listPos)); +} + +static void RankingsMachine_PrintDeleteInstruction(RankingsMachineManager *machineMan) +{ + Window_FillTilemap(&machineMan->msgBoxWindow, PIXEL_FILL(15)); + Text_AddPrinterWithParamsAndColor(&machineMan->msgBoxWindow, FONT_MESSAGE, machineMan->text.deleteInstructions[0], 0, 0, TEXT_SPEED_INSTANT, TEXT_COLOR(1, 2, 15), NULL); +} + +static void RankingsMachine_PrepareForDeletingRecord(RankingsMachineManager *machineMan) +{ + RankingsMachine_PrintDeleteInstruction(machineMan); + ManagedSprite_SetPositionXY(machineMan->managedSprites[MANAGED_SPRITE_CURSOR], 126, 16 + machineMan->cursorPos * 16); + ManagedSprite_SetDrawFlag(machineMan->managedSprites[MANAGED_SPRITE_CURSOR], TRUE); +} + +static void RankingsMachine_PrintRecordExplanation(RankingsMachineManager *machineMan) +{ + Window_FillTilemap(&machineMan->msgBoxWindow, PIXEL_FILL(15)); + Text_AddPrinterWithParamsAndColor(&machineMan->msgBoxWindow, FONT_MESSAGE, machineMan->text.explanations[machineMan->selectedRecordID], 0, 0, TEXT_SPEED_INSTANT, TEXT_COLOR(1, 2, 15), NULL); + ManagedSprite_SetDrawFlag(machineMan->managedSprites[MANAGED_SPRITE_CURSOR], FALSE); +} + +static void RankingsMachine_PrintRecordRankings(RankingsMachineManager *machineMan, BOOL showDeleteScreen) +{ + int i, unused, rank, rankingID, recordValue, prevRecordValue; + MachineRankings *machineRankings; + const RecordPrintingData *printingData; + + machineRankings = &(machineMan->machineRankings[machineMan->selectedRecordID]); + printingData = &(sRecordsPrintingData[machineMan->listID][machineMan->selectedRecordID]); + + Window_FillTilemap(&machineMan->listWindow, PIXEL_FILL(15)); + + unused = machineRankings->rankingsCount; + rank = 1; + rankingID = 0; + prevRecordValue = 0; + + for (i = 0; i < machineRankings->rankingsCount; i++) { + if (!machineRankings->rankingsInfo[i].exists) { + continue; + } + + recordValue = machineRankings->rankingsInfo[i].playerInfo->recordValue; + + if (recordValue > printingData->maxScore) { + recordValue = printingData->maxScore; + } + + if (recordValue < prevRecordValue) { + ++rank; + } + + StringTemplate_SetNumber(machineMan->text.strTemplate, 0, rank, 1, PADDING_MODE_SPACES, CHARSET_MODE_EN); + StringTemplate_SetString(machineMan->text.strTemplate, 1, machineRankings->rankingsInfo[i].playerInfo->playerName, 2, 1, GAME_LANGUAGE); + StringTemplate_Format(machineMan->text.strTemplate, machineMan->text.strBuffer, machineMan->text.recordEntryInfo); + Text_AddPrinterWithParamsAndColor(&machineMan->listWindow, FONT_SYSTEM, machineMan->text.strBuffer, 8, rankingID * 16, TEXT_SPEED_NO_TRANSFER, TEXT_COLOR(1, 2, 15), NULL); + StringTemplate_SetNumber(machineMan->text.strTemplate, 0, recordValue, printingData->maxDigits, PADDING_MODE_SPACES, CHARSET_MODE_EN); + StringTemplate_Format(machineMan->text.strTemplate, machineMan->text.strBuffer, machineMan->text.values[printingData->valueString - 15]); + Text_AddPrinterWithParamsAndColor(&machineMan->listWindow, FONT_SYSTEM, machineMan->text.strBuffer, (24 * 8) - Font_CalcStringWidth(FONT_SYSTEM, machineMan->text.strBuffer, 0) - 8, rankingID * 16, TEXT_SPEED_NO_TRANSFER, TEXT_COLOR(1, 2, 15), NULL); + + machineMan->rankingIDs[rankingID] = i; + prevRecordValue = recordValue; + + if (++rankingID >= MAX_RANKINGS_ENTRIES) { + break; + } + } + + Window_CopyToVRAM(&machineMan->listWindow); + + machineMan->lastRankingID = rankingID; + + if (machineMan->cursorPos > 0 && machineMan->cursorPos >= machineMan->lastRankingID) { + machineMan->cursorPos--; + } + + if (showDeleteScreen) { + RankingsMachine_PrepareForDeletingRecord(machineMan); + } else { + RankingsMachine_PrintRecordExplanation(machineMan); + } +} + +static void RankingsMachine_ShowRankingList(RankingsMachineManager *machineMan, u16 cursorPos) +{ + Window_Add(machineMan->bgConfig, &machineMan->listWindow, BG_LAYER_MAIN_1, 4, 1, 24, 12, 13, 1); + Window_DrawStandardFrame(&machineMan->listWindow, 1, BASE_TILE_STANDARD_WINDOW_FRAME, 11); + RankingsMachine_PrintRecordRankings(machineMan, FALSE); + ManagedSprite_SetDrawFlag(machineMan->managedSprites[MANAGED_SPRITE_DELETE_WINDOW], TRUE); + Window_Add(machineMan->bgConfig, &machineMan->rankingsWindow, BG_LAYER_MAIN_3, 8, 14, 8, 2, 13, BASE_TILE_RANKINGS_WINDOW); + Window_FillTilemap(&machineMan->rankingsWindow, PIXEL_FILL(0)); + Text_AddPrinterWithParamsAndColor(&machineMan->rankingsWindow, FONT_SYSTEM, machineMan->text.deleteRecord, 0, 0, TEXT_SPEED_INSTANT, TEXT_COLOR(1, 2, 0), NULL); + Bg_ScheduleTilemapTransfer(machineMan->bgConfig, BG_LAYER_MAIN_3); +} + +static void RankingsMachine_RemoveRankingList(RankingsMachineManager *machineMan) +{ + Window_ClearAndCopyToVRAM(&machineMan->listWindow); + Window_EraseStandardFrame(&machineMan->listWindow, 0); + Window_Remove(&machineMan->listWindow); + Window_ClearAndCopyToVRAM(&machineMan->rankingsWindow); + Window_Remove(&machineMan->rankingsWindow); + ManagedSprite_SetDrawFlag(machineMan->managedSprites[MANAGED_SPRITE_CURSOR], FALSE); + ManagedSprite_SetDrawFlag(machineMan->managedSprites[MANAGED_SPRITE_DELETE_WINDOW], FALSE); +} + +static BOOL RankingsMachine_Show(FieldTask *task) +{ + FieldSystem *fieldSystem = FieldTask_GetFieldSystem(task); + RankingsMachine *rankingsMachine = FieldTask_GetEnv(task); + RankingsMachineManager *machineMan = rankingsMachine->manager; + + switch (rankingsMachine->state) { + case STATE_INIT_MANAGER: + rankingsMachine->state = RankingsMachine_InitManager(rankingsMachine, fieldSystem, rankingsMachine->id); + break; + case STATE_INIT: + rankingsMachine->state = RankingsMachine_Init(rankingsMachine->manager, fieldSystem->saveData); + break; + case STATE_PRINT_RECORD_TITLES: + rankingsMachine->state = RankingsMachine_StateShowRecordsList(rankingsMachine->manager); + SpriteList_Update(rankingsMachine->manager->spriteManager.spriteList); + break; + case STATE_HANDLE_RECORDS_LIST_INPUT: + rankingsMachine->state = RankingsMachine_HandleRecordsListInput(rankingsMachine->manager); + SpriteList_Update(rankingsMachine->manager->spriteManager.spriteList); + break; + case STATE_SHOW_RANKINGS_LIST: + rankingsMachine->state = RankingsMachine_StateShowRankingList(rankingsMachine->manager); + SpriteList_Update(rankingsMachine->manager->spriteManager.spriteList); + break; + case STATE_HANDLE_RANKINGS_LIST_INPUT: + rankingsMachine->state = RankingsMachine_HandleRankingListInput(rankingsMachine->manager); + SpriteList_Update(rankingsMachine->manager->spriteManager.spriteList); + break; + case STATE_HANDLE_DELETE_RANKINGS_INPUT: + rankingsMachine->state = RankingsMachine_HandleDeleteRankingInput(rankingsMachine->manager); + SpriteList_Update(rankingsMachine->manager->spriteManager.spriteList); + break; + case STATE_ASK_DELETE_RANKING: + rankingsMachine->state = RankingsMachine_AskDeleteRanking(rankingsMachine->manager); + SpriteList_Update(rankingsMachine->manager->spriteManager.spriteList); + break; + case STATE_CANT_DELETE_OWN_RANKING: + rankingsMachine->state = RankingsMachine_CantDeleteOwnRanking(machineMan); + SpriteList_Update(rankingsMachine->manager->spriteManager.spriteList); + break; + case STATE_UNUSED: + if (!(JOY_NEW(PAD_BUTTON_A))) { + return FALSE; + } + + rankingsMachine->state = STATE_FREE; + break; + case STATE_FREE: + rankingsMachine->state = RankingsMachine_Free(rankingsMachine->manager); + break; + case STATE_FREE_MANAGER: + rankingsMachine->state = RankingsMachine_FreeManager(rankingsMachine); + break; + case STATE_FREE_MACHINE: + Heap_Free(rankingsMachine); + return TRUE; + } + + return FALSE; +} + +void RankingsMachine_InitFieldTask(FieldTask *task, u16 machineID) +{ + FieldSystem *fieldSystem = FieldTask_GetFieldSystem(task); + RankingsMachine *rankingsMachine = Heap_Alloc(HEAP_ID_FIELD2, sizeof(RankingsMachine)); + + rankingsMachine->state = STATE_INIT_MANAGER; + rankingsMachine->id = machineID; + rankingsMachine->manager = NULL; + + FieldTask_InitCall(fieldSystem->task, RankingsMachine_Show, rankingsMachine); +} diff --git a/src/savedata/save_table.c b/src/savedata/save_table.c index 9f22533cff..400e1094da 100644 --- a/src/savedata/save_table.c +++ b/src/savedata/save_table.c @@ -21,6 +21,7 @@ #include "poffin.h" #include "pokedex.h" #include "poketch.h" +#include "rankings.h" #include "record_mixed_rng.h" #include "save_player.h" #include "savedata.h" @@ -36,7 +37,6 @@ #include "unk_0202C9F4.h" #include "unk_0202D778.h" #include "unk_0202E2CC.h" -#include "unk_0202E840.h" #include "unk_0202EEC0.h" #include "unk_0202F1D4.h" #include "unk_0203061C.h" diff --git a/src/scrcmd.c b/src/scrcmd.c index b1f975fe10..f282bddd60 100644 --- a/src/scrcmd.c +++ b/src/scrcmd.c @@ -136,6 +136,7 @@ #include "pokemon.h" #include "pokeradar.h" #include "poketch.h" +#include "rankings_machine.h" #include "render_window.h" #include "roaming_pokemon.h" #include "rtc.h" @@ -209,7 +210,6 @@ #include "unk_020655F4.h" #include "unk_02069BE0.h" #include "unk_0206C660.h" -#include "unk_0206F314.h" #include "unk_02070428.h" #include "unk_020722AC.h" #include "unk_0207DA28.h" @@ -549,7 +549,7 @@ static BOOL ScrCmd_ShowObject(ScriptContext *ctx); static BOOL ScrCmd_HideObject(ScriptContext *ctx); static BOOL ScrCmd_1B3(ScriptContext *ctx); static BOOL ScrCmd_1B4(ScriptContext *ctx); -static BOOL ScrCmd_1B5(ScriptContext *ctx); +static BOOL ScrCmd_StartRankingsMachine(ScriptContext *ctx); static BOOL ScrCmd_GetTimeOfDay(ScriptContext *ctx); static BOOL ScrCmd_GetRandom(ScriptContext *ctx); static BOOL ScrCmd_GetRandom2(ScriptContext *ctx); @@ -1202,7 +1202,7 @@ const ScrCmdFunc Unk_020EAC58[] = { ScrCmd_HideObject, ScrCmd_1B3, ScrCmd_1B4, - ScrCmd_1B5, + ScrCmd_StartRankingsMachine, ScrCmd_GetTimeOfDay, ScrCmd_GetRandom, ScrCmd_GetRandom2, @@ -5767,11 +5767,11 @@ static BOOL ScrCmd_1B4(ScriptContext *ctx) return FALSE; } -static BOOL ScrCmd_1B5(ScriptContext *ctx) +static BOOL ScrCmd_StartRankingsMachine(ScriptContext *ctx) { - u16 listIndex = ScriptContext_GetVar(ctx); + u16 machineID = ScriptContext_GetVar(ctx); - sub_020703FC(ctx->task, listIndex); + RankingsMachine_InitFieldTask(ctx->task, machineID); return TRUE; } diff --git a/src/trainer_card.c b/src/trainer_card.c index e8b9677311..bb186f724c 100644 --- a/src/trainer_card.c +++ b/src/trainer_card.c @@ -67,7 +67,7 @@ void TrainerCard_Init(u8 badgesInteractable, u8 liveTimeDisplay, u8 gymLeadersTo TrainerCard_SetDates(SystemFlag_CheckGameCompleted(SaveData_GetVarsFlags(fieldSystem->saveData)), playTime, &adventureStartedDate, &firstCompletionDate, &firstCompletionTime, liveTimeDisplay, trainerCard); TrainerCardSaveData *tcSaveData = SaveData_GetTrainerCardSaveData(fieldSystem->saveData); - u32 timesLinked = GameRecords_GetRecordValue(gameRecords, RECORD_UNK_091) + GameRecords_GetRecordValue(gameRecords, RECORD_LOCAL_LINK_TRADES) + GameRecords_GetRecordValue(gameRecords, RECORD_WIFI_TRADES) + GameRecords_GetRecordValue(gameRecords, RECORD_UNK_020) + GameRecords_GetRecordValue(gameRecords, RECORD_UNK_025) + GameRecords_GetRecordValue(gameRecords, RECORD_UNK_032); + u32 timesLinked = GameRecords_GetRecordValue(gameRecords, RECORD_LINK_CONTEST_PARTICIPATIONS) + GameRecords_GetRecordValue(gameRecords, RECORD_LOCAL_LINK_TRADES) + GameRecords_GetRecordValue(gameRecords, RECORD_WIFI_TRADES) + GameRecords_GetRecordValue(gameRecords, RECORD_UNK_020) + GameRecords_GetRecordValue(gameRecords, RECORD_UNK_025) + GameRecords_GetRecordValue(gameRecords, RECORD_UNK_032); u32 linkBattleWins = GameRecords_GetRecordValue(gameRecords, RECORD_LOCAL_LINK_BATTLE_WINS) + GameRecords_GetRecordValue(gameRecords, RECORD_WIFI_BATTLE_WINS); u32 linkBattleLosses = GameRecords_GetRecordValue(gameRecords, RECORD_LOCAL_LINK_BATTLE_LOSSES) + GameRecords_GetRecordValue(gameRecords, RECORD_WIFI_BATTLE_LOSSES); u32 linkTrades = GameRecords_GetRecordValue(gameRecords, RECORD_LOCAL_LINK_TRADES) + GameRecords_GetRecordValue(gameRecords, RECORD_WIFI_TRADES); diff --git a/src/unk_0202E840.c b/src/unk_0202E840.c deleted file mode 100644 index 06392b759a..0000000000 --- a/src/unk_0202E840.c +++ /dev/null @@ -1,452 +0,0 @@ -#include "unk_0202E840.h" - -#include -#include - -#include "generated/game_records.h" - -#include "struct_defs/battle_frontier.h" -#include "struct_defs/struct_0202E858.h" -#include "struct_defs/struct_0202E8C0.h" -#include "struct_defs/struct_0202E91C.h" -#include "struct_defs/struct_0202EA80.h" -#include "struct_defs/struct_0202EE10.h" - -#include "charcode_util.h" -#include "game_records.h" -#include "heap.h" -#include "record_mixed_rng.h" -#include "save_player.h" -#include "savedata.h" -#include "string_gf.h" -#include "trainer_info.h" -#include "unk_0203061C.h" - -typedef struct { - int unk_00; - int unk_04; - int unk_08; - UnkStruct_0202E858 *unk_0C[11]; - UnkStruct_0202E858 *unk_38[6]; - UnkStruct_0202EA80 unk_50; -} UnkStruct_0202EABC; - -static const u8 Unk_020E5CD0[][2] = { - { 0x6, 0x0 }, - { 0x4, 0x6 }, - { 0x3, 0xA } -}; - -u8 sub_0202E840(int param0) -{ - return Unk_020E5CD0[param0][0]; -} - -u8 sub_0202E84C(int param0) -{ - return Unk_020E5CD0[param0][1]; -} - -void sub_0202E858(UnkStruct_0202E858 *param0) -{ - param0->unk_00 = 0; - param0->unk_04 = 0; - - CharCode_FillWithEOS(param0->unk_08, 7 + 1); - SaveData_SetChecksum(SAVE_TABLE_ENTRY_RANKINGS); -} - -BOOL sub_0202E870(UnkStruct_0202E858 *param0) -{ - if (CharCode_Length(param0->unk_08) == 0) { - return 0; - } - - return 1; -} - -int Rankings_SaveSize(void) -{ - return sizeof(UnkStruct_0202E8C0); -} - -void Rankings_Init(UnkStruct_0202E8C0 *param0) -{ - int v0, v1; - - MI_CpuClear8(param0, sizeof(UnkStruct_0202E8C0)); - - for (v0 = 0; v0 < (13 * 2); v0++) { - for (v1 = 0; v1 < 6; v1++) { - sub_0202E858(&(param0->unk_00[v0].unk_00[v1])); - } - } - - SaveData_SetChecksum(SAVE_TABLE_ENTRY_RANKINGS); -} - -UnkStruct_0202E8C0 *sub_0202E8C0(SaveData *saveData) -{ - SaveData_Checksum(SAVE_TABLE_ENTRY_RANKINGS); - return SaveData_SaveTable(saveData, SAVE_TABLE_ENTRY_RANKINGS); -} - -void sub_0202E8D4(UnkStruct_0202E8C0 *param0, int param1, u8 param2) -{ - int v0; - UnkStruct_0202EA80 *v1; - - if (param2 >= 6) { - GF_ASSERT(param2 < 6); - return; - } - - v1 = &(param0->unk_00[param1]); - - for (v0 = param2; v0 < (6 - 1); v0++) { - v1->unk_00[v0] = v1->unk_00[v0 + 1]; - } - - sub_0202E858(&(v1->unk_00[6 - 1])); - SaveData_SetChecksum(SAVE_TABLE_ENTRY_RANKINGS); -} - -int sub_0202E91C(void) -{ - return sizeof(UnkStruct_0202E91C); -} - -static u32 *sub_0202E924(SaveData *saveData, enum HeapID heapID) -{ - int v0; - u32 v1; - GameRecords *v2; - BattleFrontier *frontier; - u32 *v4; - static const int v5[] = { - 0x0, - 0x2, - 0x4, - 0x6, - 0x8, - 0x1D, - 0x29, - 0x9, - 0xB, - 0xA, - 0x5C, - 0x5A, - 0x5E - }; - - v2 = SaveData_GetGameRecords(saveData); - frontier = SaveData_GetBattleFrontier(saveData); - v4 = Heap_AllocAtEnd(heapID, 4 * 13); - - for (v0 = 0; v0 < 13; v0++) { - switch (v0) { - case 5: - v1 = GameRecords_GetRecordValue(v2, RECORD_UNK_015); - - if (v1 > 0) { - v1 = GameRecords_GetRecordValue(v2, RECORD_UNK_029) / v1; - } - - v4[v0] = v1; - break; - case 10: - v1 = GameRecords_GetRecordValue(v2, RECORD_SUPER_CONTEST_WINS); - v1 += GameRecords_GetRecordValue(v2, RECORD_LINK_CONTEST_WINS); - v4[v0] = v1; - break; - case 11: - v1 = GameRecords_GetRecordValue(v2, RECORD_UNK_090); - v1 += GameRecords_GetRecordValue(v2, RECORD_UNK_091); - - if (v1 > 0) { - v1 = (v4[10] * 100) / v1; - } - - v4[v0] = v1; - break; - default: - if ((v0 >= 0) && (v0 <= 4)) { - v4[v0] = sub_02030698(frontier, v5[v0], 0xff); - } else { - v4[v0] = GameRecords_GetRecordValue(v2, v5[v0]); - } - } - } - - SaveData_SetChecksum(SAVE_TABLE_ENTRY_RANKINGS); - - return v4; -} - -void *sub_0202E9FC(SaveData *saveData, enum HeapID heapID) -{ - int v0; - u32 v1, v2; - UnkStruct_0202E91C *v3; - String *v4; - TrainerInfo *v5 = SaveData_GetTrainerInfo(saveData); - u32 *v6; - - v3 = Heap_AllocAtEnd(heapID, sizeof(UnkStruct_0202E91C)); - MI_CpuClear8(v3, sizeof(UnkStruct_0202E91C)); - - v1 = RecordMixedRNG_GetEntrySeed(SaveData_GetRecordMixedRNG(saveData), 1); - v4 = TrainerInfo_NameNewString(v5, heapID); - v6 = sub_0202E924(saveData, heapID); - - for (v0 = 0; v0 < 13; v0++) { - v2 = 0; - - v3->unk_00[v0].unk_00 = v1; - String_ToChars(v4, v3->unk_00[v0].unk_08, 7 + 1); - v3->unk_00[v0].unk_04 = v6[v0]; - } - - Heap_Free(v6); - String_Free(v4); - SaveData_SetChecksum(SAVE_TABLE_ENTRY_RANKINGS); - - return v3; -} - -static void sub_0202EA80(UnkStruct_0202EA80 *param0) -{ - int v0; - - for (v0 = 0; v0 < 6; v0++) { - sub_0202E858(&(param0->unk_00[v0])); - } -} - -static BOOL sub_0202EA98(const UnkStruct_0202E858 *param0, const UnkStruct_0202E858 *param1) -{ - if (param0->unk_00 != param1->unk_00) { - return 0; - } - - if (CharCode_Compare(param0->unk_08, param1->unk_08)) { - return 0; - } - - return 1; -} - -static BOOL sub_0202EABC(UnkStruct_0202EABC *param0, const UnkStruct_0202E858 *param1) -{ - int v0; - - for (v0 = 0; v0 < param0->unk_04; v0++) { - if (sub_0202EA98(param0->unk_0C[v0], param1)) { - return 1; - } - } - - return 0; -} - -static void sub_0202EAEC(UnkStruct_0202E8C0 *param0, UnkStruct_0202EABC *param1, u32 param2, u8 param3, u8 param4, UnkStruct_0202E91C **param5, u8 param6, enum HeapID heapID) -{ - int v0, v1; - UnkStruct_0202E858 *v2; - UnkStruct_0202EA80 *v3; - - MI_CpuClear8(param1, sizeof(UnkStruct_0202EABC)); - - if (param4 == 0) { - v3 = &(param0->unk_00[param3]); - - MI_CpuCopy8(v3, &(param1->unk_50), sizeof(UnkStruct_0202EA80)); - - for (v0 = 0; v0 < param6; v0++) { - param1->unk_0C[param1->unk_04++] = &(param5[v0]->unk_00[param3]); - } - - for (v0 = 0; v0 < 6; v0++) { - if (!sub_0202E870(&(param1->unk_50.unk_00[v0]))) { - continue; - } - - if (sub_0202EABC(param1, &(param1->unk_50.unk_00[v0]))) { - continue; - } - - param1->unk_38[param1->unk_00++] = &(param1->unk_50.unk_00[v0]); - } - } else { - v3 = &(param0->unk_00[param3 + 13]); - MI_CpuCopy8(v3, &(param1->unk_50), sizeof(UnkStruct_0202EA80)); - - for (v0 = 0; v0 < param6; v0++) { - if ((param5[v0]->unk_00[param3].unk_00 == 0) || (param5[v0]->unk_00[param3].unk_00 != param2)) { - continue; - } - - param1->unk_0C[param1->unk_04++] = &(param5[v0]->unk_00[param3]); - } - - for (v0 = 0; v0 < 6; v0++) { - if (!sub_0202E870(&(param1->unk_50.unk_00[v0]))) { - continue; - } - - if (param1->unk_50.unk_00[v0].unk_00 != param2) { - continue; - } - - if (sub_0202EABC(param1, &(param1->unk_50.unk_00[v0]))) { - continue; - } - - param1->unk_38[param1->unk_00++] = &(param1->unk_50.unk_00[v0]); - } - } - - param1->unk_08 = param1->unk_04 + param1->unk_00; - - for (v0 = 0; v0 < param1->unk_00; v0++) { - param1->unk_0C[v0 + param1->unk_04] = param1->unk_38[v0]; - } - - for (v0 = 0; v0 < (param1->unk_08 - 1); v0++) { - for (v1 = (param1->unk_08 - 1); v1 > v0; v1--) { - if (param1->unk_0C[v0]->unk_04 >= param1->unk_0C[v1]->unk_04) { - continue; - } - - v2 = param1->unk_0C[v0]; - - param1->unk_0C[v0] = param1->unk_0C[v1]; - param1->unk_0C[v1] = v2; - } - } - - sub_0202EA80(v3); - - for (v0 = 0; (v0 < 6 && v0 < param1->unk_08); v0++) { - v3->unk_00[v0] = *(param1->unk_0C[v0]); - } -} - -static void sub_0202ECB0(UnkStruct_0202E8C0 *param0, u32 param1, u8 param2, UnkStruct_0202E91C **param3, u8 param4, enum HeapID heapID) -{ - int v0, v1; - UnkStruct_0202EABC *v2 = Heap_AllocAtEnd(heapID, sizeof(UnkStruct_0202EABC)); - - sub_0202EAEC(param0, v2, param1, param2, 0, param3, param4, heapID); - - if (param1 != 0) { - sub_0202EAEC(param0, v2, param1, param2, 1, param3, param4, heapID); - } - - Heap_Free(v2); -} - -void sub_0202ED0C(SaveData *saveData, int param1, u8 param2, const void **param3, enum HeapID heapID) -{ - u8 v0, v1; - u32 v2; - UnkStruct_0202E91C *v3[5]; - UnkStruct_0202E8C0 *v4; - UnkStruct_0202EE10 *v5; - - v4 = sub_0202E8C0(saveData); - v2 = RecordMixedRNG_GetEntrySeed(SaveData_GetRecordMixedRNG(saveData), 1); - v1 = 0; - - for (v0 = 0; v0 < param2; v0++) { - if (v0 == param1) { - continue; - } - - if (param3[v0] == NULL) { - continue; - } - - v3[v1++] = (UnkStruct_0202E91C *)param3[v0]; - } - - if (v1 == 0) { - return; - } - - for (v0 = 0; v0 < 13; v0++) { - sub_0202ECB0(v4, v2, v0, v3, v1, heapID); - } - - SaveData_SetChecksum(SAVE_TABLE_ENTRY_RANKINGS); - - return; -} - -UnkStruct_0202EE10 *sub_0202ED8C(SaveData *saveData, int param1, enum HeapID heapID) -{ - int v0, v1; - u32 v2; - UnkStruct_0202EE10 *v3; - u32 *v4; - TrainerInfo *v5 = SaveData_GetTrainerInfo(saveData); - v3 = Heap_Alloc(heapID, sizeof(UnkStruct_0202EE10)); - - MI_CpuClear8(v3, sizeof(UnkStruct_0202EE10)); - - v2 = RecordMixedRNG_GetEntrySeed(SaveData_GetRecordMixedRNG(saveData), 1); - v4 = sub_0202E924(saveData, heapID); - v3->unk_00 = sub_0202E840(param1); - v1 = sub_0202E84C(param1); - - for (v0 = 0; v0 < v3->unk_00; v0++) { - v3->unk_04[v0].unk_00 = v2; - v3->unk_04[v0].unk_04 = v4[v0 + v1]; - v3->unk_04[v0].unk_08 = TrainerInfo_NameNewString(v5, heapID); - } - - Heap_Free(v4); - return v3; -} - -UnkStruct_0202EE10 *sub_0202EE10(UnkStruct_0202E8C0 *param0, int param1, enum HeapID heapID) -{ - int v0; - UnkStruct_0202EE10 *v1; - UnkStruct_0202EA80 *v2; - - v1 = Heap_Alloc(heapID, sizeof(UnkStruct_0202EE10)); - MI_CpuClear8(v1, sizeof(UnkStruct_0202EE10)); - v2 = &(param0->unk_00[param1]); - - for (v0 = 0; v0 < 6; v0++) { - if (!sub_0202E870(&(v2->unk_00[v0]))) { - continue; - } - - v1->unk_04[v1->unk_00].unk_00 = v2->unk_00[v0].unk_00; - v1->unk_04[v1->unk_00].unk_04 = v2->unk_00[v0].unk_04; - v1->unk_04[v1->unk_00].unk_08 = String_Init(7 + 1, heapID); - String_CopyChars(v1->unk_04[v1->unk_00].unk_08, v2->unk_00[v0].unk_08); - ++v1->unk_00; - } - - return v1; -} - -void sub_0202EE8C(UnkStruct_0202EE10 *param0) -{ - int v0; - - for (v0 = 0; v0 < 6; v0++) { - if (param0->unk_04[v0].unk_08 != NULL) { - String_Free(param0->unk_04[v0].unk_08); - } - } - - MI_CpuClear8(param0, sizeof(UnkStruct_0202EE10)); - - Heap_Free(param0); - param0 = NULL; - SaveData_SetChecksum(SAVE_TABLE_ENTRY_RANKINGS); -} diff --git a/src/unk_02049D08.c b/src/unk_02049D08.c index 5c019cf863..faac8cca82 100644 --- a/src/unk_02049D08.c +++ b/src/unk_02049D08.c @@ -393,7 +393,7 @@ BattleTower *BattleTower_Init(SaveData *saveData, u16 param1, u16 challengeMode) battleTower->roomNum = sub_0202D3B4(battleTower->unk_74, battleTower->challengeMode, 0); } - battleTower->unk_20 = GameRecords_GetRecordValue(v5, RECORD_UNK_029); + battleTower->unk_20 = GameRecords_GetRecordValue(v5, RECORD_BATTLE_TOWER_VICTORIES); } if (battleTower->challengeMode == BATTLE_TOWER_MODE_6) { @@ -626,11 +626,11 @@ void BattleTower_UpdateGameRecords(BattleTower *battleTower, SaveData *saveData) sub_0202D414(battleTower->unk_74, 8 + battleTower->challengeMode, 2); } - GameRecords_AddToRecordValue(v5, RECORD_UNK_029, battleTower->unk_0D); + GameRecords_AddToRecordValue(v5, RECORD_BATTLE_TOWER_VICTORIES, battleTower->unk_0D); sub_0202D3B4(battleTower->unk_74, battleTower->challengeMode, 2); if (battleTower->challengeMode != BATTLE_TOWER_MODE_6) { - GameRecords_AddToRecordValue(SaveData_GetGameRecords(saveData), RECORD_UNK_015, 1); + GameRecords_AddToRecordValue(SaveData_GetGameRecords(saveData), RECORD_BATTLE_TOWER_CHALLENGES, 1); } sub_0204ACC8(battleTower); @@ -683,11 +683,11 @@ void BattleTower_UpdateGameRecordsAndJournal(BattleTower *battleTower, SaveData v3 = sub_02030698(frontier, v1, sub_0205E6A8(v1)); v4 = sub_02030848(frontier, v1, sub_0205E6A8(v1), v0); - GameRecords_AddToRecordValue(v6, RECORD_UNK_029, 7); + GameRecords_AddToRecordValue(v6, RECORD_BATTLE_TOWER_VICTORIES, 7); sub_0202D3B4(battleTower->unk_74, battleTower->challengeMode, 3); if (battleTower->challengeMode != BATTLE_TOWER_MODE_6) { - GameRecords_AddToRecordValue(v6, RECORD_UNK_015, 1); + GameRecords_AddToRecordValue(v6, RECORD_BATTLE_TOWER_CHALLENGES, 1); } GameRecords_IncrementTrainerScore(v6, TRAINER_SCORE_EVENT_UNK_14); diff --git a/src/unk_0206F314.c b/src/unk_0206F314.c deleted file mode 100644 index 73fa01811c..0000000000 --- a/src/unk_0206F314.c +++ /dev/null @@ -1,909 +0,0 @@ -#include "unk_0206F314.h" - -#include -#include - -#include "struct_decls/struct_0202E8C0_decl.h" -#include "struct_defs/struct_0202EE10.h" -#include "struct_defs/struct_0202EE10_sub1.h" - -#include "field/field_system.h" -#include "overlay005/sprite_resource_manager.h" - -#include "bg_window.h" -#include "field_task.h" -#include "font.h" -#include "game_options.h" -#include "heap.h" -#include "list_menu.h" -#include "menu.h" -#include "message.h" -#include "narc.h" -#include "render_window.h" -#include "save_player.h" -#include "savedata.h" -#include "sound_playback.h" -#include "sprite.h" -#include "sprite_system.h" -#include "string_gf.h" -#include "string_list.h" -#include "string_template.h" -#include "system.h" -#include "text.h" -#include "unk_0202E840.h" - -typedef struct { - MessageLoader *unk_00; - StringTemplate *unk_04; - String *unk_08; - String *unk_0C; - String *unk_10; - String *unk_14; - String *unk_18; - String *unk_1C[7]; - String *unk_38[6]; - String *unk_50[6]; - String *unk_68[3]; -} UnkStruct_0206F7F8_sub1; - -typedef struct { - UnkStruct_0202EE10_sub1 *unk_00; - u16 unk_04; - u8 unk_06; -} UnkStruct_0206F3A0; - -typedef struct { - int unk_00; - UnkStruct_0206F3A0 unk_04[7]; -} UnkStruct_02070050; - -typedef struct { - u32 unk_00; - u16 unk_04; - u16 unk_06; -} UnkStruct_020F02D0; - -typedef struct { - enum HeapID heapID; - int *unk_04; - int unk_08; - int unk_0C; - u16 unk_10; - u16 unk_12; - u16 unk_14; - u8 unk_16; - u8 unk_17; - u8 unk_18; - u8 unk_19; - u16 unk_1A; - u16 unk_1C; - u8 unk_1E; - u8 unk_1F; - u8 unk_20; - u8 unk_21; - u16 unk_22; - u16 unk_24; - u16 unk_26; - u16 unk_28; - UnkStruct_0206F7F8_sub1 unk_2C; - ListMenuTemplate unk_A0; - ListMenu *unk_C0; - StringList *unk_C4; - Menu *unk_C8; - FieldSystem *fieldSystem; - BgConfig *unk_D0; - Window unk_D4; - Window unk_E4; - Window unk_F4; - Window unk_104[3]; - SpriteResourceManager spriteManager; - ManagedSprite *unk_2FC[2]; - UnkStruct_0202E8C0 *unk_304; - UnkStruct_0202EE10 *unk_308[7]; - UnkStruct_02070050 *unk_324; - UnkStruct_0206F3A0 *unk_328; - u8 unk_32C[6]; -} UnkStruct_0206F7F8; - -typedef struct { - int unk_00; - u16 unk_04; - UnkStruct_0206F7F8 *unk_08; -} UnkStruct_0206F314; - -static void sub_0206F7F8(UnkStruct_0206F7F8 *param0, SaveData *saveData); -static void sub_0206F9D4(UnkStruct_0206F7F8 *param0); -static void sub_0206FA08(UnkStruct_0206F7F8 *param0); -static void sub_0206FAC0(UnkStruct_0206F7F8 *param0); -static void sub_0206FB38(UnkStruct_0206F7F8 *param0); -static void sub_0206FC4C(UnkStruct_0206F7F8 *param0); -static void sub_0206FCC4(UnkStruct_0206F7F8 *param0); -static void sub_0206FD94(UnkStruct_0206F7F8 *param0); -static void sub_0206FDC0(UnkStruct_0206F7F8 *param0, u16 param1, u16 param2); -static void sub_0206FF10(UnkStruct_0206F7F8 *param0); -static void sub_0206FF60(ListMenu *param0, u32 param1, u8 param2); -static void sub_0206FFB4(UnkStruct_0206F7F8 *param0); -static void sub_0206FFE4(UnkStruct_0206F7F8 *param0); -static void sub_02070010(UnkStruct_0206F7F8 *param0); -static void sub_02070050(UnkStruct_0206F7F8 *param0, BOOL param1); -static void sub_020701DC(UnkStruct_0206F7F8 *param0, u16 param1); -static void sub_02070288(UnkStruct_0206F7F8 *param0); - -static const ListMenuTemplate Unk_020F02B0 = { - NULL, - NULL, - NULL, - NULL, - 0x0, - 0x7, - 0x2, - 0x8, - 0x1, - 0x0, - 0x1, - 0xF, - 0x2, - 0x0, - 0x0, - 0x1, - 0x0, - 0x1, - NULL -}; - -static const UnkStruct_020F02D0 Unk_020F02D0[] = { - { 0x270F, 0x4, 0xF }, - { 0x270F, 0x4, 0xF }, - { 0x270F, 0x4, 0xF }, - { 0x270F, 0x4, 0xF }, - { 0x270F, 0x4, 0xF }, - { 0x7, 0x1, 0x10 } -}; - -static const UnkStruct_020F02D0 Unk_020F0290[] = { - { 0xF423F, 0x6, 0x13 }, - { 0xF423F, 0x6, 0x13 }, - { 0xF423F, 0x6, 0x12 }, - { 0xF423F, 0x6, 0x13 } -}; - -static const UnkStruct_020F02D0 Unk_020F0278[] = { - { 0x270F, 0x4, 0x15 }, - { 0x64, 0x4, 0x14 }, - { 0xFFFF, 0x5, 0x11 } -}; - -static const UnkStruct_020F02D0 *const Unk_020F0254[] = { - Unk_020F02D0, - Unk_020F0290, - Unk_020F0278 -}; - -static int sub_0206F314(UnkStruct_0206F314 *param0, FieldSystem *fieldSystem, u16 param2) -{ - UnkStruct_0206F7F8 *v0; - SaveData *saveData = fieldSystem->saveData; - - Heap_Create(HEAP_ID_APPLICATION, HEAP_ID_80, 0x6000); - - v0 = Heap_Alloc(HEAP_ID_80, sizeof(UnkStruct_0206F7F8)); - MI_CpuClear8(v0, sizeof(UnkStruct_0206F7F8)); - - v0->heapID = HEAP_ID_80; - v0->unk_16 = param2 % 3; - v0->unk_17 = param2 / 3; - v0->unk_18 = sub_0202E840(v0->unk_16); - v0->unk_19 = sub_0202E84C(v0->unk_16); - v0->fieldSystem = fieldSystem; - v0->unk_D0 = fieldSystem->bgConfig; - v0->unk_304 = sub_0202E8C0(saveData); - v0->unk_1A = Options_TextFrameDelay(SaveData_GetOptions(saveData)); - v0->unk_1C = Options_Frame(SaveData_GetOptions(saveData)); - - param0->unk_08 = v0; - - return 1; -} - -static int sub_0206F3A0(UnkStruct_0206F314 *param0) -{ - int v0, v1, v2, heapID; - UnkStruct_0206F3A0 *v4; - UnkStruct_0206F7F8 *v5 = param0->unk_08; - - for (v0 = 0; v0 < v5->unk_18; v0++) { - v2 = 0; - - for (v1 = 0; v1 < v5->unk_324[v0].unk_00; v1++) { - v4 = &(v5->unk_324[v0].unk_04[v1]); - - if ((v4->unk_06 == 0xFF) || v4->unk_04) { - continue; - } - - sub_0202E8D4(v5->unk_304, (v5->unk_17 * 13) + v5->unk_19 + v0, v4->unk_06 - v2); - ++v2; - } - } - - heapID = v5->heapID; - - Heap_Free(v5); - MI_CpuClear8(v5, sizeof(UnkStruct_0206F7F8)); - Heap_Destroy(heapID); - - return 12; -} - -static int sub_0206F448(UnkStruct_0206F7F8 *param0, SaveData *saveData) -{ - sub_0206F7F8(param0, saveData); - sub_0206FA08(param0); - sub_0206FB38(param0); - sub_0206FCC4(param0); - - return 2; -} - -static int sub_0206F468(UnkStruct_0206F7F8 *param0) -{ - sub_0206FD94(param0); - sub_0206FC4C(param0); - sub_0206FAC0(param0); - sub_0206F9D4(param0); - - return 11; -} - -static int sub_0206F488(UnkStruct_0206F7F8 *param0) -{ - sub_0206FDC0(param0, param0->unk_22, param0->unk_24); - return 3; -} - -static int sub_0206F498(UnkStruct_0206F7F8 *param0) -{ - s32 v0 = ListMenu_ProcessInput(param0->unk_C0); - - if (gSystem.pressedKeys & PAD_BUTTON_B) { - Sound_PlayEffect(SEQ_SE_CONFIRM); - sub_0206FF10(param0); - return 10; - } - - if (!(gSystem.pressedKeys & PAD_BUTTON_A)) { - return 3; - } - - Sound_PlayEffect(SEQ_SE_CONFIRM); - - switch (v0) { - case 0xffffffff: - case 0xfffffffe: - case 0xFFFF: - sub_0206FF10(param0); - return 10; - default: - param0->unk_1F = v0; - param0->unk_28 = 0; - sub_0206FF10(param0); - return 4; - } - - return 3; -} - -static int sub_0206F508(UnkStruct_0206F7F8 *param0) -{ - sub_020701DC(param0, param0->unk_28); - return 5; -} - -static int sub_0206F514(UnkStruct_0206F7F8 *param0) -{ - if (gSystem.pressedKeys & (PAD_BUTTON_B | PAD_BUTTON_A)) { - Sound_PlayEffect(SEQ_SE_CONFIRM); - sub_02070288(param0); - return 2; - } - - if (gSystem.pressedKeys & PAD_BUTTON_SELECT) { - Sound_PlayEffect(SEQ_SE_CONFIRM); - sub_0206FFE4(param0); - return 6; - } - - return 5; -} - -static int sub_0206F554(UnkStruct_0206F7F8 *param0) -{ - UnkStruct_0206F3A0 *v0; - - if (gSystem.pressedKeys & (PAD_BUTTON_B)) { - Sound_PlayEffect(SEQ_SE_CONFIRM); - sub_02070010(param0); - return 5; - } - - if (gSystem.pressedKeys & PAD_BUTTON_A) { - Sound_PlayEffect(SEQ_SE_CONFIRM); - param0->unk_0C = 0; - param0->unk_328 = &(param0->unk_324[param0->unk_1F].unk_04[param0->unk_32C[param0->unk_28]]); - - if (param0->unk_328->unk_06 == 0xFF) { - return 8; - } - - return 7; - } - - if (gSystem.pressedKeys & PAD_KEY_UP) { - if (param0->unk_28 > 0) { - Sound_PlayEffect(SEQ_SE_CONFIRM); - --param0->unk_28; - ManagedSprite_SetPositionXY(param0->unk_2FC[0], 126, 16 + 16 * param0->unk_28); - } - } - - if (gSystem.pressedKeys & PAD_KEY_DOWN) { - if (param0->unk_28 < (param0->unk_21 - 1)) { - Sound_PlayEffect(SEQ_SE_CONFIRM); - ++param0->unk_28; - ManagedSprite_SetPositionXY(param0->unk_2FC[0], 126, 16 + 16 * param0->unk_28); - } - } - - return 6; -} - -static void sub_0206F62C(UnkStruct_0206F7F8 *param0) -{ - static const WindowTemplate v0 = { - 0x3, - 0x19, - 0xD, - 0x6, - 0x4, - 0xD, - 0x355 - }; - - param0->unk_C8 = Menu_MakeYesNoChoice(param0->unk_D0, &v0, (1024 - (18 + 12) - 9), 11, param0->heapID); -} - -static int sub_0206F658(UnkStruct_0206F7F8 *param0) -{ - int v0 = 0; - - switch (param0->unk_0C) { - case 0: - Window_FillTilemap(¶m0->unk_E4, ((15 << 4) | 15)); - param0->unk_1E = Text_AddPrinterWithParamsAndColor(¶m0->unk_E4, FONT_MESSAGE, param0->unk_2C.unk_68[1], 0, 0, param0->unk_1A, TEXT_COLOR(1, 2, 15), NULL); - ManagedSprite_SetExplicitPalette(param0->unk_2FC[0], 2); - param0->unk_0C++; - break; - case 1: - if (Text_IsPrinterActive(param0->unk_1E)) { - break; - } - - sub_0206F62C(param0); - param0->unk_0C++; - break; - case 2: - switch (Menu_ProcessInputAndHandleExit(param0->unk_C8, param0->heapID)) { - case 0: - param0->unk_0C++; - break; - case 0xfffffffe: - param0->unk_0C = 0xFF; - break; - } - break; - case 3: - param0->unk_328->unk_04 = 0; - sub_02070050(param0, 1); - ManagedSprite_SetExplicitPalette(param0->unk_2FC[0], 1); - param0->unk_0C = 0; - return 6; - case 0xFF: - sub_0206FFB4(param0); - ManagedSprite_SetExplicitPalette(param0->unk_2FC[0], 1); - param0->unk_0C = 0; - return 6; - } - - return 7; -} - -static int sub_0206F748(UnkStruct_0206F7F8 *param0) -{ - int v0 = 0; - - switch (param0->unk_0C) { - case 0: - Sound_PlayEffect(SEQ_SE_DP_CUSTOM06); - Window_FillTilemap(¶m0->unk_E4, ((15 << 4) | 15)); - param0->unk_1E = Text_AddPrinterWithParamsAndColor(¶m0->unk_E4, FONT_MESSAGE, param0->unk_2C.unk_68[2], 0, 0, param0->unk_1A, TEXT_COLOR(1, 2, 15), NULL); - ManagedSprite_SetExplicitPalette(param0->unk_2FC[0], 2); - param0->unk_0C++; - break; - case 1: - if (Text_IsPrinterActive(param0->unk_1E)) { - break; - } - - param0->unk_0C++; - break; - case 2: - if (!(gSystem.pressedKeys & (PAD_BUTTON_A | PAD_BUTTON_B))) { - break; - } - - Sound_PlayEffect(SEQ_SE_CONFIRM); - sub_0206FFB4(param0); - ManagedSprite_SetExplicitPalette(param0->unk_2FC[0], 1); - param0->unk_0C = 0; - return 6; - } - - return 8; -} - -static void sub_0206F7F8(UnkStruct_0206F7F8 *param0, SaveData *saveData) -{ - int v0, v1, v2, v3; - UnkStruct_0202EE10 *v4; - - param0->unk_324 = Heap_Alloc(param0->heapID, sizeof(UnkStruct_02070050) * param0->unk_18); - MI_CpuClear8(param0->unk_324, sizeof(UnkStruct_02070050) * param0->unk_18); - param0->unk_308[0] = sub_0202ED8C(saveData, param0->unk_16, param0->heapID); - - for (v0 = 0; v0 < param0->unk_18; v0++) { - param0->unk_308[v0 + 1] = sub_0202EE10(param0->unk_304, (param0->unk_17 * 13) + param0->unk_19 + v0, param0->heapID); - - v4 = param0->unk_308[v0 + 1]; - v2 = 0; - v3 = 0; - - if (v4->unk_00 == 0) { - param0->unk_324[v0].unk_04[0].unk_00 = &(param0->unk_308[0]->unk_04[v0]); - param0->unk_324[v0].unk_04[0].unk_04 = 1; - param0->unk_324[v0].unk_04[0].unk_06 = 0xFF; - param0->unk_324[v0].unk_00 = 1; - } else { - for (v1 = 0; v1 < v4->unk_00; v1++) { - if ((v3 == 0) && (param0->unk_308[0]->unk_04[v0].unk_04 >= v4->unk_04[v1].unk_04)) { - param0->unk_324[v0].unk_04[v2].unk_00 = &(param0->unk_308[0]->unk_04[v0]); - param0->unk_324[v0].unk_04[v2].unk_04 = 1; - param0->unk_324[v0].unk_04[v2].unk_06 = 0xFF; - ++v2; - param0->unk_324[v0].unk_04[v2].unk_00 = &(v4->unk_04[v1]); - param0->unk_324[v0].unk_04[v2].unk_04 = 1; - param0->unk_324[v0].unk_04[v2].unk_06 = v1; - v3 = 1; - } else { - param0->unk_324[v0].unk_04[v2].unk_00 = &(v4->unk_04[v1]); - param0->unk_324[v0].unk_04[v2].unk_04 = 1; - param0->unk_324[v0].unk_04[v2].unk_06 = v1; - } - - ++v2; - } - - if (!v3) { - param0->unk_324[v0].unk_04[v2].unk_00 = &(param0->unk_308[0]->unk_04[v0]); - param0->unk_324[v0].unk_04[v2].unk_04 = 1; - param0->unk_324[v0].unk_04[v2].unk_06 = 0xFF; - } - - param0->unk_324[v0].unk_00 = v4->unk_00 + 1; - } - } -} - -static void sub_0206F9D4(UnkStruct_0206F7F8 *param0) -{ - int v0; - - for (v0 = 0; v0 < param0->unk_18 + 1; v0++) { - sub_0202EE8C(param0->unk_308[v0]); - } - - Heap_Free(param0->unk_324); -} - -static void sub_0206FA08(UnkStruct_0206F7F8 *param0) -{ - int v0; - - param0->unk_2C.unk_00 = MessageLoader_Init(MSG_LOADER_PRELOAD_ENTIRE_BANK, NARC_INDEX_MSGDATA__PL_MSG, TEXT_BANK_UNK_0532, param0->heapID); - param0->unk_2C.unk_04 = StringTemplate_New(2, (38 * 2), param0->heapID); - param0->unk_2C.unk_08 = String_Init((38 * 2), param0->heapID); - param0->unk_2C.unk_0C = MessageLoader_GetNewString(param0->unk_2C.unk_00, 13); - param0->unk_2C.unk_10 = MessageLoader_GetNewString(param0->unk_2C.unk_00, 22); - param0->unk_2C.unk_14 = MessageLoader_GetNewString(param0->unk_2C.unk_00, 36); - param0->unk_2C.unk_18 = MessageLoader_GetNewString(param0->unk_2C.unk_00, 14); - - for (v0 = 0; v0 < param0->unk_18; v0++) { - param0->unk_2C.unk_38[v0] = MessageLoader_GetNewString(param0->unk_2C.unk_00, 0 + param0->unk_19 + v0); - param0->unk_2C.unk_50[v0] = MessageLoader_GetNewString(param0->unk_2C.unk_00, 23 + param0->unk_19 + v0); - } - - for (v0 = 0; v0 < 7; v0++) { - param0->unk_2C.unk_1C[v0] = MessageLoader_GetNewString(param0->unk_2C.unk_00, 15 + v0); - } - - for (v0 = 0; v0 < 3; v0++) { - param0->unk_2C.unk_68[v0] = MessageLoader_GetNewString(param0->unk_2C.unk_00, 37 + v0); - } -} - -static void sub_0206FAC0(UnkStruct_0206F7F8 *param0) -{ - int v0; - - for (v0 = 0; v0 < 3; v0++) { - String_Free(param0->unk_2C.unk_68[v0]); - } - - for (v0 = 0; v0 < 7; v0++) { - String_Free(param0->unk_2C.unk_1C[v0]); - } - - for (v0 = 0; v0 < param0->unk_18; v0++) { - String_Free(param0->unk_2C.unk_38[v0]); - String_Free(param0->unk_2C.unk_50[v0]); - } - - String_Free(param0->unk_2C.unk_18); - String_Free(param0->unk_2C.unk_14); - String_Free(param0->unk_2C.unk_10); - String_Free(param0->unk_2C.unk_0C); - String_Free(param0->unk_2C.unk_08); - StringTemplate_Free(param0->unk_2C.unk_04); - MessageLoader_Free(param0->unk_2C.unk_00); -} - -static void sub_0206FB38(UnkStruct_0206F7F8 *param0) -{ - Bg_ClearTilesRange(BG_LAYER_MAIN_1, 32 * (24 * (12 + 2) + 9 + 1), 0, param0->heapID); - Bg_FillTilemapRect(param0->unk_D0, 1, 0x0, 0, 0, 32, 32, 17); - Bg_ScheduleTilemapTransfer(param0->unk_D0, 1); - Bg_ToggleLayer(BG_LAYER_MAIN_1, 1); - - param0->unk_10 = Bg_GetPriority(param0->unk_D0, BG_LAYER_MAIN_0); - param0->unk_12 = Bg_GetPriority(param0->unk_D0, BG_LAYER_MAIN_1); - - Bg_SetPriority(BG_LAYER_MAIN_0, 2); - Bg_SetPriority(BG_LAYER_MAIN_1, 1); - LoadMessageBoxGraphics(param0->unk_D0, BG_LAYER_MAIN_3, (1024 - (18 + 12)), 10, param0->unk_1C, param0->heapID); - LoadStandardWindowGraphics(param0->unk_D0, BG_LAYER_MAIN_3, (1024 - (18 + 12) - 9), 11, 0, param0->heapID); - LoadStandardWindowGraphics(param0->unk_D0, BG_LAYER_MAIN_1, (1024 - (18 + 12) - 9), 11, 0, param0->heapID); - Font_LoadTextPalette(0, 13 * 32, param0->heapID); - Font_LoadScreenIndicatorsPalette(0, 12 * 32, param0->heapID); - Window_Add(param0->unk_D0, ¶m0->unk_E4, 3, 2, 19, 27, 4, 12, ((1024 - (18 + 12) - 9) - 27 * 4)); - Window_FillTilemap(¶m0->unk_E4, ((15 << 4) | 15)); -} - -static void sub_0206FC4C(UnkStruct_0206F7F8 *param0) -{ - Window_EraseMessageBox(¶m0->unk_E4, 1); - Window_ClearAndCopyToVRAM(¶m0->unk_E4); - Window_Remove(¶m0->unk_E4); - Bg_ClearTilesRange(BG_LAYER_MAIN_1, 32 * (24 * (12 + 2) + 9 + 1), 0, param0->heapID); - Bg_FillTilemapRect(param0->unk_D0, 1, 0x0, 0, 0, 32, 32, 17); - Bg_ScheduleTilemapTransfer(param0->unk_D0, 1); - Bg_ToggleLayer(BG_LAYER_MAIN_1, 0); - Bg_SetPriority(BG_LAYER_MAIN_0, param0->unk_10); - Bg_SetPriority(BG_LAYER_MAIN_1, param0->unk_12); -} - -static void sub_0206FCC4(UnkStruct_0206F7F8 *param0) -{ - int v0; - SpriteResourceCapacities v1 = { - 1, 1, 1, 1, 0, 0 - }; - static const SpriteTemplate v2[] = { - { - 0x7E, - 0x10, - 0x0, - 0x0, - 0x0, - 0x1, - NNS_G2D_VRAM_TYPE_2DMAIN, - { 0x34D8, 0x34D8, 0x34D8, 0x34D8, 0x0, 0x0 }, - 0x1, - 0x0, - }, - { - 0x4A, - 0x78, - 0x0, - 0x1, - 0x1, - 0x0, - NNS_G2D_VRAM_TYPE_2DMAIN, - { 0x34D8, 0x34D8, 0x34D8, 0x34D8, 0x0, 0x0 }, - 0x1, - 0x0, - }, - }; - - SpriteResourceManager_SetCapacities(¶m0->spriteManager, &v1, 2, param0->heapID); - - { - NARC *v3; - - v3 = NARC_ctor(NARC_INDEX_GRAPHIC__RANKING, param0->heapID); - - SpriteResourceManager_LoadPalette(¶m0->spriteManager, v3, 0, 0, 3, NNS_G2D_VRAM_TYPE_2DMAIN, 13528); - SpriteResourceManager_LoadCell(¶m0->spriteManager, v3, 2, 0, 13528); - SpriteResourceManager_LoadAnimation(¶m0->spriteManager, v3, 3, 0, 13528); - SpriteResourceManager_LoadTiles(¶m0->spriteManager, v3, 1, 0, NNS_G2D_VRAM_TYPE_2DMAIN, 13528); - - NARC_dtor(v3); - } - - for (v0 = 0; v0 < 2; v0++) { - param0->unk_2FC[v0] = SpriteResourceManager_CreateManagedSprite(¶m0->spriteManager, &v2[v0]); - } - - ManagedSprite_SetDrawFlag(param0->unk_2FC[1], 0); -} - -static void sub_0206FD94(UnkStruct_0206F7F8 *param0) -{ - int v0; - - for (v0 = 0; v0 < 2; v0++) { - if (param0->unk_2FC[v0] != NULL) { - Sprite_DeleteAndFreeResources(param0->unk_2FC[v0]); - } - } - - SpriteResourceManager_Cleanup(¶m0->spriteManager); -} - -static void sub_0206FDC0(UnkStruct_0206F7F8 *param0, u16 param1, u16 param2) -{ - int v0, v1; - - v1 = param0->unk_18 + 1; - param0->unk_C4 = StringList_New(v1, param0->heapID); - - Window_Add(param0->unk_D0, ¶m0->unk_D4, 1, 4, 1, 24, v1 * 2, 13, 1); - Window_FillTilemap(¶m0->unk_D4, ((15 << 4) | 15)); - - for (v0 = 0; v0 < param0->unk_18; v0++) { - StringList_AddFromString(param0->unk_C4, param0->unk_2C.unk_38[v0], v0); - } - - StringList_AddFromString(param0->unk_C4, param0->unk_2C.unk_0C, 0xFFFF); - - MI_CpuCopy8((void *)&Unk_020F02B0, (void *)&(param0->unk_A0), sizeof(ListMenuTemplate)); - - param0->unk_A0.window = &(param0->unk_D4); - param0->unk_A0.choices = param0->unk_C4; - param0->unk_A0.parent = (void *)param0; - param0->unk_A0.count = v1; - param0->unk_A0.yOffset = 0; - param0->unk_A0.cursorCallback = sub_0206FF60; - param0->unk_A0.printCallback = NULL; - param0->unk_C0 = ListMenu_New(&(param0->unk_A0), param1, param2, param0->heapID); - - Window_DrawStandardFrame(¶m0->unk_D4, 0, (1024 - (18 + 12) - 9), 11); - Window_DrawMessageBoxWithScrollCursor(¶m0->unk_E4, 1, (1024 - (18 + 12)), 10); - Window_FillTilemap(¶m0->unk_E4, ((15 << 4) | 15)); - Text_AddPrinterWithParamsAndColor(¶m0->unk_E4, FONT_MESSAGE, param0->unk_2C.unk_10, 0, 0, TEXT_SPEED_INSTANT, TEXT_COLOR(1, 2, 15), NULL); - ManagedSprite_SetDrawFlag(param0->unk_2FC[0], 1); - Bg_ScheduleTilemapTransfer(param0->unk_D0, 3); -} - -static void sub_0206FF10(UnkStruct_0206F7F8 *param0) -{ - ListMenu_Free(param0->unk_C0, &(param0->unk_22), &(param0->unk_24)); - StringList_Free(param0->unk_C4); - Window_ClearAndCopyToVRAM(&(param0->unk_D4)); - Window_EraseStandardFrame(&(param0->unk_D4), 0); - Window_Remove(&(param0->unk_D4)); - ManagedSprite_SetDrawFlag(param0->unk_2FC[0], 0); - Bg_ScheduleTilemapTransfer(param0->unk_D0, 3); -} - -static void sub_0206FF60(ListMenu *param0, u32 param1, u8 param2) -{ - u16 v0, v1, v2; - UnkStruct_0206F7F8 *v3 = (UnkStruct_0206F7F8 *)ListMenu_GetAttribute(param0, 19); - - if (param2 == 0) { - Sound_PlayEffect(SEQ_SE_CONFIRM); - } - - ListMenu_GetListAndCursorPos(param0, &v0, &v1); - v2 = ListMenu_GetAttribute(param0, 2); - - ManagedSprite_SetPositionXY(v3->unk_2FC[0], 126, 16 + 16 * (v1 + v0)); -} - -static void sub_0206FFB4(UnkStruct_0206F7F8 *param0) -{ - Window_FillTilemap(¶m0->unk_E4, ((15 << 4) | 15)); - Text_AddPrinterWithParamsAndColor(¶m0->unk_E4, FONT_MESSAGE, param0->unk_2C.unk_68[0], 0, 0, TEXT_SPEED_INSTANT, TEXT_COLOR(1, 2, 15), NULL); -} - -static void sub_0206FFE4(UnkStruct_0206F7F8 *param0) -{ - sub_0206FFB4(param0); - ManagedSprite_SetPositionXY(param0->unk_2FC[0], 126, 16 + param0->unk_28 * 16); - ManagedSprite_SetDrawFlag(param0->unk_2FC[0], 1); -} - -static void sub_02070010(UnkStruct_0206F7F8 *param0) -{ - Window_FillTilemap(¶m0->unk_E4, ((15 << 4) | 15)); - Text_AddPrinterWithParamsAndColor(¶m0->unk_E4, FONT_MESSAGE, param0->unk_2C.unk_50[param0->unk_1F], 0, 0, TEXT_SPEED_INSTANT, TEXT_COLOR(1, 2, 15), NULL); - ManagedSprite_SetDrawFlag(param0->unk_2FC[0], 0); -} - -static void sub_02070050(UnkStruct_0206F7F8 *param0, BOOL param1) -{ - int v0, v1, v2, v3, v4, v5; - UnkStruct_02070050 *v6; - const UnkStruct_020F02D0 *v7; - - v6 = &(param0->unk_324[param0->unk_1F]); - v7 = &(Unk_020F0254[param0->unk_16][param0->unk_1F]); - - Window_FillTilemap(¶m0->unk_D4, ((15 << 4) | 15)); - - v1 = v6->unk_00; - v2 = 1; - v3 = 0; - v5 = 0; - - for (v0 = 0; v0 < v6->unk_00; v0++) { - if (!v6->unk_04[v0].unk_04) { - continue; - } - - v4 = v6->unk_04[v0].unk_00->unk_04; - - if (v4 > v7->unk_00) { - v4 = v7->unk_00; - } - - if (v4 < v5) { - ++v2; - } - - StringTemplate_SetNumber(param0->unk_2C.unk_04, 0, v2, 1, 1, 1); - StringTemplate_SetString(param0->unk_2C.unk_04, 1, v6->unk_04[v0].unk_00->unk_08, 2, 1, GAME_LANGUAGE); - StringTemplate_Format(param0->unk_2C.unk_04, param0->unk_2C.unk_08, param0->unk_2C.unk_18); - Text_AddPrinterWithParamsAndColor(¶m0->unk_D4, FONT_SYSTEM, param0->unk_2C.unk_08, 8, v3 * 16, TEXT_SPEED_NO_TRANSFER, TEXT_COLOR(1, 2, 15), NULL); - StringTemplate_SetNumber(param0->unk_2C.unk_04, 0, v4, v7->unk_04, 1, 1); - StringTemplate_Format(param0->unk_2C.unk_04, param0->unk_2C.unk_08, param0->unk_2C.unk_1C[v7->unk_06 - 15]); - Text_AddPrinterWithParamsAndColor(¶m0->unk_D4, FONT_SYSTEM, param0->unk_2C.unk_08, (24 * 8) - Font_CalcStringWidth(FONT_SYSTEM, param0->unk_2C.unk_08, 0) - 8, v3 * 16, TEXT_SPEED_NO_TRANSFER, TEXT_COLOR(1, 2, 15), NULL); - - param0->unk_32C[v3] = v0; - v5 = v4; - - if (++v3 >= 6) { - break; - } - } - - Window_CopyToVRAM(¶m0->unk_D4); - - param0->unk_21 = v3; - - if ((param0->unk_28 > 0) && (param0->unk_28 >= param0->unk_21)) { - param0->unk_28--; - } - - if (param1) { - sub_0206FFE4(param0); - } else { - sub_02070010(param0); - } -} - -static void sub_020701DC(UnkStruct_0206F7F8 *param0, u16 param1) -{ - Window_Add(param0->unk_D0, ¶m0->unk_D4, 1, 4, 1, 24, 12, 13, 1); - Window_DrawStandardFrame(¶m0->unk_D4, 1, (1024 - (18 + 12) - 9), 11); - sub_02070050(param0, 0); - ManagedSprite_SetDrawFlag(param0->unk_2FC[1], 1); - Window_Add(param0->unk_D0, ¶m0->unk_F4, 3, 8, 14, 8, 2, 13, ((((1024 - (18 + 12) - 9) - 27 * 4) - 6 * 4) - (8 * 2))); - Window_FillTilemap(¶m0->unk_F4, ((0 << 4) | 0)); - Text_AddPrinterWithParamsAndColor(¶m0->unk_F4, FONT_SYSTEM, param0->unk_2C.unk_14, 0, 0, TEXT_SPEED_INSTANT, TEXT_COLOR(1, 2, 0), NULL); - Bg_ScheduleTilemapTransfer(param0->unk_D0, 3); -} - -static void sub_02070288(UnkStruct_0206F7F8 *param0) -{ - Window_ClearAndCopyToVRAM(¶m0->unk_D4); - Window_EraseStandardFrame(¶m0->unk_D4, 0); - Window_Remove(¶m0->unk_D4); - Window_ClearAndCopyToVRAM(¶m0->unk_F4); - Window_Remove(¶m0->unk_F4); - ManagedSprite_SetDrawFlag(param0->unk_2FC[0], 0); - ManagedSprite_SetDrawFlag(param0->unk_2FC[1], 0); -} - -static BOOL sub_020702D0(FieldTask *param0) -{ - FieldSystem *fieldSystem = FieldTask_GetFieldSystem(param0); - UnkStruct_0206F314 *v1 = FieldTask_GetEnv(param0); - UnkStruct_0206F7F8 *v2 = v1->unk_08; - - switch (v1->unk_00) { - case 0: - v1->unk_00 = sub_0206F314(v1, fieldSystem, v1->unk_04); - break; - case 1: - v1->unk_00 = sub_0206F448(v1->unk_08, fieldSystem->saveData); - break; - case 2: - v1->unk_00 = sub_0206F488(v1->unk_08); - SpriteList_Update(v1->unk_08->spriteManager.spriteList); - break; - case 3: - v1->unk_00 = sub_0206F498(v1->unk_08); - SpriteList_Update(v1->unk_08->spriteManager.spriteList); - break; - case 4: - v1->unk_00 = sub_0206F508(v1->unk_08); - SpriteList_Update(v1->unk_08->spriteManager.spriteList); - break; - case 5: - v1->unk_00 = sub_0206F514(v1->unk_08); - SpriteList_Update(v1->unk_08->spriteManager.spriteList); - break; - case 6: - v1->unk_00 = sub_0206F554(v1->unk_08); - SpriteList_Update(v1->unk_08->spriteManager.spriteList); - break; - case 7: - v1->unk_00 = sub_0206F658(v1->unk_08); - SpriteList_Update(v1->unk_08->spriteManager.spriteList); - break; - case 8: - v1->unk_00 = sub_0206F748(v2); - SpriteList_Update(v1->unk_08->spriteManager.spriteList); - break; - case 9: - if (!(gSystem.pressedKeys & PAD_BUTTON_A)) { - return 0; - } - - v1->unk_00 = 10; - break; - case 10: - v1->unk_00 = sub_0206F468(v1->unk_08); - break; - case 11: - v1->unk_00 = sub_0206F3A0(v1); - break; - case 12: - Heap_Free(v1); - return 1; - } - - return 0; -} - -void sub_020703FC(FieldTask *param0, u16 param1) -{ - FieldSystem *fieldSystem = FieldTask_GetFieldSystem(param0); - UnkStruct_0206F314 *v1 = Heap_Alloc(HEAP_ID_FIELD2, sizeof(UnkStruct_0206F314)); - - v1->unk_00 = 0; - v1->unk_04 = param1; - v1->unk_08 = NULL; - - FieldTask_InitCall(fieldSystem->task, sub_020702D0, v1); -} diff --git a/src/unk_020933F8.c b/src/unk_020933F8.c index e279c3fb2b..e112033961 100644 --- a/src/unk_020933F8.c +++ b/src/unk_020933F8.c @@ -1596,7 +1596,7 @@ void sub_02094C44(UnkStruct_02095C48 *param0, SaveData *saveData, u32 param2, Jo sub_0206CF14(broadcast, param0->unk_1974, param0->unk_00.contestType, param0->unk_00.contestRank, param0->unk_00.unk_118[param0->unk_00.unk_113].unk_08 + 1); GameRecords *v5 = SaveData_GetGameRecords(param0->saveData); - GameRecords_IncrementRecordValue(v5, RECORD_UNK_090); + GameRecords_IncrementRecordValue(v5, RECORD_SUPER_CONTEST_PARTICIPATIONS); if (sub_02094790(param0) == 0) { GameRecords_IncrementRecordValue(v5, RECORD_SUPER_CONTEST_WINS); @@ -1604,7 +1604,7 @@ void sub_02094C44(UnkStruct_02095C48 *param0, SaveData *saveData, u32 param2, Jo } if (v0 == 1) { - GameRecords_IncrementRecordValue(v5, RECORD_UNK_094); + GameRecords_IncrementRecordValue(v5, RECORD_RIBBONS_WON); } int i; @@ -1617,7 +1617,7 @@ void sub_02094C44(UnkStruct_02095C48 *param0, SaveData *saveData, u32 param2, Jo LinkContestRecords_IncrementSavaData(param0->saveData, param0->unk_00.contestType, param0->unk_00.unk_118[param0->unk_00.unk_113].unk_08); GameRecords *records = SaveData_GetGameRecords(param0->saveData); - GameRecords_IncrementRecordValue(records, RECORD_UNK_091); + GameRecords_IncrementRecordValue(records, RECORD_LINK_CONTEST_PARTICIPATIONS); if (sub_02094790(param0) == 0) { GameRecords_IncrementRecordValue(records, RECORD_LINK_CONTEST_WINS);