From 95ffe06be07d9ec597976497e5da70a8d5cdd114 Mon Sep 17 00:00:00 2001 From: James Petersen Date: Mon, 4 Aug 2025 18:15:23 -0300 Subject: [PATCH] Start Documenting Naming Screen (#655) --- generated/text_banks.txt | 2 +- include/applications/naming_screen.h | 45 + include/constants/charcode.h | 2 +- include/constants/heap.h | 2 +- include/constants/string.h | 1 + include/constdata/const_020F2DAC.h | 8 - include/struct_decls/struct_02087A10_decl.h | 6 - include/struct_defs/struct_0208737C.h | 23 - include/struct_defs/struct_0209843C.h | 5 +- include/unk_0203D1B8.h | 13 +- include/unk_0208694C.h | 11 - platinum.us/main.lsf | 2 +- res/text/{unk_0427.gmm => generic_names.gmm} | 0 src/applications/naming_screen.c | 2941 +++++++++++++++++ .../rowan_intro/rowan_intro_app.c | 21 +- src/battle/battle_script.c | 20 +- src/meson.build | 2 +- src/overlay019/ov19_021D0D80.c | 13 +- src/overlay064/ov64_0222DCE0.c | 23 +- src/overlay097/gba_convert_string.c | 2 +- src/overlay104/ov104_0222FBE4.c | 9 +- src/scrcmd.c | 8 +- src/unk_02012744.c | 34 +- src/unk_0203D1B8.c | 41 +- src/unk_02048BD0.c | 4 +- src/unk_0208694C.c | 2624 --------------- src/unk_02098218.c | 9 +- 27 files changed, 3106 insertions(+), 2765 deletions(-) create mode 100644 include/applications/naming_screen.h delete mode 100644 include/constdata/const_020F2DAC.h delete mode 100644 include/struct_decls/struct_02087A10_decl.h delete mode 100644 include/struct_defs/struct_0208737C.h delete mode 100644 include/unk_0208694C.h rename res/text/{unk_0427.gmm => generic_names.gmm} (100%) create mode 100644 src/applications/naming_screen.c delete mode 100644 src/unk_0208694C.c diff --git a/generated/text_banks.txt b/generated/text_banks.txt index da35a58932..e91f483caf 100644 --- a/generated/text_banks.txt +++ b/generated/text_banks.txt @@ -425,7 +425,7 @@ TEXT_BANK_BERRY_DESCRIPTIONS TEXT_BANK_BERRY_NAMES TEXT_BANK_UNK_0425 TEXT_BANK_UNK_0426 -TEXT_BANK_UNK_0427 +TEXT_BANK_GENERIC_NAMES TEXT_BANK_UNK_0428 TEXT_BANK_FOLLOWER_PARTNERS TEXT_BANK_UNK_0430 diff --git a/include/applications/naming_screen.h b/include/applications/naming_screen.h new file mode 100644 index 0000000000..be8427dd29 --- /dev/null +++ b/include/applications/naming_screen.h @@ -0,0 +1,45 @@ +#ifndef POKEPLATINUM_KEYBOARD_H +#define POKEPLATINUM_KEYBOARD_H + +#include "struct_decls/pc_boxes_decl.h" + +#include "game_options.h" +#include "overlay_manager.h" +#include "strbuf.h" + +enum NamingScreenType { + NAMING_SCREEN_TYPE_PLAYER, + NAMING_SCREEN_TYPE_POKEMON, + NAMING_SCREEN_TYPE_BOX, + NAMING_SCREEN_TYPE_RIVAL, + NAMING_SCREEN_TYPE_UNK4, + NAMING_SCREEN_TYPE_GROUP, + NAMING_SCREEN_TYPE_UNK6, + NAMING_SCREEN_TYPE_PAL_PAD, +}; + +typedef struct NamingScreenArgs { + enum NamingScreenType type; + int unk_04; + int unk_08; + int maxChars; + int unk_10; + int unk_14; + Strbuf *textInputStr; + u16 unk_1C[20]; + int unk_44; + PCBoxes *pcBoxes; + Options *options; +} NamingScreenArgs; + +extern const ApplicationManagerTemplate gNamingScreenAppTemplate; + +NamingScreenArgs *NamingScreenArgs_Init( + enum HeapId heapID, + enum NamingScreenType type, + int param2, + int param3, + Options *options); +void NamingScreenArgs_Free(NamingScreenArgs *param0); + +#endif // POKEPLATINUM_KEYBOARD_H diff --git a/include/constants/charcode.h b/include/constants/charcode.h index e94bb1d03a..a35025d799 100644 --- a/include/constants/charcode.h +++ b/include/constants/charcode.h @@ -437,7 +437,7 @@ enum CharCode { CHAR_QUESTION, CHAR_COMMA, CHAR_PERIOD, - CHAR_ELLPSIS, + CHAR_ELLIPSIS, CHAR_DOT, CHAR_SLASH, CHAR_SINGLE_QUOTE_OPEN, diff --git a/include/constants/heap.h b/include/constants/heap.h index 8c293f0803..476860d57b 100644 --- a/include/constants/heap.h +++ b/include/constants/heap.h @@ -20,7 +20,7 @@ enum HeapId { HEAP_ID_COMMUNICATION, HEAP_ID_16, HEAP_ID_17, - HEAP_ID_18, + HEAP_ID_NAMING_SCREEN_APP, HEAP_ID_POKEMON_SUMMARY_SCREEN, HEAP_ID_20, HEAP_ID_21, diff --git a/include/constants/string.h b/include/constants/string.h index 6decfb7489..e098cbd353 100644 --- a/include/constants/string.h +++ b/include/constants/string.h @@ -6,5 +6,6 @@ #define TABLET_NAME_LEN 10 #define MOVE_NAME_LEN 16 #define UNION_GROUP_NAME_LEN 7 +#define BOX_NAME_LEN 8 #endif diff --git a/include/constdata/const_020F2DAC.h b/include/constdata/const_020F2DAC.h deleted file mode 100644 index 9e1aad721d..0000000000 --- a/include/constdata/const_020F2DAC.h +++ /dev/null @@ -1,8 +0,0 @@ -#ifndef POKEPLATINUM_CONST_020F2DAC_H -#define POKEPLATINUM_CONST_020F2DAC_H - -#include "overlay_manager.h" - -extern const ApplicationManagerTemplate Unk_020F2DAC; - -#endif // POKEPLATINUM_CONST_020F2DAC_H diff --git a/include/struct_decls/struct_02087A10_decl.h b/include/struct_decls/struct_02087A10_decl.h deleted file mode 100644 index 2d2f29c454..0000000000 --- a/include/struct_decls/struct_02087A10_decl.h +++ /dev/null @@ -1,6 +0,0 @@ -#ifndef POKEPLATINUM_STRUCT_02087A10_DECL_H -#define POKEPLATINUM_STRUCT_02087A10_DECL_H - -typedef struct UnkStruct_02087A10_t UnkStruct_02087A10; - -#endif // POKEPLATINUM_STRUCT_02087A10_DECL_H diff --git a/include/struct_defs/struct_0208737C.h b/include/struct_defs/struct_0208737C.h deleted file mode 100644 index 4f3dfd6290..0000000000 --- a/include/struct_defs/struct_0208737C.h +++ /dev/null @@ -1,23 +0,0 @@ -#ifndef POKEPLATINUM_STRUCT_0208737C_H -#define POKEPLATINUM_STRUCT_0208737C_H - -#include "struct_decls/pc_boxes_decl.h" - -#include "game_options.h" -#include "strbuf.h" - -typedef struct { - int unk_00; - int unk_04; - int unk_08; - int unk_0C; - int unk_10; - int unk_14; - Strbuf *textInputStr; - u16 unk_1C[20]; - int unk_44; - PCBoxes *pcBoxes; - Options *options; -} UnkStruct_0208737C; - -#endif // POKEPLATINUM_STRUCT_0208737C_H diff --git a/include/struct_defs/struct_0209843C.h b/include/struct_defs/struct_0209843C.h index 27cf55b533..17ea1ce61d 100644 --- a/include/struct_defs/struct_0209843C.h +++ b/include/struct_defs/struct_0209843C.h @@ -2,12 +2,13 @@ #define POKEPLATINUM_STRUCT_0209843C_H #include "struct_defs/struct_0203E2FC.h" -#include "struct_defs/struct_0208737C.h" + +#include "applications/naming_screen.h" typedef struct { int unk_00; BOOL unk_04; - UnkStruct_0208737C *unk_08; + NamingScreenArgs *unk_08; UnkStruct_0203E2FC unk_0C; } UnkStruct_0209843C; diff --git a/include/unk_0203D1B8.h b/include/unk_0203D1B8.h index 6bcbc8e792..3f6c8b08b0 100644 --- a/include/unk_0203D1B8.h +++ b/include/unk_0203D1B8.h @@ -13,6 +13,7 @@ #include "struct_defs/struct_02098C44.h" #include "struct_defs/struct_020997B8.h" +#include "applications/naming_screen.h" #include "applications/pokemon_summary_screen/main.h" #include "field/field_system_decl.h" #include "overlay019/pokemon_storage_session.h" @@ -67,8 +68,16 @@ void sub_0203DDFC(FieldSystem *fieldSystem); void *sub_0203DE34(FieldSystem *fieldSystem); void sub_0203DE78(FieldSystem *fieldSystem, SaveData *saveData); void sub_0203DE88(FieldSystem *fieldSystem, SaveData *saveData); -void sub_0203DFE8(FieldTask *param0, int param1, int param2, int param3, int param4, const u16 *param5, u16 *param6); -void FieldSystem_OpenTrainerCardScreen(FieldSystem *fieldSystem, TrainerCard *param1); +void sub_0203DFE8( + FieldTask *param0, + enum NamingScreenType type, + int param2, + int param3, + int param4, + const u16 *param5, + u16 *param6); +void sub_0203E09C(FieldSystem *fieldSystem, TrainerCard *param1); +void FieldSystem_OpenTrainerCardScreen(FieldSystem *fieldSystem, TrainerCard *trainerCard); BOOL sub_0203E0AC(FieldSystem *fieldSystem, void *param1); void FieldSystem_LaunchChooseStarterApp(FieldSystem *fieldSystem, ChooseStarterData *param1); void sub_0203E0D0(FieldSystem *fieldSystem); diff --git a/include/unk_0208694C.h b/include/unk_0208694C.h deleted file mode 100644 index 0304bf79c3..0000000000 --- a/include/unk_0208694C.h +++ /dev/null @@ -1,11 +0,0 @@ -#ifndef POKEPLATINUM_UNK_0208694C_H -#define POKEPLATINUM_UNK_0208694C_H - -#include "struct_defs/struct_0208737C.h" - -#include "game_options.h" - -UnkStruct_0208737C *sub_0208712C(int heapID, int param1, int param2, int param3, Options *options); -void sub_0208716C(UnkStruct_0208737C *param0); - -#endif // POKEPLATINUM_UNK_0208694C_H diff --git a/platinum.us/main.lsf b/platinum.us/main.lsf index 92f79d26f0..8eec7632be 100644 --- a/platinum.us/main.lsf +++ b/platinum.us/main.lsf @@ -310,7 +310,7 @@ Static main Object main.nef.p/src_unk_02082C2C.c.o Object main.nef.p/src_unk_02083370.c.o Object main.nef.p/src_unk_02084B70.c.o - Object main.nef.p/src_unk_0208694C.c.o + Object main.nef.p/src_applications_naming_screen.c.o Object main.nef.p/src_unk_020890F4.c.o Object main.nef.p/src_unk_02089604.c.o Object main.nef.p/src_unk_0208A3F4.c.o diff --git a/res/text/unk_0427.gmm b/res/text/generic_names.gmm similarity index 100% rename from res/text/unk_0427.gmm rename to res/text/generic_names.gmm diff --git a/src/applications/naming_screen.c b/src/applications/naming_screen.c new file mode 100644 index 0000000000..cd9b933937 --- /dev/null +++ b/src/applications/naming_screen.c @@ -0,0 +1,2941 @@ +#include "applications/naming_screen.h" + +#include +#include + +#include "constants/charcode.h" +#include "constants/graphics.h" +#include "constants/heap.h" + +#include "struct_defs/struct_02099F80.h" + +#include "bg_window.h" +#include "char_transfer.h" +#include "charcode.h" +#include "charcode_util.h" +#include "font.h" +#include "game_options.h" +#include "graphics.h" +#include "gx_layers.h" +#include "heap.h" +#include "math_util.h" +#include "message.h" +#include "message_util.h" +#include "narc.h" +#include "overlay_manager.h" +#include "pc_boxes.h" +#include "pltt_transfer.h" +#include "pokemon.h" +#include "pokemon_icon.h" +#include "render_oam.h" +#include "render_window.h" +#include "screen_fade.h" +#include "sound.h" +#include "sound_playback.h" +#include "sprite.h" +#include "sprite_resource.h" +#include "sprite_transfer.h" +#include "sprite_util.h" +#include "strbuf.h" +#include "string_template.h" +#include "sys_task_manager.h" +#include "system.h" +#include "text.h" +#include "unk_0200679C.h" +#include "unk_02012744.h" +#include "unk_0201567C.h" +#include "vram_transfer.h" + +#define NAMING_SCREEN_CONTROL_DAKU 0xD001 +#define NAMING_SCREEN_CONTROL_HANDAKU 0xD002 +#define NAMING_SCREEN_CONTROL_SPACE 0xD003 +#define NAMING_SCREEN_CONTROL_SKIP 0xD004 +#define NAMING_SCREEN_BUTTON_START 0xE001 +#define NAMING_SCREEN_BUTTON_PAGE_UPPER 0xE002 +#define NAMING_SCREEN_BUTTON_PAGE_LOWER 0xE003 +#define NAMING_SCREEN_BUTTON_PAGE_OTHERS 0xE004 +#define NAMING_SCREEN_BUTTON_PAGE_JP_UNUSED 0xE005 +#define NAMING_SCREEN_BUTTON_PAGE_JP_UNUSED_2 0xE006 +#define NAMING_SCREEN_BUTTON_BACK 0xE007 +#define NAMING_SCREEN_BUTTON_OK 0xE008 + +enum NamingScreenAppState { + NMS_APP_STATE_WAIT_FADE_IN = 0, + NMS_APP_STATE_INITIAL_DELAY, + NMS_APP_STATE_RUNNING, + NMS_APP_STATE_WAIT_FADE_OUT, +}; + +enum NamingScreenState { + NMS_STATE_PLACEHOLDER_4 = 4, + NMS_STATE_PLACEHOLDER_5, + NMS_STATE_PLACEHOLDER_6, + NMS_STATE_PLACEHOLDER_7, +}; + +enum ChangeCharsState { + CC_STATE_LOAD_GRAPHICS = 0, + CC_STATE_SET_INITIAL_POSITION, + CC_STATE_SLIDE_IN, + CC_STATE_FINISH_SLIDING_OUT, + CC_STATE_NOTHING, +}; + +enum NamingScreenSprite { + NMS_SPRITE_OVERLAY = 7, +}; + +typedef struct { + int unk_00; + int unk_04; + int unk_08; + int unk_0C; + int unk_10; + BOOL hasCharacterBeenEntered; + int unk_18; +} UnkStruct_02087A10_sub1; + +typedef struct NamingScreen { + enum NamingScreenType type; + int unk_04; + int unk_08; + int unk_0C; + int unk_10; + int unk_14; + Options *options; + UnkStruct_02087A10_sub1 unk_1C; + u16 unk_38; + u16 unk_3A[6][13]; + u16 unk_D6; + charcode_t entryBuf[32]; + charcode_t entryBufBak[32]; + u16 textCursorPos; + u16 tmpBuf[3]; + BgConfig *bgConfig; + BOOL unk_164; + StringTemplate *strTemplate; + MessageLoader *namingScreenMsgLoader; + MessageLoader *genericNamesMsgLoader; + MessageLoader *battleStringsMsgLoader; + Strbuf *unk_178; + Strbuf *unk_17C; + Strbuf *unk_180; + Strbuf *unk_184; + SpriteList *unk_188; + G2dRenderer unk_18C; + SpriteResourceCollection *unk_318[4]; + SpriteResource *unk_328[2][4]; + SpriteResourcesHeader unk_348; + SpriteResourcesHeader unk_36C; + Sprite *miscSprites[14]; + Sprite *textCursorSprites[12]; + Sprite *entitySprite[2]; + SysTask *unk_400[7]; + Window unk_41C[10]; + int unk_4BC; + union { + enum NamingScreenState main; + enum ChangeCharsState changeChars; + } state; + int currentCharsIdx; + // initially set to 0 (in memset in init) + // alternates between 0 and 1. (see NamingScreen_AnimateChangeChars) + enum BgLayer freeCharsBgLayer; + VecFx32 charsPosition[2]; + int unk_4E4; + int unk_4E8; + int unk_4EC; + int unk_4F0; + BOOL spritesToUpdate[7]; + void *charDataAlloc; + NNSG2dCharacterData *charData; + void *unk_518; + NNSG2dCharacterData *unk_51C; + void *unk_520; + NNSG2dPaletteData *unk_524; + u8 pixelBuf[256]; + UnkStruct_020157E4 *unk_628; + BOOL unk_62C; + int delayUpdateCounter; +} NamingScreen; + +typedef struct { + Sprite *unk_00; + Sprite *unk_04; + int unk_08; + int unk_0C; +} UnkStruct_020879DC; + +typedef struct OverlayWiggleParameters { + Sprite *overlaySprite; + int state; + fx32 overlayXPosition; + fx32 overlayYPosition; +} OverlayWiggleParameters; + +typedef struct NamingScreenTouchHitbox { + u8 unk_00; + u8 unk_01; + u16 unk_02_0 : 2; + u8 unk_04_0 : 5; + u8 unk_05_0 : 5; +} NamingScreenTouchHitbox; + +static BOOL NamingScreen_Init(ApplicationManager *appMan, int *state); +static BOOL NamingScreen_Main(ApplicationManager *appMan, int *state); +static BOOL NamingScreen_Exit(ApplicationManager *appMan, int *state); +static void NamingScreen_VBlankCallback(void *unused); +static void NamingScreen_InitGraphicsBanks(void); +static void NamingScreen_InitBgs(BgConfig *bgConfig); +static void sub_0208765C(BgConfig *param0, Window *param1); +static void NamingScreen_LoadGraphicsFromNarc(NamingScreen *namingScreen, NARC *narc); +static void NamingScreen_AnimateChangeChars( + BgConfig *bgConfig, + Window *window, + enum ChangeCharsState *statePtr, + int currentCharsIdx, + enum BgLayer *bgLayerPtr, + VecFx32 charsPosition[], + Sprite **param6, + void *rawCharData); +static void NamingScreen_InitCursorsAndChars(NamingScreen *param0, ApplicationManager *appMan); +static void NamingScreen_UpdateCharsPriorities(BgConfig *unused0, enum BgLayer oldBgLayer, VecFx32 unused1[]); +static void NamingScreen_InitializeCharsPosition(VecFx32 param0[], enum BgLayer freeBgLayer); +static void sub_020877F4(NamingScreen *param0, NARC *param1); +static void NamingScreen_InitSprites(NamingScreen *param0); +static void NamingScreen_TransferChars(void); +static void sub_02087FC0(NamingScreen *param0, ApplicationManager *appMan, NARC *param2); +static void NamingScreen_ProcessDirectionInputs(NamingScreen *param0); +static void sub_02088514(u16 *param0); +static void NamingScreen_PrintChars( + Window *window, + const charcode_t *charCodes, + int baseXOffset, + int yOffset, + int charSpacing, + int renderDelay, + TextColor textColor, + void *rawCharData); +static void NamingScreen_PrintCharOnWindowAndOBJ(Window *param0, const charcode_t *param1, u8 *param2, Strbuf *param3); +static void sub_02088844(u16 param0[][13], const int param1); +static void sub_02088754(Window *param0, u16 *param1, int param2, u16 *param3, u8 *param4, Strbuf *param5); +static int sub_02088898(NamingScreen *param0, u16 param1, int param2); +static int sub_02088D08(int param0, int param1, int param2, int param3, u16 *param4, int param5); +static int sub_02088C9C(int param0, int param1, u16 *param2, int param3); +static void sub_02088E1C(Sprite **param0, int param1, int param2); +static void NamingScreen_CopyParamsFromArgs(NamingScreen *namingScreen, NamingScreenArgs *namingScreenArgs); +static void NamingScreen_InitializeCharsGraphics( + Window *param0, + u16 param1, + int param2, + TextColor param3, + void *rawCharData); +static void NamingScreen_MoveCursor(NamingScreen *param0, int param1); +static void NamingScreen_UpdateSpriteAnimations(int param0[], Sprite **param1, int param2); +static void sub_020879DC(SysTask *param0, void *param1); +static void NamingScreen_WiggleOverlayTask(SysTask *param0, void *param1); +static void sub_02086B30(NNSG2dCharacterData *param0, NNSG2dPaletteData *param1, int param2, int param3); +static void NamingScreen_ToggleEngineLayers(BOOL enable); +static void sub_02087544(NamingScreen *param0, ApplicationManager *appMan); +static void sub_02087BE4(NamingScreen *param0, AffineSpriteListTemplate *param1); +static void sub_02086E6C(NamingScreen *param0, NamingScreenArgs *param1); +static void sub_02087F48(Window *param0, int param1, Strbuf *param2); +static void sub_02088FD0(NamingScreen *param0); +static enum NamingScreenAppState NamingScreen_ProcessInputs(NamingScreen *param0, enum NamingScreenAppState param1); +static int sub_02086F14(u16 *param0); +static void *NamingScreen_PrintStringOnWindowAndGetPixelBuffer(Window *param0, Strbuf *param1, u8 param2, TextColor param3); +static BOOL sub_0208903C(NamingScreen *param0); + +static const int sNamingScreenSpriteAnimations[][4] = { + { 0x4, 0x44, 0x3, 0x1 }, + { 0x24, 0x44, 0x8, 0x1 }, + { 0x44, 0x44, 0xD, 0x1 }, + { 0x0, 0xC8, 0x12, 0x1 }, + { 0x65, 0x44, 0x14, 0x1 }, + { 0x88, 0x44, 0x17, 0x1 }, + { 0xB0, 0x44, 0x19, 0x1 }, + { 0x16, 0x38, 0x25, 0x2 }, + { 0x1A, 0x5B, 0x27, 0x0 } +}; + +static const charcode_t sNamingScreenHomeRowAll[] = { + NAMING_SCREEN_BUTTON_PAGE_UPPER, + NAMING_SCREEN_BUTTON_PAGE_UPPER, + NAMING_SCREEN_BUTTON_PAGE_LOWER, + NAMING_SCREEN_BUTTON_PAGE_LOWER, + NAMING_SCREEN_BUTTON_PAGE_OTHERS, + NAMING_SCREEN_BUTTON_PAGE_OTHERS, + NAMING_SCREEN_CONTROL_SKIP, + NAMING_SCREEN_CONTROL_SKIP, + NAMING_SCREEN_BUTTON_BACK, + NAMING_SCREEN_BUTTON_BACK, + NAMING_SCREEN_BUTTON_BACK, + NAMING_SCREEN_BUTTON_OK, + NAMING_SCREEN_BUTTON_OK, +}; + +static const charcode_t sNamingScreenHomeRowNumpad[] = { + NAMING_SCREEN_CONTROL_SKIP, + NAMING_SCREEN_CONTROL_SKIP, + NAMING_SCREEN_CONTROL_SKIP, + NAMING_SCREEN_CONTROL_SKIP, + NAMING_SCREEN_CONTROL_SKIP, + NAMING_SCREEN_CONTROL_SKIP, + NAMING_SCREEN_CONTROL_SKIP, + NAMING_SCREEN_CONTROL_SKIP, + NAMING_SCREEN_BUTTON_BACK, + NAMING_SCREEN_BUTTON_BACK, + NAMING_SCREEN_BUTTON_BACK, + NAMING_SCREEN_BUTTON_OK, + NAMING_SCREEN_BUTTON_OK, +}; + +static const charcode_t *sNamingScreenHomeRowLayouts[] = { + sNamingScreenHomeRowAll, + sNamingScreenHomeRowAll, + sNamingScreenHomeRowAll, + sNamingScreenHomeRowAll, + sNamingScreenHomeRowNumpad +}; + +static const u16 sHomeRowCursorXCoords[] = { + 0x19, + 0x39, + 0x59, + 0x61, + 0x7A, + 0x9E, + 0xC6, + 0, +}; + +static const u8 sHomeRowCursorAnimIDs[] = { + 0x28, + 0x28, + 0x28, + 0x28, + 0x29, + 0x29, + 0x29, +}; + +static const charcode_t sNamingScreenCharCodesUpper0[] = { + CHAR_A, + CHAR_B, + CHAR_C, + CHAR_D, + CHAR_E, + CHAR_F, + CHAR_G, + CHAR_H, + CHAR_I, + CHAR_J, + CHAR_SPACE, + CHAR_COMMA, + CHAR_PERIOD, + CHAR_EOS, +}; + +static const charcode_t sNamingScreenCharCodesUpper1[] = { + CHAR_K, + CHAR_L, + CHAR_M, + CHAR_N, + CHAR_O, + CHAR_P, + CHAR_Q, + CHAR_R, + CHAR_S, + CHAR_T, + CHAR_SPACE, + CHAR_SINGLE_QUOTE_CLOSE, + CHAR_MINUS, + CHAR_EOS, +}; + +static const charcode_t sNamingScreenCharCodesUpper2[] = { + CHAR_U, + CHAR_V, + CHAR_W, + CHAR_X, + CHAR_Y, + CHAR_Z, + CHAR_SPACE, + CHAR_SPACE, + CHAR_SPACE, + CHAR_SPACE, + CHAR_SPACE, + CHAR_MALE, + CHAR_FEMALE, + CHAR_EOS, +}; + +static const charcode_t sNamingScreenCharCodesUpper3[] = { + CHAR_SPACE, + CHAR_SPACE, + CHAR_SPACE, + CHAR_SPACE, + CHAR_SPACE, + CHAR_SPACE, + CHAR_SPACE, + CHAR_SPACE, + CHAR_SPACE, + CHAR_SPACE, + CHAR_SPACE, + CHAR_SPACE, + CHAR_SPACE, + CHAR_EOS, +}; + +static const charcode_t sNamingScreenCharCodesUpper4[] = { + CHAR_0, + CHAR_1, + CHAR_2, + CHAR_3, + CHAR_4, + CHAR_5, + CHAR_6, + CHAR_7, + CHAR_8, + CHAR_9, + CHAR_SPACE, + CHAR_SPACE, + CHAR_SPACE, + CHAR_EOS, +}; + +static const u16 sNamingScreenCharCodesLower0[] = { + CHAR_a, + CHAR_b, + CHAR_c, + CHAR_d, + CHAR_e, + CHAR_f, + CHAR_g, + CHAR_h, + CHAR_i, + CHAR_j, + CHAR_SPACE, + CHAR_COMMA, + CHAR_PERIOD, + CHAR_EOS, +}; + +static const charcode_t sNamingScreenCharCodesLower1[] = { + CHAR_k, + CHAR_l, + CHAR_m, + CHAR_n, + CHAR_o, + CHAR_p, + CHAR_q, + CHAR_r, + CHAR_s, + CHAR_t, + CHAR_SPACE, + CHAR_SINGLE_QUOTE_CLOSE, + CHAR_MINUS, + CHAR_EOS, +}; + +static const charcode_t sNamingScreenCharCodesLower2[] = { + CHAR_u, + CHAR_v, + CHAR_w, + CHAR_x, + CHAR_y, + CHAR_z, + CHAR_SPACE, + CHAR_SPACE, + CHAR_SPACE, + CHAR_SPACE, + CHAR_SPACE, + CHAR_MALE, + CHAR_FEMALE, + CHAR_EOS, +}; + +static const charcode_t sNamingScreenCharCodesLower3[] = { + CHAR_SPACE, + CHAR_SPACE, + CHAR_SPACE, + CHAR_SPACE, + CHAR_SPACE, + CHAR_SPACE, + CHAR_SPACE, + CHAR_SPACE, + CHAR_SPACE, + CHAR_SPACE, + CHAR_SPACE, + CHAR_SPACE, + CHAR_SPACE, + CHAR_EOS, +}; + +static const charcode_t sNamingScreenCharCodesLower4[] = { + CHAR_0, + CHAR_1, + CHAR_2, + CHAR_3, + CHAR_4, + CHAR_5, + CHAR_6, + CHAR_7, + CHAR_8, + CHAR_9, + CHAR_SPACE, + CHAR_SPACE, + CHAR_SPACE, + CHAR_EOS, +}; + +static const charcode_t sNamingScreenCharCodesOthers0[] = { + CHAR_COMMA, + CHAR_PERIOD, + CHAR_COLON, + CHAR_SEMICOLON, + CHAR_EXCLAMATION, + CHAR_QUESTION, + CHAR_SPACE, + CHAR_SPACE, + CHAR_SPACE, + CHAR_MALE, + CHAR_FEMALE, + CHAR_SPACE, + CHAR_SPACE, + CHAR_EOS, +}; + +static const charcode_t sNamingScreenCharCodesOthers1[] = { + CHAR_DOUBLE_QUOTE_OPEN, + CHAR_DOUBLE_QUOTE_CLOSE, + CHAR_SINGLE_QUOTE_OPEN, + CHAR_SINGLE_QUOTE_CLOSE, + CHAR_PAREN_OPEN, + CHAR_PAREN_CLOSE, + CHAR_SPACE, + CHAR_SPACE, + CHAR_SPACE, + CHAR_SPACE, + CHAR_SPACE, + CHAR_SPACE, + CHAR_SPACE, + CHAR_EOS, +}; + +static const charcode_t sNamingScreenCharCodesOthers2[] = { + CHAR_ELLIPSIS, + CHAR_DOT, + CHAR_TILDE, + CHAR_AT_SIGN, + CHAR_HASH, + CHAR_PERCENT, + CHAR_PLUS, + CHAR_MINUS, + CHAR_ASTERISK, + CHAR_SLASH, + CHAR_EQUALS, + CHAR_SPACE, + CHAR_SPACE, + CHAR_EOS, +}; + +static const charcode_t sNamingScreenCharCodesOthers3[] = { + CHAR_DOUBLE_CIRCLE, + CHAR_CIRCLE, + CHAR_SQUARE, + CHAR_TRIANGLE, + CHAR_DIAMOND_OPEN, + CHAR_SPADE, + CHAR_HEART, + CHAR_DIAMOND, + CHAR_CLUB, + CHAR_STAR, + CHAR_EIGHT_NOTE, + CHAR_SPACE, + CHAR_SPACE, + CHAR_EOS, +}; + +static const charcode_t sNamingScreenCharCodesOthers4[] = { + CHAR_SUN, + CHAR_CLOUD, + CHAR_UMBRELLA, + CHAR_SILHOUETTE, + CHAR_EMOTE_SMILE, + CHAR_EMOTE_LAUGH, + CHAR_EMOTE_UPSET, + CHAR_EMOTE_FROWN, + CHAR_ZZZ, + CHAR_ARROW_CURVE_UP, + CHAR_ARROW_CURVE_DOWN, + CHAR_SPACE, + CHAR_SPACE, + CHAR_EOS, +}; + +static const charcode_t sNamingScreenCharCodesJpMisc0[] = { + CHAR_WIDE_0, + CHAR_WIDE_1, + CHAR_WIDE_2, + CHAR_WIDE_3, + CHAR_WIDE_4, + CHAR_WIDE_5, + CHAR_WIDE_6, + CHAR_WIDE_7, + CHAR_WIDE_8, + CHAR_WIDE_9, + CHAR_WIDE_SPACE, + CHAR_WIDE_EXCLAMATION, + CHAR_WIDE_QUESTION, + CHAR_EOS, +}; + +static const charcode_t sNamingScreenCharCodesJpMisc1[] = { + CHAR_JP_COMMA, + CHAR_JP_PERIOD, + CHAR_WIDE_COMMA, + CHAR_WIDE_PERIOD, + CHAR_JP_ELLIPSIS, + CHAR_JP_DOT, + CHAR_WIDE_TILDE, + CHAR_WIDE_COLON, + CHAR_WIDE_SEMICOLON, + CHAR_WIDE_SLASH, + CHAR_WIDE_SPACE, + CHAR_WIDE_MALE, + CHAR_WIDE_FEMALE, + CHAR_EOS, +}; + +static const charcode_t sNamingScreenCharCodesJpMisc2[] = { + CHAR_JP_SINGLE_QUOTE_OPEN, + CHAR_JP_SINGLE_QUOTE_CLOSE, + CHAR_JP_DOUBLE_QUOTE_OPEN, + CHAR_JP_DOUBLE_QUOTE_CLOSE, + CHAR_JP_PAREN_OPEN, + CHAR_JP_PAREN_CLOSE, + CHAR_WIDE_PLUS, + CHAR_WIDE_MINUS, + CHAR_WIDE_MULTIPLY, + CHAR_WIDE_DIVIDE, + CHAR_WIDE_EQUALS, + CHAR_WIDE_PERCENT, + CHAR_WIDE_AT_SIGN, + CHAR_EOS, +}; + +static const charcode_t sNamingScreenCharCodesJpMisc3[] = { + CHAR_WIDE_DOUBLE_CIRCLE, + CHAR_WIDE_CIRCLE, + CHAR_WIDE_SQUARE, + CHAR_WIDE_TRIANGLE, + CHAR_WIDE_DIAMOND_OPEN, + CHAR_WIDE_HEART, + CHAR_WIDE_SPADE, + CHAR_WIDE_DIAMOND, + CHAR_WIDE_CLUB, + CHAR_WIDE_STAR, + CHAR_WIDE_EIGHTH_NOTE, + CHAR_WIDE_SPACE, + CHAR_WIDE_SPACE, + CHAR_EOS, +}; + +static const charcode_t sNamingScreenCharCodesJpMisc4[] = { + CHAR_WIDE_SUN, + CHAR_WIDE_CLOUD, + CHAR_WIDE_UMBRELLA, + CHAR_WIDE_SILHOUETTE, + CHAR_WIDE_EMOTE_SMILE, + CHAR_WIDE_EMOTE_LAUGH, + CHAR_WIDE_EMOTE_UPSET, + CHAR_WIDE_EMOTE_FROWN, + CHAR_WIDE_ZZZ, + CHAR_WIDE_ARROW_CURVE_UP, + CHAR_WIDE_ARROW_CURVE_DOWN, + CHAR_WIDE_SPACE, + CHAR_WIDE_SPACE, + CHAR_EOS, +}; + +static const charcode_t sNamingScreenCharCodesNumpad0[] = { + CHAR_0, + CHAR_1, + CHAR_2, + CHAR_3, + CHAR_4, + CHAR_WIDE_SPACE, + CHAR_WIDE_SPACE, + CHAR_WIDE_SPACE, + CHAR_WIDE_SPACE, + CHAR_WIDE_SPACE, + CHAR_WIDE_SPACE, + CHAR_WIDE_SPACE, + CHAR_WIDE_SPACE, + CHAR_WIDE_SPACE, + CHAR_WIDE_SPACE, + CHAR_WIDE_SPACE, + CHAR_WIDE_SPACE, + CHAR_EOS, +}; + +static const charcode_t sNamingScreenCharCodesNumpad1[] = { + CHAR_5, + CHAR_6, + CHAR_7, + CHAR_8, + CHAR_9, + CHAR_WIDE_SPACE, + CHAR_WIDE_SPACE, + CHAR_WIDE_SPACE, + CHAR_WIDE_SPACE, + CHAR_WIDE_SPACE, + CHAR_WIDE_SPACE, + CHAR_WIDE_SPACE, + CHAR_WIDE_SPACE, + CHAR_WIDE_SPACE, + CHAR_WIDE_SPACE, + CHAR_WIDE_SPACE, + CHAR_WIDE_SPACE, + CHAR_EOS, +}; + +static const charcode_t sNamingScreenCharCodesNumpad345[] = { + CHAR_WIDE_SPACE, + CHAR_WIDE_SPACE, + CHAR_WIDE_SPACE, + CHAR_WIDE_SPACE, + CHAR_WIDE_SPACE, + CHAR_WIDE_SPACE, + CHAR_WIDE_SPACE, + CHAR_WIDE_SPACE, + CHAR_WIDE_SPACE, + CHAR_WIDE_SPACE, + CHAR_WIDE_SPACE, + CHAR_WIDE_SPACE, + CHAR_WIDE_SPACE, + CHAR_WIDE_SPACE, + CHAR_WIDE_SPACE, + CHAR_WIDE_SPACE, + CHAR_WIDE_SPACE, + CHAR_EOS, +}; + +const charcode_t *sNamingScreenCharCodes[][5] = { + { + sNamingScreenCharCodesUpper0, + sNamingScreenCharCodesUpper1, + sNamingScreenCharCodesUpper2, + sNamingScreenCharCodesUpper3, + sNamingScreenCharCodesUpper4, + }, + { + sNamingScreenCharCodesLower0, + sNamingScreenCharCodesLower1, + sNamingScreenCharCodesLower2, + sNamingScreenCharCodesLower3, + sNamingScreenCharCodesLower4, + }, + { + sNamingScreenCharCodesOthers0, + sNamingScreenCharCodesOthers1, + sNamingScreenCharCodesOthers2, + sNamingScreenCharCodesOthers3, + sNamingScreenCharCodesOthers4, + }, + { + sNamingScreenCharCodesJpMisc0, + sNamingScreenCharCodesJpMisc1, + sNamingScreenCharCodesJpMisc2, + sNamingScreenCharCodesJpMisc3, + sNamingScreenCharCodesJpMisc4, + }, + { + sNamingScreenCharCodesNumpad0, + sNamingScreenCharCodesNumpad1, + sNamingScreenCharCodesNumpad345, + sNamingScreenCharCodesNumpad345, + sNamingScreenCharCodesNumpad345, + } +}; + +static const u16 sUnkConversionTable[][3] = { + { 0x3, 0x1, 0x2 }, + { 0x5, 0x1, 0x4 }, + { 0x7, 0x1, 0x6 }, + { 0x9, 0x1, 0x8 }, + { 0xB, 0x1, 0xA }, + { 0x53, 0x1, 0x52 }, + { 0x55, 0x1, 0x54 }, + { 0x57, 0x1, 0x56 }, + { 0x59, 0x1, 0x58 }, + { 0x5B, 0x1, 0x5A }, + { 0x45, 0x1, 0x44 }, + { 0x47, 0x1, 0x46 }, + { 0x49, 0x1, 0x48 }, + { 0x95, 0x1, 0x94 }, + { 0x97, 0x1, 0x96 }, + { 0x99, 0x1, 0x98 }, + { 0xAC, 0x1, 0xC6 }, + { 0xAD, 0x1, 0xC7 }, + { 0xAE, 0x1, 0xC8 }, + { 0xaf, 0x1, 0xC9 }, + { 0xB0, 0x1, 0xCA }, + { 0xB1, 0x1, 0xCB }, + { 0xB2, 0x1, 0xCC }, + { 0xB3, 0x1, 0xCD }, + { 0xB4, 0x1, 0xCE }, + { 0xB5, 0x1, 0xcf }, + { 0xB6, 0x1, 0xD0 }, + { 0xB7, 0x1, 0xD1 }, + { 0xB8, 0x1, 0xD2 }, + { 0xB9, 0x1, 0xD3 }, + { 0xBA, 0x1, 0xD4 }, + { 0xBB, 0x1, 0xD5 }, + { 0xBC, 0x1, 0xD6 }, + { 0xBD, 0x1, 0xD7 }, + { 0xBE, 0x1, 0xD8 }, + { 0xbf, 0x1, 0xD9 }, + { 0xC0, 0x1, 0xDA }, + { 0xC1, 0x1, 0xDB }, + { 0xC2, 0x1, 0xDC }, + { 0xC3, 0x1, 0xDD }, + { 0xC4, 0x1, 0xDE }, + { 0xC5, 0x1, 0xdf }, + { 0x25, 0x26, 0x24 }, + { 0x75, 0x76, 0x74 }, + { 0xC, 0xD, 0x1 }, + { 0xE, 0x0f, 0x1 }, + { 0x10, 0x11, 0x1 }, + { 0x12, 0x13, 0x1 }, + { 0x14, 0x15, 0x1 }, + { 0x16, 0x17, 0x1 }, + { 0x18, 0x19, 0x1 }, + { 0x1A, 0x1B, 0x1 }, + { 0x1C, 0x1D, 0x1 }, + { 0x1E, 0x1f, 0x1 }, + { 0x20, 0x21, 0x1 }, + { 0x22, 0x23, 0x1 }, + { 0x27, 0x28, 0x1 }, + { 0x29, 0x2A, 0x1 }, + { 0x5C, 0x5D, 0x1 }, + { 0x5E, 0x5f, 0x1 }, + { 0x60, 0x61, 0x1 }, + { 0x62, 0x63, 0x1 }, + { 0x64, 0x65, 0x1 }, + { 0x66, 0x67, 0x1 }, + { 0x68, 0x69, 0x1 }, + { 0x6A, 0x6B, 0x1 }, + { 0x6C, 0x6D, 0x1 }, + { 0x6E, 0x6f, 0x1 }, + { 0x70, 0x71, 0x1 }, + { 0x72, 0x73, 0x1 }, + { 0x77, 0x78, 0x1 }, + { 0x79, 0x7A, 0x1 }, + { 0x30, 0x31, 0x32 }, + { 0x33, 0x34, 0x35 }, + { 0x36, 0x37, 0x38 }, + { 0x39, 0x3A, 0x3B }, + { 0x3C, 0x3D, 0x3E }, + { 0x80, 0x81, 0x82 }, + { 0x83, 0x84, 0x85 }, + { 0x86, 0x87, 0x88 }, + { 0x89, 0x8A, 0x8B }, + { 0x8C, 0x8D, 0x8E } +}; + +static const u16 Unk_020F2954[][2] = { + { 0x24, 0x26 }, + { 0x74, 0x76 }, + { 0x32, 0x31 }, + { 0x35, 0x34 }, + { 0x38, 0x37 }, + { 0x3B, 0x3A }, + { 0x3E, 0x3D }, + { 0x82, 0x81 }, + { 0x85, 0x84 }, + { 0x88, 0x87 }, + { 0x8B, 0x8A }, + { 0x8E, 0x8D } +}; + +static const u16 Unk_020F292C[][2] = { + { 0x31, 0x32 }, + { 0x34, 0x35 }, + { 0x37, 0x38 }, + { 0x3A, 0x3B }, + { 0x3D, 0x3E }, + { 0x81, 0x82 }, + { 0x84, 0x85 }, + { 0x87, 0x88 }, + { 0x8A, 0x8B }, + { 0x8D, 0x8E } +}; + +static const int sUnkGXObjOffsets0[] = { + 0x70, + 0x4C, + 0x48 +}; + +static const u8 sNamingScreenCharsBgColor[4] = { + 0x4, + 0x7, + 0xD, + 0xA +}; + +const charcode_t sDummy0[] = { + 0x3, + 0x2B, + 0x20, + 0x2f, + 0x1, + 0x2B, + 0x3f, + 0x9, + 0x30, + 0xE2, + 0xffff +}; + +const charcode_t sDummy1[] = { + 0x8E, + 0x62, + 0x93, + 0xA1, + 0x2f, + 0x1, + 0x7C, + 0x74, + 0x60, + 0x7E, + 0xf1, + 0x91, + 0x30, + 0xE2, + 0xffff +}; + +const charcode_t sDummy2[] = { + 0x8D, + 0x74, + 0x60, + 0x6A, + 0x2f, + 0x1, + 0x2B, + 0x3f, + 0x9, + 0x30, + 0xE2, + 0xffff +}; + +static const charcode_t *sDummy3[] = { + sDummy0, + sDummy1, + sDummy2, +}; + +static const int Unk_020F2850[] = { + 0x0, + 0x1, + 0x2, + 0x3, + 0x4, + 0x5, + 0x6, + 0x3 +}; + +const ApplicationManagerTemplate gNamingScreenAppTemplate = { + .init = NamingScreen_Init, + .main = NamingScreen_Main, + .exit = NamingScreen_Exit, + .overlayID = FS_OVERLAY_ID_NONE, +}; + +static NamingScreen *sNamingScreenDummy; + +static BOOL NamingScreen_Init(ApplicationManager *appMan, int *state) +{ + NamingScreen *namingScreen; + NARC *narc; + + switch (*state) { + case 0: + SetVBlankCallback(NULL, NULL); + DisableHBlank(); + GXLayers_DisableEngineALayers(); + GXLayers_DisableEngineBLayers(); + + GX_SetVisiblePlane(0); + GXS_SetVisiblePlane(0); + + Heap_Create(HEAP_ID_APPLICATION, HEAP_ID_NAMING_SCREEN_APP, 0x20000 + 0x8000); + + namingScreen = ApplicationManager_NewData(appMan, sizeof(NamingScreen), HEAP_ID_NAMING_SCREEN_APP); + memset(namingScreen, 0, sizeof(NamingScreen)); + namingScreen->bgConfig = BgConfig_New(HEAP_ID_NAMING_SCREEN_APP); + narc = NARC_ctor(NARC_INDEX_DATA__NAMEIN, HEAP_ID_NAMING_SCREEN_APP); + + namingScreen->strTemplate = StringTemplate_Default(HEAP_ID_NAMING_SCREEN_APP); + namingScreen->namingScreenMsgLoader = MessageLoader_Init( + MESSAGE_LOADER_BANK_HANDLE, + NARC_INDEX_MSGDATA__PL_MSG, + TEXT_BANK_NAMING_SCREEN, + HEAP_ID_NAMING_SCREEN_APP); + namingScreen->genericNamesMsgLoader = MessageLoader_Init( + MESSAGE_LOADER_NARC_HANDLE, + NARC_INDEX_MSGDATA__PL_MSG, + TEXT_BANK_GENERIC_NAMES, + HEAP_ID_NAMING_SCREEN_APP); + namingScreen->battleStringsMsgLoader = MessageLoader_Init( + MESSAGE_LOADER_NARC_HANDLE, + NARC_INDEX_MSGDATA__PL_MSG, + TEXT_BANK_BATTLE_STRINGS, + HEAP_ID_NAMING_SCREEN_APP); + + SetAutorepeat(4, 8); + NamingScreen_InitGraphicsBanks(); + NamingScreen_InitBgs(namingScreen->bgConfig); + NamingScreen_CopyParamsFromArgs(namingScreen, (NamingScreenArgs *)ApplicationManager_Args(appMan)); + NamingScreen_LoadGraphicsFromNarc(namingScreen, narc); + Font_InitManager(FONT_SUBSCREEN, HEAP_ID_NAMING_SCREEN_APP); + SetVBlankCallback(NamingScreen_VBlankCallback, NULL); + NamingScreen_InitCursorsAndChars(namingScreen, appMan); + Font_UseImmediateGlyphAccess(FONT_SYSTEM, HEAP_ID_NAMING_SCREEN_APP); + NamingScreen_TransferChars(); + sub_020877F4(namingScreen, narc); + NamingScreen_InitSprites(namingScreen); + sub_02087FC0(namingScreen, appMan, narc); + sub_02088754( + &namingScreen->unk_41C[4], + namingScreen->entryBuf, + namingScreen->textCursorPos, + namingScreen->tmpBuf, + namingScreen->pixelBuf, + namingScreen->unk_17C); + Sound_SetSceneAndPlayBGM(SOUND_SCENE_SUB_52, SEQ_NONE, 0); + StartScreenFade(FADE_BOTH_SCREENS, FADE_TYPE_BRIGHTNESS_IN, FADE_TYPE_BRIGHTNESS_IN, COLOR_BLACK, 16, 1, HEAP_ID_NAMING_SCREEN_APP); + NamingScreen_ToggleEngineLayers(TRUE); + + { + gSystem.whichScreenIs3D = DS_SCREEN_SUB; + GXLayers_SwapDisplay(); + } + + NARC_dtor(narc); + (*state)++; + break; + case 1: + namingScreen = ApplicationManager_Data(appMan); + + if (namingScreen->type == NAMING_SCREEN_TYPE_POKEMON) { + sub_02086B30(namingScreen->unk_51C, namingScreen->unk_524, namingScreen->unk_04, namingScreen->unk_08); + } + + sNamingScreenDummy = namingScreen; + namingScreen->unk_628 = sub_0201567C(NULL, 1, 12, HEAP_ID_NAMING_SCREEN_APP); + + (*state) = NMS_APP_STATE_WAIT_FADE_IN; + return TRUE; + break; + } + + return FALSE; +} + +static void sub_02086B30(NNSG2dCharacterData *param0, NNSG2dPaletteData *param1, int param2, int param3) +{ + u8 *v0; + + GX_LoadOBJ(param0->pRawData, (21 * 32 + 31) * 0x20, 0x20 * 4 * 4); + v0 = (u8 *)param1->pRawData; + GX_LoadOBJPltt((void *)(v0 + PokeIconPaletteIndex(param2, param3, 0) * 0x20), 6 * 0x20, 0x20); +} + +static BOOL NamingScreen_Main(ApplicationManager *appMan, int *state) +{ + NamingScreen *namingScreen = ApplicationManager_Data(appMan); + + switch (*state) { + case NMS_APP_STATE_WAIT_FADE_IN: + if (IsScreenFadeDone()) { + *state = NMS_APP_STATE_INITIAL_DELAY; + namingScreen->delayUpdateCounter = 0; + } + break; + case NMS_APP_STATE_INITIAL_DELAY: + namingScreen->delayUpdateCounter++; + + // these just process the animations. + sub_02088FD0(namingScreen); + NamingScreen_UpdateSpriteAnimations(namingScreen->spritesToUpdate, namingScreen->miscSprites, namingScreen->currentCharsIdx); + + if (namingScreen->delayUpdateCounter > 5) { + *state = NMS_APP_STATE_RUNNING; + namingScreen->delayUpdateCounter = 0; + } + break; + case NMS_APP_STATE_RUNNING: + switch (namingScreen->state.main) { + case NMS_STATE_PLACEHOLDER_4: + *state = NamingScreen_ProcessInputs(namingScreen, *state); + sub_02088FD0(namingScreen); + break; + case NMS_STATE_PLACEHOLDER_5: + sub_02087544(namingScreen, appMan); + Window_FillTilemap(&namingScreen->unk_41C[9], 0x0f); + Window_DrawMessageBoxWithScrollCursor(&namingScreen->unk_41C[9], 0, 32 * 8, 10); + namingScreen->unk_4BC = Text_AddPrinterWithParams(&namingScreen->unk_41C[9], FONT_MESSAGE, namingScreen->unk_180, 0, 0, TEXT_SPEED_FAST, NULL); + Window_CopyToVRAM(&namingScreen->unk_41C[9]); + namingScreen->state.main = NMS_STATE_PLACEHOLDER_6; + break; + case NMS_STATE_PLACEHOLDER_6: + if (Text_IsPrinterActive(namingScreen->unk_4BC) == 0) { + Sound_PlayEffect(SEQ_SE_DP_PIRORIRO); + namingScreen->spritesToUpdate[6]++; + namingScreen->delayUpdateCounter = 0; + namingScreen->state.main = NMS_STATE_PLACEHOLDER_7; + } + break; + case NMS_STATE_PLACEHOLDER_7: + namingScreen->delayUpdateCounter++; + + if (namingScreen->delayUpdateCounter > 30) { + StartScreenFade( + FADE_SUB_THEN_MAIN, + FADE_TYPE_BRIGHTNESS_OUT, + FADE_TYPE_BRIGHTNESS_OUT, + COLOR_BLACK, + 16, + 1, + HEAP_ID_NAMING_SCREEN_APP); + *state = NMS_APP_STATE_WAIT_FADE_OUT; + } + break; + } + + NamingScreen_AnimateChangeChars( + namingScreen->bgConfig, + &namingScreen->unk_41C[0], + &namingScreen->state.changeChars, + namingScreen->currentCharsIdx, + &namingScreen->freeCharsBgLayer, + namingScreen->charsPosition, + namingScreen->miscSprites, + namingScreen->charData->pRawData); + NamingScreen_UpdateSpriteAnimations(namingScreen->spritesToUpdate, namingScreen->miscSprites, namingScreen->currentCharsIdx); + sub_02088514(&namingScreen->unk_38); + break; + case NMS_APP_STATE_WAIT_FADE_OUT: + if (IsScreenFadeDone()) { + return TRUE; + } + break; + } + + SpriteList_Update(namingScreen->unk_188); + + return FALSE; +} + +static enum NamingScreenAppState NamingScreen_ProcessInputs(NamingScreen *namingScreen, enum NamingScreenAppState appState) +{ + NamingScreen_ProcessDirectionInputs(namingScreen); + + if (gSystem.pressedKeys & PAD_BUTTON_SELECT) { + if (!Sprite_GetDrawFlag(namingScreen->miscSprites[8])) { + Sprite_SetDrawFlag(namingScreen->miscSprites[8], TRUE); + return appState; + } + + if (namingScreen->type != NAMING_SCREEN_TYPE_UNK4) { + namingScreen->state.changeChars = CC_STATE_LOAD_GRAPHICS; + namingScreen->currentCharsIdx++; + + if (namingScreen->currentCharsIdx >= 3) { + namingScreen->currentCharsIdx = 0; + } + + namingScreen->spritesToUpdate[namingScreen->currentCharsIdx]++; + + sub_02088844(namingScreen->unk_3A, namingScreen->currentCharsIdx); + Sound_PlayEffect(SEQ_SE_DP_SYU03); + + namingScreen->unk_1C.hasCharacterBeenEntered = TRUE; + } + + namingScreen->spritesToUpdate[namingScreen->currentCharsIdx]++; + + sub_02088844(namingScreen->unk_3A, namingScreen->currentCharsIdx); + Sound_PlayEffect(SEQ_SE_DP_SYU03); + } else if (gSystem.pressedKeys & PAD_BUTTON_A) { + appState = sub_02088898(namingScreen, namingScreen->unk_3A[namingScreen->unk_1C.unk_04][namingScreen->unk_1C.unk_00], 1); + namingScreen->unk_1C.hasCharacterBeenEntered = TRUE; + } else if (namingScreen->unk_62C == 1) { + appState = sub_02088898(namingScreen, namingScreen->unk_3A[namingScreen->unk_1C.unk_04][namingScreen->unk_1C.unk_00], 0); + namingScreen->unk_1C.hasCharacterBeenEntered = FALSE; + } else if (gSystem.pressedKeys & PAD_BUTTON_B) { + appState = sub_02088898(namingScreen, 0xe001 + 6, 1); + } else if (gSystem.pressedKeys & PAD_BUTTON_R) { + appState = sub_02088898(namingScreen, 0xe001 + 5, 1); + } + + return appState; +} + +static void sub_02086E6C(NamingScreen *param0, NamingScreenArgs *param1) +{ + if (param0->type == NAMING_SCREEN_TYPE_PLAYER) { + Strbuf *v0; + + if (param0->unk_04 == 0) { + v0 = MessageLoader_GetNewStrbuf(param0->genericNamesMsgLoader, 0 + LCRNG_Next() % 18); + } else if (param0->unk_04 == 1) { + v0 = MessageLoader_GetNewStrbuf(param0->genericNamesMsgLoader, 18 + LCRNG_Next() % 18); + } + + Strbuf_Copy(param1->textInputStr, v0); + Strbuf_Free(v0); + Strbuf_ToChars(param1->textInputStr, param1->unk_1C, 10); + } else if (param0->type == NAMING_SCREEN_TYPE_RIVAL) { + Strbuf *v1; + + v1 = MessageLoader_GetNewStrbuf(param0->genericNamesMsgLoader, 88 + (LCRNG_Next() % 2)); + + Strbuf_Copy(param1->textInputStr, v1); + Strbuf_Free(v1); + Strbuf_ToChars(param1->textInputStr, param1->unk_1C, 10); + } else { + param1->unk_14 = 1; + } +} + +static int sub_02086F14(u16 *param0) +{ + int v0 = 1; + int v1; + + for (v1 = 0;; v1++) { + if (param0[v1] == 0xffff) { + break; + } + + if (param0[v1] != 0x1de) { + v0 = 0; + } + } + + return v0; +} + +static BOOL NamingScreen_Exit(ApplicationManager *appMan, int *unusedState) +{ + NamingScreen *namingScreen = ApplicationManager_Data(appMan); + NamingScreenArgs *namingScreenArgs = (NamingScreenArgs *)ApplicationManager_Args(appMan); + int v2; + + namingScreen->entryBuf[namingScreen->textCursorPos] = CHAR_EOS; + + if (namingScreen->type == NAMING_SCREEN_TYPE_POKEMON) { + Pokemon *mon; + + mon = Pokemon_New(HEAP_ID_NAMING_SCREEN_APP); + Pokemon_InitWith(mon, namingScreen->unk_04, 5, 10, 10, 10, 10, 10); + Heap_Free(mon); + } + + if ((namingScreen->textCursorPos == 0) || (CharCode_Compare(namingScreen->entryBuf, namingScreen->entryBufBak) == 0) || sub_02086F14(namingScreen->entryBuf)) { + sub_02086E6C(namingScreen, namingScreenArgs); + } else { + CharCode_Copy(namingScreen->entryBufBak, namingScreen->entryBuf); + CharCode_Copy(namingScreenArgs->unk_1C, namingScreen->entryBuf); + Strbuf_CopyChars(namingScreenArgs->textInputStr, namingScreen->entryBuf); + } + + Strbuf_Free(namingScreen->unk_184); + + for (v2 = 0; v2 < 7; v2++) { + SysTask_FinishAndFreeParam(namingScreen->unk_400[v2]); + } + + SpriteTransfer_ResetCharTransfer(namingScreen->unk_328[0][0]); + SpriteTransfer_ResetCharTransfer(namingScreen->unk_328[1][0]); + SpriteTransfer_ResetPlttTransfer(namingScreen->unk_328[0][1]); + SpriteTransfer_ResetPlttTransfer(namingScreen->unk_328[1][1]); + + for (v2 = 0; v2 < 4; v2++) { + SpriteResourceCollection_Delete(namingScreen->unk_318[v2]); + } + + SpriteList_Delete(namingScreen->unk_188); + RenderOam_Free(); + Heap_FreeExplicit(HEAP_ID_NAMING_SCREEN_APP, namingScreen->charDataAlloc); + + if (namingScreen->type == NAMING_SCREEN_TYPE_POKEMON) { + Heap_FreeExplicit(HEAP_ID_NAMING_SCREEN_APP, namingScreen->unk_518); + Heap_FreeExplicit(HEAP_ID_NAMING_SCREEN_APP, namingScreen->unk_520); + } + + Bg_FreeTilemapBuffer(namingScreen->bgConfig, BG_LAYER_SUB_3); + CharTransfer_Free(); + PlttTransfer_Free(); + sub_0208765C(namingScreen->bgConfig, namingScreen->unk_41C); + Font_UseLazyGlyphAccess(FONT_SYSTEM); + + GX_SetVisibleWnd(GX_WNDMASK_NONE); + + Font_Free(FONT_SUBSCREEN); + + if (namingScreen->unk_180) { + Strbuf_Free(namingScreen->unk_180); + } + + Strbuf_Free(namingScreen->unk_178); + Strbuf_Free(namingScreen->unk_17C); + MessageLoader_Free(namingScreen->battleStringsMsgLoader); + MessageLoader_Free(namingScreen->genericNamesMsgLoader); + MessageLoader_Free(namingScreen->namingScreenMsgLoader); + StringTemplate_Free(namingScreen->strTemplate); + ApplicationManager_FreeData(appMan); + SetVBlankCallback(NULL, NULL); + Heap_Destroy(HEAP_ID_NAMING_SCREEN_APP); + + { + gSystem.whichScreenIs3D = DS_SCREEN_MAIN; + GXLayers_SwapDisplay(); + } + + return TRUE; +} + +NamingScreenArgs *NamingScreenArgs_Init(enum HeapId heapID, enum NamingScreenType type, int param2, int maxChars, Options *options) +{ + NamingScreenArgs *v0 = (NamingScreenArgs *)Heap_AllocFromHeap(heapID, sizeof(NamingScreenArgs)); + + v0->type = type; + v0->unk_04 = param2; + v0->maxChars = maxChars; + v0->unk_14 = 0; + v0->unk_1C[0] = 0xffff; + v0->textInputStr = Strbuf_Init(32, heapID); + v0->unk_44 = 0; + v0->pcBoxes = NULL; + v0->unk_10 = 0; + v0->options = options; + v0->unk_08 = 0; + + return v0; +} + +void NamingScreenArgs_Free(NamingScreenArgs *param0) +{ + GF_ASSERT((param0->textInputStr) != NULL); + GF_ASSERT((param0) != NULL); + + Strbuf_Free(param0->textInputStr); + Heap_Free(param0); +} + +static void NamingScreen_VBlankCallback(void *unused) +{ + VramTransfer_Process(); + RenderOam_Transfer(); + + OS_SetIrqCheckFlag(OS_IE_V_BLANK); +} + +static void NamingScreen_CopyParamsFromArgs(NamingScreen *namingScreen, NamingScreenArgs *namingScreenArgs) +{ + namingScreen->type = namingScreenArgs->type; + namingScreen->unk_04 = namingScreenArgs->unk_04; + namingScreen->unk_08 = namingScreenArgs->unk_08; + namingScreen->unk_0C = namingScreenArgs->maxChars; + namingScreen->unk_10 = namingScreenArgs->unk_10; + namingScreen->options = namingScreenArgs->options; +} + +static void NamingScreen_InitGraphicsBanks(void) +{ + UnkStruct_02099F80 banks = { + .unk_00 = GX_VRAM_BG_128_A, + .unk_04 = GX_VRAM_BGEXTPLTT_NONE, + .unk_08 = GX_VRAM_SUB_BG_128_C, + .unk_0C = GX_VRAM_SUB_BGEXTPLTT_NONE, + .unk_10 = GX_VRAM_OBJ_128_B, + .unk_14 = GX_VRAM_OBJEXTPLTT_NONE, + .unk_18 = GX_VRAM_SUB_OBJ_16_I, + .unk_1C = GX_VRAM_SUB_OBJEXTPLTT_NONE, + .unk_20 = GX_VRAM_TEX_NONE, + .unk_24 = GX_VRAM_TEXPLTT_NONE, + }; + + GXLayers_SetBanks(&banks); +} + +static void NamingScreen_InitBgs(BgConfig *bgConfig) +{ + { + GraphicsModes graphicsModes = { + .displayMode = GX_DISPMODE_GRAPHICS, + .mainBgMode = GX_BGMODE_0, + .subBgMode = GX_BGMODE_0, + .bg0As2DOr3D = GX_BG0_AS_2D, + }; + + SetAllGraphicsModes(&graphicsModes); + } + + { + BgTemplate layerMain0Template = { + .x = 0, + .y = 0, + .bufferSize = 0x1000, + .baseTile = 0, + .screenSize = BG_SCREEN_SIZE_512x256, + .colorMode = GX_BG_COLORMODE_16, + .screenBase = GX_BG_SCRBASE_0xf000, + .charBase = GX_BG_CHARBASE_0x10000, + .bgExtPltt = GX_BG_EXTPLTT_01, + .priority = 1, + .areaOver = 0, + .mosaic = FALSE, + }; + + Bg_InitFromTemplate(bgConfig, BG_LAYER_MAIN_0, &layerMain0Template, BG_TYPE_STATIC); + Bg_ClearTilemap(bgConfig, BG_LAYER_MAIN_0); + } + + { + BgTemplate layerMain1Template = { + .x = 0, + .y = 0, + .bufferSize = 0x1000, + .baseTile = 0, + .screenSize = BG_SCREEN_SIZE_512x256, + .colorMode = GX_BG_COLORMODE_16, + .screenBase = GX_BG_SCRBASE_0xe000, + .charBase = GX_BG_CHARBASE_0x10000, + .bgExtPltt = GX_BG_EXTPLTT_01, + .priority = 2, + .areaOver = 0, + .mosaic = FALSE, + }; + + Bg_InitFromTemplate(bgConfig, BG_LAYER_MAIN_1, &layerMain1Template, BG_TYPE_STATIC); + Bg_ClearTilemap(bgConfig, BG_LAYER_MAIN_1); + } + + { + BgTemplate layerMain2Template = { + .x = 0, + .y = 0, + .bufferSize = 0x800, + .baseTile = 0, + .screenSize = BG_SCREEN_SIZE_256x256, + .colorMode = GX_BG_COLORMODE_16, + .screenBase = GX_BG_SCRBASE_0xd000, + .charBase = GX_BG_CHARBASE_0x00000, + .bgExtPltt = GX_BG_EXTPLTT_01, + .priority = 3, + .areaOver = 0, + .mosaic = FALSE, + }; + + Bg_InitFromTemplate(bgConfig, BG_LAYER_MAIN_2, &layerMain2Template, BG_TYPE_STATIC); + Bg_ClearTilemap(bgConfig, BG_LAYER_MAIN_2); + } + + { + BgTemplate layerSub0Template = { + .x = 0, + .y = 0, + .bufferSize = 0x800, + .baseTile = 0, + .screenSize = BG_SCREEN_SIZE_256x256, + .colorMode = GX_BG_COLORMODE_16, + .screenBase = GX_BG_SCRBASE_0xf800, + .charBase = GX_BG_CHARBASE_0x10000, + .bgExtPltt = GX_BG_EXTPLTT_01, + .priority = 0, + .areaOver = 0, + .mosaic = FALSE, + }; + + Bg_InitFromTemplate(bgConfig, BG_LAYER_SUB_0, &layerSub0Template, BG_TYPE_STATIC); + Bg_ClearTilemap(bgConfig, BG_LAYER_SUB_0); + } + + NamingScreen_ToggleEngineLayers(FALSE); + Bg_ClearTilesRange(BG_LAYER_MAIN_0, 32, 0, HEAP_ID_NAMING_SCREEN_APP); + Bg_ClearTilesRange(BG_LAYER_SUB_0, 32, 0, HEAP_ID_NAMING_SCREEN_APP); + + GX_SetVisibleWnd(GX_WNDMASK_W0); + G2_SetWnd0InsidePlane(GX_WND_PLANEMASK_BG2 | GX_WND_PLANEMASK_OBJ, TRUE); + G2_SetWndOutsidePlane(GX_WND_PLANEMASK_BG0 | GX_WND_PLANEMASK_BG1 | GX_WND_PLANEMASK_BG2 | GX_WND_PLANEMASK_BG3 | GX_WND_PLANEMASK_OBJ, TRUE); + G2_SetWnd0Position(0, 0, 255, 64); + G2S_BlendNone(); +} + +static void NamingScreen_ToggleEngineLayers(BOOL enable) +{ + GXLayers_EngineAToggleLayers(GX_BLEND_PLANEMASK_BG0, enable); + GXLayers_EngineAToggleLayers(GX_BLEND_PLANEMASK_BG1, enable); + GXLayers_EngineAToggleLayers(GX_BLEND_PLANEMASK_BG2, enable); + GXLayers_EngineAToggleLayers(GX_BLEND_PLANEMASK_BG3, FALSE); + GXLayers_EngineAToggleLayers(GX_BLEND_PLANEMASK_OBJ, enable); + GXLayers_EngineBToggleLayers(GX_BLEND_PLANEMASK_BG0, enable); + GXLayers_EngineBToggleLayers(GX_BLEND_PLANEMASK_BG1, FALSE); + GXLayers_EngineBToggleLayers(GX_BLEND_PLANEMASK_OBJ, FALSE); +} + +static void NamingScreen_InitCursorsAndChars(NamingScreen *namingScreen, ApplicationManager *appMan) +{ + NamingScreenArgs *namingScreenArgs = (NamingScreenArgs *)ApplicationManager_Args(appMan); + + namingScreen->state.main = NMS_STATE_PLACEHOLDER_4; + + NamingScreen_InitializeCharsPosition(namingScreen->charsPosition, BG_LAYER_MAIN_0); + Bg_SetOffset( + namingScreen->bgConfig, + namingScreen->freeCharsBgLayer, + BG_OFFSET_UPDATE_SET_X, + namingScreen->charsPosition[namingScreen->freeCharsBgLayer].x); + Bg_SetOffset( + namingScreen->bgConfig, + namingScreen->freeCharsBgLayer, + BG_OFFSET_UPDATE_SET_Y, + namingScreen->charsPosition[namingScreen->freeCharsBgLayer].y); + Bg_SetOffset( + namingScreen->bgConfig, + ((namingScreen->freeCharsBgLayer) ^ 1), + BG_OFFSET_UPDATE_SET_X, + namingScreen->charsPosition[((namingScreen->freeCharsBgLayer) ^ 1)].x); + Bg_SetOffset( + namingScreen->bgConfig, + ((namingScreen->freeCharsBgLayer) ^ 1), + BG_OFFSET_UPDATE_SET_Y, + namingScreen->charsPosition[((namingScreen->freeCharsBgLayer) ^ 1)].y); + + namingScreen->entryBufBak[0] = CHAR_EOS; + + if (namingScreenArgs->textInputStr) { + Strbuf_ToChars(namingScreenArgs->textInputStr, namingScreen->entryBufBak, 32); + } + + MI_CpuFill16(namingScreen->entryBuf, 1, 32 * 2); + + if (namingScreen->type == NAMING_SCREEN_TYPE_POKEMON) { + Pokemon *pkm; + + pkm = Pokemon_New(HEAP_ID_NAMING_SCREEN_APP); + Pokemon_InitWith(pkm, namingScreen->unk_04, 5, 10, 10, 10, 10, 10); + StringTemplate_SetSpeciesName(namingScreen->strTemplate, 0, Pokemon_GetBoxPokemon(pkm)); + Heap_Free(pkm); + } + + if (namingScreenArgs->unk_44 != 0) { + namingScreen->unk_14 = 1; + } + + namingScreen->unk_178 = MessageUtil_ExpandedStrbuf( + namingScreen->strTemplate, + namingScreen->namingScreenMsgLoader, + Unk_020F2850[namingScreen->type], + HEAP_ID_NAMING_SCREEN_APP); + namingScreen->unk_17C = MessageUtil_ExpandedStrbuf(namingScreen->strTemplate, namingScreen->namingScreenMsgLoader, 8, HEAP_ID_NAMING_SCREEN_APP); + namingScreen->unk_184 = MessageLoader_GetNewStrbuf(namingScreen->namingScreenMsgLoader, 7); + namingScreen->textCursorPos = CharCode_Length(namingScreen->entryBufBak); + namingScreen->unk_1C.unk_00 = 0; + namingScreen->unk_1C.unk_04 = 1; + namingScreen->unk_1C.unk_08 = -1; + namingScreen->unk_1C.unk_0C = -1; + namingScreen->unk_1C.hasCharacterBeenEntered = FALSE; + namingScreen->unk_1C.unk_18 = 0; + namingScreen->unk_4E8 = 0xffffffff; + namingScreen->unk_4EC = 0; + namingScreen->unk_4F0 = 0; + namingScreen->entryBuf[namingScreen->unk_0C] = CHAR_EOS; + + { + int v2; + + for (v2 = 0; v2 < 7; v2++) { + namingScreen->spritesToUpdate[v2] = 0; + } + + switch (namingScreen->type) { + case NAMING_SCREEN_TYPE_UNK4: + namingScreen->spritesToUpdate[3] = 1; + break; + default: + namingScreen->spritesToUpdate[0] = 1; + break; + } + } +} + +static void sub_02087544(NamingScreen *param0, ApplicationManager *appMan) +{ + Strbuf *v0 = NULL; + NamingScreenArgs *v1 = (NamingScreenArgs *)ApplicationManager_Args(appMan); + + if (v1->unk_44 != 0) { + int v2, v3; + + v0 = Strbuf_Init(200, HEAP_ID_NAMING_SCREEN_APP); + param0->unk_180 = NULL; + v2 = PCBoxes_GetCurrentBoxID(v1->pcBoxes); + v3 = PCBoxes_FirstEmptyBox(v1->pcBoxes); + + StringTemplate_SetPCBoxName(param0->strTemplate, 1, v1->pcBoxes, v2); + + if (v2 != v3) { + StringTemplate_SetPCBoxName(param0->strTemplate, 2, v1->pcBoxes, v3); + v1->unk_44 += 2; + } else { + StringTemplate_SetPCBoxName(param0->strTemplate, 2, v1->pcBoxes, v2); + } + + if ((param0->textCursorPos == 0) || sub_02086F14(param0->entryBuf)) { + Pokemon *v4 = Pokemon_New(HEAP_ID_NAMING_SCREEN_APP); + + Pokemon_InitWith(v4, param0->unk_04, 1, 0, 0, 0, 0, 0); + StringTemplate_SetSpeciesName(param0->strTemplate, 0, Pokemon_GetBoxPokemon(v4)); + Heap_Free(v4); + } else { + param0->entryBuf[param0->textCursorPos] = CHAR_EOS; + Strbuf_CopyChars(v0, param0->entryBuf); + StringTemplate_SetStrbuf(param0->strTemplate, 0, v0, 0, 0, 0); + } + + param0->unk_180 = MessageUtil_ExpandedStrbuf(param0->strTemplate, param0->battleStringsMsgLoader, v1->unk_44, HEAP_ID_NAMING_SCREEN_APP); + param0->unk_14 = 1; + + Strbuf_Free(v0); + } +} + +static void sub_0208765C(BgConfig *param0, Window *param1) +{ + int v0; + + for (v0 = 0; v0 < 10; v0++) { + Window_Remove(¶m1[v0]); + } + + Bg_FreeTilemapBuffer(param0, BG_LAYER_SUB_0); + Bg_FreeTilemapBuffer(param0, BG_LAYER_MAIN_2); + Bg_FreeTilemapBuffer(param0, BG_LAYER_MAIN_1); + Bg_FreeTilemapBuffer(param0, BG_LAYER_MAIN_0); + Heap_FreeExplicit(HEAP_ID_NAMING_SCREEN_APP, param0); +} + +static void NamingScreen_LoadGraphicsFromNarc(NamingScreen *namingScreen, NARC *narc) +{ + BgConfig *bgConfig = namingScreen->bgConfig; + + Graphics_LoadPaletteFromOpenNARC(narc, 0, PAL_LOAD_MAIN_BG, 0, 16 * 3 * 2, HEAP_ID_NAMING_SCREEN_APP); + Graphics_LoadPalette(NARC_INDEX_GRAPHIC__POKETCH, 12, PAL_LOAD_SUB_BG, 0, 16 * 2, HEAP_ID_NAMING_SCREEN_APP); + Bg_MaskPalette(BG_LAYER_SUB_0, 0); + Graphics_LoadTilesToBgLayerFromOpenNARC( + narc, + 2, + bgConfig, + BG_LAYER_MAIN_2, + 0, + (32 * 8) * 0x20, + TRUE, + HEAP_ID_NAMING_SCREEN_APP); + Graphics_LoadTilemapToBgLayerFromOpenNARC( + narc, + 4, + bgConfig, + BG_LAYER_MAIN_2, + 0, + 32 * 24 * 2, + TRUE, + HEAP_ID_NAMING_SCREEN_APP); + Graphics_LoadTilesToBgLayerFromOpenNARC( + narc, + 2, + bgConfig, + BG_LAYER_MAIN_1, + 0, + 32 * 8 * 0x20, + TRUE, + HEAP_ID_NAMING_SCREEN_APP); + Graphics_LoadTilemapToBgLayerFromOpenNARC( + narc, + 6, + bgConfig, + BG_LAYER_MAIN_1, + 0, + 32 * 14 * 2, + TRUE, + HEAP_ID_NAMING_SCREEN_APP); + Graphics_LoadTilemapToBgLayerFromOpenNARC( + narc, + 7, + bgConfig, + BG_LAYER_MAIN_0, + 0, + 32 * 14 * 2, + TRUE, + HEAP_ID_NAMING_SCREEN_APP); + Font_LoadScreenIndicatorsPalette(PAL_LOAD_MAIN_BG, 12 * 32, HEAP_ID_NAMING_SCREEN_APP); + LoadMessageBoxGraphics( + namingScreen->bgConfig, + BG_LAYER_SUB_0, + 32 * 8, + 10, + Options_Frame(namingScreen->options), + HEAP_ID_NAMING_SCREEN_APP); + Font_LoadScreenIndicatorsPalette(PAL_LOAD_SUB_BG, 12 * 32, HEAP_ID_NAMING_SCREEN_APP); + + namingScreen->charDataAlloc = Graphics_GetCharDataFromOpenNARC( + narc, + 16, + TRUE, + &namingScreen->charData, + HEAP_ID_NAMING_SCREEN_APP); +} + +void NamingScreen_TransferChars(void) +{ + { + CharTransferTemplate charTransferTemplate = { + .maxTasks = 20, + .sizeMain = 2048, + .sizeSub = 2048, + .heapID = HEAP_ID_NAMING_SCREEN_APP, + }; + + CharTransfer_Init(&charTransferTemplate); + } + + PlttTransfer_Init(20, HEAP_ID_NAMING_SCREEN_APP); + CharTransfer_ClearBuffers(); + PlttTransfer_Clear(); +} + +static void sub_020877F4(NamingScreen *param0, NARC *param1) +{ + int v0; + + NNS_G2dInitOamManagerModule(); + RenderOam_Init(0, 128, 0, 32, 0, 128, 0, 32, HEAP_ID_NAMING_SCREEN_APP); + + param0->unk_188 = SpriteList_InitRendering(40 + 4, ¶m0->unk_18C, HEAP_ID_NAMING_SCREEN_APP); + + SetSubScreenViewRect(¶m0->unk_18C, 0, 256 * FX32_ONE); + + for (v0 = 0; v0 < 4; v0++) { + param0->unk_318[v0] = SpriteResourceCollection_New(2, v0, HEAP_ID_NAMING_SCREEN_APP); + } + + param0->unk_328[0][0] = SpriteResourceCollection_AddTilesFrom(param0->unk_318[0], param1, 10, 1, 0, NNS_G2D_VRAM_TYPE_2DMAIN, HEAP_ID_NAMING_SCREEN_APP); + param0->unk_328[0][1] = SpriteResourceCollection_AddPaletteFrom(param0->unk_318[1], param1, 1, 0, 0, NNS_G2D_VRAM_TYPE_2DMAIN, 9, HEAP_ID_NAMING_SCREEN_APP); + param0->unk_328[0][2] = SpriteResourceCollection_AddFrom(param0->unk_318[2], param1, 12, 1, 0, 2, HEAP_ID_NAMING_SCREEN_APP); + param0->unk_328[0][3] = SpriteResourceCollection_AddFrom(param0->unk_318[3], param1, 14, 1, 0, 3, HEAP_ID_NAMING_SCREEN_APP); + + if (param0->type == NAMING_SCREEN_TYPE_POKEMON) { + param0->unk_518 = Graphics_GetCharData(NARC_INDEX_POKETOOL__ICONGRA__PL_POKE_ICON, PokeIconSpriteIndex(param0->unk_04, 0, param0->unk_08), 0, ¶m0->unk_51C, HEAP_ID_NAMING_SCREEN_APP); + DC_FlushRange(param0->unk_51C, 0x20 * 4 * 4); + + param0->unk_520 = Graphics_GetPlttData(NARC_INDEX_POKETOOL__ICONGRA__PL_POKE_ICON, PokeIconPalettesFileIndex(), ¶m0->unk_524, HEAP_ID_NAMING_SCREEN_APP); + DC_FlushRange(param0->unk_524, 0x20 * 4); + } + + param0->unk_328[1][0] = SpriteResourceCollection_AddTilesFrom(param0->unk_318[0], param1, 11, 1, 1, NNS_G2D_VRAM_TYPE_2DSUB, HEAP_ID_NAMING_SCREEN_APP); + param0->unk_328[1][1] = SpriteResourceCollection_AddPaletteFrom(param0->unk_318[1], param1, 1, 0, 1, NNS_G2D_VRAM_TYPE_2DSUB, 3, HEAP_ID_NAMING_SCREEN_APP); + param0->unk_328[1][2] = SpriteResourceCollection_AddFrom(param0->unk_318[2], param1, 13, 1, 1, 2, HEAP_ID_NAMING_SCREEN_APP); + param0->unk_328[1][3] = SpriteResourceCollection_AddFrom(param0->unk_318[3], param1, 15, 1, 1, 3, HEAP_ID_NAMING_SCREEN_APP); + + SpriteTransfer_RequestChar(param0->unk_328[0][0]); + SpriteTransfer_RequestChar(param0->unk_328[1][0]); + SpriteTransfer_RequestPlttWholeRange(param0->unk_328[0][1]); + SpriteTransfer_RequestPlttWholeRange(param0->unk_328[1][1]); +} + +static void sub_020879DC(SysTask *param0, void *param1) +{ + const VecFx32 *v0; + VecFx32 v1; + UnkStruct_020879DC *v2 = (UnkStruct_020879DC *)param1; + + v0 = Sprite_GetPosition(v2->unk_00); + v1.x = v0->x + v2->unk_08; + v1.y = FX32_ONE * sNamingScreenSpriteAnimations[v2->unk_0C][1]; + v1.z = 0; + + Sprite_SetPosition(v2->unk_04, &v1); +} + +static void NamingScreen_InitSprites(NamingScreen *namingScreen) +{ + int i; + + SpriteResourcesHeader_Init( + &namingScreen->unk_348, + 0, + 0, + 0, + 0, + 0xffffffff, + 0xffffffff, + 0, + 1, + namingScreen->unk_318[0], + namingScreen->unk_318[1], + namingScreen->unk_318[2], + namingScreen->unk_318[3], + NULL, + NULL); + SpriteResourcesHeader_Init( + &namingScreen->unk_36C, + 1, + 1, + 1, + 1, + 0xffffffff, + 0xffffffff, + 0, + 0, + namingScreen->unk_318[0], + namingScreen->unk_318[1], + namingScreen->unk_318[2], + namingScreen->unk_318[3], + NULL, + NULL); + + { + AffineSpriteListTemplate v1; + + v1.list = namingScreen->unk_188; + v1.resourceData = &namingScreen->unk_348; + v1.position.x = FX32_CONST(32); + v1.position.y = FX32_CONST(96); + v1.position.z = 0; + v1.affineScale.x = FX32_ONE; + v1.affineScale.y = FX32_ONE; + v1.affineScale.z = FX32_ONE; + v1.affineZRotation = 0; + v1.priority = 1; + v1.vramType = NNS_G2D_VRAM_TYPE_2DMAIN; + v1.heapID = HEAP_ID_NAMING_SCREEN_APP; + + for (i = 0; i < 9; i++) { + v1.position.x = FX32_ONE * sNamingScreenSpriteAnimations[i][0]; + v1.position.y = FX32_ONE * sNamingScreenSpriteAnimations[i][1]; + + namingScreen->miscSprites[i] = SpriteList_AddAffine(&v1); + + Sprite_SetAnimateFlag(namingScreen->miscSprites[i], TRUE); + Sprite_SetAnim(namingScreen->miscSprites[i], sNamingScreenSpriteAnimations[i][2]); + Sprite_SetPriority(namingScreen->miscSprites[i], sNamingScreenSpriteAnimations[i][3]); + } + + Sprite_SetDrawFlag(namingScreen->miscSprites[4], FALSE); + Sprite_SetDrawFlag(namingScreen->miscSprites[8], FALSE); + + for (i = 0; i < 7; i++) { + UnkStruct_020879DC *v2; + + namingScreen->unk_400[i] = SysTask_StartAndAllocateParam(sub_020879DC, 16, 5, HEAP_ID_NAMING_SCREEN_APP); + v2 = SysTask_GetParam(namingScreen->unk_400[i]); + v2->unk_00 = namingScreen->miscSprites[7]; + v2->unk_04 = namingScreen->miscSprites[i]; + v2->unk_08 = FX32_ONE * sNamingScreenSpriteAnimations[i][0]; + v2->unk_0C = i; + } + + for (i = 0; i < namingScreen->unk_0C; i++) { + v1.position.x = FX32_ONE * ((10 * 8) + i * 12); + v1.position.y = FX32_ONE * (4 * 8 + 7); + + namingScreen->textCursorSprites[i] = SpriteList_AddAffine(&v1); + + Sprite_SetAnimateFlag(namingScreen->textCursorSprites[i], TRUE); + Sprite_SetAnim(namingScreen->textCursorSprites[i], 43); + } + + sub_02088E1C(namingScreen->textCursorSprites, namingScreen->textCursorPos, namingScreen->unk_0C); + sub_02087BE4(namingScreen, &v1); + } + + GXLayers_EngineAToggleLayers(GX_PLANEMASK_OBJ, 1); + GXLayers_EngineBToggleLayers(GX_PLANEMASK_OBJ, 1); +} + +static void sub_02087BE4(NamingScreen *param0, AffineSpriteListTemplate *param1) +{ + param1->position.x = FX32_ONE * 24; + param1->position.y = FX32_ONE * (16 - 8); + param0->entitySprite[0] = SpriteList_AddAffine(param1); + + Sprite_SetAnimateFlag(param0->entitySprite[0], TRUE); + + switch (param0->type) { + case NAMING_SCREEN_TYPE_PLAYER: + if (param0->unk_04 == 0) { + Sprite_SetAnim(param0->entitySprite[0], 48); + } else { + Sprite_SetAnim(param0->entitySprite[0], 49); + } + break; + case NAMING_SCREEN_TYPE_RIVAL: + Sprite_SetAnim(param0->entitySprite[0], 51); + break; + case NAMING_SCREEN_TYPE_UNK6: + Sprite_SetAnim(param0->entitySprite[0], 55); + break; + case NAMING_SCREEN_TYPE_GROUP: + Sprite_SetAnim(param0->entitySprite[0], 54); + break; + case NAMING_SCREEN_TYPE_UNK4: + case NAMING_SCREEN_TYPE_PAL_PAD: + Sprite_SetAnim(param0->entitySprite[0], 53); + break; + case NAMING_SCREEN_TYPE_BOX: + Sprite_SetAnim(param0->entitySprite[0], 47); + break; + case NAMING_SCREEN_TYPE_POKEMON: + Sprite_SetAnim(param0->entitySprite[0], 50); + + if (param0->unk_10 != 2) { + param1->position.x = FX32_ONE * ((10 * 8) + param0->unk_0C * 13); + param1->position.y = FX32_ONE * ((4 * 8 + 7) - 12); + param0->entitySprite[1] = SpriteList_AddAffine(param1); + + if (param0->unk_10 == 0) { + Sprite_SetAnim(param0->entitySprite[1], 45); + } else { + Sprite_SetAnim(param0->entitySprite[1], 46); + } + } + break; + } +} + +static void NamingScreen_WiggleOverlayTask(SysTask *task, void *paramsPtr) +{ + OverlayWiggleParameters *params = (OverlayWiggleParameters *)paramsPtr; + VecFx32 newPos; + + newPos.y = params->overlayYPosition; + newPos.z = 0; + + switch (params->state) { + case 0: + newPos.x = params->overlayXPosition + 4 * FX32_ONE; + Sprite_SetPosition(params->overlaySprite, &newPos); + break; + case 2: + newPos.x = params->overlayXPosition - 3 * FX32_ONE; + Sprite_SetPosition(params->overlaySprite, &newPos); + break; + case 4: + newPos.x = params->overlayXPosition + 2 * FX32_ONE; + Sprite_SetPosition(params->overlaySprite, &newPos); + break; + case 6: + newPos.x = params->overlayXPosition; + Sprite_SetPosition(params->overlaySprite, &newPos); + SysTask_FinishAndFreeParam(task); + break; + } + + params->state++; +} + +static void NamingScreen_AnimateChangeChars( + BgConfig *bgConfig, + Window *window, + enum ChangeCharsState *statePtr, + int currentCharsIdx, + enum BgLayer *bgLayerPtr, + VecFx32 charsPosition[], + Sprite **sprites, + void *rawCharData) +{ + enum BgLayer bgLayer = *bgLayerPtr; + enum BgLayer oldBgLayer = bgLayer ^ 1; + + switch (*statePtr) { + case CC_STATE_LOAD_GRAPHICS: { + u16 bgColor = sNamingScreenCharsBgColor[currentCharsIdx] | (sNamingScreenCharsBgColor[currentCharsIdx] << 4); + + Graphics_LoadTilemapToBgLayer( + NARC_INDEX_DATA__NAMEIN, + 6 + currentCharsIdx, + bgConfig, + bgLayer, + 0, + 32 * 14 * 2, + TRUE, + HEAP_ID_NAMING_SCREEN_APP); + NamingScreen_InitializeCharsPosition(charsPosition, bgLayer); + NamingScreen_InitializeCharsGraphics( + &window[bgLayer], + bgColor, + currentCharsIdx, + TEXT_COLOR(14, 15, 0), + rawCharData); + (*statePtr)++; + } break; + case CC_STATE_SET_INITIAL_POSITION: + Bg_SetOffset(bgConfig, bgLayer, BG_OFFSET_UPDATE_SET_X, 238); + Bg_SetOffset(bgConfig, bgLayer, BG_OFFSET_UPDATE_SET_Y, -80); + (*statePtr)++; + break; + case CC_STATE_SLIDE_IN: + charsPosition[bgLayer].x -= 24; + + if (charsPosition[bgLayer].x < -11 + 10) { + OverlayWiggleParameters *wiggleParam; + SysTask *wiggleTask; + + wiggleTask = SysTask_StartAndAllocateParam( + NamingScreen_WiggleOverlayTask, + sizeof(OverlayWiggleParameters), + 0, + HEAP_ID_NAMING_SCREEN_APP); + wiggleParam = SysTask_GetParam(wiggleTask); + wiggleParam->overlaySprite = sprites[NMS_SPRITE_OVERLAY]; + wiggleParam->state = 0; + wiggleParam->overlayXPosition = Sprite_GetPosition(sprites[7])->x; + wiggleParam->overlayYPosition = Sprite_GetPosition(sprites[7])->y; + + charsPosition[bgLayer].x = -11; + (*statePtr)++; + } + + charsPosition[oldBgLayer].y -= 10; + + if (charsPosition[oldBgLayer].y < -196) { + charsPosition[oldBgLayer].y = -196; + } + + Bg_SetOffset(bgConfig, bgLayer, BG_OFFSET_UPDATE_SET_X, charsPosition[bgLayer].x); + Bg_SetOffset(bgConfig, oldBgLayer, BG_OFFSET_UPDATE_SET_Y, charsPosition[oldBgLayer].y); + break; + case CC_STATE_FINISH_SLIDING_OUT: + charsPosition[oldBgLayer].y -= 10; + + if (charsPosition[oldBgLayer].y < -196) { + charsPosition[oldBgLayer].y = -196; + } + + Bg_SetOffset(bgConfig, bgLayer, BG_OFFSET_UPDATE_SET_X, charsPosition[bgLayer].x); + Bg_SetOffset(bgConfig, oldBgLayer, BG_OFFSET_UPDATE_SET_Y, charsPosition[oldBgLayer].y); + + if ((charsPosition[bgLayer].x == -11) && (charsPosition[oldBgLayer].y == -196)) { + (*statePtr)++; + (*bgLayerPtr) ^= 1; + NamingScreen_UpdateCharsPriorities(bgConfig, *bgLayerPtr, charsPosition); + Sound_PlayEffect(SEQ_SE_DP_NAMEIN_01); + } + break; + case CC_STATE_NOTHING: + break; + } +} + +static void sub_02087F48(Window *param0, int param1, Strbuf *param2) +{ + Window_DrawMessageBoxWithScrollCursor(param0, 0, 32 * 8, 10); + Text_AddPrinterWithParams(param0, FONT_MESSAGE, param2, 0, 0, TEXT_SPEED_INSTANT, NULL); + Window_CopyToVRAM(param0); +} + +static void sub_02087F78(Window *param0, int param1, Strbuf *param2) +{ + int v0 = 16; + int v1 = Font_CalcStrbufWidth(FONT_SYSTEM, param2, 0); + + if (v1 > 130) { + v0 = 0; + } + + Window_FillTilemap(param0, 0x101); + Text_AddPrinterWithParamsAndColor(param0, FONT_SYSTEM, param2, v0, 0, TEXT_SPEED_INSTANT, TEXT_COLOR(14, 15, 1), NULL); + Window_CopyToVRAM(param0); +} + +static void sub_02087FC0(NamingScreen *namingScreen, ApplicationManager *appMan, NARC *param2) +{ + Window_Add(namingScreen->bgConfig, &namingScreen->unk_41C[0], 0, 2, 1, 26, 12, 1, 32 * 8); + Window_Add(namingScreen->bgConfig, &namingScreen->unk_41C[1], 1, 2, 1, 26, 12, 1, (32 * 8) + (26 * 12)); + + if (namingScreen->type == NAMING_SCREEN_TYPE_UNK4) { + Graphics_LoadTilemapToBgLayerFromOpenNARC(param2, 6 + 3, namingScreen->bgConfig, 1, 0, 32 * 14 * 2, 1, HEAP_ID_NAMING_SCREEN_APP); + namingScreen->currentCharsIdx = 4; + sub_02088844(namingScreen->unk_3A, 4); + NamingScreen_InitializeCharsGraphics(&namingScreen->unk_41C[1], 0xa0a, 4, TEXT_COLOR(14, 15, 0), namingScreen->charData->pRawData); + } else { + namingScreen->currentCharsIdx = 0; + sub_02088844(namingScreen->unk_3A, 0); + NamingScreen_InitializeCharsGraphics(&namingScreen->unk_41C[1], 0x404, 0, TEXT_COLOR(14, 15, 0), namingScreen->charData->pRawData); + } + + Window_Add(namingScreen->bgConfig, &namingScreen->unk_41C[2], 2, 7, 2, 22, 2, 0, ((32 * 8) + (26 * 12)) + (26 * 12)); + + { + int v0 = ((namingScreen->unk_0C * 12) / 8) + 1; + + Window_Add(namingScreen->bgConfig, &namingScreen->unk_41C[3], 2, 10, 3, v0, 2, 0, (((32 * 8) + (26 * 12)) + (26 * 12)) + 44); + Window_FillTilemap(&namingScreen->unk_41C[3], 0x101); + Window_Add(namingScreen->bgConfig, &namingScreen->unk_41C[8], 2, 10 + v0 - 1, 3, 7, 2, 0, ((((32 * 8) + (26 * 12)) + (26 * 12)) + 44) + 36); + Window_FillTilemap(&namingScreen->unk_41C[8], 0x101); + } + + if (namingScreen->type == NAMING_SCREEN_TYPE_GROUP) { + sub_02087F78(&namingScreen->unk_41C[8], namingScreen->type, namingScreen->unk_184); + Window_CopyToVRAM(&namingScreen->unk_41C[8]); + } + + Window_Add(namingScreen->bgConfig, &namingScreen->unk_41C[9], 4, 2, 19, 27, 4, 12, 120 + (2 * 2 * 3)); + Window_FillTilemap(&namingScreen->unk_41C[9], 0x0f); + sub_02087F48(&namingScreen->unk_41C[9], namingScreen->type, namingScreen->unk_178); + + { + NamingScreenArgs *v1 = (NamingScreenArgs *)ApplicationManager_Args(appMan); + + if (namingScreen->entryBufBak[0] != CHAR_EOS) { + CharCode_Copy(namingScreen->entryBuf, namingScreen->entryBufBak); + NamingScreen_PrintChars(&namingScreen->unk_41C[3], namingScreen->entryBuf, 0, 0, 12, TEXT_SPEED_INSTANT, TEXT_COLOR(14, 15, 1), NULL); + } + } + + { + int v2; + + for (v2 = 0; v2 < 3; v2++) { + Window_Add(namingScreen->bgConfig, &namingScreen->unk_41C[4 + v2], 2, 0, 0, 2, 2, 0, 120); + Window_FillTilemap(&namingScreen->unk_41C[4 + v2], 0); + } + + Window_Add( + namingScreen->bgConfig, + &namingScreen->unk_41C[7], + BG_LAYER_MAIN_2, + 0, + 0, + 16, + 2, + 0, + 120 + (2 * 2 * 3)); + Window_FillTilemap(&namingScreen->unk_41C[7], 0); + } +} + +static void NamingScreen_UpdateCharsPriorities(BgConfig *unused0, enum BgLayer oldBgLayer, VecFx32 unused1[]) +{ + Bg_SetPriority(oldBgLayer, 1); + Bg_SetPriority(oldBgLayer ^ 1, 2); +} + +static void NamingScreen_InitializeCharsPosition(VecFx32 charsPosition[], enum BgLayer freeBgLayer) +{ + charsPosition[freeBgLayer].x = 238; + charsPosition[freeBgLayer].y = -80; + charsPosition[freeBgLayer ^ 1].x = -11; + charsPosition[freeBgLayer ^ 1].y = -80; +} + +static const int Unk_020F2904[][2] = { + { 0x0, 0x0 }, + { 0x0, 0xFFFFFFFFFFFFFFFF }, + { 0x0, 0x1 }, + { 0xFFFFFFFFFFFFFFFF, 0x0 }, + { 0x1, 0x0 } +}; + +static int sub_02088288(int param0, int param1, int param2) +{ + if (param0 >= param2) { + param0 = param1; + } + + if (param0 < param1) { + param0 = param2 - 1; + } + + return param0; +} + +static void sub_02088298(NamingScreen *param0, int param1) +{ + int v0, v1; + u16 v2; + + if (param1 == 0) { + return; + } + + v2 = param0->unk_3A[param0->unk_1C.unk_04][param0->unk_1C.unk_00]; + v0 = sub_02088288(param0->unk_1C.unk_00 + Unk_020F2904[param1][0], 0, 13); + v1 = sub_02088288(param0->unk_1C.unk_04 + Unk_020F2904[param1][1], 0, 6); + + while (param0->unk_3A[v1][v0] == (0xd001 + 3) || (param0->unk_3A[v1][v0] == v2 && param0->unk_3A[v1][v0] > 0xe001)) { + if ((param0->unk_1C.unk_0C == 0) && (param0->unk_3A[v1][v0] == (0xd001 + 3)) && (Unk_020F2904[param1][1] != 0)) { + v0 += param0->unk_1C.unk_10; + v0 = sub_02088288(v0, 0, 13); + } else { + v0 += Unk_020F2904[param1][0]; + v0 = sub_02088288(v0, 0, 13); + v1 += Unk_020F2904[param1][1]; + v1 = sub_02088288(v1, 0, 6); + } + } + + param0->unk_1C.unk_00 = v0; + param0->unk_1C.unk_04 = v1; +} + +static void NamingScreen_ProcessDirectionInputs(NamingScreen *namingScreen) +{ + BOOL didInput = FALSE; + int v1 = 0; + BOOL v2 = FALSE; + + if (Sprite_GetDrawFlag(namingScreen->miscSprites[8]) == 0) { + v2 = TRUE; + } + + if (gSystem.pressedKeysRepeatable & PAD_KEY_UP) { + Sound_PlayEffect(SEQ_SE_CONFIRM); + Sprite_SetDrawFlag(namingScreen->miscSprites[8], TRUE); + v1 = 1; + didInput++; + } + + if (gSystem.pressedKeysRepeatable & PAD_KEY_DOWN) { + Sound_PlayEffect(SEQ_SE_CONFIRM); + Sprite_SetDrawFlag(namingScreen->miscSprites[8], TRUE); + v1 = 2; + didInput++; + } + + if (gSystem.pressedKeysRepeatable & PAD_KEY_LEFT) { + Sound_PlayEffect(SEQ_SE_CONFIRM); + Sprite_SetDrawFlag(namingScreen->miscSprites[8], TRUE); + v1 = 3; + didInput++; + } + + if (gSystem.pressedKeysRepeatable & PAD_KEY_RIGHT) { + Sound_PlayEffect(SEQ_SE_CONFIRM); + Sprite_SetDrawFlag(namingScreen->miscSprites[8], TRUE); + v1 = 4; + didInput++; + } + + // start counts as a direction input, because it moves the cursor. + if (gSystem.pressedKeys & PAD_BUTTON_START) { + Sound_PlayEffect(SEQ_SE_CONFIRM); + Sprite_SetDrawFlag(namingScreen->miscSprites[8], TRUE); + namingScreen->unk_1C.unk_00 = 12; + namingScreen->unk_1C.unk_04 = 0; + didInput++; + } + + { + if ((namingScreen->unk_62C = sub_0208903C(namingScreen)) == 1) { + v1 = 0; + didInput++; + } + } + + if (v2 == TRUE) { + didInput = 0; + NamingScreen_MoveCursor(namingScreen, v1); + } + + if (didInput) { + sub_02088298(namingScreen, v1); + NamingScreen_MoveCursor(namingScreen, v1); + } +} + +static void NamingScreen_MoveCursor(NamingScreen *param0, int param1) +{ + if (param0->unk_1C.unk_04 != 0) { + VecFx32 v0; + + if ((param0->unk_1C.unk_0C == 0) && (param0->unk_1C.unk_0C != param0->unk_1C.unk_04)) { + Sprite_SetAnim(param0->miscSprites[8], 39); + } + + v0.x = FX32_ONE * (26 + param0->unk_1C.unk_00 * 16); + v0.y = FX32_ONE * ((111 - 20) + (param0->unk_1C.unk_04 - 1) * 19); + Sprite_SetPosition(param0->miscSprites[8], &v0); + } else { + VecFx32 v1; + int v2 = param0->unk_3A[param0->unk_1C.unk_04][param0->unk_1C.unk_00] - (0xe001 + 1); + + v1.x = FX32_ONE * sHomeRowCursorXCoords[v2]; + v1.y = FX32_ONE * (88 - 20); + + Sprite_SetAnim(param0->miscSprites[8], sHomeRowCursorAnimIDs[v2]); + Sprite_SetPosition(param0->miscSprites[8], &v1); + } + + param0->unk_38 = 180; + + Sprite_SetAnimFrame(param0->miscSprites[8], 0); + + param0->unk_1C.unk_08 = param0->unk_1C.unk_00; + param0->unk_1C.unk_0C = param0->unk_1C.unk_04; + + if (Unk_020F2904[param1][0] != 0) { + param0->unk_1C.unk_10 = Unk_020F2904[param1][0]; + } +} + +static void sub_02088514(u16 *param0) +{ + fx32 v0; + GXRgb v1; + int v2, v3, v4; + + *param0 += 20; + + if (*param0 > 360) { + *param0 = 0; + } + + v0 = CalcSineDegrees_Wraparound(*param0); + v3 = 15 + (v0 * 10) / FX32_ONE; + v1 = GX_RGB(29, v3, 0); + + GX_LoadOBJPltt((u16 *)&v1, (16 + 13) * 2, 2); +} + +static void NamingScreen_PrintChars( + Window *window, + const charcode_t *charCodes, + int baseXOffset, + int yOffset, + int charSpacing, + int renderDelay, + TextColor textColor, + void *rawCharData) +{ + int i = 0, charWidth, charXOffset; + u16 charBuffer[2]; + Strbuf *strBuf = Strbuf_Init(2, HEAP_ID_NAMING_SCREEN_APP); + + while (charCodes[i] != CHAR_EOS) { + if ((charCodes[i] == 0xd001) || (charCodes[i] == (0xd001 + 1)) || (charCodes[i] == (0xd001 + 2))) { + u16 v5 = charCodes[i] - 0xd001; + Window_BlitBitmapRect( + window, + (void *)&rawCharData[v5 * 8 * 8 * 4 / 2], + 0, + 0, + 12, + 12, + baseXOffset + i * charSpacing, + yOffset + 2, + 12, + 12); + } else { + if (charCodes[i] == (0xd001 + 3)) { + i++; + continue; + } + + charBuffer[0] = charCodes[i]; + charBuffer[1] = CHAR_EOS; + + charWidth = Font_CalcStringWidth(FONT_SYSTEM, charBuffer, 0); + charXOffset = baseXOffset + i * charSpacing + ((charSpacing - charWidth) / 2); + + Strbuf_CopyChars(strBuf, charBuffer); + Text_AddPrinterWithParamsAndColor( + window, + FONT_SYSTEM, + strBuf, + charXOffset, + yOffset, + renderDelay, + textColor, + NULL); + } + + i++; + } + + Strbuf_Free(strBuf); +} + +static const u8 sUnkGXObjOffsets1[] = { + 0x60, + 0x68, + 0x50, + 0x58 +}; + +static void *NamingScreen_PrintStringOnWindowAndGetPixelBuffer(Window *window, Strbuf *string, u8 fontId, const TextColor color) +{ + Text_AddPrinterWithParamsAndColor(window, fontId, string, 0, 0, TEXT_SPEED_NO_TRANSFER, color, NULL); + return window->pixels; +} + +static void NamingScreen_PrintCharOnWindowAndOBJ(Window *window, const charcode_t *tmpBuf, u8 *pixelBuf, Strbuf *string) +{ + charcode_t curCharBuf[20 + 1]; + u16 i; + void *ptr; + Strbuf *string2; + + Window_FillTilemap(&window[3], 0); + ptr = NamingScreen_PrintStringOnWindowAndGetPixelBuffer(&window[3], string, FONT_SUBSCREEN, TEXT_COLOR(13, 14, 15)); + DC_FlushRange(ptr, 0x20 * 4 * 16); + + for (i = 0; i < 4; i++) { + // copy rect of pixels from window 3 + sub_02012C60(&window[3], 4, 2, 4 * i, 0, (char *)pixelBuf); + DC_FlushRange(pixelBuf, 0x20 * 4 * 2); + GXS_LoadOBJ(pixelBuf, sUnkGXObjOffsets1[i] * 0x20, 0x20 * 4 * 2); + } + + string2 = Strbuf_Init(20 + 1, HEAP_ID_NAMING_SCREEN_APP); + + for (i = 0; i < 3; i++) { + curCharBuf[0] = tmpBuf[i]; + curCharBuf[1] = CHAR_EOS; + + Window_FillTilemap(&window[i], 0); + Strbuf_CopyChars(string2, curCharBuf); + + ptr = NamingScreen_PrintStringOnWindowAndGetPixelBuffer(&window[i], string2, FONT_SUBSCREEN, TEXT_COLOR(13, 14, 15)); + + DC_FlushRange(ptr, 0x20 * 4); + GXS_LoadOBJ(ptr, sUnkGXObjOffsets0[i] * 0x20, 0x20 * 4); + } + + Strbuf_Free(string2); +} + +static void sub_02088754( + Window *windows, + charcode_t *srcChars, + int srcCharIdx, + charcode_t *charCodeBuf, + u8 *pixelBuf, + Strbuf *param5) +{ + int i, j; + const u16 *v2 = NULL; + u16 charCode; + + if (srcCharIdx == 0) { + charCode = (0xd001 + 2); + } else { + charCode = srcChars[srcCharIdx - 1]; + } + + switch (charCode) { + case 0xd001: + case (0xd001 + 1): + case (0xd001 + 2): + case (0xd001 + 3): + case (0xe001 + 1): + case (0xe001 + 2): + case (0xe001 + 3): + case (0xe001 + 4): + case (0xe001 + 5): + case (0xe001 + 6): + case (0xe001 + 7): + charCode = CHAR_WIDE_SPACE; + break; + } + + for (i = 0; i < 3; i++) { + charCodeBuf[i] = CHAR_WIDE_SPACE; + } + + charCodeBuf[0] = charCode; + + if (charCode != CHAR_WIDE_SPACE) { + for (i = 0; i < NELEMS(sUnkConversionTable); i++) { + if (sUnkConversionTable[i][0] == charCode) { + for (j = 0; j < 3; j++) { + charCodeBuf[j] = sUnkConversionTable[i][j]; + } + break; + } + + if (sUnkConversionTable[i][2] == charCode) { + for (j = 0; j < 3; j++) { + charCodeBuf[j] = sUnkConversionTable[i][j]; + } + break; + } + } + } + + NamingScreen_PrintCharOnWindowAndOBJ(windows, charCodeBuf, pixelBuf, param5); +} + +static void sub_02088844(u16 param0[][13], const int param1) +{ + int v0, v1; + + for (v0 = 0; v0 < 13; v0++) { + param0[0][v0] = sNamingScreenHomeRowLayouts[param1][v0]; + } + + for (v1 = 0; v1 < 6 - 1; v1++) { + for (v0 = 0; v0 < 13; v0++) { + param0[1 + v1][v0] = sNamingScreenCharCodes[param1][v1][v0]; + } + } +} + +static int sub_02088898(NamingScreen *param0, u16 param1, int param2) +{ + if ((param1 == (0xd001 + 2)) || (param1 == (0xd001 + 3))) { + param1 = 0x1; + } + + if (param0->type == NAMING_SCREEN_TYPE_UNK4) { + if ((param1 == (0xe001 + 1)) || (param1 == (0xe001 + 2)) || (param1 == (0xe001 + 3)) || (param1 == (0xe001 + 4))) { + param1 = 0x1; + } + } + + if ((Sprite_GetDrawFlag(param0->miscSprites[8]) == 0) && (gSystem.touchPressed == 0)) { + Sprite_SetDrawFlag(param0->miscSprites[8], TRUE); + return NMS_APP_STATE_RUNNING; + } + + switch (param1) { + case 0xd001: + if (sub_02088D08(42, 42 + 40, 1, 0xd001, param0->entryBuf, param0->textCursorPos)) { + Window_FillTilemap(¶m0->unk_41C[3], 0x101); + NamingScreen_PrintChars(¶m0->unk_41C[3], param0->entryBuf, 0, 0, 12, TEXT_SPEED_INSTANT, TEXT_COLOR(14, 15, 1), NULL); + Sound_PlayEffect(SEQ_SE_DP_BOX02); + } + break; + case (0xd001 + 1): + if (sub_02088D08(72, 72 + 10, 2, 0xd001 + 1, param0->entryBuf, param0->textCursorPos)) { + Window_FillTilemap(¶m0->unk_41C[3], 0x101); + NamingScreen_PrintChars(¶m0->unk_41C[3], param0->entryBuf, 0, 0, 12, TEXT_SPEED_INSTANT, TEXT_COLOR(14, 15, 1), NULL); + Sound_PlayEffect(SEQ_SE_DP_BOX02); + } + break; + case (0xe001 + 5): + if (sub_02088C9C(0, 72 + 10, param0->entryBuf, param0->textCursorPos)) { + Window_FillTilemap(¶m0->unk_41C[3], 0x101); + NamingScreen_PrintChars( + ¶m0->unk_41C[3], + param0->entryBuf, + 0, + 0, + 12, + TEXT_SPEED_INSTANT, + TEXT_COLOR(14, 15, 1), + NULL); + param0->spritesToUpdate[4]++; + Sound_PlayEffect(SEQ_SE_DP_BOX02); + } + break; + case (0xe001 + 1): + case (0xe001 + 2): + case (0xe001 + 3): + case (0xe001 + 4): + if (param0->currentCharsIdx != param1 - (0xe001 + 1)) { + param0->state.changeChars = CC_STATE_LOAD_GRAPHICS; + param0->currentCharsIdx = param1 - (0xe001 + 1); + sub_02088844(param0->unk_3A, param0->currentCharsIdx); + param0->spritesToUpdate[param1 - (0xe001 + 1)]++; + Sound_PlayEffect(SEQ_SE_DP_SYU03); + Sprite_SetDrawFlag(param0->miscSprites[8], param2); + } + break; + case (0xe001 + 6): + if (param0->textCursorPos != 0) { + param0->entryBuf[param0->textCursorPos - 1] = 0xffff; + param0->textCursorPos--; + + Window_FillTilemap(¶m0->unk_41C[3], 0x101); + + if (param0->textCursorPos == 0) { + Window_CopyToVRAM(¶m0->unk_41C[3]); + } else { + NamingScreen_PrintChars(¶m0->unk_41C[3], param0->entryBuf, 0, 0, 12, TEXT_SPEED_INSTANT, TEXT_COLOR(14, 15, 1), NULL); + } + + sub_02088754(¶m0->unk_41C[4], param0->entryBuf, param0->textCursorPos, param0->tmpBuf, param0->pixelBuf, param0->unk_17C); + sub_02088E1C(param0->textCursorSprites, param0->textCursorPos, param0->unk_0C); + + param0->spritesToUpdate[5]++; + + Sound_PlayEffect(SEQ_SE_CONFIRM); + Sprite_SetDrawFlag(param0->miscSprites[8], param2); + } + break; + case (0xe001 + 7): + sub_02015760(param0->unk_628); + Sprite_SetDrawFlag(param0->miscSprites[8], param2); + + if (param0->unk_14 == 0) { + Sound_PlayEffect(SEQ_SE_DP_PIRORIRO); + param0->spritesToUpdate[6]++; + StartScreenFade(FADE_SUB_THEN_MAIN, FADE_TYPE_BRIGHTNESS_OUT, FADE_TYPE_BRIGHTNESS_OUT, COLOR_BLACK, 16, 1, HEAP_ID_NAMING_SCREEN_APP); + return NMS_APP_STATE_WAIT_FADE_OUT; + } else { + param0->state.main = NMS_STATE_PLACEHOLDER_5; + } + break; + default: + if ((param0->currentCharsIdx == 4) && (param1 == 0x1)) { + return NMS_APP_STATE_RUNNING; + } + + if (param0->textCursorPos != param0->unk_0C) { + param0->entryBuf[param0->textCursorPos] = param1; + + Window_FillTilemap(¶m0->unk_41C[3], 0x101); + NamingScreen_PrintChars(¶m0->unk_41C[3], param0->entryBuf, 0, 0, 12, TEXT_SPEED_INSTANT, TEXT_COLOR(14, 15, 1), NULL); + + param0->textCursorPos++; + + sub_02088E1C(param0->textCursorSprites, param0->textCursorPos, param0->unk_0C); + Sound_PlayEffect(SEQ_SE_DP_BOX02); + Sprite_SetDrawFlag(param0->miscSprites[8], TRUE); + Sprite_SetExplicitOAMMode(param0->miscSprites[8], GX_OAM_MODE_XLU); + + G2_SetBlendAlpha(0, GX_BLEND_PLANEMASK_BG0 | GX_BLEND_PLANEMASK_BG1 | GX_BLEND_PLANEMASK_BG2, 8, 8); + Sprite_SetAnim(param0->miscSprites[8], 60); + + param0->unk_1C.unk_18 = 1; + + sub_02088754(¶m0->unk_41C[4], param0->entryBuf, param0->textCursorPos, param0->tmpBuf, param0->pixelBuf, param0->unk_17C); + } + } + + return NMS_APP_STATE_RUNNING; +} + +static u16 sub_02088C7C(const u16 *param0, int param1) +{ + do { + param1 = sub_02088288(++param1, 0, 3); + } while (param0[param1] == 0x1); + + return param0[param1]; +} + +static int sub_02088C9C(int param0, int param1, u16 *param2, int param3) +{ + int v0, v1; + u16 v2, v3; + + if (param3 == 0) { + return 0; + } + + v2 = param2[param3 - 1]; + + for (v0 = param0; v0 < param1; v0++) { + for (v1 = 0; v1 < 3; v1++) { + if ((sUnkConversionTable[v0][v1] == v2) && (v2 != 0x1)) { + param2[param3 - 1] = sub_02088C7C(sUnkConversionTable[v0], v1); + return 1; + } + } + } + + return 0; +} + +static int sub_02088D08(int param0, int param1, int param2, int param3, u16 *param4, int param5) +{ + int v0; + u16 v1; + + if ((param5 == 0) || (param4[param5 - 1] == 0x1)) { + return 0; + } + + v1 = param4[param5 - 1]; + + for (v0 = param0; v0 < param1; v0++) { + if (sUnkConversionTable[v0][0] == v1) { + param4[param5 - 1] = sUnkConversionTable[v0][param2]; + return 1; + } + } + + for (v0 = param0; v0 < param1; v0++) { + if (sUnkConversionTable[v0][param2] == v1) { + param4[param5 - 1] = sUnkConversionTable[v0][0]; + return 1; + } + } + + switch (param3) { + case 0xd001: + for (v0 = 0; v0 < NELEMS(Unk_020F2954); v0++) { + if (Unk_020F2954[v0][0] == v1) { + param4[param5 - 1] = Unk_020F2954[v0][1]; + return 1; + } + } + break; + case (0xd001 + 1): + for (v0 = 0; v0 < NELEMS(Unk_020F292C); v0++) { + if (Unk_020F292C[v0][0] == v1) { + param4[param5 - 1] = Unk_020F292C[v0][1]; + return 1; + } + } + break; + case (0xe001 + 5): + if (v1 == 0x26) { + param4[param5 - 1] = 0x24; + return 1; + } + + if (v1 == 0x76) { + param4[param5 - 1] = 0x74; + return 1; + } + break; + } + + return 0; +} + +static void sub_02088E1C(Sprite **param0, int param1, int param2) +{ + int v0; + + for (v0 = 0; v0 < param2; v0++) { + Sprite_SetAnim(param0[v0], 43); + } + + if (param1 != param2) { + Sprite_SetAnim(param0[param1], 44); + } +} + +static const u8 sNamingScreenCharsAltBgColor[] = { + 0x3, + 0x6, + 0xC, + 0x9, + 0x9 +}; + +static void NamingScreen_InitializeCharsGraphics( + Window *window, + u16 bgColor, + int currentCharsIdx, + TextColor textColor, + void *rawCharData) +{ + int i; + + Window_FillTilemap(window, bgColor); + + // fill checkerboard + for (i = 0; i < 6; i++) { + Window_FillRectWithColor(window, sNamingScreenCharsAltBgColor[currentCharsIdx], 16 + 32 * i, 0, 16, 19); + Window_FillRectWithColor(window, sNamingScreenCharsAltBgColor[currentCharsIdx], 16 + 32 * i, 19 * 2, 16, 19); + Window_FillRectWithColor(window, sNamingScreenCharsAltBgColor[currentCharsIdx], 16 + 32 * i, 19 * 4, 16, 19); + } + for (i = 0; i < 7; i++) { + Window_FillRectWithColor(window, sNamingScreenCharsAltBgColor[currentCharsIdx], 32 * i, 19, 16, 19); + Window_FillRectWithColor(window, sNamingScreenCharsAltBgColor[currentCharsIdx], 32 * i, 19 * 3, 16, 19); + } + + for (i = 0; i < 5; i++) { + NamingScreen_PrintChars( + window, + sNamingScreenCharCodes[currentCharsIdx][i], + 0, + i * 19 + 4, + 16, + TEXT_SPEED_NO_TRANSFER, + textColor, + rawCharData); + } + + Window_CopyToVRAM(window); +} + +static void NamingScreen_UpdateSpriteAnimations(BOOL spritesToUpdate[], Sprite **sprites, int unused) +{ + int i, j; + + for (i = 0; i < 3; i++) { + if (spritesToUpdate[i]) { + for (j = 0; j < 3; j++) { + Sprite_SetAnim(sprites[j], sNamingScreenSpriteAnimations[j][2]); + } + + Sprite_SetAnim(sprites[i], sNamingScreenSpriteAnimations[i][2] - 3); + break; + } + } + + for (i = 5; i < 7; i++) { + if (spritesToUpdate[i]) { + Sprite_SetAnim(sprites[i], sNamingScreenSpriteAnimations[i][2] + 1); + } + } + + for (i = 0; i < 7; i++) { + spritesToUpdate[i] = FALSE; + } +} + +static void sub_02088FD0(NamingScreen *namingScreen) +{ + if (!Sprite_IsAnimated(namingScreen->miscSprites[8])) { + if (namingScreen->textCursorPos == namingScreen->unk_0C) { + namingScreen->unk_1C.unk_00 = 12; + namingScreen->unk_1C.unk_04 = 0; + Sprite_SetAnim(namingScreen->miscSprites[8], 39); + } else { + Sprite_SetAnim(namingScreen->miscSprites[8], 39); + } + + if (!namingScreen->unk_1C.hasCharacterBeenEntered) { + Sprite_SetDrawFlag(namingScreen->miscSprites[8], FALSE); + } else { + NamingScreen_MoveCursor(namingScreen, 0); + } + + namingScreen->unk_1C.unk_18 = 0; + + Sprite_SetExplicitOAMMode(namingScreen->miscSprites[8], GX_OAM_MODE_NORMAL); + } +} + +static const NamingScreenTouchHitbox Unk_020F2A14[] = { + { 0x19, 0x3C, 0x0, 0x0, 0x0 }, + { 0x39, 0x3C, 0x0, 0x2, 0x0 }, + { 0x59, 0x3C, 0x0, 0x4, 0x0 }, + { 0x0, 0xC0, 0x0, 0x4, 0x0 }, + { 0x9D, 0x3C, 0x1, 0x8, 0x0 }, + { 0xC5, 0x3C, 0x1, 0xB, 0x0 }, + { 0x1C, 0x58, 0x2, 0x0, 0x1 }, + { 0x2C, 0x58, 0x2, 0x1, 0x1 }, + { 0x3C, 0x58, 0x2, 0x2, 0x1 }, + { 0x4C, 0x58, 0x2, 0x3, 0x1 }, + { 0x5C, 0x58, 0x2, 0x4, 0x1 }, + { 0x6C, 0x58, 0x2, 0x5, 0x1 }, + { 0x7C, 0x58, 0x2, 0x6, 0x1 }, + { 0x8C, 0x58, 0x2, 0x7, 0x1 }, + { 0x9C, 0x58, 0x2, 0x8, 0x1 }, + { 0xAC, 0x58, 0x2, 0x9, 0x1 }, + { 0xBC, 0x58, 0x2, 0xA, 0x1 }, + { 0xCC, 0x58, 0x2, 0xB, 0x1 }, + { 0xDC, 0x58, 0x2, 0xC, 0x1 }, + { 0x1C, 0x6B, 0x2, 0x0, 0x2 }, + { 0x2C, 0x6B, 0x2, 0x1, 0x2 }, + { 0x3C, 0x6B, 0x2, 0x2, 0x2 }, + { 0x4C, 0x6B, 0x2, 0x3, 0x2 }, + { 0x5C, 0x6B, 0x2, 0x4, 0x2 }, + { 0x6C, 0x6B, 0x2, 0x5, 0x2 }, + { 0x7C, 0x6B, 0x2, 0x6, 0x2 }, + { 0x8C, 0x6B, 0x2, 0x7, 0x2 }, + { 0x9C, 0x6B, 0x2, 0x8, 0x2 }, + { 0xAC, 0x6B, 0x2, 0x9, 0x2 }, + { 0xBC, 0x6B, 0x2, 0xA, 0x2 }, + { 0xCC, 0x6B, 0x2, 0xB, 0x2 }, + { 0xDC, 0x6B, 0x2, 0xC, 0x2 }, + { 0x1C, 0x7E, 0x2, 0x0, 0x3 }, + { 0x2C, 0x7E, 0x2, 0x1, 0x3 }, + { 0x3C, 0x7E, 0x2, 0x2, 0x3 }, + { 0x4C, 0x7E, 0x2, 0x3, 0x3 }, + { 0x5C, 0x7E, 0x2, 0x4, 0x3 }, + { 0x6C, 0x7E, 0x2, 0x5, 0x3 }, + { 0x7C, 0x7E, 0x2, 0x6, 0x3 }, + { 0x8C, 0x7E, 0x2, 0x7, 0x3 }, + { 0x9C, 0x7E, 0x2, 0x8, 0x3 }, + { 0xAC, 0x7E, 0x2, 0x9, 0x3 }, + { 0xBC, 0x7E, 0x2, 0xA, 0x3 }, + { 0xCC, 0x7E, 0x2, 0xB, 0x3 }, + { 0xDC, 0x7E, 0x2, 0xC, 0x3 }, + { 0x1C, 0x91, 0x2, 0x0, 0x4 }, + { 0x2C, 0x91, 0x2, 0x1, 0x4 }, + { 0x3C, 0x91, 0x2, 0x2, 0x4 }, + { 0x4C, 0x91, 0x2, 0x3, 0x4 }, + { 0x5C, 0x91, 0x2, 0x4, 0x4 }, + { 0x6C, 0x91, 0x2, 0x5, 0x4 }, + { 0x7C, 0x91, 0x2, 0x6, 0x4 }, + { 0x8C, 0x91, 0x2, 0x7, 0x4 }, + { 0x9C, 0x91, 0x2, 0x8, 0x4 }, + { 0xAC, 0x91, 0x2, 0x9, 0x4 }, + { 0xBC, 0x91, 0x2, 0xA, 0x4 }, + { 0xCC, 0x91, 0x2, 0xB, 0x4 }, + { 0xDC, 0x91, 0x2, 0xC, 0x4 }, + { 0x1C, 0xA4, 0x2, 0x0, 0x5 }, + { 0x2C, 0xA4, 0x2, 0x1, 0x5 }, + { 0x3C, 0xA4, 0x2, 0x2, 0x5 }, + { 0x4C, 0xA4, 0x2, 0x3, 0x5 }, + { 0x5C, 0xA4, 0x2, 0x4, 0x5 }, + { 0x6C, 0xA4, 0x2, 0x5, 0x5 }, + { 0x7C, 0xA4, 0x2, 0x6, 0x5 }, + { 0x8C, 0xA4, 0x2, 0x7, 0x5 }, + { 0x9C, 0xA4, 0x2, 0x8, 0x5 }, + { 0xAC, 0xA4, 0x2, 0x9, 0x5 }, + { 0xBC, 0xA4, 0x2, 0xA, 0x5 }, + { 0xCC, 0xA4, 0x2, 0xB, 0x5 }, + { 0xDC, 0xA4, 0x2, 0xC, 0x5 } +}; + +static BOOL sub_0208903C(NamingScreen *param0) +{ + int v0, v1 = 0; + u8 v2, v3, v4, v5, v6, v7; + + if (param0->type == 4) { + v1 = 4; + } + + if (gSystem.touchPressed) { + v2 = gSystem.touchX; + v3 = gSystem.touchY; + + for (v0 = v1; v0 < (NELEMS(Unk_020F2A14)); v0++) { + v4 = Unk_020F2A14[v0].unk_00; + v5 = Unk_020F2A14[v0].unk_01; + + switch (Unk_020F2A14[v0].unk_02_0) { + case 0: + v6 = 32 - 1; + v7 = 22; + break; + case 1: + v6 = 32; + v7 = 22; + break; + case 2: + v6 = 16; + v7 = 19; + break; + } + + if ((v2 >= v4) && (v3 >= v5) && (v2 <= (v4 + v6)) && (v3 <= (v5 + v7))) { + param0->unk_1C.unk_00 = Unk_020F2A14[v0].unk_04_0; + param0->unk_1C.unk_04 = Unk_020F2A14[v0].unk_05_0; + return 1; + } + } + } + + return 0; +} diff --git a/src/applications/rowan_intro/rowan_intro_app.c b/src/applications/rowan_intro/rowan_intro_app.c index 0150172390..1a01c78b22 100644 --- a/src/applications/rowan_intro/rowan_intro_app.c +++ b/src/applications/rowan_intro/rowan_intro_app.c @@ -2,13 +2,14 @@ #include #include "constants/heap.h" +#include "constants/string.h" #include "generated/genders.h" #include "struct_decls/struct_02015920_decl.h" #include "struct_defs/struct_02015958.h" -#include "struct_defs/struct_0208737C.h" #include "struct_defs/struct_02099F80.h" +#include "applications/naming_screen.h" #include "applications/rowan_intro/main.h" #include "bg_window.h" @@ -44,9 +45,7 @@ #include "unk_020131EC.h" #include "unk_0201567C.h" #include "unk_02015920.h" -#include "unk_0208694C.h" -#include "constdata/const_020F2DAC.h" #include "res/text/bank/rowan_intro.h" FS_EXTERN_OVERLAY(game_start); @@ -246,8 +245,8 @@ typedef struct RowanIntro { StringTemplate *strFormatter; UnkStruct_02015920 *unk_68; SysTask *unused; - UnkStruct_0208737C *unk_70; - UnkStruct_0208737C *unk_74; + NamingScreenArgs *unk_70; + NamingScreenArgs *unk_74; enum FadeBgLayerState fadeBgLayerState; int fadeBgLayerCurAlpha; int fadeBgLayerCurAlphaInv; @@ -326,8 +325,8 @@ BOOL RowanIntro_Init(ApplicationManager *appMan, int *unusedState) manager->state = RI_STATE_FIRST_FADE_BLACK_START; manager->bufferedState = RI_STATE_FIRST_FADE_BLACK_START; manager->appMan = NULL; - manager->unk_70 = sub_0208712C(heapID, 0, 0, 7, manager->options); - manager->unk_74 = sub_0208712C(heapID, 3, 0, 7, manager->options); + manager->unk_70 = NamingScreenArgs_Init(heapID, NAMING_SCREEN_TYPE_PLAYER, 0, TRAINER_NAME_LEN, manager->options); + manager->unk_74 = NamingScreenArgs_Init(heapID, NAMING_SCREEN_TYPE_RIVAL, 0, TRAINER_NAME_LEN, manager->options); manager->bgLayer3TilemapIndex = 0; manager->bgLayer1TilemapIndex = 0; manager->bgLayer2TilemapIndex = 0; @@ -448,8 +447,8 @@ BOOL RowanIntro_Exit(ApplicationManager *appMan, int *unusedState) MiscSaveBlock_SetRivalName(miscSaveBlock, manager->unk_74->textInputStr); } - sub_0208716C(manager->unk_70); - sub_0208716C(manager->unk_74); + NamingScreenArgs_Free(manager->unk_70); + NamingScreenArgs_Free(manager->unk_74); ApplicationManager_FreeData(appMan); Heap_Destroy(heapID); EnqueueApplication(FS_OVERLAY_ID(game_start), &gGameStartNewSaveAppTemplate); @@ -2707,7 +2706,7 @@ static BOOL RowanIntro_Run(RowanIntro *manager) case RI_STATE_NAME_APP_KEYBOARD: manager->unk_70->unk_04 = manager->playerGender; manager->appMan = ApplicationManager_New( - &Unk_020F2DAC, + &gNamingScreenAppTemplate, manager->unk_70, manager->heapID); manager->state = RI_STATE_NAME_KEYBOARD; @@ -2875,7 +2874,7 @@ static BOOL RowanIntro_Run(RowanIntro *manager) break; case RI_STATE_RIVAL_NAME_APP_KEYBOARD: manager->appMan = ApplicationManager_New( - &Unk_020F2DAC, + &gNamingScreenAppTemplate, manager->unk_74, manager->heapID); manager->state = RI_STATE_RIVAL_NAME_KEYBOARD; diff --git a/src/battle/battle_script.c b/src/battle/battle_script.c index afc8e61a6d..89d9f6ed26 100644 --- a/src/battle/battle_script.c +++ b/src/battle/battle_script.c @@ -8,6 +8,7 @@ #include "constants/pokemon.h" #include "constants/rtc.h" #include "constants/species.h" +#include "constants/string.h" #include "generated/abilities.h" #include "generated/genders.h" @@ -16,9 +17,9 @@ #include "struct_defs/battle_system.h" #include "struct_defs/fraction.h" #include "struct_defs/struct_020127E8.h" -#include "struct_defs/struct_0208737C.h" #include "struct_defs/trainer.h" +#include "applications/naming_screen.h" #include "applications/pokedex/ov21_021E8D48.h" #include "applications/pokedex/struct_ov21_021E8E0C.h" #include "battle/battle_context.h" @@ -69,10 +70,8 @@ #include "trainer_info.h" #include "unk_02012744.h" #include "unk_0201567C.h" -#include "unk_0208694C.h" #include "unk_0208C098.h" -#include "constdata/const_020F2DAC.h" #include "res/battle/scripts/sub_seq.naix.h" typedef BOOL (*BtlCmd)(BattleSystem *, BattleContext *); @@ -10853,13 +10852,18 @@ static void BattleScript_CatchMonTask(SysTask *param0, void *param1) case 20: if (PaletteData_GetSelectedBuffersMask(v4) == 0) { { - UnkStruct_0208737C *v16; + NamingScreenArgs *v16; SetScreenColorBrightness(DS_SCREEN_MAIN, COLOR_BLACK); SetScreenColorBrightness(DS_SCREEN_SUB, COLOR_BLACK); v3 = BattleSystem_PartyPokemon(v2->battleSys, v1, v2->battleCtx->selectedPartySlot[v1]); - v16 = sub_0208712C(HEAP_ID_BATTLE, 1, Pokemon_GetValue(v3, MON_DATA_SPECIES, NULL), 10, BattleSystem_GetOptions(v2->battleSys)); + v16 = NamingScreenArgs_Init( + HEAP_ID_BATTLE, + NAMING_SCREEN_TYPE_POKEMON, + Pokemon_GetValue(v3, MON_DATA_SPECIES, NULL), + MON_NAME_LEN, + BattleSystem_GetOptions(v2->battleSys)); v2->tmpPtr[1] = v16; if (BattleSystem_PartyCount(v2->battleSys, 0) < 6) { @@ -10871,7 +10875,7 @@ static void BattleScript_CatchMonTask(SysTask *param0, void *param1) v16->unk_08 = Pokemon_GetValue(v3, MON_DATA_FORM, NULL); v16->pcBoxes = BattleSystem_PCBoxes(v2->battleSys); v16->unk_10 = Pokemon_GetValue(v3, MON_DATA_GENDER, NULL); - v2->tmpPtr[0] = ApplicationManager_New(&Unk_020F2DAC, v16, HEAP_ID_BATTLE); + v2->tmpPtr[0] = ApplicationManager_New(&gNamingScreenAppTemplate, v16, HEAP_ID_BATTLE); v2->seqNum = 21; ov16_0223F414(v2->battleSys); @@ -10898,7 +10902,7 @@ static void BattleScript_CatchMonTask(SysTask *param0, void *param1) case 21: if (ApplicationManager_Exec(v2->tmpPtr[0])) { { - UnkStruct_0208737C *v19; + NamingScreenArgs *v19; int v20; v19 = v2->tmpPtr[1]; @@ -10909,7 +10913,7 @@ static void BattleScript_CatchMonTask(SysTask *param0, void *param1) ov16_0223F24C(v2->battleSys, (1 + 48)); } - sub_0208716C(v19); + NamingScreenArgs_Free(v19); ApplicationManager_Free(v2->tmpPtr[0]); ov16_0223F314(v2->battleSys, 2); diff --git a/src/meson.build b/src/meson.build index ac9d333dd9..1b48da00f6 100644 --- a/src/meson.build +++ b/src/meson.build @@ -293,7 +293,7 @@ pokeplatinum_c = files( 'unk_02082C2C.c', 'unk_02083370.c', 'unk_02084B70.c', - 'unk_0208694C.c', + 'applications/naming_screen.c', 'unk_020890F4.c', 'unk_02089604.c', 'unk_0208A3F4.c', diff --git a/src/overlay019/ov19_021D0D80.c b/src/overlay019/ov19_021D0D80.c index 2932a55668..2b41e92cff 100644 --- a/src/overlay019/ov19_021D0D80.c +++ b/src/overlay019/ov19_021D0D80.c @@ -5,12 +5,13 @@ #include "constants/items.h" #include "constants/species.h" +#include "constants/string.h" #include "struct_decls/pc_boxes_decl.h" #include "struct_decls/struct_0207CB08_decl.h" #include "struct_defs/chatot_cry.h" -#include "struct_defs/struct_0208737C.h" +#include "applications/naming_screen.h" #include "applications/pokemon_summary_screen/main.h" #include "overlay019/box_cursor.h" #include "overlay019/box_customization.h" @@ -55,9 +56,7 @@ #include "unk_0202CC64.h" #include "unk_0202D778.h" #include "unk_0207CB08.h" -#include "unk_0208694C.h" -#include "constdata/const_020F2DAC.h" #include "constdata/const_020F410C.h" #include "res/text/bank/box_messages.h" @@ -132,7 +131,7 @@ typedef struct UnkStruct_ov19_021D5DF8_t { SaveData *saveData; PCBoxes *pcBoxes; Party *party; - UnkStruct_0208737C *unk_128; + NamingScreenArgs *unk_128; PokemonSummary monSummary; ReleaseMon releaseMon; TouchScreenActions *mainBoxAndCompareButtonsAction; @@ -2542,7 +2541,7 @@ static void ov19_RenameBoxAction(UnkStruct_ov19_021D5DF8 *param0, u32 *state) BoxGraphics_Free(param0->unk_114); Heap_Destroy(HEAP_ID_BOX_GRAPHICS); PCBoxes_BufferBoxName(param0->pcBoxes, PCBoxes_GetCurrentBoxID(param0->pcBoxes), param0->unk_128->textInputStr); - param0->ApplicationManager = ApplicationManager_New(&Unk_020F2DAC, param0->unk_128, HEAP_ID_BOX_DATA); + param0->ApplicationManager = ApplicationManager_New(&gNamingScreenAppTemplate, param0->unk_128, HEAP_ID_BOX_DATA); (*state)++; } break; @@ -3380,7 +3379,7 @@ static void ov19_021D4BE0(UnkStruct_ov19_021D5DF8 *param0, PokemonStorageSession param0->mon = Heap_AllocFromHeap(HEAP_ID_BOX_DATA, Pokemon_StructSize()); GF_ASSERT(param0->MessageVariableBuffer); - param0->unk_128 = sub_0208712C(HEAP_ID_BOX_DATA, 2, 0, 8, param0->options); + param0->unk_128 = NamingScreenArgs_Init(HEAP_ID_BOX_DATA, NAMING_SCREEN_TYPE_BOX, 0, BOX_NAME_LEN, param0->options); if (pokemonStorageSession->boxMode != PC_MODE_COMPARE) { param0->mainBoxAndCompareButtonsAction = TouchScreenActions_RegisterHandler(sMainPcButtons, NELEMS(sMainPcButtons), ov19_BoxTouchScreenButtonHandler, param0, HEAP_ID_BOX_DATA); @@ -3417,7 +3416,7 @@ static void ov19_021D4D58(UnkStruct_ov19_021D5DF8 *param0) MessageLoader_Free(param0->speciesNameLoader); MessageLoader_Free(param0->natureNameLoader); MessageLoader_Free(param0->abilityNameLoader); - sub_0208716C(param0->unk_128); + NamingScreenArgs_Free(param0->unk_128); PCMonPreviewFree(&(param0->unk_00.pcMonPreview)); ov19_MonSelectionFree(&(param0->unk_00.selection)); diff --git a/src/overlay064/ov64_0222DCE0.c b/src/overlay064/ov64_0222DCE0.c index 15720cde9a..2d8e5311cc 100644 --- a/src/overlay064/ov64_0222DCE0.c +++ b/src/overlay064/ov64_0222DCE0.c @@ -6,13 +6,14 @@ #include "constants/graphics.h" #include "constants/savedata/vars_flags.h" +#include "constants/string.h" #include "struct_decls/struct_0202B370_decl.h" #include "struct_defs/battle_frontier.h" -#include "struct_defs/struct_0208737C.h" #include "struct_defs/struct_02089438.h" #include "struct_defs/struct_02099F80.h" +#include "applications/naming_screen.h" #include "overlay063/ov63_0222AE60.h" #include "overlay063/struct_ov63_0222AE60_decl.h" #include "overlay063/struct_ov63_0222BB38_decl.h" @@ -62,12 +63,10 @@ #include "unk_0203061C.h" #include "unk_0203909C.h" #include "unk_0205C980.h" -#include "unk_0208694C.h" #include "unk_020890F4.h" #include "vars_flags.h" #include "vram_transfer.h" -#include "constdata/const_020F2DAC.h" #include "constdata/const_020F2DBC.h" FS_EXTERN_OVERLAY(overlay63); @@ -182,7 +181,7 @@ typedef struct { typedef struct { ApplicationManager *appMan; - UnkStruct_0208737C *unk_04; + NamingScreenArgs *unk_04; UnkStruct_02089438 *unk_08; } UnkStruct_ov64_02230444; @@ -327,7 +326,7 @@ static int ov64_0223044C(UnkStruct_ov64_02230444 *param0, UnkStruct_ov64_0222DFD static void ov64_022305CC(UnkStruct_ov64_02230444 *param0, UnkStruct_ov64_0222E060 *param1, UnkStruct_ov64_0222E21C *param2); static void ov64_022305D4(UnkStruct_ov64_02230444 *param0, UnkStruct_ov64_0222E060 *param1, UnkStruct_ov64_0222E21C *param2, u32 heapID); static void ov64_022305D8(UnkStruct_ov64_02230444 *param0, UnkStruct_ov64_0222E060 *param1, UnkStruct_ov64_0222E21C *param2); -static UnkStruct_0208737C *ov64_022305DC(UnkStruct_ov64_02230444 *param0, UnkStruct_ov64_0222E060 *param1, u32 heapID); +static NamingScreenArgs *ov64_022305DC(UnkStruct_ov64_02230444 *param0, UnkStruct_ov64_0222E060 *param1, u32 heapID); static void ov64_02230620(UnkStruct_ov64_02230620 *param0, UnkStruct_ov64_0222E060 *param1, UnkStruct_ov64_0222E21C *param2, u32 heapID); static int ov64_02230628(UnkStruct_ov64_02230620 *param0, UnkStruct_ov64_0222E060 *param1, UnkStruct_ov64_0222E21C *param2); static void ov64_02230678(UnkStruct_ov64_02230620 *param0, UnkStruct_ov64_0222E060 *param1, UnkStruct_ov64_0222E21C *param2); @@ -2473,7 +2472,7 @@ static int ov64_0223044C(UnkStruct_ov64_02230444 *param0, UnkStruct_ov64_0222DFD param0->unk_08 = sub_02089400(heapID, 12, v0, SaveData_GetOptions(param2->saveData), 0, 0); ov64_0222DFD0(param1); - param0->appMan = ApplicationManager_New(&Unk_020F2DAC, param0->unk_04, heapID); + param0->appMan = ApplicationManager_New(&gNamingScreenAppTemplate, param0->unk_04, heapID); param2->unk_04 = 1; break; case 1: @@ -2502,14 +2501,14 @@ static int ov64_0223044C(UnkStruct_ov64_02230444 *param0, UnkStruct_ov64_0222DFD param2->unk_04 = 3; break; case 3: - sub_0208716C(param0->unk_04); + NamingScreenArgs_Free(param0->unk_04); sub_02089438(param0->unk_08); ov64_0222DF48(param1, heapID); return 1; case 4: param0->unk_04 = ov64_022305DC(param0, param2, heapID); ov64_0222DFD0(param1); - param0->appMan = ApplicationManager_New(&Unk_020F2DAC, param0->unk_04, heapID); + param0->appMan = ApplicationManager_New(&gNamingScreenAppTemplate, param0->unk_04, heapID); param2->unk_04 = 5; break; case 5: @@ -2529,7 +2528,7 @@ static int ov64_0223044C(UnkStruct_ov64_02230444 *param0, UnkStruct_ov64_0222DFD } break; case 6: - sub_0208716C(param0->unk_04); + NamingScreenArgs_Free(param0->unk_04); ov64_0222DF48(param1, heapID); return 1; } @@ -2552,11 +2551,11 @@ static void ov64_022305D8(UnkStruct_ov64_02230444 *param0, UnkStruct_ov64_0222E0 return; } -static UnkStruct_0208737C *ov64_022305DC(UnkStruct_ov64_02230444 *param0, UnkStruct_ov64_0222E060 *param1, u32 heapID) +static NamingScreenArgs *ov64_022305DC(UnkStruct_ov64_02230444 *param0, UnkStruct_ov64_0222E060 *param1, u32 heapID) { - UnkStruct_0208737C *v0; + NamingScreenArgs *v0; - v0 = sub_0208712C(heapID, 7, 0, 7, SaveData_GetOptions(param1->saveData)); + v0 = NamingScreenArgs_Init(heapID, NAMING_SCREEN_TYPE_PAL_PAD, 0, TRAINER_NAME_LEN, SaveData_GetOptions(param1->saveData)); if (param1->unk_34.unk_04 == 1) { { diff --git a/src/overlay097/gba_convert_string.c b/src/overlay097/gba_convert_string.c index 55a8e10ee0..40ccb357b0 100644 --- a/src/overlay097/gba_convert_string.c +++ b/src/overlay097/gba_convert_string.c @@ -183,7 +183,7 @@ static const u16 sGBACharToDSChars[][2] = { { CHAR_JP_PERIOD, CHAR_PERIOD }, { CHAR_WIDE_MINUS, CHAR_MINUS }, { CHAR_JP_DOT, CHAR_DOT }, - { CHAR_JP_ELLIPSIS, CHAR_ELLPSIS }, + { CHAR_JP_ELLIPSIS, CHAR_ELLIPSIS }, { CHAR_JP_DOUBLE_QUOTE_OPEN, CHAR_JP_DOUBLE_QUOTE_OPEN }, { CHAR_JP_DOUBLE_QUOTE_CLOSE, CHAR_JP_DOUBLE_QUOTE_CLOSE }, { CHAR_JP_SINGLE_QUOTE_OPEN, CHAR_SINGLE_QUOTE_OPEN }, diff --git a/src/overlay104/ov104_0222FBE4.c b/src/overlay104/ov104_0222FBE4.c index 0f4a761cdf..972d67fd7b 100644 --- a/src/overlay104/ov104_0222FBE4.c +++ b/src/overlay104/ov104_0222FBE4.c @@ -8,6 +8,7 @@ #include "struct_decls/struct_0202440C_decl.h" #include "struct_decls/struct_0202B370_decl.h" +#include "applications/naming_screen.h" #include "overlay004/ov4_021D0D80.h" #include "overlay063/ov63_0222BE18.h" #include "overlay063/ov63_0222CCE4.h" @@ -92,12 +93,10 @@ #include "unk_020366A0.h" #include "unk_0205DFC4.h" #include "unk_0206CCB0.h" -#include "unk_0208694C.h" #include "unk_0209B6F8.h" #include "vars_flags.h" #include "constdata/const_020EA358.h" -#include "constdata/const_020F2DAC.h" typedef struct { s16 unk_00; @@ -1448,16 +1447,16 @@ static BOOL ov104_02230900(UnkStruct_ov104_0222E930 *param0) static BOOL ov104_02230910(UnkStruct_ov104_0222E930 *param0) { UnkStruct_ov104_02230BE4 *v1 = sub_0209B970(param0->unk_00->unk_00); - void *v0 = sub_0208712C(HEAP_ID_FIELDMAP, 0, 0, 8, (void *)v1->options); + void *v0 = NamingScreenArgs_Init(HEAP_ID_FIELDMAP, NAMING_SCREEN_TYPE_PLAYER, 0, 8, (void *)v1->options); - sub_0209B988(param0->unk_00->unk_00, &Unk_020F2DAC, v0, 0, ov104_02230950); + sub_0209B988(param0->unk_00->unk_00, &gNamingScreenAppTemplate, v0, 0, ov104_02230950); return 1; } static void ov104_02230950(void *param0) { - sub_0208716C(param0); + NamingScreenArgs_Free(param0); } static BOOL ov104_02230958(UnkStruct_ov104_0222E930 *param0) diff --git a/src/scrcmd.c b/src/scrcmd.c index f534d64baa..813a86e761 100644 --- a/src/scrcmd.c +++ b/src/scrcmd.c @@ -13,6 +13,7 @@ #include "constants/overworld_weather.h" #include "constants/scrcmd.h" #include "constants/species.h" +#include "constants/string.h" #include "generated/accessories.h" #include "generated/first_arrival_to_zones.h" #include "generated/journal_location_events.h" @@ -47,6 +48,7 @@ #include "struct_defs/underground.h" #include "struct_defs/underground_record.h" +#include "applications/naming_screen.h" #include "applications/pokemon_summary_screen/main.h" #include "field/field_system.h" #include "field/field_system_sub2_t.h" @@ -4302,7 +4304,7 @@ static BOOL ScrCmd_Unused_0BA(ScriptContext *ctx) { FieldSystem *fieldSystem = ctx->fieldSystem; - sub_0203DFE8(ctx->task, 0, 0, 7, 0, NULL, ScriptContext_GetVarPointer(ctx)); + sub_0203DFE8(ctx->task, NAMING_SCREEN_TYPE_PLAYER, 0, TRAINER_NAME_LEN, 0, NULL, ScriptContext_GetVarPointer(ctx)); return TRUE; } @@ -4315,14 +4317,14 @@ static BOOL ScrCmd_0BB(ScriptContext *ctx) Pokemon *v1 = Party_GetPokemonBySlotIndex(SaveData_GetParty(fieldSystem->saveData), v3); Pokemon_GetValue(v1, MON_DATA_NICKNAME, v0); - sub_0203DFE8(ctx->task, 1, Pokemon_GetValue(v1, MON_DATA_SPECIES, NULL), 10, v3, v0, ScriptContext_GetVarPointer(ctx)); + sub_0203DFE8(ctx->task, NAMING_SCREEN_TYPE_POKEMON, Pokemon_GetValue(v1, MON_DATA_SPECIES, NULL), MON_NAME_LEN, v3, v0, ScriptContext_GetVarPointer(ctx)); return TRUE; } static BOOL ScrCmd_271(ScriptContext *ctx) { - sub_0203DFE8(ctx->task, 6, 0, 10, 0, NULL, ScriptContext_GetVarPointer(ctx)); + sub_0203DFE8(ctx->task, NAMING_SCREEN_TYPE_UNK6, 0, 10, 0, NULL, ScriptContext_GetVarPointer(ctx)); return TRUE; } diff --git a/src/unk_02012744.c b/src/unk_02012744.c index f9fb15460a..6c2971e62e 100644 --- a/src/unk_02012744.c +++ b/src/unk_02012744.c @@ -410,23 +410,31 @@ void sub_02012BE0(FontOAM *param0, const UnkStruct_02012B20 *param1, const Windo Heap_Free(v1); } -void sub_02012C60(const Window *param0, int param1, int param2, int param3, int param4, char *param5) +void sub_02012C60( + const Window *window, + int width, + int height, + int x, + int y, + char *output) { - int v0; - int v1; - int v2; + // this function copies a rectangle of pixels from the window + // to the output starting at (x,y) and spanning (width,height) + int i; + int dstOffset; + int srcOffset; - GF_ASSERT(param0->width >= (param1 + param3)); - GF_ASSERT(param0->height >= (param2 + param4)); + GF_ASSERT(window->width >= (width + x)); + GF_ASSERT(window->height >= (height + y)); - for (v0 = 0; v0 < param2; v0++) { - v1 = v0 * param1; - v1 *= 32; - v2 = ((v0 + param4) * param0->width); - v2 += param3; - v2 *= 32; + for (i = 0; i < height; i++) { + dstOffset = i * width; + dstOffset *= 32; + srcOffset = ((i + y) * window->width); + srcOffset += x; + srcOffset *= 32; - memcpy(param5 + v1, (char *)(param0->pixels) + v2, 32 * param1); + memcpy(output + dstOffset, (char *)(window->pixels) + srcOffset, 32 * width); } } diff --git a/src/unk_0203D1B8.c b/src/unk_0203D1B8.c index 88591de847..153ef326ca 100644 --- a/src/unk_0203D1B8.c +++ b/src/unk_0203D1B8.c @@ -29,12 +29,12 @@ #include "struct_defs/struct_0203E6C0.h" #include "struct_defs/struct_020684D0.h" #include "struct_defs/struct_0206BC70.h" -#include "struct_defs/struct_0208737C.h" #include "struct_defs/struct_02097728.h" #include "struct_defs/struct_02098C44.h" #include "struct_defs/struct_020997B8.h" #include "applications/journal_display/journal_controller.h" +#include "applications/naming_screen.h" #include "applications/options_menu.h" #include "applications/pokedex/pokedex_main.h" #include "applications/pokemon_summary_screen/main.h" @@ -128,7 +128,6 @@ #include "unk_0206CCB0.h" #include "unk_0207AE68.h" #include "unk_0207CB08.h" -#include "unk_0208694C.h" #include "unk_0209747C.h" #include "unk_02097624.h" #include "unk_02098218.h" @@ -139,7 +138,6 @@ #include "constdata/const_020EA328.h" #include "constdata/const_020EA358.h" #include "constdata/const_020F1E88.h" -#include "constdata/const_020F2DAC.h" #include "constdata/const_020F2FCC.h" #include "constdata/const_020F410C.h" #include "constdata/const_020F6890.h" @@ -212,7 +210,7 @@ typedef struct { int unk_00; int unk_04; u16 *unk_08; - UnkStruct_0208737C *unk_0C; + NamingScreenArgs *unk_0C; Strbuf *unk_10; } UnkStruct_0203DE98; @@ -1162,7 +1160,7 @@ static BOOL sub_0203DE98(FieldTask *param0) v2->unk_00++; break; case 1: - FieldTask_RunApplication(param0, &Unk_020F2DAC, v2->unk_0C); + FieldTask_RunApplication(param0, &gNamingScreenAppTemplate, v2->unk_0C); v2->unk_00++; break; case 2: @@ -1170,11 +1168,11 @@ static BOOL sub_0203DE98(FieldTask *param0) v2->unk_00++; break; case 3: - if (v2->unk_0C->unk_00 == 1) { + if (v2->unk_0C->type == NAMING_SCREEN_TYPE_POKEMON) { if (Strbuf_Compare(v2->unk_0C->textInputStr, v2->unk_10) == 0) { v2->unk_0C->unk_14 = 1; } - } else if (v2->unk_0C->unk_00 == 5) { + } else if (v2->unk_0C->type == NAMING_SCREEN_TYPE_GROUP) { const u16 *v3 = Strbuf_GetData(v2->unk_0C->textInputStr); RecordMixedRNG *v4 = SaveData_GetRecordMixedRNG(fieldSystem->saveData); @@ -1191,7 +1189,7 @@ static BOOL sub_0203DE98(FieldTask *param0) *v2->unk_08 = v2->unk_0C->unk_14; } - sub_0208716C(v2->unk_0C); + NamingScreenArgs_Free(v2->unk_0C); Strbuf_Free(v2->unk_10); Heap_Free(v2); @@ -1206,23 +1204,23 @@ static void sub_0203DF68(FieldTask *param0) FieldSystem *fieldSystem = FieldTask_GetFieldSystem(param0); UnkStruct_0203DE98 *v1 = FieldTask_GetEnv(param0); - switch (v1->unk_0C->unk_00) { - case 0: { + switch (v1->unk_0C->type) { + case NAMING_SCREEN_TYPE_PLAYER: { TrainerInfo *v2 = SaveData_GetTrainerInfo(fieldSystem->saveData); TrainerInfo_SetName(v2, v1->unk_0C->unk_1C); } break; - case 1: { + case NAMING_SCREEN_TYPE_POKEMON: { Pokemon *v3; int v4; v3 = Party_GetPokemonBySlotIndex(SaveData_GetParty(fieldSystem->saveData), v1->unk_04); Pokemon_SetValue(v3, MON_DATA_NICKNAME_AND_FLAG, (u8 *)&v1->unk_0C->unk_1C); } break; - case 5: { + case NAMING_SCREEN_TYPE_GROUP: { RecordMixedRNG *v5 = SaveData_GetRecordMixedRNG(fieldSystem->saveData); RecordMixedRNG_GetEntryNameAsStrbuf(v5, 0, 0, v1->unk_0C->textInputStr); } break; - case 6: { + case NAMING_SCREEN_TYPE_UNK6: { MiscSaveBlock *v6 = SaveData_MiscSaveBlock(fieldSystem->saveData); MiscSaveBlock_SetTabletName(v6, v1->unk_0C->textInputStr); } break; @@ -1231,7 +1229,14 @@ static void sub_0203DF68(FieldTask *param0) return; } -void sub_0203DFE8(FieldTask *param0, int param1, int param2, int param3, int param4, const u16 *param5, u16 *param6) +void sub_0203DFE8( + FieldTask *param0, + enum NamingScreenType type, + int param2, + int param3, + int param4, + const u16 *param5, + u16 *param6) { Pokemon *v0; FieldSystem *fieldSystem = FieldTask_GetFieldSystem(param0); @@ -1240,11 +1245,11 @@ void sub_0203DFE8(FieldTask *param0, int param1, int param2, int param3, int par v2->unk_00 = 0; v2->unk_04 = param4; v2->unk_08 = param6; - v2->unk_0C = sub_0208712C(HEAP_ID_FIELDMAP, param1, param2, param3, SaveData_GetOptions(fieldSystem->saveData)); + v2->unk_0C = NamingScreenArgs_Init(HEAP_ID_FIELDMAP, type, param2, param3, SaveData_GetOptions(fieldSystem->saveData)); v2->unk_10 = Strbuf_Init(12, HEAP_ID_FIELDMAP); - switch (param1) { - case 1: + switch (type) { + case NAMING_SCREEN_TYPE_POKEMON: v0 = Party_GetPokemonBySlotIndex(SaveData_GetParty(fieldSystem->saveData), v2->unk_04); v2->unk_0C->unk_10 = Pokemon_GetValue(v0, MON_DATA_GENDER, NULL); v2->unk_0C->unk_08 = Pokemon_GetValue(v0, MON_DATA_FORM, NULL); @@ -1253,7 +1258,7 @@ void sub_0203DFE8(FieldTask *param0, int param1, int param2, int param3, int par Strbuf_CopyChars(v2->unk_10, param5); } break; - case 5: + case NAMING_SCREEN_TYPE_GROUP: Strbuf_CopyChars(v2->unk_10, param5); break; default: diff --git a/src/unk_02048BD0.c b/src/unk_02048BD0.c index ff249b25ac..6250cd3bef 100644 --- a/src/unk_02048BD0.c +++ b/src/unk_02048BD0.c @@ -3,6 +3,8 @@ #include #include +#include "applications/naming_screen.h" + #include "field_script_context.h" #include "inlines.h" #include "math_util.h" @@ -63,7 +65,7 @@ BOOL ScrCmd_21D(ScriptContext *param0) const u16 *v11; v11 = RecordMixedRNG_GetEntryName(v1, 0, 0); - sub_0203DFE8(param0->task, 5, 0, 7, 0, v11, ScriptContext_GetVarPointer(param0)); + sub_0203DFE8(param0->task, NAMING_SCREEN_TYPE_GROUP, 0, TRAINER_NAME_LEN, 0, v11, ScriptContext_GetVarPointer(param0)); } return 1; case 5: { diff --git a/src/unk_0208694C.c b/src/unk_0208694C.c deleted file mode 100644 index dad70e509d..0000000000 --- a/src/unk_0208694C.c +++ /dev/null @@ -1,2624 +0,0 @@ -#include "unk_0208694C.h" - -#include -#include - -#include "constants/graphics.h" - -#include "struct_decls/struct_02087A10_decl.h" -#include "struct_defs/struct_0208737C.h" -#include "struct_defs/struct_02099F80.h" - -#include "bg_window.h" -#include "char_transfer.h" -#include "charcode_util.h" -#include "font.h" -#include "game_options.h" -#include "graphics.h" -#include "gx_layers.h" -#include "heap.h" -#include "math_util.h" -#include "message.h" -#include "message_util.h" -#include "narc.h" -#include "overlay_manager.h" -#include "pc_boxes.h" -#include "pltt_transfer.h" -#include "pokemon.h" -#include "pokemon_icon.h" -#include "render_oam.h" -#include "render_window.h" -#include "screen_fade.h" -#include "sound.h" -#include "sound_playback.h" -#include "sprite.h" -#include "sprite_resource.h" -#include "sprite_transfer.h" -#include "sprite_util.h" -#include "strbuf.h" -#include "string_template.h" -#include "sys_task_manager.h" -#include "system.h" -#include "text.h" -#include "unk_0200679C.h" -#include "unk_02012744.h" -#include "unk_0201567C.h" -#include "vram_transfer.h" - -#include "constdata/const_020F2DAC.h" - -typedef struct { - int unk_00; - int unk_04; - int unk_08; - int unk_0C; - int unk_10; - int unk_14; - int unk_18; -} UnkStruct_02087A10_sub1; - -struct UnkStruct_02087A10_t { - int unk_00; - int unk_04; - int unk_08; - int unk_0C; - int unk_10; - int unk_14; - Options *options; - UnkStruct_02087A10_sub1 unk_1C; - u16 unk_38; - u16 unk_3A[6][13]; - u16 unk_D6; - u16 unk_D8[32]; - u16 unk_118[32]; - u16 unk_158; - u16 unk_15A[3]; - BgConfig *unk_160; - BOOL unk_164; - StringTemplate *unk_168; - MessageLoader *unk_16C; - MessageLoader *unk_170; - MessageLoader *unk_174; - Strbuf *unk_178; - Strbuf *unk_17C; - Strbuf *unk_180; - Strbuf *unk_184; - SpriteList *unk_188; - G2dRenderer unk_18C; - SpriteResourceCollection *unk_318[4]; - SpriteResource *unk_328[2][4]; - SpriteResourcesHeader unk_348; - SpriteResourcesHeader unk_36C; - Sprite *unk_390[14]; - Sprite *unk_3C8[12]; - Sprite *unk_3F8[2]; - SysTask *unk_400[7]; - Window unk_41C[10]; - int unk_4BC; - int unk_4C0; - int unk_4C4; - int unk_4C8; - VecFx32 unk_4CC[2]; - int unk_4E4; - int unk_4E8; - int unk_4EC; - int unk_4F0; - int unk_4F4[7]; - void *unk_510; - NNSG2dCharacterData *unk_514; - void *unk_518; - NNSG2dCharacterData *unk_51C; - void *unk_520; - NNSG2dPaletteData *unk_524; - u8 unk_528[256]; - UnkStruct_020157E4 *unk_628; - BOOL unk_62C; - int unk_630; -}; - -typedef struct { - Sprite *unk_00; - Sprite *unk_04; - int unk_08; - int unk_0C; -} UnkStruct_020879DC; - -typedef struct { - Sprite *unk_00; - int unk_04; - int unk_08; - int unk_0C; -} UnkStruct_02087CDC; - -typedef struct { - u8 unk_00; - u8 unk_01; - u16 unk_02_0 : 2; - u16 : 14; - u8 unk_04_0 : 5; - u8 : 3; - u8 unk_05_0 : 5; - u8 : 3; -} UnkStruct_020F2A14; - -static int sub_0208694C(ApplicationManager *appMan, int *param1); -static int sub_02086B64(ApplicationManager *appMan, int *param1); -static int sub_02086F3C(ApplicationManager *appMan, int *param1); -static void sub_02087190(void *param0); -static void sub_020871CC(void); -static void sub_020871EC(BgConfig *param0); -static void sub_0208765C(BgConfig *param0, Window *param1); -static void sub_0208769C(UnkStruct_02087A10 *param0, NARC *param1); -static void sub_02087D64(BgConfig *param0, Window *param1, int *param2, int param3, int *param4, VecFx32 param5[], Sprite **param6, void *param7); -static void sub_0208737C(UnkStruct_02087A10 *param0, ApplicationManager *appMan); -static void sub_02088240(BgConfig *param0, int param1, VecFx32 param2[]); -static void sub_02088260(VecFx32 param0[], int param1); -static void sub_020877F4(UnkStruct_02087A10 *param0, NARC *param1); -static void sub_02087A10(UnkStruct_02087A10 *param0); -static void sub_020877C4(void); -static void sub_02087FC0(UnkStruct_02087A10 *param0, ApplicationManager *appMan, NARC *param2); -static void sub_02088350(UnkStruct_02087A10 *param0); -static void sub_02088514(u16 *param0); -static void sub_02088554(Window *param0, const u16 *param1, int param2, int param3, int param4, int param5, TextColor param6, u8 *param7); -static void sub_02088678(Window *param0, const u16 *param1, u8 *param2, Strbuf *param3); -static void sub_02088844(u16 param0[][13], const int param1); -static void sub_02088754(Window *param0, u16 *param1, int param2, u16 *param3, u8 *param4, Strbuf *param5); -static int sub_02088898(UnkStruct_02087A10 *param0, u16 param1, int param2); -static int sub_02088D08(int param0, int param1, int param2, int param3, u16 *param4, int param5); -static int sub_02088C9C(int param0, int param1, u16 *param2, int param3); -static void sub_02088E1C(Sprite **param0, int param1, int param2); -static void sub_020871B0(UnkStruct_02087A10 *param0, UnkStruct_0208737C *param1); -static void sub_02088E58(Window *param0, u16 param1, int param2, TextColor param3, u8 *param4); -static void sub_02088454(UnkStruct_02087A10 *param0, int param1); -static void sub_02088F40(int param0[], Sprite **param1, int param2); -static void sub_020879DC(SysTask *param0, void *param1); -static void sub_02087CDC(SysTask *param0, void *param1); -static void sub_02086B30(NNSG2dCharacterData *param0, NNSG2dPaletteData *param1, int param2, int param3); -static void sub_0208732C(int param0); -static void sub_02087544(UnkStruct_02087A10 *param0, ApplicationManager *appMan); -static void sub_02087BE4(UnkStruct_02087A10 *param0, AffineSpriteListTemplate *param1); -static void sub_02086E6C(UnkStruct_02087A10 *param0, UnkStruct_0208737C *param1); -static void sub_02087F48(Window *param0, int param1, Strbuf *param2); -static void sub_02088FD0(UnkStruct_02087A10 *param0); -static int sub_02086D38(UnkStruct_02087A10 *param0, int param1); -static int sub_02086F14(u16 *param0); -static void *sub_02088654(Window *param0, Strbuf *param1, u8 param2, TextColor param3); -static BOOL sub_0208903C(UnkStruct_02087A10 *param0); - -static const int Unk_020F2984[][4] = { - { 0x4, 0x44, 0x3, 0x1 }, - { 0x24, 0x44, 0x8, 0x1 }, - { 0x44, 0x44, 0xD, 0x1 }, - { 0x0, 0xC8, 0x12, 0x1 }, - { 0x65, 0x44, 0x14, 0x1 }, - { 0x88, 0x44, 0x17, 0x1 }, - { 0xB0, 0x44, 0x19, 0x1 }, - { 0x16, 0x38, 0x25, 0x2 }, - { 0x1A, 0x5B, 0x27, 0x0 } -}; - -static const u16 Unk_020F255A[] = { - 0xE002, - 0xE002, - 0xE003, - 0xE003, - 0xE004, - 0xE004, - 0xD004, - 0xD004, - 0xE007, - 0xE007, - 0xE007, - 0xE008, - 0xE008 -}; - -static const u16 Unk_020F2574[] = { - 0xD004, - 0xD004, - 0xD004, - 0xD004, - 0xD004, - 0xD004, - 0xD004, - 0xD004, - 0xE007, - 0xE007, - 0xE007, - 0xE008, - 0xE008 -}; - -static const u16 *Unk_02100C40[] = { - Unk_020F255A, - Unk_020F255A, - Unk_020F255A, - Unk_020F255A, - Unk_020F2574 -}; - -static const u16 Unk_020F251C[] = { - 0x19, - 0x39, - 0x59, - 0x61, - 0x7A, - 0x9E, - 0xC6, - 0x0 -}; - -static const u8 Unk_020F24E8[] = { - 0x28, - 0x28, - 0x28, - 0x28, - 0x29, - 0x29, - 0x29 -}; - -static const u16 Unk_020F261C[] = { - 0x12B, - 0x12C, - 0x12D, - 0x12E, - 0x12f, - 0x130, - 0x131, - 0x132, - 0x133, - 0x134, - 0x1DE, - 0x1AD, - 0x1AE, - 0xffff -}; - -static const u16 Unk_020F2638[] = { - 0x135, - 0x136, - 0x137, - 0x138, - 0x139, - 0x13A, - 0x13B, - 0x13C, - 0x13D, - 0x13E, - 0x1DE, - 0x1B3, - 0x1BE, - 0xffff -}; - -static const u16 Unk_020F2654[] = { - 0x13f, - 0x140, - 0x141, - 0x142, - 0x143, - 0x144, - 0x1DE, - 0x1DE, - 0x1DE, - 0x1DE, - 0x1DE, - 0x1BB, - 0x1BC, - 0xffff -}; - -static const u16 Unk_020F25C8[] = { - 0x1DE, - 0x1DE, - 0x1DE, - 0x1DE, - 0x1DE, - 0x1DE, - 0x1DE, - 0x1DE, - 0x1DE, - 0x1DE, - 0x1DE, - 0x1DE, - 0x1DE, - 0xffff -}; - -static const u16 Unk_020F2600[] = { - 0x121, - 0x122, - 0x123, - 0x124, - 0x125, - 0x126, - 0x127, - 0x128, - 0x129, - 0x12A, - 0x1DE, - 0x1DE, - 0x1DE, - 0xffff -}; - -static const u16 Unk_020F268C[] = { - 0x145, - 0x146, - 0x147, - 0x148, - 0x149, - 0x14A, - 0x14B, - 0x14C, - 0x14D, - 0x14E, - 0x1DE, - 0x1AD, - 0x1AE, - 0xffff -}; - -static const u16 Unk_020F26A8[] = { - 0x14f, - 0x150, - 0x151, - 0x152, - 0x153, - 0x154, - 0x155, - 0x156, - 0x157, - 0x158, - 0x1DE, - 0x1B3, - 0x1BE, - 0xffff -}; - -static const u16 Unk_020F27F8[] = { - 0x159, - 0x15A, - 0x15B, - 0x15C, - 0x15D, - 0x15E, - 0x1DE, - 0x1DE, - 0x1DE, - 0x1DE, - 0x1DE, - 0x1BB, - 0x1BC, - 0xffff -}; - -static const u16 Unk_020F26FC[] = { - 0x1DE, - 0x1DE, - 0x1DE, - 0x1DE, - 0x1DE, - 0x1DE, - 0x1DE, - 0x1DE, - 0x1DE, - 0x1DE, - 0x1DE, - 0x1DE, - 0x1DE, - 0xffff -}; - -static const u16 Unk_020F27C0[] = { - 0x121, - 0x122, - 0x123, - 0x124, - 0x125, - 0x126, - 0x127, - 0x128, - 0x129, - 0x12A, - 0x1DE, - 0x1DE, - 0x1DE, - 0xffff -}; - -static const u16 Unk_020F2734[] = { - 0x1AD, - 0x1AE, - 0x1C4, - 0x1C5, - 0x1AB, - 0x1AC, - 0x1DE, - 0x1DE, - 0x1DE, - 0x1BB, - 0x1BC, - 0x1DE, - 0x1DE, - 0xffff -}; - -static const u16 Unk_020F276C[] = { - 0x1B4, - 0x1B5, - 0x1B2, - 0x1B3, - 0x1B9, - 0x1BA, - 0x1DE, - 0x1DE, - 0x1DE, - 0x1DE, - 0x1DE, - 0x1DE, - 0x1DE, - 0xffff -}; - -static const u16 Unk_020F2788[] = { - 0x1af, - 0x1B0, - 0x1C3, - 0x1D0, - 0x1C0, - 0x1D2, - 0x1BD, - 0x1BE, - 0x1bf, - 0x1B1, - 0x1C1, - 0x1DE, - 0x1DE, - 0xffff -}; - -static const u16 Unk_020F27A4[] = { - 0x1CB, - 0x1CC, - 0x1CD, - 0x1CE, - 0x1cf, - 0x1C6, - 0x1C8, - 0x1C9, - 0x1C7, - 0x1CA, - 0x1D1, - 0x1DE, - 0x1DE, - 0xffff -}; - -static const u16 Unk_020F27DC[] = { - 0x1D3, - 0x1D4, - 0x1D5, - 0x1D6, - 0x1D7, - 0x1D8, - 0x1D9, - 0x1DA, - 0x1DD, - 0x1DB, - 0x1DC, - 0x1DE, - 0x1DE, - 0xffff -}; - -static const u16 Unk_020F2718[] = { - 0xA2, - 0xA3, - 0xA4, - 0xA5, - 0xA6, - 0xA7, - 0xA8, - 0xA9, - 0xAA, - 0xAB, - 0x1, - 0xE1, - 0xE2, - 0xffff -}; - -static const u16 Unk_020F258E[] = { - 0xE3, - 0xE4, - 0xf9, - 0xf8, - 0xE5, - 0xE6, - 0xf5, - 0xf6, - 0xf7, - 0xE7, - 0x1, - 0xEE, - 0xef, - 0xffff -}; - -static const u16 Unk_020F26E0[] = { - 0xE8, - 0xE9, - 0xEA, - 0xEB, - 0xEC, - 0xED, - 0xf0, - 0xf1, - 0xf2, - 0xf3, - 0xf4, - 0x106, - 0x104, - 0xffff -}; - -static const u16 Unk_020F26C4[] = { - 0xff, - 0x100, - 0x101, - 0x102, - 0x103, - 0xfc, - 0xfa, - 0xfd, - 0xfb, - 0xfe, - 0x105, - 0x1, - 0x1, - 0xffff -}; - -static const u16 Unk_020F25E4[] = { - 0x107, - 0x108, - 0x109, - 0x10A, - 0x10B, - 0x10C, - 0x10D, - 0x10E, - 0x111, - 0x10f, - 0x110, - 0x1, - 0x1, - 0xffff -}; - -static const u16 Unk_020F2870[] = { - 0x121, - 0x122, - 0x123, - 0x124, - 0x125, - 0x1, - 0x1, - 0x1, - 0x1, - 0x1, - 0x1, - 0x1, - 0x1, - 0x1, - 0x1, - 0x1, - 0x1, - 0xffff -}; - -static const u16 Unk_020F2894[] = { - 0x126, - 0x127, - 0x128, - 0x129, - 0x12A, - 0x1, - 0x1, - 0x1, - 0x1, - 0x1, - 0x1, - 0x1, - 0x1, - 0x1, - 0x1, - 0x1, - 0x1, - 0xffff -}; - -static const u16 Unk_020F28B8[] = { - 0x1, - 0x1, - 0x1, - 0x1, - 0x1, - 0x1, - 0x1, - 0x1, - 0x1, - 0x1, - 0x1, - 0x1, - 0x1, - 0x1, - 0x1, - 0x1, - 0x1, - 0xffff -}; - -const u16 *Unk_02100C54[][5] = { - { Unk_020F261C, Unk_020F2638, Unk_020F2654, Unk_020F25C8, Unk_020F2600 }, - { Unk_020F268C, Unk_020F26A8, Unk_020F27F8, Unk_020F26FC, Unk_020F27C0 }, - { Unk_020F2734, Unk_020F276C, Unk_020F2788, Unk_020F27A4, Unk_020F27DC }, - { Unk_020F2718, Unk_020F258E, Unk_020F26E0, Unk_020F26C4, Unk_020F25E4 }, - { Unk_020F2870, Unk_020F2894, Unk_020F28B8, Unk_020F28B8, Unk_020F28B8 } -}; - -static const u16 Unk_020F2BBE[][3] = { - { 0x3, 0x1, 0x2 }, - { 0x5, 0x1, 0x4 }, - { 0x7, 0x1, 0x6 }, - { 0x9, 0x1, 0x8 }, - { 0xB, 0x1, 0xA }, - { 0x53, 0x1, 0x52 }, - { 0x55, 0x1, 0x54 }, - { 0x57, 0x1, 0x56 }, - { 0x59, 0x1, 0x58 }, - { 0x5B, 0x1, 0x5A }, - { 0x45, 0x1, 0x44 }, - { 0x47, 0x1, 0x46 }, - { 0x49, 0x1, 0x48 }, - { 0x95, 0x1, 0x94 }, - { 0x97, 0x1, 0x96 }, - { 0x99, 0x1, 0x98 }, - { 0xAC, 0x1, 0xC6 }, - { 0xAD, 0x1, 0xC7 }, - { 0xAE, 0x1, 0xC8 }, - { 0xaf, 0x1, 0xC9 }, - { 0xB0, 0x1, 0xCA }, - { 0xB1, 0x1, 0xCB }, - { 0xB2, 0x1, 0xCC }, - { 0xB3, 0x1, 0xCD }, - { 0xB4, 0x1, 0xCE }, - { 0xB5, 0x1, 0xcf }, - { 0xB6, 0x1, 0xD0 }, - { 0xB7, 0x1, 0xD1 }, - { 0xB8, 0x1, 0xD2 }, - { 0xB9, 0x1, 0xD3 }, - { 0xBA, 0x1, 0xD4 }, - { 0xBB, 0x1, 0xD5 }, - { 0xBC, 0x1, 0xD6 }, - { 0xBD, 0x1, 0xD7 }, - { 0xBE, 0x1, 0xD8 }, - { 0xbf, 0x1, 0xD9 }, - { 0xC0, 0x1, 0xDA }, - { 0xC1, 0x1, 0xDB }, - { 0xC2, 0x1, 0xDC }, - { 0xC3, 0x1, 0xDD }, - { 0xC4, 0x1, 0xDE }, - { 0xC5, 0x1, 0xdf }, - { 0x25, 0x26, 0x24 }, - { 0x75, 0x76, 0x74 }, - { 0xC, 0xD, 0x1 }, - { 0xE, 0x0f, 0x1 }, - { 0x10, 0x11, 0x1 }, - { 0x12, 0x13, 0x1 }, - { 0x14, 0x15, 0x1 }, - { 0x16, 0x17, 0x1 }, - { 0x18, 0x19, 0x1 }, - { 0x1A, 0x1B, 0x1 }, - { 0x1C, 0x1D, 0x1 }, - { 0x1E, 0x1f, 0x1 }, - { 0x20, 0x21, 0x1 }, - { 0x22, 0x23, 0x1 }, - { 0x27, 0x28, 0x1 }, - { 0x29, 0x2A, 0x1 }, - { 0x5C, 0x5D, 0x1 }, - { 0x5E, 0x5f, 0x1 }, - { 0x60, 0x61, 0x1 }, - { 0x62, 0x63, 0x1 }, - { 0x64, 0x65, 0x1 }, - { 0x66, 0x67, 0x1 }, - { 0x68, 0x69, 0x1 }, - { 0x6A, 0x6B, 0x1 }, - { 0x6C, 0x6D, 0x1 }, - { 0x6E, 0x6f, 0x1 }, - { 0x70, 0x71, 0x1 }, - { 0x72, 0x73, 0x1 }, - { 0x77, 0x78, 0x1 }, - { 0x79, 0x7A, 0x1 }, - { 0x30, 0x31, 0x32 }, - { 0x33, 0x34, 0x35 }, - { 0x36, 0x37, 0x38 }, - { 0x39, 0x3A, 0x3B }, - { 0x3C, 0x3D, 0x3E }, - { 0x80, 0x81, 0x82 }, - { 0x83, 0x84, 0x85 }, - { 0x86, 0x87, 0x88 }, - { 0x89, 0x8A, 0x8B }, - { 0x8C, 0x8D, 0x8E } -}; - -static const u16 Unk_020F2954[][2] = { - { 0x24, 0x26 }, - { 0x74, 0x76 }, - { 0x32, 0x31 }, - { 0x35, 0x34 }, - { 0x38, 0x37 }, - { 0x3B, 0x3A }, - { 0x3E, 0x3D }, - { 0x82, 0x81 }, - { 0x85, 0x84 }, - { 0x88, 0x87 }, - { 0x8B, 0x8A }, - { 0x8E, 0x8D } -}; - -static const u16 Unk_020F292C[][2] = { - { 0x31, 0x32 }, - { 0x34, 0x35 }, - { 0x37, 0x38 }, - { 0x3A, 0x3B }, - { 0x3D, 0x3E }, - { 0x81, 0x82 }, - { 0x84, 0x85 }, - { 0x87, 0x88 }, - { 0x8A, 0x8B }, - { 0x8D, 0x8E } -}; - -static const int Unk_020F24F0[] = { - 0x70, - 0x4C, - 0x48 -}; - -static const u8 Unk_020F24DC[4] = { - 0x4, - 0x7, - 0xD, - 0xA -}; - -const u16 Unk_020F252C[] = { - 0x3, - 0x2B, - 0x20, - 0x2f, - 0x1, - 0x2B, - 0x3f, - 0x9, - 0x30, - 0xE2, - 0xffff -}; - -const u16 Unk_020F2830[] = { - 0x8E, - 0x62, - 0x93, - 0xA1, - 0x2f, - 0x1, - 0x7C, - 0x74, - 0x60, - 0x7E, - 0xf1, - 0x91, - 0x30, - 0xE2, - 0xffff -}; - -const u16 Unk_020F2542[] = { - 0x8D, - 0x74, - 0x60, - 0x6A, - 0x2f, - 0x1, - 0x2B, - 0x3f, - 0x9, - 0x30, - 0xE2, - 0xffff -}; - -static const u16 *dummy[] = { - Unk_020F252C, - Unk_020F2830, - Unk_020F2542, -}; - -static const int Unk_020F2850[] = { - 0x0, - 0x1, - 0x2, - 0x3, - 0x4, - 0x5, - 0x6, - 0x3 -}; - -const ApplicationManagerTemplate Unk_020F2DAC = { - sub_0208694C, - sub_02086B64, - sub_02086F3C, - 0xFFFFFFFF -}; - -static UnkStruct_02087A10 *Unk_021C0A30; - -static int sub_0208694C(ApplicationManager *appMan, int *param1) -{ - UnkStruct_02087A10 *v0; - NARC *v1; - - switch (*param1) { - case 0: - SetVBlankCallback(NULL, NULL); - DisableHBlank(); - GXLayers_DisableEngineALayers(); - GXLayers_DisableEngineBLayers(); - - GX_SetVisiblePlane(0); - GXS_SetVisiblePlane(0); - - Heap_Create(HEAP_ID_APPLICATION, HEAP_ID_18, 0x20000 + 0x8000); - - v0 = ApplicationManager_NewData(appMan, sizeof(UnkStruct_02087A10), HEAP_ID_18); - memset(v0, 0, sizeof(UnkStruct_02087A10)); - v0->unk_160 = BgConfig_New(HEAP_ID_18); - v1 = NARC_ctor(NARC_INDEX_DATA__NAMEIN, HEAP_ID_18); - - v0->unk_168 = StringTemplate_Default(HEAP_ID_18); - v0->unk_16C = MessageLoader_Init(MESSAGE_LOADER_BANK_HANDLE, NARC_INDEX_MSGDATA__PL_MSG, TEXT_BANK_NAMING_SCREEN, HEAP_ID_18); - v0->unk_170 = MessageLoader_Init(MESSAGE_LOADER_NARC_HANDLE, NARC_INDEX_MSGDATA__PL_MSG, TEXT_BANK_UNK_0427, HEAP_ID_18); - v0->unk_174 = MessageLoader_Init(MESSAGE_LOADER_NARC_HANDLE, NARC_INDEX_MSGDATA__PL_MSG, TEXT_BANK_BATTLE_STRINGS, HEAP_ID_18); - - SetAutorepeat(4, 8); - sub_020871CC(); - sub_020871EC(v0->unk_160); - sub_020871B0(v0, (UnkStruct_0208737C *)ApplicationManager_Args(appMan)); - sub_0208769C(v0, v1); - Font_InitManager(FONT_SUBSCREEN, HEAP_ID_18); - SetVBlankCallback(sub_02087190, NULL); - sub_0208737C(v0, appMan); - Font_UseImmediateGlyphAccess(FONT_SYSTEM, 18); - sub_020877C4(); - sub_020877F4(v0, v1); - sub_02087A10(v0); - sub_02087FC0(v0, appMan, v1); - sub_02088754(&v0->unk_41C[4], v0->unk_D8, v0->unk_158, v0->unk_15A, v0->unk_528, v0->unk_17C); - Sound_SetSceneAndPlayBGM(SOUND_SCENE_SUB_52, SEQ_NONE, 0); - StartScreenFade(FADE_BOTH_SCREENS, FADE_TYPE_BRIGHTNESS_IN, FADE_TYPE_BRIGHTNESS_IN, COLOR_BLACK, 16, 1, HEAP_ID_18); - sub_0208732C(1); - - { - gSystem.whichScreenIs3D = DS_SCREEN_SUB; - GXLayers_SwapDisplay(); - } - - NARC_dtor(v1); - (*param1)++; - break; - case 1: - v0 = ApplicationManager_Data(appMan); - - if (v0->unk_00 == 1) { - sub_02086B30(v0->unk_51C, v0->unk_524, v0->unk_04, v0->unk_08); - } - - Unk_021C0A30 = v0; - v0->unk_628 = sub_0201567C(NULL, 1, 12, HEAP_ID_18); - - (*param1) = 0; - return 1; - break; - } - - return 0; -} - -static void sub_02086B30(NNSG2dCharacterData *param0, NNSG2dPaletteData *param1, int param2, int param3) -{ - u8 *v0; - - GX_LoadOBJ(param0->pRawData, (21 * 32 + 31) * 0x20, 0x20 * 4 * 4); - v0 = (u8 *)param1->pRawData; - GX_LoadOBJPltt((void *)(v0 + PokeIconPaletteIndex(param2, param3, 0) * 0x20), 6 * 0x20, 0x20); -} - -static int sub_02086B64(ApplicationManager *appMan, int *param1) -{ - UnkStruct_02087A10 *v0 = ApplicationManager_Data(appMan); - - switch (*param1) { - case 0: - if (IsScreenFadeDone()) { - *param1 = 1; - v0->unk_630 = 0; - } - break; - case 1: - v0->unk_630++; - - sub_02088FD0(v0); - sub_02088F40(v0->unk_4F4, v0->unk_390, v0->unk_4C4); - - if (v0->unk_630 > 5) { - *param1 = 2; - v0->unk_630 = 0; - } - break; - case 2: - switch (v0->unk_4C0) { - case 4: - *param1 = sub_02086D38(v0, *param1); - sub_02088FD0(v0); - break; - case 5: - sub_02087544(v0, appMan); - Window_FillTilemap(&v0->unk_41C[9], 0xf0f); - Window_DrawMessageBoxWithScrollCursor(&v0->unk_41C[9], 0, 32 * 8, 10); - v0->unk_4BC = Text_AddPrinterWithParams(&v0->unk_41C[9], FONT_MESSAGE, v0->unk_180, 0, 0, TEXT_SPEED_FAST, NULL); - Window_CopyToVRAM(&v0->unk_41C[9]); - v0->unk_4C0 = 6; - break; - case 6: - if (Text_IsPrinterActive(v0->unk_4BC) == 0) { - Sound_PlayEffect(SEQ_SE_DP_PIRORIRO); - v0->unk_4F4[6]++; - v0->unk_630 = 0; - v0->unk_4C0 = 7; - } - break; - case 7: - v0->unk_630++; - - if (v0->unk_630 > 30) { - StartScreenFade(FADE_SUB_THEN_MAIN, FADE_TYPE_BRIGHTNESS_OUT, FADE_TYPE_BRIGHTNESS_OUT, COLOR_BLACK, 16, 1, HEAP_ID_18); - *param1 = 3; - } - break; - } - - sub_02087D64(v0->unk_160, &v0->unk_41C[0], &v0->unk_4C0, v0->unk_4C4, &v0->unk_4C8, v0->unk_4CC, v0->unk_390, v0->unk_514->pRawData); - sub_02088F40(v0->unk_4F4, v0->unk_390, v0->unk_4C4); - sub_02088514(&v0->unk_38); - break; - case 3: - if (IsScreenFadeDone()) { - return 1; - } - break; - } - - SpriteList_Update(v0->unk_188); - - return 0; -} - -static int sub_02086D38(UnkStruct_02087A10 *param0, int param1) -{ - sub_02088350(param0); - - if (gSystem.pressedKeys & PAD_BUTTON_SELECT) { - if (Sprite_GetDrawFlag(param0->unk_390[8]) == 0) { - Sprite_SetDrawFlag(param0->unk_390[8], TRUE); - return param1; - } - - if (param0->unk_00 != 4) { - param0->unk_4C0 = 0; - param0->unk_4C4++; - - if (param0->unk_4C4 >= 3) { - param0->unk_4C4 = 0; - } - - param0->unk_4F4[param0->unk_4C4]++; - - sub_02088844(param0->unk_3A, param0->unk_4C4); - Sound_PlayEffect(SEQ_SE_DP_SYU03); - - param0->unk_1C.unk_14 = 1; - } - - param0->unk_4F4[param0->unk_4C4]++; - - sub_02088844(param0->unk_3A, param0->unk_4C4); - Sound_PlayEffect(SEQ_SE_DP_SYU03); - } else if (gSystem.pressedKeys & PAD_BUTTON_A) { - param1 = sub_02088898(param0, param0->unk_3A[param0->unk_1C.unk_04][param0->unk_1C.unk_00], 1); - param0->unk_1C.unk_14 = 1; - } else if (param0->unk_62C == 1) { - param1 = sub_02088898(param0, param0->unk_3A[param0->unk_1C.unk_04][param0->unk_1C.unk_00], 0); - param0->unk_1C.unk_14 = 0; - } else if (gSystem.pressedKeys & PAD_BUTTON_B) { - param1 = sub_02088898(param0, 0xe001 + 6, 1); - } else if (gSystem.pressedKeys & PAD_BUTTON_R) { - param1 = sub_02088898(param0, 0xe001 + 5, 1); - } - - return param1; -} - -static void sub_02086E6C(UnkStruct_02087A10 *param0, UnkStruct_0208737C *param1) -{ - if (param0->unk_00 == 0) { - Strbuf *v0; - - if (param0->unk_04 == 0) { - v0 = MessageLoader_GetNewStrbuf(param0->unk_170, 0 + LCRNG_Next() % 18); - } else if (param0->unk_04 == 1) { - v0 = MessageLoader_GetNewStrbuf(param0->unk_170, 18 + LCRNG_Next() % 18); - } - - Strbuf_Copy(param1->textInputStr, v0); - Strbuf_Free(v0); - Strbuf_ToChars(param1->textInputStr, param1->unk_1C, 10); - } else if (param0->unk_00 == 3) { - Strbuf *v1; - - v1 = MessageLoader_GetNewStrbuf(param0->unk_170, 88 + (LCRNG_Next() % 2)); - - Strbuf_Copy(param1->textInputStr, v1); - Strbuf_Free(v1); - Strbuf_ToChars(param1->textInputStr, param1->unk_1C, 10); - } else { - param1->unk_14 = 1; - } -} - -static int sub_02086F14(u16 *param0) -{ - int v0 = 1; - int v1; - - for (v1 = 0;; v1++) { - if (param0[v1] == 0xffff) { - break; - } - - if (param0[v1] != 0x1de) { - v0 = 0; - } - } - - return v0; -} - -static int sub_02086F3C(ApplicationManager *appMan, int *param1) -{ - UnkStruct_02087A10 *v0 = ApplicationManager_Data(appMan); - UnkStruct_0208737C *v1 = (UnkStruct_0208737C *)ApplicationManager_Args(appMan); - int v2; - - v0->unk_D8[v0->unk_158] = 0xffff; - - if (v0->unk_00 == 1) { - u16 v3[10 + 1]; - Pokemon *v4; - - v4 = Pokemon_New(HEAP_ID_18); - Pokemon_InitWith(v4, v0->unk_04, 5, 10, 10, 10, 10, 10); - Heap_Free(v4); - } - - if ((v0->unk_158 == 0) || (CharCode_Compare(v0->unk_D8, v0->unk_118) == 0) || sub_02086F14(v0->unk_D8)) { - sub_02086E6C(v0, v1); - } else { - CharCode_Copy(v0->unk_118, v0->unk_D8); - CharCode_Copy(v1->unk_1C, v0->unk_D8); - Strbuf_CopyChars(v1->textInputStr, v0->unk_D8); - } - - Strbuf_Free(v0->unk_184); - - for (v2 = 0; v2 < 7; v2++) { - SysTask_FinishAndFreeParam(v0->unk_400[v2]); - } - - SpriteTransfer_ResetCharTransfer(v0->unk_328[0][0]); - SpriteTransfer_ResetCharTransfer(v0->unk_328[1][0]); - SpriteTransfer_ResetPlttTransfer(v0->unk_328[0][1]); - SpriteTransfer_ResetPlttTransfer(v0->unk_328[1][1]); - - for (v2 = 0; v2 < 4; v2++) { - SpriteResourceCollection_Delete(v0->unk_318[v2]); - } - - SpriteList_Delete(v0->unk_188); - RenderOam_Free(); - Heap_FreeExplicit(HEAP_ID_18, v0->unk_510); - - if (v0->unk_00 == 1) { - Heap_FreeExplicit(HEAP_ID_18, v0->unk_518); - Heap_FreeExplicit(HEAP_ID_18, v0->unk_520); - } - - Bg_FreeTilemapBuffer(v0->unk_160, BG_LAYER_SUB_3); - CharTransfer_Free(); - PlttTransfer_Free(); - sub_0208765C(v0->unk_160, v0->unk_41C); - Font_UseLazyGlyphAccess(FONT_SYSTEM); - - GX_SetVisibleWnd(GX_WNDMASK_NONE); - - Font_Free(FONT_SUBSCREEN); - - if (v0->unk_180) { - Strbuf_Free(v0->unk_180); - } - - Strbuf_Free(v0->unk_178); - Strbuf_Free(v0->unk_17C); - MessageLoader_Free(v0->unk_174); - MessageLoader_Free(v0->unk_170); - MessageLoader_Free(v0->unk_16C); - StringTemplate_Free(v0->unk_168); - ApplicationManager_FreeData(appMan); - SetVBlankCallback(NULL, NULL); - Heap_Destroy(HEAP_ID_18); - - { - gSystem.whichScreenIs3D = DS_SCREEN_MAIN; - GXLayers_SwapDisplay(); - } - - return 1; -} - -UnkStruct_0208737C *sub_0208712C(int heapID, int param1, int param2, int param3, Options *options) -{ - UnkStruct_0208737C *v0 = (UnkStruct_0208737C *)Heap_AllocFromHeap(heapID, sizeof(UnkStruct_0208737C)); - - v0->unk_00 = param1; - v0->unk_04 = param2; - v0->unk_0C = param3; - v0->unk_14 = 0; - v0->unk_1C[0] = 0xffff; - v0->textInputStr = Strbuf_Init(32, heapID); - v0->unk_44 = 0; - v0->pcBoxes = NULL; - v0->unk_10 = 0; - v0->options = options; - v0->unk_08 = 0; - - return v0; -} - -void sub_0208716C(UnkStruct_0208737C *param0) -{ - GF_ASSERT((param0->textInputStr) != NULL); - GF_ASSERT((param0) != NULL); - - Strbuf_Free(param0->textInputStr); - Heap_Free(param0); -} - -static void sub_02087190(void *param0) -{ - VramTransfer_Process(); - RenderOam_Transfer(); - - OS_SetIrqCheckFlag(OS_IE_V_BLANK); -} - -static void sub_020871B0(UnkStruct_02087A10 *param0, UnkStruct_0208737C *param1) -{ - param0->unk_00 = param1->unk_00; - param0->unk_04 = param1->unk_04; - param0->unk_08 = param1->unk_08; - param0->unk_0C = param1->unk_0C; - param0->unk_10 = param1->unk_10; - param0->options = param1->options; -} - -static void sub_020871CC(void) -{ - UnkStruct_02099F80 v0 = { - GX_VRAM_BG_128_A, - GX_VRAM_BGEXTPLTT_NONE, - GX_VRAM_SUB_BG_128_C, - GX_VRAM_SUB_BGEXTPLTT_NONE, - GX_VRAM_OBJ_128_B, - GX_VRAM_OBJEXTPLTT_NONE, - GX_VRAM_SUB_OBJ_16_I, - GX_VRAM_SUB_OBJEXTPLTT_NONE, - GX_VRAM_TEX_NONE, - GX_VRAM_TEXPLTT_NONE - }; - - GXLayers_SetBanks(&v0); -} - -static void sub_020871EC(BgConfig *param0) -{ - { - GraphicsModes v0 = { - GX_DISPMODE_GRAPHICS, - GX_BGMODE_0, - GX_BGMODE_0, - GX_BG0_AS_2D, - }; - - SetAllGraphicsModes(&v0); - } - - { - BgTemplate v1 = { - .x = 0, - .y = 0, - .bufferSize = 0x1000, - .baseTile = 0, - .screenSize = BG_SCREEN_SIZE_512x256, - .colorMode = GX_BG_COLORMODE_16, - .screenBase = GX_BG_SCRBASE_0xf000, - .charBase = GX_BG_CHARBASE_0x10000, - .bgExtPltt = GX_BG_EXTPLTT_01, - .priority = 1, - .areaOver = 0, - .mosaic = FALSE, - }; - - Bg_InitFromTemplate(param0, BG_LAYER_MAIN_0, &v1, 0); - Bg_ClearTilemap(param0, BG_LAYER_MAIN_0); - } - - { - BgTemplate v2 = { - .x = 0, - .y = 0, - .bufferSize = 0x1000, - .baseTile = 0, - .screenSize = BG_SCREEN_SIZE_512x256, - .colorMode = GX_BG_COLORMODE_16, - .screenBase = GX_BG_SCRBASE_0xe000, - .charBase = GX_BG_CHARBASE_0x10000, - .bgExtPltt = GX_BG_EXTPLTT_01, - .priority = 2, - .areaOver = 0, - .mosaic = FALSE, - }; - - Bg_InitFromTemplate(param0, BG_LAYER_MAIN_1, &v2, 0); - Bg_ClearTilemap(param0, BG_LAYER_MAIN_1); - } - - { - BgTemplate v3 = { - .x = 0, - .y = 0, - .bufferSize = 0x800, - .baseTile = 0, - .screenSize = BG_SCREEN_SIZE_256x256, - .colorMode = GX_BG_COLORMODE_16, - .screenBase = GX_BG_SCRBASE_0xd000, - .charBase = GX_BG_CHARBASE_0x00000, - .bgExtPltt = GX_BG_EXTPLTT_01, - .priority = 3, - .areaOver = 0, - .mosaic = FALSE, - }; - - Bg_InitFromTemplate(param0, BG_LAYER_MAIN_2, &v3, 0); - Bg_ClearTilemap(param0, BG_LAYER_MAIN_2); - } - - { - BgTemplate v4 = { - .x = 0, - .y = 0, - .bufferSize = 0x800, - .baseTile = 0, - .screenSize = BG_SCREEN_SIZE_256x256, - .colorMode = GX_BG_COLORMODE_16, - .screenBase = GX_BG_SCRBASE_0xf800, - .charBase = GX_BG_CHARBASE_0x10000, - .bgExtPltt = GX_BG_EXTPLTT_01, - .priority = 0, - .areaOver = 0, - .mosaic = FALSE, - }; - - Bg_InitFromTemplate(param0, BG_LAYER_SUB_0, &v4, 0); - Bg_ClearTilemap(param0, BG_LAYER_SUB_0); - } - - sub_0208732C(0); - Bg_ClearTilesRange(BG_LAYER_MAIN_0, 32, 0, HEAP_ID_18); - Bg_ClearTilesRange(4, 32, 0, HEAP_ID_18); - - GX_SetVisibleWnd(GX_WNDMASK_W0); - G2_SetWnd0InsidePlane(GX_WND_PLANEMASK_BG2 | GX_WND_PLANEMASK_OBJ, 1); - G2_SetWndOutsidePlane(GX_WND_PLANEMASK_BG0 | GX_WND_PLANEMASK_BG1 | GX_WND_PLANEMASK_BG2 | GX_WND_PLANEMASK_BG3 | GX_WND_PLANEMASK_OBJ, 1); - G2_SetWnd0Position(0, 0, 255, 64); - G2S_BlendNone(); -} - -static void sub_0208732C(int param0) -{ - GXLayers_EngineAToggleLayers(GX_BLEND_PLANEMASK_BG0, param0); - GXLayers_EngineAToggleLayers(GX_BLEND_PLANEMASK_BG1, param0); - GXLayers_EngineAToggleLayers(GX_BLEND_PLANEMASK_BG2, param0); - GXLayers_EngineAToggleLayers(GX_BLEND_PLANEMASK_BG3, 0); - GXLayers_EngineAToggleLayers(GX_BLEND_PLANEMASK_OBJ, param0); - GXLayers_EngineBToggleLayers(GX_BLEND_PLANEMASK_BG0, param0); - GXLayers_EngineBToggleLayers(GX_BLEND_PLANEMASK_BG1, 0); - GXLayers_EngineBToggleLayers(GX_BLEND_PLANEMASK_OBJ, 0); -} - -static void sub_0208737C(UnkStruct_02087A10 *param0, ApplicationManager *appMan) -{ - UnkStruct_0208737C *v0 = (UnkStruct_0208737C *)ApplicationManager_Args(appMan); - - param0->unk_4C0 = 4; - - sub_02088260(param0->unk_4CC, 0); - Bg_SetOffset(param0->unk_160, BG_LAYER_MAIN_0 + param0->unk_4C8, 0, param0->unk_4CC[param0->unk_4C8].x); - Bg_SetOffset(param0->unk_160, BG_LAYER_MAIN_0 + param0->unk_4C8, 3, param0->unk_4CC[param0->unk_4C8].y); - Bg_SetOffset(param0->unk_160, BG_LAYER_MAIN_0 + ((param0->unk_4C8) ^ 1), 0, param0->unk_4CC[((param0->unk_4C8) ^ 1)].x); - Bg_SetOffset(param0->unk_160, BG_LAYER_MAIN_0 + ((param0->unk_4C8) ^ 1), 3, param0->unk_4CC[((param0->unk_4C8) ^ 1)].y); - - param0->unk_118[0] = 0xffff; - - if (v0->textInputStr) { - Strbuf_ToChars(v0->textInputStr, param0->unk_118, 32); - } - - MI_CpuFill16(param0->unk_D8, 0x1, 32 * 2); - - if (param0->unk_00 == 1) { - Pokemon *v1; - - v1 = Pokemon_New(HEAP_ID_18); - Pokemon_InitWith(v1, param0->unk_04, 5, 10, 10, 10, 10, 10); - StringTemplate_SetSpeciesName(param0->unk_168, 0, Pokemon_GetBoxPokemon(v1)); - Heap_Free(v1); - } - - if (v0->unk_44 != 0) { - param0->unk_14 = 1; - } - - param0->unk_178 = MessageUtil_ExpandedStrbuf(param0->unk_168, param0->unk_16C, Unk_020F2850[param0->unk_00], HEAP_ID_18); - param0->unk_17C = MessageUtil_ExpandedStrbuf(param0->unk_168, param0->unk_16C, 8, HEAP_ID_18); - param0->unk_184 = MessageLoader_GetNewStrbuf(param0->unk_16C, 7); - param0->unk_158 = CharCode_Length(param0->unk_118); - param0->unk_1C.unk_00 = 0; - param0->unk_1C.unk_04 = 1; - param0->unk_1C.unk_08 = -1; - param0->unk_1C.unk_0C = -1; - param0->unk_1C.unk_14 = 0; - param0->unk_1C.unk_18 = 0; - param0->unk_4E8 = 0xffffffff; - param0->unk_4EC = 0; - param0->unk_4F0 = 0; - param0->unk_D8[param0->unk_0C] = 0xffff; - - { - int v2; - - for (v2 = 0; v2 < 7; v2++) { - param0->unk_4F4[v2] = 0; - } - - switch (param0->unk_00) { - case 4: - param0->unk_4F4[3] = 1; - break; - default: - param0->unk_4F4[0] = 1; - break; - } - } -} - -static void sub_02087544(UnkStruct_02087A10 *param0, ApplicationManager *appMan) -{ - Strbuf *v0 = NULL; - UnkStruct_0208737C *v1 = (UnkStruct_0208737C *)ApplicationManager_Args(appMan); - - if (v1->unk_44 != 0) { - int v2, v3; - - v0 = Strbuf_Init(200, HEAP_ID_18); - param0->unk_180 = NULL; - v2 = PCBoxes_GetCurrentBoxID(v1->pcBoxes); - v3 = PCBoxes_FirstEmptyBox(v1->pcBoxes); - - StringTemplate_SetPCBoxName(param0->unk_168, 1, v1->pcBoxes, v2); - - if (v2 != v3) { - StringTemplate_SetPCBoxName(param0->unk_168, 2, v1->pcBoxes, v3); - v1->unk_44 += 2; - } else { - StringTemplate_SetPCBoxName(param0->unk_168, 2, v1->pcBoxes, v2); - } - - if ((param0->unk_158 == 0) || sub_02086F14(param0->unk_D8)) { - Pokemon *v4 = Pokemon_New(HEAP_ID_18); - - Pokemon_InitWith(v4, param0->unk_04, 1, 0, 0, 0, 0, 0); - StringTemplate_SetSpeciesName(param0->unk_168, 0, Pokemon_GetBoxPokemon(v4)); - Heap_Free(v4); - } else { - param0->unk_D8[param0->unk_158] = 0xffff; - Strbuf_CopyChars(v0, param0->unk_D8); - StringTemplate_SetStrbuf(param0->unk_168, 0, v0, 0, 0, 0); - } - - param0->unk_180 = MessageUtil_ExpandedStrbuf(param0->unk_168, param0->unk_174, v1->unk_44, HEAP_ID_18); - param0->unk_14 = 1; - - Strbuf_Free(v0); - } -} - -static void sub_0208765C(BgConfig *param0, Window *param1) -{ - int v0; - - for (v0 = 0; v0 < 10; v0++) { - Window_Remove(¶m1[v0]); - } - - Bg_FreeTilemapBuffer(param0, BG_LAYER_SUB_0); - Bg_FreeTilemapBuffer(param0, BG_LAYER_MAIN_2); - Bg_FreeTilemapBuffer(param0, BG_LAYER_MAIN_1); - Bg_FreeTilemapBuffer(param0, BG_LAYER_MAIN_0); - Heap_FreeExplicit(HEAP_ID_18, param0); -} - -static void sub_0208769C(UnkStruct_02087A10 *param0, NARC *param1) -{ - BgConfig *v0 = param0->unk_160; - - Graphics_LoadPaletteFromOpenNARC(param1, 0, 0, 0, 16 * 3 * 2, HEAP_ID_18); - Graphics_LoadPalette(NARC_INDEX_GRAPHIC__POKETCH, 12, 4, 0, 16 * 2, HEAP_ID_18); - Bg_MaskPalette(BG_LAYER_SUB_0, 0); - Graphics_LoadTilesToBgLayerFromOpenNARC(param1, 2, v0, 2, 0, (32 * 8) * 0x20, 1, HEAP_ID_18); - Graphics_LoadTilemapToBgLayerFromOpenNARC(param1, 4, v0, 2, 0, 32 * 24 * 2, 1, HEAP_ID_18); - Graphics_LoadTilesToBgLayerFromOpenNARC(param1, 2, v0, 1, 0, 32 * 8 * 0x20, 1, HEAP_ID_18); - Graphics_LoadTilemapToBgLayerFromOpenNARC(param1, 6, v0, 1, 0, 32 * 14 * 2, 1, HEAP_ID_18); - Graphics_LoadTilemapToBgLayerFromOpenNARC(param1, 7, v0, 0, 0, 32 * 14 * 2, 1, HEAP_ID_18); - Font_LoadScreenIndicatorsPalette(0, 12 * 32, HEAP_ID_18); - LoadMessageBoxGraphics(param0->unk_160, BG_LAYER_SUB_0, 32 * 8, 10, Options_Frame(param0->options), HEAP_ID_18); - Font_LoadScreenIndicatorsPalette(4, 12 * 32, HEAP_ID_18); - - param0->unk_510 = Graphics_GetCharDataFromOpenNARC(param1, 16, 1, ¶m0->unk_514, HEAP_ID_18); -} - -void sub_020877C4(void) -{ - { - CharTransferTemplate v0 = { - 20, 2048, 2048, 18 - }; - - CharTransfer_Init(&v0); - } - - PlttTransfer_Init(20, HEAP_ID_18); - CharTransfer_ClearBuffers(); - PlttTransfer_Clear(); -} - -static void sub_020877F4(UnkStruct_02087A10 *param0, NARC *param1) -{ - int v0; - - NNS_G2dInitOamManagerModule(); - RenderOam_Init(0, 128, 0, 32, 0, 128, 0, 32, 18); - - param0->unk_188 = SpriteList_InitRendering(40 + 4, ¶m0->unk_18C, HEAP_ID_18); - - SetSubScreenViewRect(¶m0->unk_18C, 0, 256 * FX32_ONE); - - for (v0 = 0; v0 < 4; v0++) { - param0->unk_318[v0] = SpriteResourceCollection_New(2, v0, HEAP_ID_18); - } - - param0->unk_328[0][0] = SpriteResourceCollection_AddTilesFrom(param0->unk_318[0], param1, 10, 1, 0, NNS_G2D_VRAM_TYPE_2DMAIN, HEAP_ID_18); - param0->unk_328[0][1] = SpriteResourceCollection_AddPaletteFrom(param0->unk_318[1], param1, 1, 0, 0, NNS_G2D_VRAM_TYPE_2DMAIN, 9, HEAP_ID_18); - param0->unk_328[0][2] = SpriteResourceCollection_AddFrom(param0->unk_318[2], param1, 12, 1, 0, 2, HEAP_ID_18); - param0->unk_328[0][3] = SpriteResourceCollection_AddFrom(param0->unk_318[3], param1, 14, 1, 0, 3, HEAP_ID_18); - - if (param0->unk_00 == 1) { - param0->unk_518 = Graphics_GetCharData(NARC_INDEX_POKETOOL__ICONGRA__PL_POKE_ICON, PokeIconSpriteIndex(param0->unk_04, 0, param0->unk_08), 0, ¶m0->unk_51C, HEAP_ID_18); - DC_FlushRange(param0->unk_51C, 0x20 * 4 * 4); - - param0->unk_520 = Graphics_GetPlttData(NARC_INDEX_POKETOOL__ICONGRA__PL_POKE_ICON, PokeIconPalettesFileIndex(), ¶m0->unk_524, HEAP_ID_18); - DC_FlushRange(param0->unk_524, 0x20 * 4); - } - - param0->unk_328[1][0] = SpriteResourceCollection_AddTilesFrom(param0->unk_318[0], param1, 11, 1, 1, NNS_G2D_VRAM_TYPE_2DSUB, HEAP_ID_18); - param0->unk_328[1][1] = SpriteResourceCollection_AddPaletteFrom(param0->unk_318[1], param1, 1, 0, 1, NNS_G2D_VRAM_TYPE_2DSUB, 3, HEAP_ID_18); - param0->unk_328[1][2] = SpriteResourceCollection_AddFrom(param0->unk_318[2], param1, 13, 1, 1, 2, HEAP_ID_18); - param0->unk_328[1][3] = SpriteResourceCollection_AddFrom(param0->unk_318[3], param1, 15, 1, 1, 3, HEAP_ID_18); - - SpriteTransfer_RequestChar(param0->unk_328[0][0]); - SpriteTransfer_RequestChar(param0->unk_328[1][0]); - SpriteTransfer_RequestPlttWholeRange(param0->unk_328[0][1]); - SpriteTransfer_RequestPlttWholeRange(param0->unk_328[1][1]); -} - -static void sub_020879DC(SysTask *param0, void *param1) -{ - const VecFx32 *v0; - VecFx32 v1; - UnkStruct_020879DC *v2 = (UnkStruct_020879DC *)param1; - - v0 = Sprite_GetPosition(v2->unk_00); - v1.x = v0->x + v2->unk_08; - v1.y = FX32_ONE * Unk_020F2984[v2->unk_0C][1]; - v1.z = 0; - - Sprite_SetPosition(v2->unk_04, &v1); -} - -static void sub_02087A10(UnkStruct_02087A10 *param0) -{ - int v0; - - SpriteResourcesHeader_Init(¶m0->unk_348, 0, 0, 0, 0, 0xffffffff, 0xffffffff, 0, 1, param0->unk_318[0], param0->unk_318[1], param0->unk_318[2], param0->unk_318[3], NULL, NULL); - SpriteResourcesHeader_Init(¶m0->unk_36C, 1, 1, 1, 1, 0xffffffff, 0xffffffff, 0, 0, param0->unk_318[0], param0->unk_318[1], param0->unk_318[2], param0->unk_318[3], NULL, NULL); - - { - AffineSpriteListTemplate v1; - - v1.list = param0->unk_188; - v1.resourceData = ¶m0->unk_348; - v1.position.x = FX32_CONST(32); - v1.position.y = FX32_CONST(96); - v1.position.z = 0; - v1.affineScale.x = FX32_ONE; - v1.affineScale.y = FX32_ONE; - v1.affineScale.z = FX32_ONE; - v1.affineZRotation = 0; - v1.priority = 1; - v1.vramType = NNS_G2D_VRAM_TYPE_2DMAIN; - v1.heapID = HEAP_ID_18; - - for (v0 = 0; v0 < 9; v0++) { - v1.position.x = FX32_ONE * Unk_020F2984[v0][0]; - v1.position.y = FX32_ONE * Unk_020F2984[v0][1]; - - param0->unk_390[v0] = SpriteList_AddAffine(&v1); - - Sprite_SetAnimateFlag(param0->unk_390[v0], 1); - Sprite_SetAnim(param0->unk_390[v0], Unk_020F2984[v0][2]); - Sprite_SetPriority(param0->unk_390[v0], Unk_020F2984[v0][3]); - } - - Sprite_SetDrawFlag(param0->unk_390[4], FALSE); - Sprite_SetDrawFlag(param0->unk_390[8], FALSE); - - for (v0 = 0; v0 < 7; v0++) { - UnkStruct_020879DC *v2; - - param0->unk_400[v0] = SysTask_StartAndAllocateParam(sub_020879DC, 16, 5, 18); - v2 = SysTask_GetParam(param0->unk_400[v0]); - v2->unk_00 = param0->unk_390[7]; - v2->unk_04 = param0->unk_390[v0]; - v2->unk_08 = FX32_ONE * Unk_020F2984[v0][0]; - v2->unk_0C = v0; - } - - for (v0 = 0; v0 < param0->unk_0C; v0++) { - v1.position.x = FX32_ONE * ((10 * 8) + v0 * 12); - v1.position.y = FX32_ONE * (4 * 8 + 7); - - param0->unk_3C8[v0] = SpriteList_AddAffine(&v1); - - Sprite_SetAnimateFlag(param0->unk_3C8[v0], 1); - Sprite_SetAnim(param0->unk_3C8[v0], 43); - } - - sub_02088E1C(param0->unk_3C8, param0->unk_158, param0->unk_0C); - sub_02087BE4(param0, &v1); - } - - GXLayers_EngineAToggleLayers(GX_PLANEMASK_OBJ, 1); - GXLayers_EngineBToggleLayers(GX_PLANEMASK_OBJ, 1); -} - -static void sub_02087BE4(UnkStruct_02087A10 *param0, AffineSpriteListTemplate *param1) -{ - param1->position.x = FX32_ONE * 24; - param1->position.y = FX32_ONE * (16 - 8); - param0->unk_3F8[0] = SpriteList_AddAffine(param1); - - Sprite_SetAnimateFlag(param0->unk_3F8[0], 1); - - switch (param0->unk_00) { - case 0: - if (param0->unk_04 == 0) { - Sprite_SetAnim(param0->unk_3F8[0], 48); - } else { - Sprite_SetAnim(param0->unk_3F8[0], 49); - } - break; - case 3: - Sprite_SetAnim(param0->unk_3F8[0], 51); - break; - case 6: - Sprite_SetAnim(param0->unk_3F8[0], 55); - break; - case 5: - Sprite_SetAnim(param0->unk_3F8[0], 54); - break; - case 4: - case 7: - Sprite_SetAnim(param0->unk_3F8[0], 53); - break; - case 2: - Sprite_SetAnim(param0->unk_3F8[0], 47); - break; - case 1: - Sprite_SetAnim(param0->unk_3F8[0], 50); - - if (param0->unk_10 != 2) { - param1->position.x = FX32_ONE * ((10 * 8) + param0->unk_0C * 13); - param1->position.y = FX32_ONE * ((4 * 8 + 7) - 12); - param0->unk_3F8[1] = SpriteList_AddAffine(param1); - - if (param0->unk_10 == 0) { - Sprite_SetAnim(param0->unk_3F8[1], 45); - } else { - Sprite_SetAnim(param0->unk_3F8[1], 46); - } - } - break; - } -} - -static void sub_02087CDC(SysTask *param0, void *param1) -{ - UnkStruct_02087CDC *v0 = (UnkStruct_02087CDC *)param1; - VecFx32 v1; - - v1.y = v0->unk_0C; - v1.z = 0; - - switch (v0->unk_04) { - case 0: - v1.x = v0->unk_08 + 4 * FX32_ONE; - Sprite_SetPosition(v0->unk_00, &v1); - break; - case 2: - v1.x = v0->unk_08 - 3 * FX32_ONE; - Sprite_SetPosition(v0->unk_00, &v1); - break; - case 4: - v1.x = v0->unk_08 + 2 * FX32_ONE; - Sprite_SetPosition(v0->unk_00, &v1); - break; - case 6: - v1.x = v0->unk_08; - Sprite_SetPosition(v0->unk_00, &v1); - SysTask_FinishAndFreeParam(param0); - break; - } - - v0->unk_04++; -} - -static void sub_02087D64(BgConfig *param0, Window *param1, int *param2, int param3, int *param4, VecFx32 param5[], Sprite **param6, void *param7) -{ - int v0 = *param4; - int v1 = v0 ^ 1; - int v2; - - switch (*param2) { - case 0: { - u16 v3 = Unk_020F24DC[param3] | (Unk_020F24DC[param3] << 4); - - Graphics_LoadTilemapToBgLayer(NARC_INDEX_DATA__NAMEIN, 6 + param3, param0, 0 + v0, 0, 32 * 14 * 2, 1, HEAP_ID_18); - sub_02088260(param5, v0); - sub_02088E58(¶m1[v0], v3, param3, TEXT_COLOR(14, 15, 0), param7); - (*param2)++; - } break; - case 1: - Bg_SetOffset(param0, BG_LAYER_MAIN_0 + v0, 0, 238); - Bg_SetOffset(param0, BG_LAYER_MAIN_0 + v0, 3, -80); - (*param2)++; - break; - case 2: - param5[v0].x -= 24; - - if (param5[v0].x < -11 + 10) { - UnkStruct_02087CDC *v4; - SysTask *v5; - - v5 = SysTask_StartAndAllocateParam(sub_02087CDC, 16, 0, 18); - v4 = SysTask_GetParam(v5); - v4->unk_00 = param6[7]; - v4->unk_04 = 0; - v4->unk_08 = Sprite_GetPosition(param6[7])->x; - v4->unk_0C = Sprite_GetPosition(param6[7])->y; - - param5[v0].x = -11; - (*param2)++; - } - - param5[v1].y -= 10; - - if (param5[v1].y < -196) { - param5[v1].y = -196; - } - - Bg_SetOffset(param0, BG_LAYER_MAIN_0 + v0, 0, param5[v0].x); - Bg_SetOffset(param0, BG_LAYER_MAIN_0 + v1, 3, param5[v1].y); - break; - case 3: - param5[v1].y -= 10; - - if (param5[v1].y < -196) { - param5[v1].y = -196; - } - - Bg_SetOffset(param0, BG_LAYER_MAIN_0 + v0, 0, param5[v0].x); - Bg_SetOffset(param0, BG_LAYER_MAIN_0 + v1, 3, param5[v1].y); - - if ((param5[v0].x == -11) && (param5[v1].y == -196)) { - (*param2)++; - (*param4) ^= 1; - sub_02088240(param0, *param4, param5); - Sound_PlayEffect(SEQ_SE_DP_NAMEIN_01); - } - break; - case 4: - break; - } -} - -static void sub_02087F48(Window *param0, int param1, Strbuf *param2) -{ - Window_DrawMessageBoxWithScrollCursor(param0, 0, 32 * 8, 10); - Text_AddPrinterWithParams(param0, FONT_MESSAGE, param2, 0, 0, TEXT_SPEED_INSTANT, NULL); - Window_CopyToVRAM(param0); -} - -static void sub_02087F78(Window *param0, int param1, Strbuf *param2) -{ - int v0 = 16; - int v1 = Font_CalcStrbufWidth(FONT_SYSTEM, param2, 0); - - if (v1 > 130) { - v0 = 0; - } - - Window_FillTilemap(param0, 0x101); - Text_AddPrinterWithParamsAndColor(param0, FONT_SYSTEM, param2, v0, 0, TEXT_SPEED_INSTANT, TEXT_COLOR(14, 15, 1), NULL); - Window_CopyToVRAM(param0); -} - -static void sub_02087FC0(UnkStruct_02087A10 *param0, ApplicationManager *appMan, NARC *param2) -{ - Window_Add(param0->unk_160, ¶m0->unk_41C[0], 0, 2, 1, 26, 12, 1, 32 * 8); - Window_Add(param0->unk_160, ¶m0->unk_41C[1], 1, 2, 1, 26, 12, 1, (32 * 8) + (26 * 12)); - - if (param0->unk_00 == 4) { - Graphics_LoadTilemapToBgLayerFromOpenNARC(param2, 6 + 3, param0->unk_160, 1, 0, 32 * 14 * 2, 1, HEAP_ID_18); - param0->unk_4C4 = 4; - sub_02088844(param0->unk_3A, 4); - sub_02088E58(¶m0->unk_41C[1], 0xa0a, 4, TEXT_COLOR(14, 15, 0), param0->unk_514->pRawData); - } else { - param0->unk_4C4 = 0; - sub_02088844(param0->unk_3A, 0); - sub_02088E58(¶m0->unk_41C[1], 0x404, 0, TEXT_COLOR(14, 15, 0), param0->unk_514->pRawData); - } - - Window_Add(param0->unk_160, ¶m0->unk_41C[2], 2, 7, 2, 22, 2, 0, ((32 * 8) + (26 * 12)) + (26 * 12)); - - { - int v0 = ((param0->unk_0C * 12) / 8) + 1; - - Window_Add(param0->unk_160, ¶m0->unk_41C[3], 2, 10, 3, v0, 2, 0, (((32 * 8) + (26 * 12)) + (26 * 12)) + 44); - Window_FillTilemap(¶m0->unk_41C[3], 0x101); - Window_Add(param0->unk_160, ¶m0->unk_41C[8], 2, 10 + v0 - 1, 3, 7, 2, 0, ((((32 * 8) + (26 * 12)) + (26 * 12)) + 44) + 36); - Window_FillTilemap(¶m0->unk_41C[8], 0x101); - } - - if (param0->unk_00 == 5) { - sub_02087F78(¶m0->unk_41C[8], param0->unk_00, param0->unk_184); - Window_CopyToVRAM(¶m0->unk_41C[8]); - } - - Window_Add(param0->unk_160, ¶m0->unk_41C[9], 4, 2, 19, 27, 4, 12, 120 + (2 * 2 * 3)); - Window_FillTilemap(¶m0->unk_41C[9], 0xf0f); - sub_02087F48(¶m0->unk_41C[9], param0->unk_00, param0->unk_178); - - { - UnkStruct_0208737C *v1 = (UnkStruct_0208737C *)ApplicationManager_Args(appMan); - - if (param0->unk_118[0] != 0xffff) { - CharCode_Copy(param0->unk_D8, param0->unk_118); - sub_02088554(¶m0->unk_41C[3], param0->unk_D8, 0, 0, 12, TEXT_SPEED_INSTANT, TEXT_COLOR(14, 15, 1), NULL); - } - } - - { - int v2; - - for (v2 = 0; v2 < 3; v2++) { - Window_Add(param0->unk_160, ¶m0->unk_41C[4 + v2], 2, 0, 0, 2, 2, 0, 120); - Window_FillTilemap(¶m0->unk_41C[4 + v2], 0); - } - - Window_Add(param0->unk_160, ¶m0->unk_41C[7], 2, 0, 0, 16, 2, 0, 120 + (2 * 2 * 3)); - Window_FillTilemap(¶m0->unk_41C[7], 0); - } -} - -static void sub_02088240(BgConfig *param0, int param1, VecFx32 param2[]) -{ - Bg_SetPriority(BG_LAYER_MAIN_0 + param1, 1); - Bg_SetPriority(BG_LAYER_MAIN_0 + param1 ^ 1, 2); -} - -static void sub_02088260(VecFx32 param0[], int param1) -{ - param0[param1].x = 238; - param0[param1].y = -80; - param0[param1 ^ 1].x = -11; - param0[param1 ^ 1].y = -80; -} - -static const int Unk_020F2904[][2] = { - { 0x0, 0x0 }, - { 0x0, 0xFFFFFFFFFFFFFFFF }, - { 0x0, 0x1 }, - { 0xFFFFFFFFFFFFFFFF, 0x0 }, - { 0x1, 0x0 } -}; - -static int sub_02088288(int param0, int param1, int param2) -{ - if (param0 >= param2) { - param0 = param1; - } - - if (param0 < param1) { - param0 = param2 - 1; - } - - return param0; -} - -static void sub_02088298(UnkStruct_02087A10 *param0, int param1) -{ - int v0, v1; - u16 v2; - - if (param1 == 0) { - return; - } - - v2 = param0->unk_3A[param0->unk_1C.unk_04][param0->unk_1C.unk_00]; - v0 = sub_02088288(param0->unk_1C.unk_00 + Unk_020F2904[param1][0], 0, 13); - v1 = sub_02088288(param0->unk_1C.unk_04 + Unk_020F2904[param1][1], 0, 6); - - while (param0->unk_3A[v1][v0] == (0xd001 + 3) || (param0->unk_3A[v1][v0] == v2 && param0->unk_3A[v1][v0] > 0xe001)) { - if ((param0->unk_1C.unk_0C == 0) && (param0->unk_3A[v1][v0] == (0xd001 + 3)) && (Unk_020F2904[param1][1] != 0)) { - v0 += param0->unk_1C.unk_10; - v0 = sub_02088288(v0, 0, 13); - } else { - v0 += Unk_020F2904[param1][0]; - v0 = sub_02088288(v0, 0, 13); - v1 += Unk_020F2904[param1][1]; - v1 = sub_02088288(v1, 0, 6); - } - } - - param0->unk_1C.unk_00 = v0; - param0->unk_1C.unk_04 = v1; -} - -static void sub_02088350(UnkStruct_02087A10 *param0) -{ - int v0 = 0; - int v1 = 0; - BOOL v2 = 0; - - if (Sprite_GetDrawFlag(param0->unk_390[8]) == 0) { - v2 = 1; - } - - if (gSystem.pressedKeysRepeatable & PAD_KEY_UP) { - Sound_PlayEffect(SEQ_SE_CONFIRM); - Sprite_SetDrawFlag(param0->unk_390[8], TRUE); - v1 = 1; - v0++; - } - - if (gSystem.pressedKeysRepeatable & PAD_KEY_DOWN) { - Sound_PlayEffect(SEQ_SE_CONFIRM); - Sprite_SetDrawFlag(param0->unk_390[8], TRUE); - v1 = 2; - v0++; - } - - if (gSystem.pressedKeysRepeatable & PAD_KEY_LEFT) { - Sound_PlayEffect(SEQ_SE_CONFIRM); - Sprite_SetDrawFlag(param0->unk_390[8], TRUE); - v1 = 3; - v0++; - } - - if (gSystem.pressedKeysRepeatable & PAD_KEY_RIGHT) { - Sound_PlayEffect(SEQ_SE_CONFIRM); - Sprite_SetDrawFlag(param0->unk_390[8], TRUE); - v1 = 4; - v0++; - } - - if (gSystem.pressedKeys & PAD_BUTTON_START) { - Sound_PlayEffect(SEQ_SE_CONFIRM); - Sprite_SetDrawFlag(param0->unk_390[8], TRUE); - param0->unk_1C.unk_00 = 12; - param0->unk_1C.unk_04 = 0; - v0++; - } - - { - if ((param0->unk_62C = sub_0208903C(param0)) == 1) { - v1 = 0; - v0++; - } - } - - if (v2 == 1) { - v0 = 0; - sub_02088454(param0, v1); - } - - if (v0) { - sub_02088298(param0, v1); - sub_02088454(param0, v1); - } -} - -static void sub_02088454(UnkStruct_02087A10 *param0, int param1) -{ - if (param0->unk_1C.unk_04 != 0) { - VecFx32 v0; - - if ((param0->unk_1C.unk_0C == 0) && (param0->unk_1C.unk_0C != param0->unk_1C.unk_04)) { - Sprite_SetAnim(param0->unk_390[8], 39); - } - - v0.x = FX32_ONE * (26 + param0->unk_1C.unk_00 * 16); - v0.y = FX32_ONE * ((111 - 20) + (param0->unk_1C.unk_04 - 1) * 19); - Sprite_SetPosition(param0->unk_390[8], &v0); - } else { - VecFx32 v1; - int v2 = param0->unk_3A[param0->unk_1C.unk_04][param0->unk_1C.unk_00] - (0xe001 + 1); - - v1.x = FX32_ONE * Unk_020F251C[v2]; - v1.y = FX32_ONE * (88 - 20); - - Sprite_SetAnim(param0->unk_390[8], Unk_020F24E8[v2]); - Sprite_SetPosition(param0->unk_390[8], &v1); - } - - param0->unk_38 = 180; - - Sprite_SetAnimFrame(param0->unk_390[8], 0); - - param0->unk_1C.unk_08 = param0->unk_1C.unk_00; - param0->unk_1C.unk_0C = param0->unk_1C.unk_04; - - if (Unk_020F2904[param1][0] != 0) { - param0->unk_1C.unk_10 = Unk_020F2904[param1][0]; - } -} - -static void sub_02088514(u16 *param0) -{ - fx32 v0; - GXRgb v1; - int v2, v3, v4; - - *param0 += 20; - - if (*param0 > 360) { - *param0 = 0; - } - - v0 = CalcSineDegrees_Wraparound(*param0); - v3 = 15 + (v0 * 10) / FX32_ONE; - v1 = GX_RGB(29, v3, 0); - - GX_LoadOBJPltt((u16 *)&v1, (16 + 13) * 2, 2); -} - -static void sub_02088554(Window *param0, const u16 *param1, int param2, int param3, int param4, int param5, TextColor param6, u8 *param7) -{ - int v0 = 0, v1, v2; - u16 v3[2]; - Strbuf *v4 = Strbuf_Init(2, HEAP_ID_18); - - while (param1[v0] != 0xffff) { - if ((param1[v0] == 0xd001) || (param1[v0] == (0xd001 + 1)) || (param1[v0] == (0xd001 + 2))) { - u16 v5 = param1[v0] - 0xd001; - Window_BlitBitmapRect(param0, (void *)¶m7[v5 * 8 * 8 * 4 / 2], 0, 0, 12, 12, param2 + v0 * param4, param3 + 2, 12, 12); - } else { - if (param1[v0] == (0xd001 + 3)) { - v0++; - continue; - } - - v3[0] = param1[v0]; - v3[1] = 0xffff; - - v1 = Font_CalcStringWidth(FONT_SYSTEM, v3, 0); - v2 = param2 + v0 * param4 + ((param4 - v1) / 2); - - Strbuf_CopyChars(v4, v3); - Text_AddPrinterWithParamsAndColor(param0, FONT_SYSTEM, v4, v2, param3, param5, param6, NULL); - } - - v0++; - } - - Strbuf_Free(v4); -} - -static const u8 Unk_020F24D8[] = { - 0x60, - 0x68, - 0x50, - 0x58 -}; - -static void *sub_02088654(Window *param0, Strbuf *param1, u8 param2, const TextColor param3) -{ - Text_AddPrinterWithParamsAndColor(param0, param2, param1, 0, 0, TEXT_SPEED_NO_TRANSFER, param3, NULL); - return param0->pixels; -} - -static void sub_02088678(Window *param0, const u16 *param1, u8 *param2, Strbuf *param3) -{ - u16 v0[20 + 1], v1, v2; - void *v3; - Strbuf *v4; - - Window_FillTilemap(¶m0[3], 0); - v3 = sub_02088654(¶m0[3], param3, FONT_SUBSCREEN, TEXT_COLOR(13, 14, 15)); - DC_FlushRange(v3, 0x20 * 4 * 16); - - for (v1 = 0; v1 < 4; v1++) { - sub_02012C60(¶m0[3], 4, 2, 4 * v1, 0, (char *)param2); - DC_FlushRange(param2, 0x20 * 4 * 2); - GXS_LoadOBJ(param2, Unk_020F24D8[v1] * 0x20, 0x20 * 4 * 2); - } - - v4 = Strbuf_Init(20 + 1, HEAP_ID_18); - - for (v1 = 0; v1 < 3; v1++) { - v0[0] = param1[v1]; - v0[1] = 0xffff; - - Window_FillTilemap(¶m0[v1], 0); - Strbuf_CopyChars(v4, v0); - - v3 = sub_02088654(¶m0[v1], v4, FONT_SUBSCREEN, TEXT_COLOR(13, 14, 15)); - - DC_FlushRange(v3, 0x20 * 4); - GXS_LoadOBJ(v3, Unk_020F24F0[v1] * 0x20, 0x20 * 4); - } - - Strbuf_Free(v4); -} - -static void sub_02088754(Window *param0, u16 *param1, int param2, u16 *param3, u8 *param4, Strbuf *param5) -{ - int v0, v1; - const u16 *v2 = NULL; - u16 v3; - - if (param2 == 0) { - v3 = (0xd001 + 2); - } else { - v3 = param1[param2 - 1]; - } - - switch (v3) { - case 0xd001: - case (0xd001 + 1): - case (0xd001 + 2): - case (0xd001 + 3): - case (0xe001 + 1): - case (0xe001 + 2): - case (0xe001 + 3): - case (0xe001 + 4): - case (0xe001 + 5): - case (0xe001 + 6): - case (0xe001 + 7): - v3 = 0x1; - break; - } - - for (v0 = 0; v0 < 3; v0++) { - param3[v0] = 0x1; - } - - param3[0] = v3; - - if (v3 != 0x1) { - for (v0 = 0; v0 < sizeof(Unk_020F2BBE) / (3 * 2); v0++) { - if (Unk_020F2BBE[v0][0] == v3) { - for (v1 = 0; v1 < 3; v1++) { - param3[v1] = Unk_020F2BBE[v0][v1]; - } - break; - } - - if (Unk_020F2BBE[v0][2] == v3) { - for (v1 = 0; v1 < 3; v1++) { - param3[v1] = Unk_020F2BBE[v0][v1]; - } - break; - } - } - } - - sub_02088678(param0, param3, param4, param5); -} - -static void sub_02088844(u16 param0[][13], const int param1) -{ - int v0, v1; - - for (v0 = 0; v0 < 13; v0++) { - param0[0][v0] = Unk_02100C40[param1][v0]; - } - - for (v1 = 0; v1 < 6 - 1; v1++) { - for (v0 = 0; v0 < 13; v0++) { - param0[1 + v1][v0] = Unk_02100C54[param1][v1][v0]; - } - } -} - -static int sub_02088898(UnkStruct_02087A10 *param0, u16 param1, int param2) -{ - if ((param1 == (0xd001 + 2)) || (param1 == (0xd001 + 3))) { - param1 = 0x1; - } - - if (param0->unk_00 == 4) { - if ((param1 == (0xe001 + 1)) || (param1 == (0xe001 + 2)) || (param1 == (0xe001 + 3)) || (param1 == (0xe001 + 4))) { - param1 = 0x1; - } - } - - if ((Sprite_GetDrawFlag(param0->unk_390[8]) == 0) && (gSystem.touchPressed == 0)) { - Sprite_SetDrawFlag(param0->unk_390[8], TRUE); - return 2; - } - - switch (param1) { - case 0xd001: - if (sub_02088D08(42, 42 + 40, 1, 0xd001, param0->unk_D8, param0->unk_158)) { - Window_FillTilemap(¶m0->unk_41C[3], 0x101); - sub_02088554(¶m0->unk_41C[3], param0->unk_D8, 0, 0, 12, TEXT_SPEED_INSTANT, TEXT_COLOR(14, 15, 1), NULL); - Sound_PlayEffect(SEQ_SE_DP_BOX02); - } - break; - case (0xd001 + 1): - if (sub_02088D08(72, 72 + 10, 2, 0xd001 + 1, param0->unk_D8, param0->unk_158)) { - Window_FillTilemap(¶m0->unk_41C[3], 0x101); - sub_02088554(¶m0->unk_41C[3], param0->unk_D8, 0, 0, 12, TEXT_SPEED_INSTANT, TEXT_COLOR(14, 15, 1), NULL); - Sound_PlayEffect(SEQ_SE_DP_BOX02); - } - break; - case (0xe001 + 5): - if (sub_02088C9C(0, 72 + 10, param0->unk_D8, param0->unk_158)) { - Window_FillTilemap(¶m0->unk_41C[3], 0x101); - sub_02088554(¶m0->unk_41C[3], param0->unk_D8, 0, 0, 12, TEXT_SPEED_INSTANT, TEXT_COLOR(14, 15, 1), NULL); - param0->unk_4F4[4]++; - Sound_PlayEffect(SEQ_SE_DP_BOX02); - } - break; - case (0xe001 + 1): - case (0xe001 + 2): - case (0xe001 + 3): - case (0xe001 + 4): - if (param0->unk_4C4 != param1 - (0xe001 + 1)) { - param0->unk_4C0 = 0; - param0->unk_4C4 = param1 - (0xe001 + 1); - sub_02088844(param0->unk_3A, param0->unk_4C4); - param0->unk_4F4[param1 - (0xe001 + 1)]++; - Sound_PlayEffect(SEQ_SE_DP_SYU03); - Sprite_SetDrawFlag(param0->unk_390[8], param2); - } - break; - case (0xe001 + 6): - if (param0->unk_158 != 0) { - param0->unk_D8[param0->unk_158 - 1] = 0xffff; - param0->unk_158--; - - Window_FillTilemap(¶m0->unk_41C[3], 0x101); - - if (param0->unk_158 == 0) { - Window_CopyToVRAM(¶m0->unk_41C[3]); - } else { - sub_02088554(¶m0->unk_41C[3], param0->unk_D8, 0, 0, 12, TEXT_SPEED_INSTANT, TEXT_COLOR(14, 15, 1), NULL); - } - - sub_02088754(¶m0->unk_41C[4], param0->unk_D8, param0->unk_158, param0->unk_15A, param0->unk_528, param0->unk_17C); - sub_02088E1C(param0->unk_3C8, param0->unk_158, param0->unk_0C); - - param0->unk_4F4[5]++; - - Sound_PlayEffect(SEQ_SE_CONFIRM); - Sprite_SetDrawFlag(param0->unk_390[8], param2); - } - break; - case (0xe001 + 7): - sub_02015760(param0->unk_628); - Sprite_SetDrawFlag(param0->unk_390[8], param2); - - if (param0->unk_14 == 0) { - Sound_PlayEffect(SEQ_SE_DP_PIRORIRO); - param0->unk_4F4[6]++; - StartScreenFade(FADE_SUB_THEN_MAIN, FADE_TYPE_BRIGHTNESS_OUT, FADE_TYPE_BRIGHTNESS_OUT, COLOR_BLACK, 16, 1, HEAP_ID_18); - return 3; - } else { - param0->unk_4C0 = 5; - } - break; - default: - if ((param0->unk_4C4 == 4) && (param1 == 0x1)) { - return 2; - } - - if (param0->unk_158 != param0->unk_0C) { - param0->unk_D8[param0->unk_158] = param1; - - Window_FillTilemap(¶m0->unk_41C[3], 0x101); - sub_02088554(¶m0->unk_41C[3], param0->unk_D8, 0, 0, 12, TEXT_SPEED_INSTANT, TEXT_COLOR(14, 15, 1), NULL); - - param0->unk_158++; - - sub_02088E1C(param0->unk_3C8, param0->unk_158, param0->unk_0C); - Sound_PlayEffect(SEQ_SE_DP_BOX02); - Sprite_SetDrawFlag(param0->unk_390[8], TRUE); - Sprite_SetExplicitOAMMode(param0->unk_390[8], GX_OAM_MODE_XLU); - - G2_SetBlendAlpha(0, GX_BLEND_PLANEMASK_BG0 | GX_BLEND_PLANEMASK_BG1 | GX_BLEND_PLANEMASK_BG2, 8, 8); - Sprite_SetAnim(param0->unk_390[8], 60); - - param0->unk_1C.unk_18 = 1; - - sub_02088754(¶m0->unk_41C[4], param0->unk_D8, param0->unk_158, param0->unk_15A, param0->unk_528, param0->unk_17C); - } - } - - return 2; -} - -static u16 sub_02088C7C(const u16 *param0, int param1) -{ - do { - param1 = sub_02088288(++param1, 0, 3); - } while (param0[param1] == 0x1); - - return param0[param1]; -} - -static int sub_02088C9C(int param0, int param1, u16 *param2, int param3) -{ - int v0, v1; - u16 v2, v3; - - if (param3 == 0) { - return 0; - } - - v2 = param2[param3 - 1]; - - for (v0 = param0; v0 < param1; v0++) { - for (v1 = 0; v1 < 3; v1++) { - if ((Unk_020F2BBE[v0][v1] == v2) && (v2 != 0x1)) { - param2[param3 - 1] = sub_02088C7C(Unk_020F2BBE[v0], v1); - return 1; - } - } - } - - return 0; -} - -static int sub_02088D08(int param0, int param1, int param2, int param3, u16 *param4, int param5) -{ - int v0; - u16 v1; - - if ((param5 == 0) || (param4[param5 - 1] == 0x1)) { - return 0; - } - - v1 = param4[param5 - 1]; - - for (v0 = param0; v0 < param1; v0++) { - if (Unk_020F2BBE[v0][0] == v1) { - param4[param5 - 1] = Unk_020F2BBE[v0][param2]; - return 1; - } - } - - for (v0 = param0; v0 < param1; v0++) { - if (Unk_020F2BBE[v0][param2] == v1) { - param4[param5 - 1] = Unk_020F2BBE[v0][0]; - return 1; - } - } - - switch (param3) { - case 0xd001: - for (v0 = 0; v0 < NELEMS(Unk_020F2954); v0++) { - if (Unk_020F2954[v0][0] == v1) { - param4[param5 - 1] = Unk_020F2954[v0][1]; - return 1; - } - } - break; - case (0xd001 + 1): - for (v0 = 0; v0 < NELEMS(Unk_020F292C); v0++) { - if (Unk_020F292C[v0][0] == v1) { - param4[param5 - 1] = Unk_020F292C[v0][1]; - return 1; - } - } - break; - case (0xe001 + 5): - if (v1 == 0x26) { - param4[param5 - 1] = 0x24; - return 1; - } - - if (v1 == 0x76) { - param4[param5 - 1] = 0x74; - return 1; - } - break; - } - - return 0; -} - -static void sub_02088E1C(Sprite **param0, int param1, int param2) -{ - int v0; - - for (v0 = 0; v0 < param2; v0++) { - Sprite_SetAnim(param0[v0], 43); - } - - if (param1 != param2) { - Sprite_SetAnim(param0[param1], 44); - } -} - -static const u8 Unk_020F24E0[] = { - 0x3, - 0x6, - 0xC, - 0x9, - 0x9 -}; - -static void sub_02088E58(Window *param0, u16 param1, int param2, TextColor param3, u8 *param4) -{ - int v0, v1, v2; - - Window_FillTilemap(param0, param1); - - for (v0 = 0; v0 < 6; v0++) { - Window_FillRectWithColor(param0, Unk_020F24E0[param2], 16 + 32 * v0, 0, 16, 19); - Window_FillRectWithColor(param0, Unk_020F24E0[param2], 16 + 32 * v0, 19 * 2, 16, 19); - Window_FillRectWithColor(param0, Unk_020F24E0[param2], 16 + 32 * v0, 19 * 4, 16, 19); - } - - for (v0 = 0; v0 < 7; v0++) { - Window_FillRectWithColor(param0, Unk_020F24E0[param2], 32 * v0, 19, 16, 19); - Window_FillRectWithColor(param0, Unk_020F24E0[param2], 32 * v0, 19 * 3, 16, 19); - } - - for (v0 = 0; v0 < 5; v0++) { - sub_02088554(param0, Unk_02100C54[param2][v0], 0, v0 * 19 + 4, 16, TEXT_SPEED_NO_TRANSFER, param3, param4); - } - - Window_CopyToVRAM(param0); -} - -static void sub_02088F40(int param0[], Sprite **param1, int param2) -{ - int v0, v1; - - for (v0 = 0; v0 < 3; v0++) { - if (param0[v0]) { - for (v1 = 0; v1 < 3; v1++) { - Sprite_SetAnim(param1[v1], Unk_020F2984[v1][2]); - } - - Sprite_SetAnim(param1[v0], Unk_020F2984[v0][2] - 3); - break; - } - } - - for (v0 = 5; v0 < 7; v0++) { - if (param0[v0]) { - Sprite_SetAnim(param1[v0], Unk_020F2984[v0][2] + 1); - } - } - - for (v0 = 0; v0 < 7; v0++) { - param0[v0] = 0; - } -} - -static void sub_02088FD0(UnkStruct_02087A10 *param0) -{ - if (!Sprite_IsAnimated(param0->unk_390[8])) { - if (param0->unk_158 == param0->unk_0C) { - param0->unk_1C.unk_00 = 12; - param0->unk_1C.unk_04 = 0; - Sprite_SetAnim(param0->unk_390[8], 39); - } else { - Sprite_SetAnim(param0->unk_390[8], 39); - } - - if (param0->unk_1C.unk_14 == 0) { - Sprite_SetDrawFlag(param0->unk_390[8], FALSE); - } else { - sub_02088454(param0, 0); - } - - param0->unk_1C.unk_18 = 0; - - Sprite_SetExplicitOAMMode(param0->unk_390[8], GX_OAM_MODE_NORMAL); - } -} - -static const UnkStruct_020F2A14 Unk_020F2A14[] = { - { 0x19, 0x3C, 0x0, 0x0, 0x0 }, - { 0x39, 0x3C, 0x0, 0x2, 0x0 }, - { 0x59, 0x3C, 0x0, 0x4, 0x0 }, - { 0x0, 0xC0, 0x0, 0x4, 0x0 }, - { 0x9D, 0x3C, 0x1, 0x8, 0x0 }, - { 0xC5, 0x3C, 0x1, 0xB, 0x0 }, - { 0x1C, 0x58, 0x2, 0x0, 0x1 }, - { 0x2C, 0x58, 0x2, 0x1, 0x1 }, - { 0x3C, 0x58, 0x2, 0x2, 0x1 }, - { 0x4C, 0x58, 0x2, 0x3, 0x1 }, - { 0x5C, 0x58, 0x2, 0x4, 0x1 }, - { 0x6C, 0x58, 0x2, 0x5, 0x1 }, - { 0x7C, 0x58, 0x2, 0x6, 0x1 }, - { 0x8C, 0x58, 0x2, 0x7, 0x1 }, - { 0x9C, 0x58, 0x2, 0x8, 0x1 }, - { 0xAC, 0x58, 0x2, 0x9, 0x1 }, - { 0xBC, 0x58, 0x2, 0xA, 0x1 }, - { 0xCC, 0x58, 0x2, 0xB, 0x1 }, - { 0xDC, 0x58, 0x2, 0xC, 0x1 }, - { 0x1C, 0x6B, 0x2, 0x0, 0x2 }, - { 0x2C, 0x6B, 0x2, 0x1, 0x2 }, - { 0x3C, 0x6B, 0x2, 0x2, 0x2 }, - { 0x4C, 0x6B, 0x2, 0x3, 0x2 }, - { 0x5C, 0x6B, 0x2, 0x4, 0x2 }, - { 0x6C, 0x6B, 0x2, 0x5, 0x2 }, - { 0x7C, 0x6B, 0x2, 0x6, 0x2 }, - { 0x8C, 0x6B, 0x2, 0x7, 0x2 }, - { 0x9C, 0x6B, 0x2, 0x8, 0x2 }, - { 0xAC, 0x6B, 0x2, 0x9, 0x2 }, - { 0xBC, 0x6B, 0x2, 0xA, 0x2 }, - { 0xCC, 0x6B, 0x2, 0xB, 0x2 }, - { 0xDC, 0x6B, 0x2, 0xC, 0x2 }, - { 0x1C, 0x7E, 0x2, 0x0, 0x3 }, - { 0x2C, 0x7E, 0x2, 0x1, 0x3 }, - { 0x3C, 0x7E, 0x2, 0x2, 0x3 }, - { 0x4C, 0x7E, 0x2, 0x3, 0x3 }, - { 0x5C, 0x7E, 0x2, 0x4, 0x3 }, - { 0x6C, 0x7E, 0x2, 0x5, 0x3 }, - { 0x7C, 0x7E, 0x2, 0x6, 0x3 }, - { 0x8C, 0x7E, 0x2, 0x7, 0x3 }, - { 0x9C, 0x7E, 0x2, 0x8, 0x3 }, - { 0xAC, 0x7E, 0x2, 0x9, 0x3 }, - { 0xBC, 0x7E, 0x2, 0xA, 0x3 }, - { 0xCC, 0x7E, 0x2, 0xB, 0x3 }, - { 0xDC, 0x7E, 0x2, 0xC, 0x3 }, - { 0x1C, 0x91, 0x2, 0x0, 0x4 }, - { 0x2C, 0x91, 0x2, 0x1, 0x4 }, - { 0x3C, 0x91, 0x2, 0x2, 0x4 }, - { 0x4C, 0x91, 0x2, 0x3, 0x4 }, - { 0x5C, 0x91, 0x2, 0x4, 0x4 }, - { 0x6C, 0x91, 0x2, 0x5, 0x4 }, - { 0x7C, 0x91, 0x2, 0x6, 0x4 }, - { 0x8C, 0x91, 0x2, 0x7, 0x4 }, - { 0x9C, 0x91, 0x2, 0x8, 0x4 }, - { 0xAC, 0x91, 0x2, 0x9, 0x4 }, - { 0xBC, 0x91, 0x2, 0xA, 0x4 }, - { 0xCC, 0x91, 0x2, 0xB, 0x4 }, - { 0xDC, 0x91, 0x2, 0xC, 0x4 }, - { 0x1C, 0xA4, 0x2, 0x0, 0x5 }, - { 0x2C, 0xA4, 0x2, 0x1, 0x5 }, - { 0x3C, 0xA4, 0x2, 0x2, 0x5 }, - { 0x4C, 0xA4, 0x2, 0x3, 0x5 }, - { 0x5C, 0xA4, 0x2, 0x4, 0x5 }, - { 0x6C, 0xA4, 0x2, 0x5, 0x5 }, - { 0x7C, 0xA4, 0x2, 0x6, 0x5 }, - { 0x8C, 0xA4, 0x2, 0x7, 0x5 }, - { 0x9C, 0xA4, 0x2, 0x8, 0x5 }, - { 0xAC, 0xA4, 0x2, 0x9, 0x5 }, - { 0xBC, 0xA4, 0x2, 0xA, 0x5 }, - { 0xCC, 0xA4, 0x2, 0xB, 0x5 }, - { 0xDC, 0xA4, 0x2, 0xC, 0x5 } -}; - -static BOOL sub_0208903C(UnkStruct_02087A10 *param0) -{ - int v0, v1 = 0; - u8 v2, v3, v4, v5, v6, v7; - - if (param0->unk_00 == 4) { - v1 = 4; - } - - if (gSystem.touchPressed) { - v2 = gSystem.touchX; - v3 = gSystem.touchY; - - for (v0 = v1; v0 < (NELEMS(Unk_020F2A14)); v0++) { - v4 = Unk_020F2A14[v0].unk_00; - v5 = Unk_020F2A14[v0].unk_01; - - switch (Unk_020F2A14[v0].unk_02_0) { - case 0: - v6 = 32 - 1; - v7 = 22; - break; - case 1: - v6 = 32; - v7 = 22; - break; - case 2: - v6 = 16; - v7 = 19; - break; - } - - if ((v2 >= v4) && (v3 >= v5) && (v2 <= (v4 + v6)) && (v3 <= (v5 + v7))) { - param0->unk_1C.unk_00 = Unk_020F2A14[v0].unk_04_0; - param0->unk_1C.unk_04 = Unk_020F2A14[v0].unk_05_0; - return 1; - } - } - } - - return 0; -} diff --git a/src/unk_02098218.c b/src/unk_02098218.c index 388a5edbcb..97f466b253 100644 --- a/src/unk_02098218.c +++ b/src/unk_02098218.c @@ -9,6 +9,7 @@ #include "struct_defs/struct_0203E2FC.h" #include "struct_defs/struct_0209843C.h" +#include "applications/naming_screen.h" #include "field/field_system.h" #include "overlay005/daycare.h" #include "overlay119/ov119_021D0D80.h" @@ -37,11 +38,9 @@ #include "trainer_info.h" #include "unk_02015F84.h" #include "unk_0202F180.h" -#include "unk_0208694C.h" #include "unk_02092494.h" #include "vram_transfer.h" -#include "constdata/const_020F2DAC.h" #include "constdata/const_020F67FC.h" FS_EXTERN_OVERLAY(overlay119); @@ -236,10 +235,10 @@ static BOOL sub_0209843C(FieldTask *param0) v9 = Pokemon_GetValue(v0->unk_0C.unk_00, MON_DATA_SPECIES, 0); - v0->unk_08 = sub_0208712C(HEAP_ID_FIELDMAP, 1, v9, 10, SaveData_GetOptions(FieldSystem_GetSaveData(fieldSystem))); + v0->unk_08 = NamingScreenArgs_Init(HEAP_ID_FIELDMAP, NAMING_SCREEN_TYPE_POKEMON, v9, MON_NAME_LEN, SaveData_GetOptions(FieldSystem_GetSaveData(fieldSystem))); v0->unk_08->unk_10 = Pokemon_GetValue(v0->unk_0C.unk_00, MON_DATA_GENDER, NULL); v0->unk_08->unk_08 = Pokemon_GetValue(v0->unk_0C.unk_00, MON_DATA_FORM, NULL); - FieldTask_RunApplication(param0, &Unk_020F2DAC, v0->unk_08); + FieldTask_RunApplication(param0, &gNamingScreenAppTemplate, v0->unk_08); v0->unk_00++; } break; case 4: @@ -254,7 +253,7 @@ static BOOL sub_0209843C(FieldTask *param0) } } - sub_0208716C(v0->unk_08); + NamingScreenArgs_Free(v0->unk_08); v0->unk_00++; break; case 5: