From 6add3e17944402eab6419d217c98d14d93f38a55 Mon Sep 17 00:00:00 2001 From: Marcus Huderle Date: Fri, 8 Feb 2019 11:08:25 -0600 Subject: [PATCH] Document some battle dome stuff --- data/event_scripts.s | 228 +++++------ include/battle_dome.h | 4 +- include/strings.h | 118 ++++++ src/battle_dome.c | 871 ++++++++++++++++++------------------------ 4 files changed, 611 insertions(+), 610 deletions(-) diff --git a/data/event_scripts.s b/data/event_scripts.s index c6ebcd695..cf9590ce5 100644 --- a/data/event_scripts.s +++ b/data/event_scripts.s @@ -5631,346 +5631,346 @@ LilycoveCity_PokemonCenter_1F_Text_2A970E: @ 82A970E .include "data/text/match_call.inc" .include "data/scripts/apprentice.inc" -gBattleDomeOpponentPotential1:: +gBattleDomeOpponentPotentialText1:: .string "The best candidate to be a champ!$" -gBattleDomeOpponentPotential2:: +gBattleDomeOpponentPotentialText2:: .string "A sure-finalist team.$" -gBattleDomeOpponentPotential3:: +gBattleDomeOpponentPotentialText3:: .string "A likely top-three finisher.$" -gBattleDomeOpponentPotential4:: +gBattleDomeOpponentPotentialText4:: .string "A candidate to finish first.$" -gBattleDomeOpponentPotential5:: +gBattleDomeOpponentPotentialText5:: .string "A team with top-class potential.$" -gBattleDomeOpponentPotential6:: +gBattleDomeOpponentPotentialText6:: .string "The dark horse team this tournament.$" -gBattleDomeOpponentPotential7:: +gBattleDomeOpponentPotentialText7:: .string "A better-than-average team.$" -gBattleDomeOpponentPotential8:: +gBattleDomeOpponentPotentialText8:: .string "This tournament's average team.$" -gBattleDomeOpponentPotential9:: +gBattleDomeOpponentPotentialText9:: .string "A team with average potential.$" -gBattleDomeOpponentPotential10:: +gBattleDomeOpponentPotentialText10:: .string "A weaker-than-average team.$" -gBattleDomeOpponentPotential11:: +gBattleDomeOpponentPotentialText11:: .string "A team looking for its first win.$" -gBattleDomeOpponentPotential12:: +gBattleDomeOpponentPotentialText12:: .string "One win will make this team proud.$" -gBattleDomeOpponentPotential13:: +gBattleDomeOpponentPotentialText13:: .string "Overall, a weak team.$" -gBattleDomeOpponentPotential14:: +gBattleDomeOpponentPotentialText14:: .string "A team with very low potential.$" -gBattleDomeOpponentPotential15:: +gBattleDomeOpponentPotentialText15:: .string "A team unlikely to win the tournament.$" -gBattleDomeOpponentPotential16:: +gBattleDomeOpponentPotentialText16:: .string "The team most unlikely to win.$" -gBattleDomeOpponentPotential17:: +gBattleDomeOpponentPotentialText17:: .string "The perfect, invincible superstar!$" -gBattleDomeOpponentStyle1:: +gBattleDomeOpponentStyleText1:: .string "Willing to risk total disaster at times.$" -gBattleDomeOpponentStyle2:: +gBattleDomeOpponentStyleText2:: .string "Skilled at enduring long battles.$" -gBattleDomeOpponentStyle3:: +gBattleDomeOpponentStyleText3:: .string "Varies tactics to suit the opponent.$" -gBattleDomeOpponentStyle4:: +gBattleDomeOpponentStyleText4:: .string "Has a tough winning pattern.$" -gBattleDomeOpponentStyle5:: +gBattleDomeOpponentStyleText5:: .string "Occasionally uses a very rare move.$" -gBattleDomeOpponentStyle6:: +gBattleDomeOpponentStyleText6:: .string "Uses startling and disruptive moves.$" -gBattleDomeOpponentStyle7:: +gBattleDomeOpponentStyleText7:: .string "Constantly watches HP in battle.$" -gBattleDomeOpponentStyle8:: +gBattleDomeOpponentStyleText8:: .string "Good at storing then loosing power.$" -gBattleDomeOpponentStyle9:: +gBattleDomeOpponentStyleText9:: .string "Skilled at enfeebling foes.$" -gBattleDomeOpponentStyle10:: +gBattleDomeOpponentStyleText10:: .string "Prefers tactics that rely on luck.$" -gBattleDomeOpponentStyle11:: +gBattleDomeOpponentStyleText11:: .string "Attacks with a regal atmosphere.$" -gBattleDomeOpponentStyle12:: +gBattleDomeOpponentStyleText12:: .string "Attacks with powerful, low-PP moves.$" -gBattleDomeOpponentStyle13:: +gBattleDomeOpponentStyleText13:: .string "Skilled at enfeebling, then attacking.$" -gBattleDomeOpponentStyle14:: +gBattleDomeOpponentStyleText14:: .string "Battles while enduring all attacks.$" -gBattleDomeOpponentStyle15:: +gBattleDomeOpponentStyleText15:: .string "Skilled at upsetting foes emotionally.$" -gBattleDomeOpponentStyle16:: +gBattleDomeOpponentStyleText16:: .string "Uses strong and straightforward moves.$" -gBattleDomeOpponentStyle17:: +gBattleDomeOpponentStyleText17:: .string "Aggressively uses strong moves.$" -gBattleDomeOpponentStyle18:: +gBattleDomeOpponentStyleText18:: .string "Battles while cleverly dodging attacks.$" -gBattleDomeOpponentStyle19:: +gBattleDomeOpponentStyleText19:: .string "Skilled at using upsetting attacks.$" -gBattleDomeOpponentStyle20:: +gBattleDomeOpponentStyleText20:: .string "Uses many popular moves.$" -gBattleDomeOpponentStyle21:: +gBattleDomeOpponentStyleText21:: .string "Has moves for powerful combinations.$" -gBattleDomeOpponentStyle22:: +gBattleDomeOpponentStyleText22:: .string "Uses high-probability attacks.$" -gBattleDomeOpponentStyle23:: +gBattleDomeOpponentStyleText23:: .string "Aggressively uses spectacular moves.$" -gBattleDomeOpponentStyle24:: +gBattleDomeOpponentStyleText24:: .string "Emphasizes offense over defense.$" -gBattleDomeOpponentStyle25:: +gBattleDomeOpponentStyleText25:: .string "Emphasizes defense over offense.$" -gBattleDomeOpponentStyle26:: +gBattleDomeOpponentStyleText26:: .string "Attacks quickly with strong moves.$" -gBattleDomeOpponentStyle27:: +gBattleDomeOpponentStyleText27:: .string "Often uses moves with added effects.$" -gBattleDomeOpponentStyle28:: +gBattleDomeOpponentStyleText28:: .string "Uses a well-balanced mix of moves.$" -gBattleDomeOpponentStyleUnused1:: +gBattleDomeOpponentStyleTextUnused1:: .string "This is sample message 1.$" -gBattleDomeOpponentStyleUnused2:: +gBattleDomeOpponentStyleTextUnused2:: .string "This is sample message 2.$" -gBattleDomeOpponentStyleUnused3:: +gBattleDomeOpponentStyleTextUnused3:: .string "This is sample message 3.$" -gBattleDomeOpponentStyleUnused4:: +gBattleDomeOpponentStyleTextUnused4:: .string "This is sample message 4.$" -gBattleDomeOpponentStats1:: +gBattleDomeOpponentStatsText1:: .string "Emphasizes HP and ATTACK.$" -gBattleDomeOpponentStats2:: +gBattleDomeOpponentStatsText2:: .string "Emphasizes HP and DEFENSE.$" -gBattleDomeOpponentStats3:: +gBattleDomeOpponentStatsText3:: .string "Emphasizes HP and SPEED.$" -gBattleDomeOpponentStats4:: +gBattleDomeOpponentStatsText4:: .string "Emphasizes HP and SP. ATTACK.$" -gBattleDomeOpponentStats5:: +gBattleDomeOpponentStatsText5:: .string "Emphasizes HP and SP. DEFENSE.$" -gBattleDomeOpponentStats6:: +gBattleDomeOpponentStatsText6:: .string "Emphasizes ATTACK and DEFENSE.$" -gBattleDomeOpponentStats7:: +gBattleDomeOpponentStatsText7:: .string "Emphasizes ATTACK and SPEED.$" -gBattleDomeOpponentStats8:: +gBattleDomeOpponentStatsText8:: .string "Emphasizes ATTACK and SP. ATTACK.$" -gBattleDomeOpponentStats9:: +gBattleDomeOpponentStatsText9:: .string "Emphasizes ATTACK and SP. DEFENSE.$" -gBattleDomeOpponentStats10:: +gBattleDomeOpponentStatsText10:: .string "Emphasizes DEFENSE and SPEED.$" -gBattleDomeOpponentStats11:: +gBattleDomeOpponentStatsText11:: .string "Emphasizes DEFENSE and SP. ATTACK.$" -gBattleDomeOpponentStats12:: +gBattleDomeOpponentStatsText12:: .string "Emphasizes DEFENSE and SP. DEFENSE.$" -gBattleDomeOpponentStats13:: +gBattleDomeOpponentStatsText13:: .string "Emphasizes SPEED and SP. ATTACK.$" -gBattleDomeOpponentStats14:: +gBattleDomeOpponentStatsText14:: .string "Emphasizes SPEED and SP. DEFENSE.$" -gBattleDomeOpponentStats15:: +gBattleDomeOpponentStatsText15:: .string "Emphasizes SP. ATTACK and SP. DEFENSE.$" -gBattleDomeOpponentStats16:: +gBattleDomeOpponentStatsText16:: .string "Emphasizes HP.$" -gBattleDomeOpponentStats17:: +gBattleDomeOpponentStatsText17:: .string "Emphasizes ATTACK.$" -gBattleDomeOpponentStats18:: +gBattleDomeOpponentStatsText18:: .string "Emphasizes DEFENSE.$" -gBattleDomeOpponentStats19:: +gBattleDomeOpponentStatsText19:: .string "Emphasizes SPEED.$" -gBattleDomeOpponentStats20:: +gBattleDomeOpponentStatsText20:: .string "Emphasizes SP. ATTACK.$" -gBattleDomeOpponentStats21:: +gBattleDomeOpponentStatsText21:: .string "Emphasizes SP. DEFENSE.$" -gBattleDomeOpponentStats22:: +gBattleDomeOpponentStatsText22:: .string "Neglects HP and ATTACK.$" -gBattleDomeOpponentStats23:: +gBattleDomeOpponentStatsText23:: .string "Neglects HP and DEFENSE.$" -gBattleDomeOpponentStats24:: +gBattleDomeOpponentStatsText24:: .string "Neglects HP and SPEED.$" -gBattleDomeOpponentStats25:: +gBattleDomeOpponentStatsText25:: .string "Neglects HP and SP. ATTACK.$" -gBattleDomeOpponentStats26:: +gBattleDomeOpponentStatsText26:: .string "Neglects HP and SP. DEFENSE.$" -gBattleDomeOpponentStats27:: +gBattleDomeOpponentStatsText27:: .string "Neglects ATTACK and DEFENSE.$" -gBattleDomeOpponentStats28:: +gBattleDomeOpponentStatsText28:: .string "Neglects ATTACK and SPEED.$" -gBattleDomeOpponentStats29:: +gBattleDomeOpponentStatsText29:: .string "Neglects ATTACK and SP. ATTACK.$" -gBattleDomeOpponentStats30:: +gBattleDomeOpponentStatsText30:: .string "Neglects ATTACK and SP. DEFENSE.$" -gBattleDomeOpponentStats31:: +gBattleDomeOpponentStatsText31:: .string "Neglects DEFENSE and SPEED.$" -gBattleDomeOpponentStats32:: +gBattleDomeOpponentStatsText32:: .string "Neglects DEFENSE and SP. ATTACK.$" -gBattleDomeOpponentStats33:: +gBattleDomeOpponentStatsText33:: .string "Neglects DEFENSE and SP. DEFENSE.$" -gBattleDomeOpponentStats34:: +gBattleDomeOpponentStatsText34:: .string "Neglects SPEED and SP. ATTACK.$" -gBattleDomeOpponentStats35:: +gBattleDomeOpponentStatsText35:: .string "Neglects SPEED and SP. DEFENSE.$" -gBattleDomeOpponentStats36:: +gBattleDomeOpponentStatsText36:: .string "Neglects SP. ATTACK and SP. DEFENSE.$" -gBattleDomeOpponentStats37:: +gBattleDomeOpponentStatsText37:: .string "Neglects HP.$" -gBattleDomeOpponentStats38:: +gBattleDomeOpponentStatsText38:: .string "Neglects ATTACK.$" -gBattleDomeOpponentStats39:: +gBattleDomeOpponentStatsText39:: .string "Neglects DEFENSE.$" -gBattleDomeOpponentStats40:: +gBattleDomeOpponentStatsText40:: .string "Neglects SPEED.$" -gBattleDomeOpponentStats41:: +gBattleDomeOpponentStatsText41:: .string "Neglects SP. ATTACK.$" -gBattleDomeOpponentStats42:: +gBattleDomeOpponentStatsText42:: .string "Neglects SP. DEFENSE.$" -gBattleDomeOpponentStats43:: +gBattleDomeOpponentStatsText43:: .string "Raises POKéMON in a well-balanced way.$" -gBattleDomeWinStrings1:: +gBattleDomeWinText1:: .string "Let the battle begin!$" -gBattleDomeWinStrings2:: +gBattleDomeWinText2:: .string "{STR_VAR_1} won using {STR_VAR_2}!$" -gBattleDomeWinStrings3:: +gBattleDomeWinText3:: .string "{STR_VAR_1} became the champ!$" -gBattleDomeWinStrings4:: +gBattleDomeWinText4:: .string "{STR_VAR_1} won by default!$" -gBattleDomeWinStrings5:: +gBattleDomeWinText5:: .string "{STR_VAR_1} won outright by default!$" -gBattleDomeWinStrings6:: +gBattleDomeWinText6:: .string "{STR_VAR_1} won without using a move!$" -gBattleDomeWinStrings7:: +gBattleDomeWinText7:: .string "{STR_VAR_1} won outright with no moves!$" -gBattleDomeMatchNumber1:: +gBattleDomeMatchNumberText1:: .string "Round 1, Match 1$" -gBattleDomeMatchNumber2:: +gBattleDomeMatchNumberText2:: .string "Round 1, Match 2$" -gBattleDomeMatchNumber3:: +gBattleDomeMatchNumberText3:: .string "Round 1, Match 3$" -gBattleDomeMatchNumber4:: +gBattleDomeMatchNumberText4:: .string "Round 1, Match 4$" -gBattleDomeMatchNumber5:: +gBattleDomeMatchNumberText5:: .string "Round 1, Match 5$" -gBattleDomeMatchNumber6:: +gBattleDomeMatchNumberText6:: .string "Round 1, Match 6$" -gBattleDomeMatchNumber7:: +gBattleDomeMatchNumberText7:: .string "Round 1, Match 7$" -gBattleDomeMatchNumber8:: +gBattleDomeMatchNumberText8:: .string "Round 1, Match 8$" -gBattleDomeMatchNumber9:: +gBattleDomeMatchNumberText9:: .string "Round 2, Match 1$" -gBattleDomeMatchNumber10:: +gBattleDomeMatchNumberText10:: .string "Round 2, Match 2$" -gBattleDomeMatchNumber11:: +gBattleDomeMatchNumberText11:: .string "Round 2, Match 3$" -gBattleDomeMatchNumber12:: +gBattleDomeMatchNumberText12:: .string "Round 2, Match 4$" -gBattleDomeMatchNumber13:: +gBattleDomeMatchNumberText13:: .string "Semifinal Match 1$" -gBattleDomeMatchNumber14:: +gBattleDomeMatchNumberText14:: .string "Semifinal Match 2$" -gBattleDomeMatchNumber15:: +gBattleDomeMatchNumberText15:: .string "Final Match$" BattleFrontier_BattlePikeRandomRoom1_MapScripts_2C3E1B: @ 82C3E1B diff --git a/include/battle_dome.h b/include/battle_dome.h index 2265f14ce..d1dfdb100 100644 --- a/include/battle_dome.h +++ b/include/battle_dome.h @@ -3,7 +3,7 @@ extern u32 gUnknown_0203CD70; -s32 GetDomeTrainerMonCountInBits(u16 tournamentTrainerId); -s32 TrainerIdToDomeTournamentId(u16 trainerId); +int GetDomeTrainerMonCountInBits(u16 tournamentTrainerId); +int TrainerIdToDomeTournamentId(u16 trainerId); #endif // GUARD_BATTLE_DOME_H diff --git a/include/strings.h b/include/strings.h index 15acde0f7..9557dcca2 100644 --- a/include/strings.h +++ b/include/strings.h @@ -1687,6 +1687,122 @@ extern const u8 BattleFrontier_BattleTowerMultiBattleRoom_Text_24692B[]; extern const u8 BattleFrontier_BattleTowerMultiBattleRoom_Text_246ACF[]; extern const u8 BattleFrontier_BattleTowerMultiBattleRoom_Text_24649D[]; +// Battle Dome. +extern const u8 gBattleDomeOpponentPotentialText1[]; +extern const u8 gBattleDomeOpponentPotentialText2[]; +extern const u8 gBattleDomeOpponentPotentialText3[]; +extern const u8 gBattleDomeOpponentPotentialText4[]; +extern const u8 gBattleDomeOpponentPotentialText5[]; +extern const u8 gBattleDomeOpponentPotentialText6[]; +extern const u8 gBattleDomeOpponentPotentialText7[]; +extern const u8 gBattleDomeOpponentPotentialText8[]; +extern const u8 gBattleDomeOpponentPotentialText9[]; +extern const u8 gBattleDomeOpponentPotentialText10[]; +extern const u8 gBattleDomeOpponentPotentialText11[]; +extern const u8 gBattleDomeOpponentPotentialText12[]; +extern const u8 gBattleDomeOpponentPotentialText13[]; +extern const u8 gBattleDomeOpponentPotentialText14[]; +extern const u8 gBattleDomeOpponentPotentialText15[]; +extern const u8 gBattleDomeOpponentPotentialText16[]; +extern const u8 gBattleDomeOpponentPotentialText17[]; +extern const u8 gBattleDomeOpponentStyleText1[]; +extern const u8 gBattleDomeOpponentStyleText2[]; +extern const u8 gBattleDomeOpponentStyleText3[]; +extern const u8 gBattleDomeOpponentStyleText4[]; +extern const u8 gBattleDomeOpponentStyleText5[]; +extern const u8 gBattleDomeOpponentStyleText6[]; +extern const u8 gBattleDomeOpponentStyleText7[]; +extern const u8 gBattleDomeOpponentStyleText8[]; +extern const u8 gBattleDomeOpponentStyleText9[]; +extern const u8 gBattleDomeOpponentStyleText10[]; +extern const u8 gBattleDomeOpponentStyleText11[]; +extern const u8 gBattleDomeOpponentStyleText12[]; +extern const u8 gBattleDomeOpponentStyleText13[]; +extern const u8 gBattleDomeOpponentStyleText14[]; +extern const u8 gBattleDomeOpponentStyleText15[]; +extern const u8 gBattleDomeOpponentStyleText16[]; +extern const u8 gBattleDomeOpponentStyleText17[]; +extern const u8 gBattleDomeOpponentStyleText18[]; +extern const u8 gBattleDomeOpponentStyleText19[]; +extern const u8 gBattleDomeOpponentStyleText20[]; +extern const u8 gBattleDomeOpponentStyleText21[]; +extern const u8 gBattleDomeOpponentStyleText22[]; +extern const u8 gBattleDomeOpponentStyleText23[]; +extern const u8 gBattleDomeOpponentStyleText24[]; +extern const u8 gBattleDomeOpponentStyleText25[]; +extern const u8 gBattleDomeOpponentStyleText26[]; +extern const u8 gBattleDomeOpponentStyleText27[]; +extern const u8 gBattleDomeOpponentStyleText28[]; +extern const u8 gBattleDomeOpponentStyleTextUnused1[]; +extern const u8 gBattleDomeOpponentStyleTextUnused2[]; +extern const u8 gBattleDomeOpponentStyleTextUnused3[]; +extern const u8 gBattleDomeOpponentStyleTextUnused4[]; +extern const u8 gBattleDomeOpponentStatsText1[]; +extern const u8 gBattleDomeOpponentStatsText2[]; +extern const u8 gBattleDomeOpponentStatsText3[]; +extern const u8 gBattleDomeOpponentStatsText4[]; +extern const u8 gBattleDomeOpponentStatsText5[]; +extern const u8 gBattleDomeOpponentStatsText6[]; +extern const u8 gBattleDomeOpponentStatsText7[]; +extern const u8 gBattleDomeOpponentStatsText8[]; +extern const u8 gBattleDomeOpponentStatsText9[]; +extern const u8 gBattleDomeOpponentStatsText10[]; +extern const u8 gBattleDomeOpponentStatsText11[]; +extern const u8 gBattleDomeOpponentStatsText12[]; +extern const u8 gBattleDomeOpponentStatsText13[]; +extern const u8 gBattleDomeOpponentStatsText14[]; +extern const u8 gBattleDomeOpponentStatsText15[]; +extern const u8 gBattleDomeOpponentStatsText16[]; +extern const u8 gBattleDomeOpponentStatsText17[]; +extern const u8 gBattleDomeOpponentStatsText18[]; +extern const u8 gBattleDomeOpponentStatsText19[]; +extern const u8 gBattleDomeOpponentStatsText20[]; +extern const u8 gBattleDomeOpponentStatsText21[]; +extern const u8 gBattleDomeOpponentStatsText22[]; +extern const u8 gBattleDomeOpponentStatsText23[]; +extern const u8 gBattleDomeOpponentStatsText24[]; +extern const u8 gBattleDomeOpponentStatsText25[]; +extern const u8 gBattleDomeOpponentStatsText26[]; +extern const u8 gBattleDomeOpponentStatsText27[]; +extern const u8 gBattleDomeOpponentStatsText28[]; +extern const u8 gBattleDomeOpponentStatsText29[]; +extern const u8 gBattleDomeOpponentStatsText30[]; +extern const u8 gBattleDomeOpponentStatsText31[]; +extern const u8 gBattleDomeOpponentStatsText32[]; +extern const u8 gBattleDomeOpponentStatsText33[]; +extern const u8 gBattleDomeOpponentStatsText34[]; +extern const u8 gBattleDomeOpponentStatsText35[]; +extern const u8 gBattleDomeOpponentStatsText36[]; +extern const u8 gBattleDomeOpponentStatsText37[]; +extern const u8 gBattleDomeOpponentStatsText38[]; +extern const u8 gBattleDomeOpponentStatsText39[]; +extern const u8 gBattleDomeOpponentStatsText40[]; +extern const u8 gBattleDomeOpponentStatsText41[]; +extern const u8 gBattleDomeOpponentStatsText42[]; +extern const u8 gBattleDomeOpponentStatsText43[]; +extern const u8 gBattleDomeMatchNumberText1[]; +extern const u8 gBattleDomeMatchNumberText2[]; +extern const u8 gBattleDomeMatchNumberText3[]; +extern const u8 gBattleDomeMatchNumberText4[]; +extern const u8 gBattleDomeMatchNumberText5[]; +extern const u8 gBattleDomeMatchNumberText6[]; +extern const u8 gBattleDomeMatchNumberText7[]; +extern const u8 gBattleDomeMatchNumberText8[]; +extern const u8 gBattleDomeMatchNumberText9[]; +extern const u8 gBattleDomeMatchNumberText10[]; +extern const u8 gBattleDomeMatchNumberText11[]; +extern const u8 gBattleDomeMatchNumberText12[]; +extern const u8 gBattleDomeMatchNumberText13[]; +extern const u8 gBattleDomeMatchNumberText14[]; +extern const u8 gBattleDomeMatchNumberText15[]; +extern const u8 gBattleDomeWinText1[]; +extern const u8 gBattleDomeWinText2[]; +extern const u8 gBattleDomeWinText3[]; +extern const u8 gBattleDomeWinText4[]; +extern const u8 gBattleDomeWinText5[]; +extern const u8 gBattleDomeWinText6[]; +extern const u8 gBattleDomeWinText7[]; + // Battle Pyramid. extern const u8 BattlePyramid_ExitHintUp_Text1[]; extern const u8 BattlePyramid_ExitHintLeft_Text1[]; @@ -1815,6 +1931,8 @@ extern const u8 BattlePyramid_FiveTrainersRemaining_Text6[]; extern const u8 BattlePyramid_SixTrainersRemaining_Text6[]; extern const u8 BattlePyramid_SevenTrainersRemaining_Text6[]; + + // PC strings extern const u8 gText_ExitFromBox[]; extern const u8 gText_WhatDoYouWantToDo[]; diff --git a/src/battle_dome.c b/src/battle_dome.c index b9e27675b..f6327f31f 100644 --- a/src/battle_dome.c +++ b/src/battle_dome.c @@ -17,6 +17,7 @@ #include "text.h" #include "bg.h" #include "window.h" +#include "strings.h" #include "palette.h" #include "decompress.h" #include "party_menu.h" @@ -59,177 +60,62 @@ struct UnkStruct_860DD10 }; // text -extern const u8 gTrainerClassNames[][0xD]; - -extern const u8 gBattleDomeOpponentPotential1[]; -extern const u8 gBattleDomeOpponentPotential2[]; -extern const u8 gBattleDomeOpponentPotential3[]; -extern const u8 gBattleDomeOpponentPotential4[]; -extern const u8 gBattleDomeOpponentPotential5[]; -extern const u8 gBattleDomeOpponentPotential6[]; -extern const u8 gBattleDomeOpponentPotential7[]; -extern const u8 gBattleDomeOpponentPotential8[]; -extern const u8 gBattleDomeOpponentPotential9[]; -extern const u8 gBattleDomeOpponentPotential10[]; -extern const u8 gBattleDomeOpponentPotential11[]; -extern const u8 gBattleDomeOpponentPotential12[]; -extern const u8 gBattleDomeOpponentPotential13[]; -extern const u8 gBattleDomeOpponentPotential14[]; -extern const u8 gBattleDomeOpponentPotential15[]; -extern const u8 gBattleDomeOpponentPotential16[]; -extern const u8 gBattleDomeOpponentPotential17[]; -extern const u8 gBattleDomeOpponentStyle1[]; -extern const u8 gBattleDomeOpponentStyle2[]; -extern const u8 gBattleDomeOpponentStyle3[]; -extern const u8 gBattleDomeOpponentStyle4[]; -extern const u8 gBattleDomeOpponentStyle5[]; -extern const u8 gBattleDomeOpponentStyle6[]; -extern const u8 gBattleDomeOpponentStyle7[]; -extern const u8 gBattleDomeOpponentStyle8[]; -extern const u8 gBattleDomeOpponentStyle9[]; -extern const u8 gBattleDomeOpponentStyle10[]; -extern const u8 gBattleDomeOpponentStyle11[]; -extern const u8 gBattleDomeOpponentStyle12[]; -extern const u8 gBattleDomeOpponentStyle13[]; -extern const u8 gBattleDomeOpponentStyle14[]; -extern const u8 gBattleDomeOpponentStyle15[]; -extern const u8 gBattleDomeOpponentStyle16[]; -extern const u8 gBattleDomeOpponentStyle17[]; -extern const u8 gBattleDomeOpponentStyle18[]; -extern const u8 gBattleDomeOpponentStyle19[]; -extern const u8 gBattleDomeOpponentStyle20[]; -extern const u8 gBattleDomeOpponentStyle21[]; -extern const u8 gBattleDomeOpponentStyle22[]; -extern const u8 gBattleDomeOpponentStyle23[]; -extern const u8 gBattleDomeOpponentStyle24[]; -extern const u8 gBattleDomeOpponentStyle25[]; -extern const u8 gBattleDomeOpponentStyle26[]; -extern const u8 gBattleDomeOpponentStyle27[]; -extern const u8 gBattleDomeOpponentStyle28[]; -extern const u8 gBattleDomeOpponentStyleUnused1[]; -extern const u8 gBattleDomeOpponentStyleUnused2[]; -extern const u8 gBattleDomeOpponentStyleUnused3[]; -extern const u8 gBattleDomeOpponentStyleUnused4[]; -extern const u8 gBattleDomeOpponentStats1[]; -extern const u8 gBattleDomeOpponentStats2[]; -extern const u8 gBattleDomeOpponentStats3[]; -extern const u8 gBattleDomeOpponentStats4[]; -extern const u8 gBattleDomeOpponentStats5[]; -extern const u8 gBattleDomeOpponentStats6[]; -extern const u8 gBattleDomeOpponentStats7[]; -extern const u8 gBattleDomeOpponentStats8[]; -extern const u8 gBattleDomeOpponentStats9[]; -extern const u8 gBattleDomeOpponentStats10[]; -extern const u8 gBattleDomeOpponentStats11[]; -extern const u8 gBattleDomeOpponentStats12[]; -extern const u8 gBattleDomeOpponentStats13[]; -extern const u8 gBattleDomeOpponentStats14[]; -extern const u8 gBattleDomeOpponentStats15[]; -extern const u8 gBattleDomeOpponentStats16[]; -extern const u8 gBattleDomeOpponentStats17[]; -extern const u8 gBattleDomeOpponentStats18[]; -extern const u8 gBattleDomeOpponentStats19[]; -extern const u8 gBattleDomeOpponentStats20[]; -extern const u8 gBattleDomeOpponentStats21[]; -extern const u8 gBattleDomeOpponentStats22[]; -extern const u8 gBattleDomeOpponentStats23[]; -extern const u8 gBattleDomeOpponentStats24[]; -extern const u8 gBattleDomeOpponentStats25[]; -extern const u8 gBattleDomeOpponentStats26[]; -extern const u8 gBattleDomeOpponentStats27[]; -extern const u8 gBattleDomeOpponentStats28[]; -extern const u8 gBattleDomeOpponentStats29[]; -extern const u8 gBattleDomeOpponentStats30[]; -extern const u8 gBattleDomeOpponentStats31[]; -extern const u8 gBattleDomeOpponentStats32[]; -extern const u8 gBattleDomeOpponentStats33[]; -extern const u8 gBattleDomeOpponentStats34[]; -extern const u8 gBattleDomeOpponentStats35[]; -extern const u8 gBattleDomeOpponentStats36[]; -extern const u8 gBattleDomeOpponentStats37[]; -extern const u8 gBattleDomeOpponentStats38[]; -extern const u8 gBattleDomeOpponentStats39[]; -extern const u8 gBattleDomeOpponentStats40[]; -extern const u8 gBattleDomeOpponentStats41[]; -extern const u8 gBattleDomeOpponentStats42[]; -extern const u8 gBattleDomeOpponentStats43[]; -extern const u8 gBattleDomeMatchNumber1[]; -extern const u8 gBattleDomeMatchNumber2[]; -extern const u8 gBattleDomeMatchNumber3[]; -extern const u8 gBattleDomeMatchNumber4[]; -extern const u8 gBattleDomeMatchNumber5[]; -extern const u8 gBattleDomeMatchNumber6[]; -extern const u8 gBattleDomeMatchNumber7[]; -extern const u8 gBattleDomeMatchNumber8[]; -extern const u8 gBattleDomeMatchNumber9[]; -extern const u8 gBattleDomeMatchNumber10[]; -extern const u8 gBattleDomeMatchNumber11[]; -extern const u8 gBattleDomeMatchNumber12[]; -extern const u8 gBattleDomeMatchNumber13[]; -extern const u8 gBattleDomeMatchNumber14[]; -extern const u8 gBattleDomeMatchNumber15[]; -extern const u8 gBattleDomeWinStrings1[]; -extern const u8 gBattleDomeWinStrings2[]; -extern const u8 gBattleDomeWinStrings3[]; -extern const u8 gBattleDomeWinStrings4[]; -extern const u8 gBattleDomeWinStrings5[]; -extern const u8 gBattleDomeWinStrings6[]; -extern const u8 gBattleDomeWinStrings7[]; +extern const u8 gTrainerClassNames[][13]; // This file's functions. static u8 GetDomeTrainerMonIvs(u16 trainerId); -static void SwapDomeTrainers(s32 id1, s32 id2, u16 *statsArray); -static void CalcDomeMonStats(u16 species, s32 level, s32 ivs, u8 evBits, u8 nature, s32 *stats); -static void CreateDomeTrainerMons(u16 tournamentTrainerId); -static s32 sub_818FCBC(u16 tournamentTrainerId, bool8 arg1); -static s32 sub_818FDB8(u16 tournamentTrainerId, bool8 arg1); -static s32 GetTypeEffectivenessPoints(s32 move, s32 species, s32 arg2); -static s32 sub_818FEB4(s32 *arr, bool8 arg1); -static void sub_8190400(u8 taskId); +static void SwapDomeTrainers(int id1, int id2, u16 *statsArray); +static void CalcDomeMonStats(u16 species, int level, int ivs, u8 evBits, u8 nature, int *stats); +static void CreateDomeOpponentMons(u16 tournamentTrainerId); +static int sub_818FCBC(u16 tournamentTrainerId, bool8 arg1); +static int sub_818FDB8(u16 tournamentTrainerId, bool8 arg1); +static int GetTypeEffectivenessPoints(int move, int species, int arg2); +static int sub_818FEB4(int *arr, bool8 arg1); +static void Task_ShowOpponentInfo(u8 taskId); static void sub_8190CD4(u8 taskId); static u8 sub_819221C(u8 taskId); -static void sub_8194D48(void); -static s32 TrainerIdToTournamentId(u16 trainerId); +static void InitDomeFacilityTrainersAndMons(void); +static int TrainerIdToTournamentId(u16 trainerId); static u16 TrainerIdOfPlayerOpponent(void); -static void sub_8194220(u8 taskId); +static void Task_ShowTourneyTree(u8 taskId); static void sub_8194950(u8 taskId); static void CB2_BattleDome(void); static void VblankCb0_BattleDome(void); static void DisplayMatchInfoOnCard(u8 flags, u8 matchNo); static void DisplayTrainerInfoOnCard(u8 flags, u8 trainerTournamentId); -static s32 sub_8192F08(u8, u8*); +static int sub_8192F08(u8, u8*); static u8 GetDomeBrainTrainerPicId(void); static u8 GetDomeBrainTrainerClass(void); -static void CopyDomeBrainTrainerName(u8 *dst); -static void CopyDomeTrainerName(u8 *dst, u16 trainerId); +static void CopyDomeBrainTrainerName(u8 *str); +static void CopyDomeTrainerName(u8 *str, u16 trainerId); static void HblankCb_BattleDome(void); static void VblankCb1_BattleDome(void); -static u8 sub_8193BDC(u8 taskId); +static u8 UpdateTourneyTreeCursor(u8 taskId); static void DecideRoundWinners(u8 roundId); static u8 sub_81953E8(u8 tournamentId, u8); static void sub_81948EC(u8, u8); static void sub_8190B40(struct Sprite *sprite); static void sub_8190C6C(struct Sprite *sprite); -static void sub_818E9CC(void); -static void sub_818EA84(void); -static void sub_818ED28(void); -static void sub_818F9B0(void); -static void sub_818F9E0(void); -static void sub_818FA20(void); +static void InitDomeChallenge(void); +static void GetDomeData(void); +static void SetDomeData(void); +static void BufferDomeRoundText(void); +static void BufferDomeOpponentName(void); +static void InitDomeOpponentParty(void); static void ShowDomeOpponentInfo(void); -static void sub_81938A4(void); -static void sub_81938E0(void); -static void sub_8190298(void); -static void sub_81902E4(void); -static void sub_8193D40(void); -static void sub_8193D7C(void); +static void ShowDomeTourneyTree(void); +static void ShowPreviousDomeResultsTourneyTree(void); +static void SetDomeOpponentId(void); +static void SetDomeOpponentGraphicsId(void); +static void ShowNonInteractiveDomeTourneyTree(void); +static void ResolveDomeRoundWinners(void); static void sub_81902F8(void); -static void sub_819033C(void); -static void sub_8194D68(void); -static void sub_8194E44(void); -static void sub_8194EB4(void); -static void sub_8194EC0(void); -static void sub_8194EF8(void); +static void UpdateDomeStreaks(void); +static void RestoreDomePlayerParty(void); +static void RestoreDomePlayerPartyHeldItems(void); +static void ReduceDomePlayerPartyTo3Mons(void); +static void GetPlayerSeededBeforeOpponent(void); +static void BufferLastDomeWinnerName(void); static void sub_8194F58(void); static void InitDomeTrainers(void); @@ -240,7 +126,7 @@ static EWRAM_DATA struct BattleDomeStruct *sBattleDomeStruct = {0}; static EWRAM_DATA u8 *sTilemapBuffer = NULL; // Const rom data. -static const u8 sMovePointsForDomeTrainers[MOVES_COUNT][DOME_TOURNAMENT_TRAINERS_COUNT] = +static const u8 sMovePointsForDomeTrainers[][DOME_TOURNAMENT_TRAINERS_COUNT] = { [MOVE_NONE] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, [MOVE_POUND] = {0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0}, @@ -645,7 +531,7 @@ static const u8 sUnusedArray[] = 0, 0, 0, 254, 0, 0, 0, 0, 0, }; -static const u8 gUnknown_0860CBF1[][5][4]= +static const u8 sTourneyTreeCursorMovementMap[][5][4]= { {{0x07, 0x01, 0x08, 0x10}, {0x07, 0x01, 0x08, 0x10}, {0x07, 0x01, 0x08, 0x10}, {0x07, 0x01, 0x08, 0x10}, {0x07, 0x01, 0x08, 0x10}}, {{0x00, 0x02, 0x09, 0x10}, {0x00, 0x02, 0x09, 0x10}, {0x00, 0x02, 0x09, 0x10}, {0x00, 0x02, 0x09, 0x10}, {0x00, 0x02, 0x09, 0x10}}, @@ -960,14 +846,14 @@ static const struct WindowTemplate gUnknown_0860CEB4[] = // UB: No DUMMY_WIN_TEMPLATE at the array's end. }; -static const struct ScanlineEffectParams gUnknown_0860CF44 = +static const struct ScanlineEffectParams sTourneyTreeScanlineEffectParams = { .dmaDest = (void *)REG_ADDR_BG3CNT, - .dmaControl = 0xa2600001, + .dmaControl = SCANLINE_EFFECT_DMACNT_16BIT, .initState = 1, }; -static const struct CompressedSpriteSheet gUnknown_0860CF50[] = +static const struct CompressedSpriteSheet sDomeOptionsSpriteSheet[] = { {gBattleFrontierGfx_DomeOptions, 0x0600, 0x0000}, {}, @@ -1191,34 +1077,31 @@ static const struct SpriteTemplate gUnknown_0860D068 = .callback = sub_8190C6C }; -static const u8 gUnknown_0860D080[DOME_TOURNAMENT_TRAINERS_COUNT] = -{ - 0x00, 0x08, 0x0c, 0x04, 0x07, 0x0f, 0x0b, 0x03, 0x02, 0x0a, 0x0e, 0x06, 0x05, 0x0d, 0x09, 0x01 -}; +static const u8 sTourneyTreeTrainerIds[] = {0, 8, 12, 4, 7, 15, 11, 3, 2, 10, 14, 6, 5, 13, 9, 1}; -static void (* const gUnknown_0860D090[])(void) = +static void (* const sBattleDomeFunctions[])(void) = { - sub_818E9CC, - sub_818EA84, - sub_818ED28, - sub_818F9B0, - sub_818F9E0, - sub_818FA20, + InitDomeChallenge, + GetDomeData, + SetDomeData, + BufferDomeRoundText, + BufferDomeOpponentName, + InitDomeOpponentParty, ShowDomeOpponentInfo, - sub_81938A4, - sub_81938E0, - sub_8190298, - sub_81902E4, - sub_8193D40, - sub_8193D7C, + ShowDomeTourneyTree, + ShowPreviousDomeResultsTourneyTree, + SetDomeOpponentId, + SetDomeOpponentGraphicsId, + ShowNonInteractiveDomeTourneyTree, + ResolveDomeRoundWinners, sub_81902F8, - sub_819033C, - sub_8194D48, - sub_8194D68, - sub_8194E44, - sub_8194EB4, - sub_8194EC0, - sub_8194EF8, + UpdateDomeStreaks, + InitDomeFacilityTrainersAndMons, + RestoreDomePlayerParty, + RestoreDomePlayerPartyHeldItems, + ReduceDomePlayerPartyTo3Mons, + GetPlayerSeededBeforeOpponent, + BufferLastDomeWinnerName, sub_8194F58, InitDomeTrainers, }; @@ -1293,108 +1176,108 @@ static const u8 gUnknown_0860D1A0[][4] = static const u8 gUnknown_0860D1C0[] = {0x00, 0x0f, 0x08, 0x07, 0x03, 0x0c, 0x0b, 0x04, 0x01, 0x0e, 0x09, 0x06, 0x02, 0x0d, 0x0a, 0x05}; -static const u8 *const gBattleDomePotentialPointers[] = +static const u8 *const sBattleDomePotentialTexts[] = { - gBattleDomeOpponentPotential1, - gBattleDomeOpponentPotential2, - gBattleDomeOpponentPotential3, - gBattleDomeOpponentPotential4, - gBattleDomeOpponentPotential5, - gBattleDomeOpponentPotential6, - gBattleDomeOpponentPotential7, - gBattleDomeOpponentPotential8, - gBattleDomeOpponentPotential9, - gBattleDomeOpponentPotential10, - gBattleDomeOpponentPotential11, - gBattleDomeOpponentPotential12, - gBattleDomeOpponentPotential13, - gBattleDomeOpponentPotential14, - gBattleDomeOpponentPotential15, - gBattleDomeOpponentPotential16, - gBattleDomeOpponentPotential17, + gBattleDomeOpponentPotentialText1, + gBattleDomeOpponentPotentialText2, + gBattleDomeOpponentPotentialText3, + gBattleDomeOpponentPotentialText4, + gBattleDomeOpponentPotentialText5, + gBattleDomeOpponentPotentialText6, + gBattleDomeOpponentPotentialText7, + gBattleDomeOpponentPotentialText8, + gBattleDomeOpponentPotentialText9, + gBattleDomeOpponentPotentialText10, + gBattleDomeOpponentPotentialText11, + gBattleDomeOpponentPotentialText12, + gBattleDomeOpponentPotentialText13, + gBattleDomeOpponentPotentialText14, + gBattleDomeOpponentPotentialText15, + gBattleDomeOpponentPotentialText16, + gBattleDomeOpponentPotentialText17, }; -static const u8 *const gBattleDomeOpponentStylePointers[] = +static const u8 *const sBattleDomeOpponentStyleTexts[] = { - gBattleDomeOpponentStyle1, - gBattleDomeOpponentStyle2, - gBattleDomeOpponentStyle3, - gBattleDomeOpponentStyle4, - gBattleDomeOpponentStyle5, - gBattleDomeOpponentStyle6, - gBattleDomeOpponentStyle7, - gBattleDomeOpponentStyle8, - gBattleDomeOpponentStyle9, - gBattleDomeOpponentStyle10, - gBattleDomeOpponentStyle11, - gBattleDomeOpponentStyle12, - gBattleDomeOpponentStyle13, - gBattleDomeOpponentStyle14, - gBattleDomeOpponentStyle15, - gBattleDomeOpponentStyle16, - gBattleDomeOpponentStyle17, - gBattleDomeOpponentStyle18, - gBattleDomeOpponentStyle19, - gBattleDomeOpponentStyle20, - gBattleDomeOpponentStyle21, - gBattleDomeOpponentStyle22, - gBattleDomeOpponentStyle23, - gBattleDomeOpponentStyle24, - gBattleDomeOpponentStyle25, - gBattleDomeOpponentStyle26, - gBattleDomeOpponentStyle27, - gBattleDomeOpponentStyle28, - gBattleDomeOpponentStyleUnused1, - gBattleDomeOpponentStyleUnused2, - gBattleDomeOpponentStyleUnused3, - gBattleDomeOpponentStyleUnused4, + gBattleDomeOpponentStyleText1, + gBattleDomeOpponentStyleText2, + gBattleDomeOpponentStyleText3, + gBattleDomeOpponentStyleText4, + gBattleDomeOpponentStyleText5, + gBattleDomeOpponentStyleText6, + gBattleDomeOpponentStyleText7, + gBattleDomeOpponentStyleText8, + gBattleDomeOpponentStyleText9, + gBattleDomeOpponentStyleText10, + gBattleDomeOpponentStyleText11, + gBattleDomeOpponentStyleText12, + gBattleDomeOpponentStyleText13, + gBattleDomeOpponentStyleText14, + gBattleDomeOpponentStyleText15, + gBattleDomeOpponentStyleText16, + gBattleDomeOpponentStyleText17, + gBattleDomeOpponentStyleText18, + gBattleDomeOpponentStyleText19, + gBattleDomeOpponentStyleText20, + gBattleDomeOpponentStyleText21, + gBattleDomeOpponentStyleText22, + gBattleDomeOpponentStyleText23, + gBattleDomeOpponentStyleText24, + gBattleDomeOpponentStyleText25, + gBattleDomeOpponentStyleText26, + gBattleDomeOpponentStyleText27, + gBattleDomeOpponentStyleText28, + gBattleDomeOpponentStyleTextUnused1, + gBattleDomeOpponentStyleTextUnused2, + gBattleDomeOpponentStyleTextUnused3, + gBattleDomeOpponentStyleTextUnused4, }; -static const u8 *const gBattleDomeOpponentStatsPointers[] = +static const u8 *const sBattleDomeOpponentStatsTexts[] = { - gBattleDomeOpponentStats1, - gBattleDomeOpponentStats2, - gBattleDomeOpponentStats3, - gBattleDomeOpponentStats4, - gBattleDomeOpponentStats5, - gBattleDomeOpponentStats6, - gBattleDomeOpponentStats7, - gBattleDomeOpponentStats8, - gBattleDomeOpponentStats9, - gBattleDomeOpponentStats10, - gBattleDomeOpponentStats11, - gBattleDomeOpponentStats12, - gBattleDomeOpponentStats13, - gBattleDomeOpponentStats14, - gBattleDomeOpponentStats15, - gBattleDomeOpponentStats16, - gBattleDomeOpponentStats17, - gBattleDomeOpponentStats18, - gBattleDomeOpponentStats19, - gBattleDomeOpponentStats20, - gBattleDomeOpponentStats21, - gBattleDomeOpponentStats22, - gBattleDomeOpponentStats23, - gBattleDomeOpponentStats24, - gBattleDomeOpponentStats25, - gBattleDomeOpponentStats26, - gBattleDomeOpponentStats27, - gBattleDomeOpponentStats28, - gBattleDomeOpponentStats29, - gBattleDomeOpponentStats30, - gBattleDomeOpponentStats31, - gBattleDomeOpponentStats32, - gBattleDomeOpponentStats33, - gBattleDomeOpponentStats34, - gBattleDomeOpponentStats35, - gBattleDomeOpponentStats36, - gBattleDomeOpponentStats37, - gBattleDomeOpponentStats38, - gBattleDomeOpponentStats39, - gBattleDomeOpponentStats40, - gBattleDomeOpponentStats41, - gBattleDomeOpponentStats42, - gBattleDomeOpponentStats43, + gBattleDomeOpponentStatsText1, + gBattleDomeOpponentStatsText2, + gBattleDomeOpponentStatsText3, + gBattleDomeOpponentStatsText4, + gBattleDomeOpponentStatsText5, + gBattleDomeOpponentStatsText6, + gBattleDomeOpponentStatsText7, + gBattleDomeOpponentStatsText8, + gBattleDomeOpponentStatsText9, + gBattleDomeOpponentStatsText10, + gBattleDomeOpponentStatsText11, + gBattleDomeOpponentStatsText12, + gBattleDomeOpponentStatsText13, + gBattleDomeOpponentStatsText14, + gBattleDomeOpponentStatsText15, + gBattleDomeOpponentStatsText16, + gBattleDomeOpponentStatsText17, + gBattleDomeOpponentStatsText18, + gBattleDomeOpponentStatsText19, + gBattleDomeOpponentStatsText20, + gBattleDomeOpponentStatsText21, + gBattleDomeOpponentStatsText22, + gBattleDomeOpponentStatsText23, + gBattleDomeOpponentStatsText24, + gBattleDomeOpponentStatsText25, + gBattleDomeOpponentStatsText26, + gBattleDomeOpponentStatsText27, + gBattleDomeOpponentStatsText28, + gBattleDomeOpponentStatsText29, + gBattleDomeOpponentStatsText30, + gBattleDomeOpponentStatsText31, + gBattleDomeOpponentStatsText32, + gBattleDomeOpponentStatsText33, + gBattleDomeOpponentStatsText34, + gBattleDomeOpponentStatsText35, + gBattleDomeOpponentStatsText36, + gBattleDomeOpponentStatsText37, + gBattleDomeOpponentStatsText38, + gBattleDomeOpponentStatsText39, + gBattleDomeOpponentStatsText40, + gBattleDomeOpponentStatsText41, + gBattleDomeOpponentStatsText42, + gBattleDomeOpponentStatsText43, }; static const u8 sInfoTrainerMonX[] = {0x68, 0x88, 0x68}; @@ -1403,34 +1286,34 @@ static const u8 gUnknown_0860D346[] = {0x00, 0x04, 0x00}; static const u8 gUnknown_0860D349[] = {0x00, 0x05, 0x09, 0x0c, 0x0e, 0x00, 0x00}; -static const u8 *const gBattleDomeMatchNumberPointers[] = +static const u8 *const sBattleDomeMatchNumberTexts[] = { - gBattleDomeMatchNumber1, - gBattleDomeMatchNumber2, - gBattleDomeMatchNumber3, - gBattleDomeMatchNumber4, - gBattleDomeMatchNumber5, - gBattleDomeMatchNumber6, - gBattleDomeMatchNumber7, - gBattleDomeMatchNumber8, - gBattleDomeMatchNumber9, - gBattleDomeMatchNumber10, - gBattleDomeMatchNumber11, - gBattleDomeMatchNumber12, - gBattleDomeMatchNumber13, - gBattleDomeMatchNumber14, - gBattleDomeMatchNumber15, + gBattleDomeMatchNumberText1, + gBattleDomeMatchNumberText2, + gBattleDomeMatchNumberText3, + gBattleDomeMatchNumberText4, + gBattleDomeMatchNumberText5, + gBattleDomeMatchNumberText6, + gBattleDomeMatchNumberText7, + gBattleDomeMatchNumberText8, + gBattleDomeMatchNumberText9, + gBattleDomeMatchNumberText10, + gBattleDomeMatchNumberText11, + gBattleDomeMatchNumberText12, + gBattleDomeMatchNumberText13, + gBattleDomeMatchNumberText14, + gBattleDomeMatchNumberText15, }; -static const u8 *const gBattleDomeWinStringsPointers[] = +static const u8 *const sBattleDomeWinTexts[] = { - gBattleDomeWinStrings1, - gBattleDomeWinStrings2, - gBattleDomeWinStrings3, - gBattleDomeWinStrings4, - gBattleDomeWinStrings5, - gBattleDomeWinStrings6, - gBattleDomeWinStrings7, + gBattleDomeWinText1, + gBattleDomeWinText2, + gBattleDomeWinText3, + gBattleDomeWinText4, + gBattleDomeWinText5, + gBattleDomeWinText6, + gBattleDomeWinText7, }; static const u8 sFirstTrainerMonX[] = {0x60, 0x60, 0x60}; @@ -2373,10 +2256,10 @@ static const u8 gUnknown_0860DE10[DOME_TOURNAMENT_TRAINERS_COUNT][4] = // code void CallBattleDomeFunction(void) { - gUnknown_0860D090[gSpecialVar_0x8004](); + sBattleDomeFunctions[gSpecialVar_0x8004](); } -static void sub_818E9CC(void) +static void InitDomeChallenge(void) { u32 lvlMode = gSaveBlock2Ptr->frontier.lvlMode; u32 battleMode = VarGet(VAR_FRONTIER_BATTLE_MODE); @@ -2392,7 +2275,7 @@ static void sub_818E9CC(void) gTrainerBattleOpponent_A = 0; } -static void sub_818EA84(void) +static void GetDomeData(void) { u32 lvlMode = gSaveBlock2Ptr->frontier.lvlMode; u32 battleMode = VarGet(VAR_FRONTIER_BATTLE_MODE); @@ -2460,7 +2343,7 @@ static void sub_818EA84(void) } } -static void sub_818ED28(void) +static void SetDomeData(void) { u32 lvlMode = gSaveBlock2Ptr->frontier.lvlMode; u32 battleMode = VarGet(VAR_FRONTIER_BATTLE_MODE); @@ -2528,21 +2411,21 @@ static void sub_818ED28(void) static void InitDomeTrainers(void) { - s32 i, j, k; - s32 monLevel; - s32 species[3]; - s32 monTypesBits, monTypesCount; - s32 trainerId; - s32 monSetId; + int i, j, k; + int monLevel; + int species[3]; + int monTypesBits, monTypesCount; + int trainerId; + int monSetId; u16 *statSums; - s32 *statValues; + int *statValues; u8 ivs = 0; species[0] = 0; species[1] = 0; species[2] = 0; statSums = AllocZeroed(sizeof(u16) * DOME_TOURNAMENT_TRAINERS_COUNT); - statValues = AllocZeroed(sizeof(s32) * 6); + statValues = AllocZeroed(sizeof(int) * 6); gSaveBlock2Ptr->frontier.field_D0A = gSaveBlock2Ptr->frontier.lvlMode + 1; gSaveBlock2Ptr->frontier.field_D0B = VarGet(VAR_FRONTIER_BATTLE_MODE) + 1; @@ -2599,7 +2482,7 @@ static void InitDomeTrainers(void) monSetId = RandomizeFacilityTrainerMonSet(trainerId); for (k = 0; k < j; k++) { - s32 checkingMonSetId = gSaveBlock2Ptr->frontier.domeMonIds[i][k]; + int checkingMonSetId = gSaveBlock2Ptr->frontier.domeMonIds[i][k]; if (checkingMonSetId == monSetId || species[0] == gFacilityTrainerMons[monSetId].species || species[1] == gFacilityTrainerMons[monSetId].species @@ -2729,12 +2612,12 @@ static void InitDomeTrainers(void) stats[statIndex] = (u8) ModifyStatByNature(nature, stats[statIndex], statIndex); \ } -static void CalcDomeMonStats(u16 species, s32 level, s32 ivs, u8 evBits, u8 nature, s32 *stats) +static void CalcDomeMonStats(u16 species, int level, int ivs, u8 evBits, u8 nature, int *stats) { - s32 i, count; + int i, count; u8 bits; u16 resultingEvs; - s32 evs[NUM_STATS]; + int evs[NUM_STATS]; count = 0, bits = evBits; for (i = 0; i < NUM_STATS; bits >>= 1, i++) @@ -2757,7 +2640,7 @@ static void CalcDomeMonStats(u16 species, s32 level, s32 ivs, u8 evBits, u8 natu } else { - s32 n = 2 * gBaseStats[species].baseHP; + int n = 2 * gBaseStats[species].baseHP; stats[STAT_HP] = (((n + ivs + evs[STAT_HP] / 4) * level) / 100) + level + 10; } @@ -2768,9 +2651,9 @@ static void CalcDomeMonStats(u16 species, s32 level, s32 ivs, u8 evBits, u8 natu CALC_STAT(baseSpDefense, STAT_SPDEF); } -static void SwapDomeTrainers(s32 id1, s32 id2, u16 *statsArray) +static void SwapDomeTrainers(int id1, int id2, u16 *statsArray) { - s32 i; + int i; u16 temp; SWAP(statsArray[id1], statsArray[id2], temp); @@ -2780,29 +2663,29 @@ static void SwapDomeTrainers(s32 id1, s32 id2, u16 *statsArray) SWAP(gSaveBlock2Ptr->frontier.domeMonIds[id1][i], gSaveBlock2Ptr->frontier.domeMonIds[id2][i], temp); } -static void sub_818F9B0(void) +static void BufferDomeRoundText(void) { StringCopy(gStringVar1, gRoundsStringTable[gSaveBlock2Ptr->frontier.curChallengeBattleNum]); } -static void sub_818F9E0(void) +static void BufferDomeOpponentName(void) { StringCopy(gStringVar1, gRoundsStringTable[gSaveBlock2Ptr->frontier.curChallengeBattleNum]); CopyDomeTrainerName(gStringVar2, gTrainerBattleOpponent_A); } -static void sub_818FA20(void) +static void InitDomeOpponentParty(void) { gUnknown_0203CD70 = 0; gUnknown_0203CD74 = GetMonData(&gPlayerParty[0], MON_DATA_MAX_HP, NULL); gUnknown_0203CD74 += GetMonData(&gPlayerParty[1], MON_DATA_MAX_HP, NULL); CalculatePlayerPartyCount(); - CreateDomeTrainerMons(TrainerIdToTournamentId(gTrainerBattleOpponent_A)); + CreateDomeOpponentMons(TrainerIdToTournamentId(gTrainerBattleOpponent_A)); } -static void CreateDomeMon(u8 monPartyId, u16 tournamentTrainerId, u8 tournamentMonId, u32 otId) +static void CreateDomeOpponentMon(u8 monPartyId, u16 tournamentTrainerId, u8 tournamentMonId, u32 otId) { - s32 i; + int i; u8 happiness = 0xFF; u8 fixedIv = GetDomeTrainerMonIvs(tournamentTrainerId); // BUG: Should be using trainerId instead of tournamentTrainerId. As a result, all Pokemon have ivs of 3. u8 level = SetFacilityPtrsGetLevel(); @@ -2827,11 +2710,11 @@ static void CreateDomeMon(u8 monPartyId, u16 tournamentTrainerId, u8 tournamentM &gBattleFrontierHeldItems[gFacilityTrainerMons[gSaveBlock2Ptr->frontier.domeMonIds[tournamentTrainerId][tournamentMonId]].itemTableId]); } -static void CreateDomeTrainerMons(u16 tournamentTrainerId) +static void CreateDomeOpponentMons(u16 tournamentTrainerId) { u8 monsCount = 0; u32 otId = 0; - s32 i, bits; + int i, bits; ZeroEnemyPartyMons(); bits = GetDomeTrainerMonCountInBits(tournamentTrainerId); @@ -2842,7 +2725,7 @@ static void CreateDomeTrainerMons(u16 tournamentTrainerId) { if (bits & 1) { - CreateDomeMon(monsCount, tournamentTrainerId, i, otId); + CreateDomeOpponentMon(monsCount, tournamentTrainerId, i, otId); monsCount++; } bits >>= 1; @@ -2854,7 +2737,7 @@ static void CreateDomeTrainerMons(u16 tournamentTrainerId) { if (bits & 4) { - CreateDomeMon(monsCount, tournamentTrainerId, i, otId); + CreateDomeOpponentMon(monsCount, tournamentTrainerId, i, otId); monsCount++; } bits <<= 1; @@ -2862,9 +2745,9 @@ static void CreateDomeTrainerMons(u16 tournamentTrainerId) } } -s32 GetDomeTrainerMonCountInBits(u16 tournamentTrainerId) +int GetDomeTrainerMonCountInBits(u16 tournamentTrainerId) { - s32 bits; + int bits; if (Random() & 1) { bits = sub_818FCBC(tournamentTrainerId, FALSE); @@ -2881,10 +2764,10 @@ s32 GetDomeTrainerMonCountInBits(u16 tournamentTrainerId) return bits; } -static s32 sub_818FCBC(u16 tournamentTrainerId, bool8 arg1) +static int sub_818FCBC(u16 tournamentTrainerId, bool8 arg1) { - s32 i, moveId, playerMonId; - s32 array[3]; + int i, moveId, playerMonId; + int array[3]; for (i = 0; i < 3; i++) { @@ -2909,10 +2792,10 @@ static s32 sub_818FCBC(u16 tournamentTrainerId, bool8 arg1) return sub_818FEB4(array, arg1); } -static s32 sub_818FDB8(u16 tournamentTrainerId, bool8 arg1) +static int sub_818FDB8(u16 tournamentTrainerId, bool8 arg1) { - s32 i, moveId, playerMonId; - s32 array[3]; + int i, moveId, playerMonId; + int array[3]; for (i = 0; i < 3; i++) { @@ -2937,11 +2820,11 @@ static s32 sub_818FDB8(u16 tournamentTrainerId, bool8 arg1) return sub_818FEB4(array, arg1); } -static s32 sub_818FEB4(s32 *arr, bool8 arg1) +static int sub_818FEB4(int *arr, bool8 arg1) { - s32 i, j; - s32 bits = 0; - s32 array[3]; + int i, j; + int bits = 0; + int array[3]; for (i = 0; i < 3; i++) array[i] = i; @@ -2968,7 +2851,7 @@ static s32 sub_818FEB4(s32 *arr, bool8 arg1) { for (j = i + 1; j < 3; j++) { - s32 temp; + int temp; if (arr[i] < arr[j]) { @@ -3012,11 +2895,11 @@ static s32 sub_818FEB4(s32 *arr, bool8 arg1) // Functionally equivalent, while loop is impossible to match. #ifdef NONMATCHING -static s32 GetTypeEffectivenessPoints(s32 move, s32 targetSpecies, s32 arg2) +static int GetTypeEffectivenessPoints(int move, int targetSpecies, int arg2) { - s32 defType1, defType2, defAbility, moveType; - s32 i = 0; - s32 typePower = TYPE_x1; + int defType1, defType2, defAbility, moveType; + int i = 0; + int typePower = TYPE_x1; if (move == MOVE_NONE || move == 0xFFFF || gBattleMoves[move].power == 0) return 0; @@ -3131,7 +3014,7 @@ static s32 GetTypeEffectivenessPoints(s32 move, s32 targetSpecies, s32 arg2) } #else NAKED -static s32 GetTypeEffectivenessPoints(s32 move, s32 species, s32 arg2) +static int GetTypeEffectivenessPoints(int move, int species, int arg2) { asm_unified("\n\ push {r4-r7,lr}\n\ @@ -3394,9 +3277,9 @@ static u8 GetDomeTrainerMonIvs(u16 trainerId) return fixedIv; } -static s32 TournamentIdOfOpponent(s32 roundId, s32 trainerId) +static int TournamentIdOfOpponent(int roundId, int trainerId) { - s32 i, j, val; + int i, j, val; for (i = 0; i < DOME_TOURNAMENT_TRAINERS_COUNT; i++) { @@ -3431,7 +3314,7 @@ static s32 TournamentIdOfOpponent(s32 roundId, s32 trainerId) } } -static void sub_8190298(void) +static void SetDomeOpponentId(void) { gTrainerBattleOpponent_A = TrainerIdOfPlayerOpponent(); } @@ -3441,7 +3324,7 @@ static u16 TrainerIdOfPlayerOpponent(void) return gSaveBlock2Ptr->frontier.domeTrainers[TournamentIdOfOpponent(gSaveBlock2Ptr->frontier.curChallengeBattleNum, TRAINER_PLAYER)].trainerId; } -static void sub_81902E4(void) +static void SetDomeOpponentGraphicsId(void) { SetBattleFacilityTrainerGfxId(gTrainerBattleOpponent_A, 0); } @@ -3454,7 +3337,7 @@ static void sub_81902F8(void) sub_81A4C30(); } -static void sub_819033C(void) +static void UpdateDomeStreaks(void) { u8 lvlMode = gSaveBlock2Ptr->frontier.lvlMode; u8 battleMode = VarGet(VAR_FRONTIER_BATTLE_MODE); @@ -3470,7 +3353,7 @@ static void sub_819033C(void) static void ShowDomeOpponentInfo(void) { - u8 taskId = CreateTask(sub_8190400, 0); + u8 taskId = CreateTask(Task_ShowOpponentInfo, 0); gTasks[taskId].data[0] = 0; gTasks[taskId].data[1] = TrainerIdToTournamentId(TrainerIdOfPlayerOpponent()); gTasks[taskId].data[2] = 0; @@ -3479,12 +3362,12 @@ static void ShowDomeOpponentInfo(void) SetMainCallback2(CB2_BattleDome); } -static void sub_8190400(u8 taskId) +static void Task_ShowOpponentInfo(u8 taskId) { - s32 i; - s32 r5 = gTasks[taskId].data[1]; - s32 r9 = gTasks[taskId].data[2]; - s32 r7 = gTasks[taskId].data[3]; + int i; + int r5 = gTasks[taskId].data[1]; + int r9 = gTasks[taskId].data[2]; + int r7 = gTasks[taskId].data[3]; switch (gTasks[taskId].data[0]) { @@ -3531,7 +3414,7 @@ static void sub_8190400(u8 taskId) DecompressAndLoadBgGfxUsingHeap(2, gUnknown_08D83D50, 0x2000, 0, 0); DecompressAndLoadBgGfxUsingHeap(2, gUnknown_08D84970, 0x2000, 0, 1); DecompressAndLoadBgGfxUsingHeap(3, gUnknown_08D84F00, 0x800, 0, 1); - LoadCompressedSpriteSheet(gUnknown_0860CF50); + LoadCompressedSpriteSheet(sDomeOptionsSpriteSheet); LoadCompressedPalette(gUnknown_08D85358, 0, 0x200); LoadCompressedPalette(gUnknown_08D85444, 0x100, 0x200); LoadCompressedPalette(gUnknown_08D85600, 0xF0, 0x20); @@ -3774,10 +3657,10 @@ static void SpriteCb_MonIconCardScrollRight(struct Sprite *sprite) static void sub_8190B40(struct Sprite *sprite) { - s32 taskId1 = sprite->data[0]; - s32 arrId = gTasks[gTasks[taskId1].data[4]].data[1]; - s32 tournmanetTrainerId = gUnknown_0860D080[arrId]; - s32 roundId = gSaveBlock2Ptr->frontier.curChallengeBattleNum; + int taskId1 = sprite->data[0]; + int arrId = gTasks[gTasks[taskId1].data[4]].data[1]; + int tournmanetTrainerId = sTourneyTreeTrainerIds[arrId]; + int roundId = gSaveBlock2Ptr->frontier.curChallengeBattleNum; if (gTasks[taskId1].data[3] == 1) { @@ -3843,7 +3726,7 @@ static void sub_8190B40(struct Sprite *sprite) static void sub_8190C6C(struct Sprite *sprite) { - s32 taskId1 = sprite->data[0]; + int taskId1 = sprite->data[0]; if (gTasks[taskId1].data[3] == 1) { @@ -3873,12 +3756,12 @@ static void sub_8190C6C(struct Sprite *sprite) static void sub_8190CD4(u8 taskId) { - s32 i; - s32 windowId = 0; - s32 r9 = gTasks[taskId].data[3]; - s32 taskId2 = gTasks[taskId].data[4]; - s32 trainerTournamentId = 0; - s32 matchNo = 0; + int i; + int windowId = 0; + int r9 = gTasks[taskId].data[3]; + int taskId2 = gTasks[taskId].data[4]; + int trainerTournamentId = 0; + int matchNo = 0; switch (gTasks[taskId].data[0]) { @@ -3946,14 +3829,14 @@ static void sub_8190CD4(u8 taskId) { gBattle_BG2_X = 0; gBattle_BG2_Y = 320; - trainerTournamentId = gUnknown_0860D080[gTasks[taskId2].data[1]]; + trainerTournamentId = sTourneyTreeTrainerIds[gTasks[taskId2].data[1]]; DisplayTrainerInfoOnCard(gTasks[taskId].data[2] | 0x10, trainerTournamentId); } else { gBattle_BG2_X = 256; gBattle_BG2_Y = 0; - trainerTournamentId = gUnknown_0860D080[gTasks[taskId2].data[1]]; + trainerTournamentId = sTourneyTreeTrainerIds[gTasks[taskId2].data[1]]; DisplayTrainerInfoOnCard(gTasks[taskId].data[2] | 0x10, trainerTournamentId); sBattleDomeStruct->unk_10 = 0; } @@ -4062,14 +3945,14 @@ static void sub_8190CD4(u8 taskId) { gBattle_BG2_X = 0; gBattle_BG2_Y = 160; - trainerTournamentId = gUnknown_0860D080[gTasks[taskId2].data[1]]; + trainerTournamentId = sTourneyTreeTrainerIds[gTasks[taskId2].data[1]]; DisplayTrainerInfoOnCard(gTasks[taskId].data[2] | 4, trainerTournamentId); } else { gBattle_BG2_X = 0; gBattle_BG2_Y = 0; - trainerTournamentId = gUnknown_0860D080[gTasks[taskId2].data[1]]; + trainerTournamentId = sTourneyTreeTrainerIds[gTasks[taskId2].data[1]]; DisplayTrainerInfoOnCard(gTasks[taskId].data[2] | 4, trainerTournamentId); sBattleDomeStruct->unk_10 = 0; } @@ -4175,7 +4058,7 @@ static void sub_8190CD4(u8 taskId) { gBattle_BG2_X = 256; gBattle_BG2_Y = 160; - trainerTournamentId = gUnknown_0860D080[gTasks[taskId2].data[1]]; + trainerTournamentId = sTourneyTreeTrainerIds[gTasks[taskId2].data[1]]; DisplayTrainerInfoOnCard(gTasks[taskId].data[2] | 8, trainerTournamentId); } else @@ -4574,7 +4457,7 @@ static void sub_8190CD4(u8 taskId) } else { - i = CreateTask(sub_8194220, 0); + i = CreateTask(Task_ShowTourneyTree, 0); gTasks[i].data[0] = 0; gTasks[i].data[1] = 0; gTasks[i].data[2] = 3; @@ -4590,9 +4473,9 @@ static void sub_8190CD4(u8 taskId) static u8 sub_819221C(u8 taskId) { u8 retVal = 0; - s32 taskId2 = gTasks[taskId].data[4]; - s32 r5 = gTasks[taskId2].data[1]; - u8 r10 = gUnknown_0860D080[r5]; + int taskId2 = gTasks[taskId].data[4]; + int r5 = gTasks[taskId2].data[1]; + u8 r10 = sTourneyTreeTrainerIds[r5]; u16 roundId = gSaveBlock2Ptr->frontier.curChallengeBattleNum; if (gMain.newKeys & (A_BUTTON | B_BUTTON)) @@ -4699,12 +4582,12 @@ static u8 sub_819221C(u8 taskId) static void DisplayTrainerInfoOnCard(u8 flags, u8 trainerTournamentId) { struct TextPrinterTemplate textPrinter; - s32 i, j, k; - s32 trainerId = 0; + int i, j, k; + int trainerId = 0; u8 nature = 0; - s32 arrId = 0; - s32 windowId = 0; - s32 x = 0, y = 0; + int arrId = 0; + int windowId = 0; + int x = 0, y = 0; u8 palSlot = 0; s16 *allocatedArray = AllocZeroed(sizeof(s16) * 18); trainerId = gSaveBlock2Ptr->frontier.domeTrainers[trainerTournamentId].trainerId; @@ -4835,9 +4718,9 @@ static void DisplayTrainerInfoOnCard(u8 flags, u8 trainerTournamentId) PutWindowTilemap(windowId + 4); CopyWindowToVram(windowId + 4, 3); if (trainerId == TRAINER_FRONTIER_BRAIN) - textPrinter.currentChar = gBattleDomePotentialPointers[16]; + textPrinter.currentChar = sBattleDomePotentialTexts[16]; else - textPrinter.currentChar = gBattleDomePotentialPointers[trainerTournamentId]; + textPrinter.currentChar = sBattleDomePotentialTexts[trainerTournamentId]; textPrinter.fontId = 1; textPrinter.windowId = windowId + 4; @@ -4864,7 +4747,7 @@ static void DisplayTrainerInfoOnCard(u8 flags, u8 trainerTournamentId) for (i = 0; i < ARRAY_COUNT(gUnknown_0860C988); i++) { - s32 r4 = 0; + int r4 = 0; for (k = 0, j = 0; j < DOME_TOURNAMENT_TRAINERS_COUNT; j++) { @@ -4879,7 +4762,7 @@ static void DisplayTrainerInfoOnCard(u8 flags, u8 trainerTournamentId) break; } - textPrinter.currentChar = gBattleDomeOpponentStylePointers[i]; + textPrinter.currentChar = sBattleDomeOpponentStyleTexts[i]; textPrinter.y = 20; textPrinter.currentY = 20; AddTextPrinter(&textPrinter, 0, NULL); @@ -4930,7 +4813,7 @@ static void DisplayTrainerInfoOnCard(u8 flags, u8 trainerTournamentId) { for (i = 0; i < 3; i++) { - s32 evBits = gFacilityTrainerMons[gSaveBlock2Ptr->frontier.domeMonIds[trainerTournamentId][i]].evSpread; + int evBits = gFacilityTrainerMons[gSaveBlock2Ptr->frontier.domeMonIds[trainerTournamentId][i]].evSpread; for (k = 0, j = 0; j < NUM_STATS; j++) { allocatedArray[j] = 0; @@ -5051,19 +4934,19 @@ static void DisplayTrainerInfoOnCard(u8 flags, u8 trainerTournamentId) else i = 42; - textPrinter.currentChar = gBattleDomeOpponentStatsPointers[i]; + textPrinter.currentChar = sBattleDomeOpponentStatsTexts[i]; textPrinter.y = 36; textPrinter.currentY = 36; AddTextPrinter(&textPrinter, 0, NULL); Free(allocatedArray); } -static s32 sub_8192F08(u8 arg0, u8 *arg1) +static int sub_8192F08(u8 arg0, u8 *arg1) { - s32 i; + int i; u8 tournamentId; - s32 retVal = 0; - s32 count = 0; + int retVal = 0; + int count = 0; for (i = gUnknown_0860D3C4[arg0][0]; i < gUnknown_0860D3C4[arg0][0] + gUnknown_0860D3C4[arg0][1]; i++) { @@ -5123,14 +5006,14 @@ static s32 sub_8192F08(u8 arg0, u8 *arg1) static void DisplayMatchInfoOnCard(u8 flags, u8 matchNo) { struct TextPrinterTemplate textPrinter; - s32 tournamentIds[2]; - s32 trainerIds[2]; + int tournamentIds[2]; + int trainerIds[2]; bool32 lost[2]; - s32 i; - s32 winStringId = 0; - s32 arrId = 0; - s32 windowId = 0; - s32 x = 0, y = 0; + int i; + int winStringId = 0; + int arrId = 0; + int windowId = 0; + int x = 0, y = 0; u8 palSlot = 0; if (flags & 1) @@ -5274,7 +5157,7 @@ static void DisplayMatchInfoOnCard(u8 flags, u8 matchNo) textPrinter.fgColor = 14; textPrinter.bgColor = 0; textPrinter.shadowColor = 13; - StringExpandPlaceholders(gStringVar4, gBattleDomeWinStringsPointers[winStringId]); + StringExpandPlaceholders(gStringVar4, sBattleDomeWinTexts[winStringId]); textPrinter.currentChar = gStringVar4; textPrinter.windowId = windowId + 8; textPrinter.fontId = 1; @@ -5320,7 +5203,7 @@ static void DisplayMatchInfoOnCard(u8 flags, u8 matchNo) // Print match number. textPrinter.letterSpacing = 0; - textPrinter.currentChar = gBattleDomeMatchNumberPointers[matchNo]; + textPrinter.currentChar = sBattleDomeMatchNumberTexts[matchNo]; textPrinter.windowId = windowId + 5; textPrinter.currentX = GetStringCenterAlignXOffsetWithLetterSpacing(textPrinter.fontId, textPrinter.currentChar, 0xA0, textPrinter.letterSpacing); textPrinter.currentY = textPrinter.y = 2; @@ -5329,9 +5212,9 @@ static void DisplayMatchInfoOnCard(u8 flags, u8 matchNo) AddTextPrinter(&textPrinter, 0, NULL); } -static void sub_81938A4(void) +static void ShowDomeTourneyTree(void) { - u8 taskId = CreateTask(sub_8194220, 0); + u8 taskId = CreateTask(Task_ShowTourneyTree, 0); gTasks[taskId].data[0] = 0; gTasks[taskId].data[1] = 0; gTasks[taskId].data[2] = 2; @@ -5339,14 +5222,14 @@ static void sub_81938A4(void) SetMainCallback2(CB2_BattleDome); } -static void sub_81938E0(void) +static void ShowPreviousDomeResultsTourneyTree(void) { u8 taskId; - sub_8194D48(); + InitDomeFacilityTrainersAndMons(); gSaveBlock2Ptr->frontier.lvlMode = gSaveBlock2Ptr->frontier.field_D0A - 1; gSaveBlock2Ptr->frontier.curChallengeBattleNum = 3; - taskId = CreateTask(sub_8194220, 0); + taskId = CreateTask(Task_ShowTourneyTree, 0); gTasks[taskId].data[0] = 0; gTasks[taskId].data[1] = 0; gTasks[taskId].data[2] = 2; @@ -5357,7 +5240,7 @@ static void sub_81938E0(void) static void sub_819395C(u8 taskId) { u8 newTaskId = 0; - s32 spriteId = gTasks[taskId].data[1]; + int spriteId = gTasks[taskId].data[1]; switch (gTasks[taskId].data[0]) { @@ -5374,7 +5257,7 @@ static void sub_819395C(u8 taskId) gTasks[taskId].data[0] = 2; break; case 2: - switch (sub_8193BDC(taskId)) + switch (UpdateTourneyTreeCursor(taskId)) { case 0: default: @@ -5399,9 +5282,9 @@ static void sub_819395C(u8 taskId) FreeAllWindowBuffers(); ScanlineEffect_Stop(); FREE_AND_SET_NULL(sTilemapBuffer); - newTaskId = CreateTask(sub_8190400, 0); + newTaskId = CreateTask(Task_ShowOpponentInfo, 0); gTasks[newTaskId].data[0] = 0; - gTasks[newTaskId].data[1] = gUnknown_0860D080[spriteId]; + gTasks[newTaskId].data[1] = sTourneyTreeTrainerIds[spriteId]; gTasks[newTaskId].data[2] = 1; gTasks[newTaskId].data[3] = taskId; @@ -5417,7 +5300,7 @@ static void sub_819395C(u8 taskId) FreeAllWindowBuffers(); ScanlineEffect_Stop(); FREE_AND_SET_NULL(sTilemapBuffer); - newTaskId = CreateTask(sub_8190400, 0); + newTaskId = CreateTask(Task_ShowOpponentInfo, 0); gTasks[newTaskId].data[0] = 0; gTasks[newTaskId].data[1] = spriteId - 16; gTasks[newTaskId].data[2] = 2; @@ -5442,21 +5325,21 @@ static void sub_819395C(u8 taskId) } } -static u8 sub_8193BDC(u8 taskId) +static u8 UpdateTourneyTreeCursor(u8 taskId) { u8 retVal = 1; - s32 arrId = 4; - s32 spriteId = gTasks[taskId].data[1]; - s32 roundId = gSaveBlock2Ptr->frontier.curChallengeBattleNum; + int direction = 4; + int tourneyTreeCursorSpriteId = gTasks[taskId].data[1]; + int roundId = gSaveBlock2Ptr->frontier.curChallengeBattleNum; - if (gMain.newKeys == B_BUTTON || (gMain.newKeys & A_BUTTON && spriteId == 31)) + if (gMain.newKeys == B_BUTTON || (gMain.newKeys & A_BUTTON && tourneyTreeCursorSpriteId == 31)) { PlaySE(SE_SELECT); retVal = 0; } else if (gMain.newKeys & A_BUTTON) { - if (spriteId < 16) + if (tourneyTreeCursorSpriteId < 16) { PlaySE(SE_SELECT); retVal = 2; @@ -5469,31 +5352,31 @@ static u8 sub_8193BDC(u8 taskId) } else { - if (gMain.newKeys == DPAD_UP && gUnknown_0860CBF1[spriteId][roundId][0] != 0xFF) - arrId = 0; - else if (gMain.newKeys == DPAD_DOWN && gUnknown_0860CBF1[spriteId][roundId][1] != 0xFF) - arrId = 1; - else if (gMain.newKeys == DPAD_LEFT && gUnknown_0860CBF1[spriteId][roundId][2] != 0xFF) - arrId = 2; - else if (gMain.newKeys == DPAD_RIGHT && gUnknown_0860CBF1[spriteId][roundId][3] != 0xFF) - arrId = 3; + if (gMain.newKeys == DPAD_UP && sTourneyTreeCursorMovementMap[tourneyTreeCursorSpriteId][roundId][0] != 0xFF) + direction = 0; + else if (gMain.newKeys == DPAD_DOWN && sTourneyTreeCursorMovementMap[tourneyTreeCursorSpriteId][roundId][1] != 0xFF) + direction = 1; + else if (gMain.newKeys == DPAD_LEFT && sTourneyTreeCursorMovementMap[tourneyTreeCursorSpriteId][roundId][2] != 0xFF) + direction = 2; + else if (gMain.newKeys == DPAD_RIGHT && sTourneyTreeCursorMovementMap[tourneyTreeCursorSpriteId][roundId][3] != 0xFF) + direction = 3; } - if (arrId != 4) + if (direction != 4) { PlaySE(SE_SELECT); - StartSpriteAnim(&gSprites[spriteId], 0); - spriteId = gUnknown_0860CBF1[spriteId][roundId][arrId]; - StartSpriteAnim(&gSprites[spriteId], 1); - gTasks[taskId].data[1] = spriteId; + StartSpriteAnim(&gSprites[tourneyTreeCursorSpriteId], 0); + tourneyTreeCursorSpriteId = sTourneyTreeCursorMovementMap[tourneyTreeCursorSpriteId][roundId][direction]; + StartSpriteAnim(&gSprites[tourneyTreeCursorSpriteId], 1); + gTasks[taskId].data[1] = tourneyTreeCursorSpriteId; } return retVal; } -static void sub_8193D40(void) +static void ShowNonInteractiveDomeTourneyTree(void) { - u8 taskId = CreateTask(sub_8194220, 0); + u8 taskId = CreateTask(Task_ShowTourneyTree, 0); gTasks[taskId].data[0] = 0; gTasks[taskId].data[1] = 1; gTasks[taskId].data[2] = 2; @@ -5501,9 +5384,9 @@ static void sub_8193D40(void) SetMainCallback2(CB2_BattleDome); } -static void sub_8193D7C(void) +static void ResolveDomeRoundWinners(void) { - s32 i; + int i; if (gSpecialVar_0x8005 == 1) { @@ -5525,14 +5408,14 @@ static void sub_8193D7C(void) } } -static u16 GetWinningMove(s32 winnerTournamentId, s32 loserTournamentId, u8 roundId) +static u16 GetWinningMove(int winnerTournamentId, int loserTournamentId, u8 roundId) { - s32 i, j, k; - s32 moveScores[4 * 3]; + int i, j, k; + int moveScores[4 * 3]; u16 moveIds[4 * 3]; u16 bestScore = 0; u16 bestId = 0; - s32 movePower = 0; + int movePower = 0; SetFacilityPtrsGetLevel(); // Calc move points of all 4 moves for all 3 pokemon hitting all 3 target mons. @@ -5639,12 +5522,12 @@ static u16 GetWinningMove(s32 winnerTournamentId, s32 loserTournamentId, u8 roun return moveIds[j]; } -static void sub_8194220(u8 taskId) +static void Task_ShowTourneyTree(u8 taskId) { - s32 i; + int i; struct TextPrinterTemplate textPrinter; - s32 r10 = gTasks[taskId].data[1]; - s32 r4 = gTasks[taskId].data[2]; + int r10 = gTasks[taskId].data[1]; + int r4 = gTasks[taskId].data[2]; switch (gTasks[taskId].data[0]) { @@ -5703,7 +5586,7 @@ static void sub_8194220(u8 taskId) gTasks[taskId].data[0]++; break; case 3: - LoadCompressedSpriteSheet(gUnknown_0860CF50); + LoadCompressedSpriteSheet(sDomeOptionsSpriteSheet); if (r10 == 0) { for (i = 0; i < (unsigned) 31; i++) @@ -5734,7 +5617,7 @@ static void sub_8194220(u8 taskId) AddTextPrinter(&textPrinter, 0, NULL); for (i = 0; i < DOME_TOURNAMENT_TRAINERS_COUNT; i++) { - s32 roundId, var2; + int roundId, var2; CopyDomeTrainerName(gDisplayedStringBattle, gSaveBlock2Ptr->frontier.domeTrainers[i].trainerId); if (r10 == 1) @@ -5851,19 +5734,19 @@ static void sub_8194220(u8 taskId) i = 0; while (i < 91) { - gScanlineEffectRegBuffers[0][i] = 0x1F0A; - gScanlineEffectRegBuffers[1][i] = 0x1F0A; + gScanlineEffectRegBuffers[0][i] = BGCNT_PRIORITY(2) | BGCNT_SCREENBASE(31) | BGCNT_16COLOR | BGCNT_CHARBASE(2) | BGCNT_TXT256x256; + gScanlineEffectRegBuffers[1][i] = BGCNT_PRIORITY(2) | BGCNT_SCREENBASE(31) | BGCNT_16COLOR | BGCNT_CHARBASE(2) | BGCNT_TXT256x256; i++; } while (i < 160) { - gScanlineEffectRegBuffers[0][i] = 0x1F09; - gScanlineEffectRegBuffers[1][i] = 0x1F09; + gScanlineEffectRegBuffers[0][i] = BGCNT_PRIORITY(1) | BGCNT_SCREENBASE(31) | BGCNT_16COLOR | BGCNT_CHARBASE(2) | BGCNT_TXT256x256; + gScanlineEffectRegBuffers[1][i] = BGCNT_PRIORITY(1) | BGCNT_SCREENBASE(31) | BGCNT_16COLOR | BGCNT_CHARBASE(2) | BGCNT_TXT256x256; i++; } - ScanlineEffect_SetParams(gUnknown_0860CF44); + ScanlineEffect_SetParams(sTourneyTreeScanlineEffectParams); DestroyTask(taskId); break; } @@ -5871,7 +5754,7 @@ static void sub_8194220(u8 taskId) static void sub_81948EC(u8 tournamentId, u8 arg1) { - s32 i; + int i; const struct UnkStruct_860DD10 *structPtr = gUnknown_0860DD10[tournamentId][arg1]; for (i = 0; i < gUnknown_0860DE10[tournamentId][arg1]; i++) @@ -5882,7 +5765,7 @@ static void sub_81948EC(u8 tournamentId, u8 arg1) static void sub_8194950(u8 taskId) { - s32 i; + int i; struct TextPrinterTemplate textPrinter; switch (gTasks[taskId].data[0]) @@ -5923,7 +5806,7 @@ static void sub_8194950(u8 taskId) } if (!gSaveBlock2Ptr->frontier.domeTrainers[i].isEliminated) { - s32 roundId = gSaveBlock2Ptr->frontier.curChallengeBattleNum - 1; + int roundId = gSaveBlock2Ptr->frontier.curChallengeBattleNum - 1; sub_81948EC(i, roundId); } } @@ -6050,20 +5933,20 @@ static void VblankCb1_BattleDome(void) ScanlineEffect_InitHBlankDmaTransfer(); } -static void sub_8194D48(void) +static void InitDomeFacilityTrainersAndMons(void) { gFacilityTrainerMons = gBattleFrontierMons; gFacilityTrainers = gBattleFrontierTrainers; } -static void sub_8194D68(void) +static void RestoreDomePlayerParty(void) { - s32 i, moveSlot; + int i, moveSlot; for (i = 0; i < 2; i++) { - s32 playerMonId = gSaveBlock2Ptr->frontier.selectedPartyMons[gSelectedOrderFromParty[i] - 1] - 1; - s32 count; + int playerMonId = gSaveBlock2Ptr->frontier.selectedPartyMons[gSelectedOrderFromParty[i] - 1] - 1; + int count; for (moveSlot = 0; moveSlot < MAX_MON_MOVES; moveSlot++) { @@ -6082,24 +5965,24 @@ static void sub_8194D68(void) } } -static void sub_8194E44(void) +static void RestoreDomePlayerPartyHeldItems(void) { - s32 i; + int i; for (i = 0; i < 2; i++) { - s32 playerMonId = gSaveBlock2Ptr->frontier.selectedPartyMons[gSelectedOrderFromParty[i] - 1] - 1; + int playerMonId = gSaveBlock2Ptr->frontier.selectedPartyMons[gSelectedOrderFromParty[i] - 1] - 1; u16 item = GetMonData(&gSaveBlock1Ptr->playerParty[playerMonId], MON_DATA_HELD_ITEM, NULL); SetMonData(&gPlayerParty[i], MON_DATA_HELD_ITEM, &item); } } -static void sub_8194EB4(void) +static void ReduceDomePlayerPartyTo3Mons(void) { ReducePlayerPartyToSelectedMons(); } -static void sub_8194EC0(void) +static void GetPlayerSeededBeforeOpponent(void) { if (TrainerIdToTournamentId(gTrainerBattleOpponent_A) > TrainerIdToTournamentId(TRAINER_PLAYER)) gSpecialVar_Result = 1; @@ -6107,11 +5990,11 @@ static void sub_8194EC0(void) gSpecialVar_Result = 2; } -static void sub_8194EF8(void) +static void BufferLastDomeWinnerName(void) { - s32 i; + int i; - sub_8194D48(); + InitDomeFacilityTrainersAndMons(); for (i = 0; i < DOME_TOURNAMENT_TRAINERS_COUNT; i++) { if (!gSaveBlock2Ptr->frontier.domeTrainers[i].isEliminated) @@ -6122,15 +6005,15 @@ static void sub_8194EF8(void) static void sub_8194F58(void) { - s32 i, j, k; - s32 monLevel; - s32 species[3]; - s32 monTypesBits; - s32 trainerId; - s32 monSetId; + int i, j, k; + int monLevel; + int species[3]; + int monTypesBits; + int trainerId; + int monSetId; u8 lvlMode; u16 *statSums; - s32 *statValues; + int *statValues; u8 ivs = 0; species[0] = 0; @@ -6140,7 +6023,7 @@ static void sub_8194F58(void) return; statSums = AllocZeroed(sizeof(u16) * DOME_TOURNAMENT_TRAINERS_COUNT); - statValues = AllocZeroed(sizeof(s32) * 6); + statValues = AllocZeroed(sizeof(int) * 6); lvlMode = gSaveBlock2Ptr->frontier.lvlMode; gSaveBlock2Ptr->frontier.lvlMode = 0; // This one, I'd like to call a 'C fakematching'. @@ -6177,7 +6060,7 @@ static void sub_8194F58(void) monSetId = RandomizeFacilityTrainerMonSet(trainerId); for (k = 0; k < j; k++) { - s32 checkingMonId = gSaveBlock2Ptr->frontier.domeMonIds[i][k]; + int checkingMonId = gSaveBlock2Ptr->frontier.domeMonIds[i][k]; if (checkingMonId == monSetId || species[0] == gFacilityTrainerMons[monSetId].species || species[1] == gFacilityTrainerMons[monSetId].species @@ -6253,9 +6136,9 @@ static void sub_8194F58(void) gSaveBlock2Ptr->frontier.lvlMode = lvlMode; } -static s32 TrainerIdToTournamentId(u16 trainerId) +static int TrainerIdToTournamentId(u16 trainerId) { - s32 i; + int i; for (i = 0; i < DOME_TOURNAMENT_TRAINERS_COUNT; i++) { @@ -6267,9 +6150,9 @@ static s32 TrainerIdToTournamentId(u16 trainerId) } // The same as the above one, but has global scope. -s32 TrainerIdToDomeTournamentId(u16 trainerId) +int TrainerIdToDomeTournamentId(u16 trainerId) { - s32 i; + int i; for (i = 0; i < DOME_TOURNAMENT_TRAINERS_COUNT; i++) { @@ -6280,10 +6163,10 @@ s32 TrainerIdToDomeTournamentId(u16 trainerId) return i; } -static u8 sub_81953E8(u8 tournamentId, u8 arg1) +static u8 sub_81953E8(u8 tournamentId, u8 round) { u8 arr[2]; - sub_8192F08(gUnknown_0860D1A0[gUnknown_0860D1C0[tournamentId] / 2][arg1] - 16, arr); + sub_8192F08(gUnknown_0860D1A0[gUnknown_0860D1C0[tournamentId] / 2][round] - 16, arr); if (tournamentId == arr[0]) return arr[1]; else @@ -6292,11 +6175,11 @@ static u8 sub_81953E8(u8 tournamentId, u8 arg1) static void DecideRoundWinners(u8 roundId) { - s32 i; - s32 moveSlot, monId1, monId2; - s32 tournamentId1, tournamentId2; - s32 species; - s32 points1 = 0, points2 = 0; + int i; + int moveSlot, monId1, monId2; + int tournamentId1, tournamentId2; + int species; + int points1 = 0, points2 = 0; for (i = 0; i < DOME_TOURNAMENT_TRAINERS_COUNT; i++) { @@ -6400,28 +6283,28 @@ static void DecideRoundWinners(u8 roundId) } } -static void CopyDomeTrainerName(u8 *dst, u16 trainerId) +static void CopyDomeTrainerName(u8 *str, u16 trainerId) { - s32 i = 0; + int i = 0; SetFacilityPtrsGetLevel(); if (trainerId == TRAINER_FRONTIER_BRAIN) { - CopyDomeBrainTrainerName(dst); + CopyDomeBrainTrainerName(str); } else { if (trainerId == TRAINER_PLAYER) { for (i = 0; i < PLAYER_NAME_LENGTH; i++) - dst[i] = gSaveBlock2Ptr->playerName[i]; + str[i] = gSaveBlock2Ptr->playerName[i]; } else if (trainerId < 300) { for (i = 0; i < PLAYER_NAME_LENGTH; i++) - dst[i] = gFacilityTrainers[trainerId].trainerName[i]; + str[i] = gFacilityTrainers[trainerId].trainerName[i]; } - dst[i] = EOS; + str[i] = EOS; } } @@ -6435,11 +6318,11 @@ static u8 GetDomeBrainTrainerClass(void) return gTrainers[TRAINER_TUCKER].trainerClass; } -static void CopyDomeBrainTrainerName(u8 *dst) +static void CopyDomeBrainTrainerName(u8 *str) { - s32 i; + int i; for (i = 0; i < PLAYER_NAME_LENGTH; i++) - dst[i] = gTrainers[TRAINER_TUCKER].trainerName[i]; - dst[i] = EOS; + str[i] = gTrainers[TRAINER_TUCKER].trainerName[i]; + str[i] = EOS; }