From 28f41f995d6e24ae5bd0d03d7220784d30c61b35 Mon Sep 17 00:00:00 2001 From: YamaArashi Date: Thu, 18 Aug 2016 22:03:18 -0700 Subject: make game version equal 1 for sapphire --- src/main.c | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) (limited to 'src') diff --git a/src/main.c b/src/main.c index 751a2c7f8..937978c38 100644 --- a/src/main.c +++ b/src/main.c @@ -18,7 +18,13 @@ void SerialIntr(void); void IntrDummy(void); void Timer3Intr(void); -const u8 gGameVersion = 2; // Ruby +#ifdef SAPPHIRE +#define GAME_VERSION VERSION_SAPPHIRE +#else +#define GAME_VERSION VERSION_RUBY +#endif + +const u8 gGameVersion = GAME_VERSION; const u8 gGameLanguage = 2; // English -- cgit v1.2.3 From 61601293b2e4b8978b60744b9fcb9d79f59a9b29 Mon Sep 17 00:00:00 2001 From: YamaArashi Date: Mon, 29 Aug 2016 21:30:01 -0700 Subject: dump songs --- src/m4a_tables.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src') diff --git a/src/m4a_tables.c b/src/m4a_tables.c index 39344a590..f557fb073 100644 --- a/src/m4a_tables.c +++ b/src/m4a_tables.c @@ -260,7 +260,7 @@ const struct PokemonCrySong gPokemonCrySongTemplate = 0, // block count 255, // priority 0, // reverb - (struct ToneData *)&gUnknown_0842FC88, + (struct ToneData *)&voicegroup_842FC88, NULL, NULL, 0, -- cgit v1.2.3 From 4d518e8ea5c93c669eb14de89b5baf6eba1ac9b0 Mon Sep 17 00:00:00 2001 From: YamaArashi Date: Sat, 3 Sep 2016 23:39:12 -0700 Subject: WIP menu.c --- src/menu.c | 1008 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ src/text.c | 2 +- 2 files changed, 1009 insertions(+), 1 deletion(-) create mode 100644 src/menu.c (limited to 'src') diff --git a/src/menu.c b/src/menu.c new file mode 100644 index 000000000..aff3655da --- /dev/null +++ b/src/menu.c @@ -0,0 +1,1008 @@ +#include "global.h" +#include "main.h" +#include "text.h" +#include "songs.h" + +struct Menu +{ + u8 left; + u8 top; + s8 cursorPos; + s8 minCursorPos; + s8 maxCursorPos; + u8 width; + u8 height; + u8 menu_field_7; + u8 columnXCoords[8]; +}; + +void sub_8071C4C(struct WindowConfig *); +void sub_8071C58(struct WindowConfig *); +void sub_8071C64(struct WindowConfig *, u16); +bool32 sub_8071C94(void); +void sub_8071D48(struct WindowConfig *, u16); +void unref_sub_8071DA4(struct WindowConfig *, u16); +void sub_8071E00(u8); +void GetMapNamePopUpWindowId(void); +void sub_8071E2C(struct WindowConfig *); +void Print(u8 *, u8, u8); +void Reset(u8, u8, u8, u8); +void sub_8071EBC(u8, u8, u8, u8); +void sub_8071EF4(void); +void DrawDefaultWindow(u8, u8, u8, u8); +void sub_8071F40(u8 *); +void sub_8071F60(u8, u8, u8, u8); +u16 unref_sub_8071F98(u8, u8); +void unref_sub_8071FBC(u16, u8, u8, u8, u8); +void sub_8071FFC(void); +void AddTextPrinterWithCallbackForMessage(u8 *, u8, u8); +void sub_8072044(u8 *); +void sub_807206C(u8 *); +u8 sub_8072080(void); +u8 unref_sub_8072098(void); +void sub_80720B0(void); +u8 MoveMenuCursor(s8); +u8 MoveMenuCursorNoWrapAround(s8); +u8 GetMenuCursorPos(void); +s8 ProcessMenuInput(void); +s8 ProcessMenuInputNoWrap(void); +u8 MoveMenuCursor3(s8); +u8 MoveMenuCursor4(s8); +bool8 sub_80723D4(void); +u8 sub_8072484(u8, u8, u8, u8, u8, u8, u32); +u8 sub_80724F4(u8, u8, u8, u8*[][2], u8); +void sub_8072620(u8, u8, u8, u8*[][2], u8); +void sub_807274C(u8, u8, u8, u8, u8*[][2], u8, u32); +s8 sub_80727CC(void); +u8 sub_807288C(u8); +void PrintStringArray(u8, u8, u8, u8*[][2]); +void sub_80728E4(u8, u8, u8, u8*[][2], u8*); +void sub_807292C(u8, u8, u8); +void sub_8072974(u8, u8, u32); +s8 FillWindowPixelBuffer(void); +u8 sub_80729D8(u8 *, u8, u16, u8); +u8 sub_8072A18(u8 *, u8, u16, u8, u32); +u8 unref_sub_8072A5C(u8 *, u8 *, u8, u16, u8, u32); +int sub_8072AB0(u8 *, u8, u16, u8, u8, u32); +void PrintCoinsString(u8 *, u8, u8); +void sub_8072B80(u8 *, u8, u8, u8 *); +void Free(u8 *, u8, u8, u16); +u8 *sub_8072C14(u8 *, s32, u8, u8); +u8 *sub_8072C44(u8 *, s32, u8, u8); +u8 *sub_8072C74(u8 *, u8 *, u8, u8); +u8 sub_8072CA4(u8 *s); +u8 sub_8072CBC(void); +void sub_8072CD4(u8 *, u8 *, u8 *); +u32 sub_8072CF4(u8); +struct Window * unref_sub_8072D0C(void); +void sub_8072D18(u8, u8); +u8 InitMenu(u8, u8, u8, u8, u8, u8); +void RedrawMenuCursor(u8, u8); +void unref_sub_8072DC0(void); +void sub_8072DCC(u8); +void sub_8072DDC(u8); +void sub_8072DEC(void); + +extern u16 sub_8064EF4(u16); +extern void sub_8064F08(struct Window *); +extern void sub_8064F6C(struct Window *, u8); +extern u16 sub_80651C8(u16); +extern void AddTextPrinterParametrized(struct Window *win, u8 left, u8 top, u8 right, u8 bottom); +extern void copy_textbox_border_tile_patterns_to_vram(struct Window *); +extern void sub_814A5C0(u8, u16, u8, u16, u8); +extern void sub_814A880(u8, u8); +extern void sub_814A904(void); +extern void sub_814A958(u8); +extern void sub_814A7FC(void); + +static struct Menu gMenu; + +extern struct Window stru_202E908; +extern struct Window *dword_202E9C8; +extern u8 byte_202E9CC; +extern u16 word_202E9CE; +extern u16 word_202E9D0; +extern u16 word_202E9D2; +extern u16 word_202E9D4; + +extern const u8 *gUnknown_08376D74[][2]; + +void sub_8071C4C(struct WindowConfig *a1) +{ + sub_8071D48(a1, 1); +} + +void sub_8071C58(struct WindowConfig *a1) +{ + sub_8071C64(a1, 1); +} + +void sub_8071C64(struct WindowConfig *a1, u16 a2) +{ + byte_202E9CC = 0; + word_202E9CE = a2; + dword_202E9C8 = &stru_202E908; + InitWindowFromConfig(&stru_202E908, a1); +} + +bool32 sub_8071C94(void) +{ + switch (byte_202E9CC) + { + case 0: + byte_202E9CC++; + return 0; + case 1: + word_202E9D0 = MultistepInitWindowTileData(dword_202E9C8, word_202E9CE); + goto next; + case 2: + if (!MultistepLoadFont()) + goto fail; + goto next; + case 3: + word_202E9D2 = sub_8064EF4(word_202E9D0); + next: + byte_202E9CC++; + return 0; + case 4: + sub_8064F08(dword_202E9C8); + word_202E9D4 = sub_80651C8(word_202E9D2); + return 1; + default: + fail: + return 0; + } +} + +void sub_8071D48(struct WindowConfig *a1, u16 a2) +{ + dword_202E9C8 = &stru_202E908; + InitWindowFromConfig(&stru_202E908, a1); + word_202E9CE = a2; + word_202E9D0 = InitWindowTileData(dword_202E9C8, word_202E9CE); + word_202E9D2 = sub_8064EF4(word_202E9D0); + sub_8064F08(dword_202E9C8); + word_202E9D4 = sub_80651C8(word_202E9D2); +} + +void unref_sub_8071DA4(struct WindowConfig *a1, u16 a2) +{ + dword_202E9C8 = &stru_202E908; + InitWindowFromConfig(&stru_202E908, a1); + word_202E9D0 = a2; + word_202E9D2 = sub_8064EF4(word_202E9D0); + sub_8064F08(dword_202E9C8); + word_202E9CE = sub_80651C8(word_202E9D2); + word_202E9D4 = InitWindowTileData(dword_202E9C8, word_202E9CE); +} + +void sub_8071E00(u8 a1) +{ + sub_8064F6C(dword_202E9C8, a1); +} + +void GetMapNamePopUpWindowId(void) +{ + sub_8064F08(dword_202E9C8); +} + +void sub_8071E2C(struct WindowConfig *a1) +{ + InitWindowFromConfig(dword_202E9C8, a1); + dword_202E9C8->tileDataStartOffset = word_202E9CE; +} + +void Print(u8 *str, u8 left, u8 top) +{ + sub_8003460(dword_202E9C8, str, word_202E9CE, left, top); +} + +void Reset(u8 a1, u8 a2, u8 a3, u8 a4) +{ + ZeroFillWindowRect(dword_202E9C8, a1, a2, a3, a4); +} + +void sub_8071EBC(u8 left, u8 top, u8 right, u8 bottom) +{ + FillWindowRectWithBlankTile(dword_202E9C8, left, top, right, bottom); +} + +void sub_8071EF4(void) +{ + Reset(0, 0, 29, 19); +} + +void DrawDefaultWindow(u8 left, u8 top, u8 right, u8 bottom) +{ + AddTextPrinterParametrized(dword_202E9C8, left, top, right, bottom); +} + +void sub_8071F40(u8 *str) +{ + DrawDefaultWindow(2, 14, 28, 19); + Print(str, 3, 15); +} + +void sub_8071F60(u8 a1, u8 a2, u8 a3, u8 a4) +{ + sub_8003490(dword_202E9C8, a1, word_202E9CE, a2, a3); +} + +u16 unref_sub_8071F98(u8 x, u8 y) +{ + return GetWindowTilemapEntry(dword_202E9C8, x, y); +} + +void unref_sub_8071FBC(u16 a1, u8 a2, u8 a3, u8 a4, u8 a5) +{ + DrawWindowRect(dword_202E9C8, a1, a2, a3, a4, a5); +} + +void sub_8071FFC(void) +{ + copy_textbox_border_tile_patterns_to_vram(dword_202E9C8); +} + +void AddTextPrinterWithCallbackForMessage(u8 *str, u8 a2, u8 a3) +{ + sub_8002EB0(dword_202E9C8, str, word_202E9CE, a2, a3); +} + +void sub_8072044(u8 *str) +{ + sub_8002EB0(dword_202E9C8, str, word_202E9CE, 2, 15); +} + +void sub_807206C(u8 *str) +{ + sub_8002E90(dword_202E9C8, str); +} + +u8 sub_8072080(void) +{ + return sub_80035AC(dword_202E9C8); +} + +u8 unref_sub_8072098(void) +{ + return sub_8003418(dword_202E9C8); +} + +void sub_80720B0(void) +{ + ClearWindowTextLines(dword_202E9C8); +} + +u8 MoveMenuCursor(s8 delta) +{ + s32 newPos = gMenu.cursorPos + delta; + + if (newPos < gMenu.minCursorPos) + gMenu.cursorPos = gMenu.maxCursorPos; + else if (newPos > gMenu.maxCursorPos) + gMenu.cursorPos = gMenu.minCursorPos; + else + gMenu.cursorPos += delta; + + RedrawMenuCursor(gMenu.left, 2 * gMenu.cursorPos + gMenu.top); + return gMenu.cursorPos; +} + +u8 MoveMenuCursorNoWrapAround(s8 delta) +{ + s32 newPos = gMenu.cursorPos + delta; + + if (newPos < gMenu.minCursorPos) + gMenu.cursorPos = gMenu.minCursorPos; + else if (newPos > gMenu.maxCursorPos) + gMenu.cursorPos = gMenu.maxCursorPos; + else + gMenu.cursorPos += delta; + + RedrawMenuCursor(gMenu.left, 2 * gMenu.cursorPos + gMenu.top); + return gMenu.cursorPos; +} + +u8 GetMenuCursorPos(void) +{ + return gMenu.cursorPos; +} + +s8 ProcessMenuInput(void) +{ + if (gMain.newKeys & A_BUTTON) + { + audio_play(SE_SELECT); + if (gMenu.menu_field_7) + sub_8072DEC(); + return gMenu.cursorPos; + } + + if (gMain.newKeys & B_BUTTON) + { + if (gMenu.menu_field_7) + sub_8072DEC(); + return -1; + } + + if (gMain.newKeys & DPAD_UP) + { + audio_play(SE_SELECT); + MoveMenuCursor(-1); + return -2; + } + else if (gMain.newKeys & DPAD_DOWN) + { + audio_play(SE_SELECT); + MoveMenuCursor(1); + return -2; + } + + return -2; +} + +s8 ProcessMenuInputNoWrap(void) +{ + u8 cursorPos = gMenu.cursorPos; + + if (gMain.newKeys & A_BUTTON) + { + audio_play(SE_SELECT); + if (gMenu.menu_field_7) + sub_8072DEC(); + return gMenu.cursorPos; + } + + if (gMain.newKeys & B_BUTTON) + { + if (gMenu.menu_field_7) + sub_8072DEC(); + return -1; + } + + if (gMain.newKeys & DPAD_UP) + { + if (cursorPos != MoveMenuCursorNoWrapAround(-1)) + audio_play(SE_SELECT); + return -2; + } + else if (gMain.newKeys & DPAD_DOWN) + { + if (cursorPos != MoveMenuCursorNoWrapAround(1)) + audio_play(SE_SELECT); + return -2; + } + + MoveMenuCursorNoWrapAround(0); + return -2; +} + +u8 MoveMenuCursor3(s8 delta) +{ + u8 menuHeight = (gMenu.maxCursorPos + 1) >> 1; + s32 newPos = gMenu.cursorPos + delta; + + if (newPos < gMenu.minCursorPos) + gMenu.cursorPos = gMenu.maxCursorPos; + else if (newPos > gMenu.maxCursorPos) + gMenu.cursorPos = gMenu.minCursorPos; + else + gMenu.cursorPos += delta; + + RedrawMenuCursor( + 6 * (gMenu.cursorPos / menuHeight) + gMenu.left, + 2 * (gMenu.cursorPos % menuHeight) + gMenu.top); + + return gMenu.cursorPos; +} + +u8 MoveMenuCursor4(s8 delta) +{ + if (gMenu.cursorPos + delta <= gMenu.maxCursorPos) + { + if (sub_80723D4() == TRUE) + return gMenu.cursorPos; + } + else + { + return gMenu.cursorPos; + } + + gMenu.cursorPos += delta; + + if ((gMenu.maxCursorPos + 1) / gMenu.width == 0) + RedrawMenuCursor( + gMenu.left + gMenu.columnXCoords[gMenu.cursorPos % gMenu.width], + 2 * ((gMenu.cursorPos / gMenu.width) % gMenu.height) + gMenu.top); + else + RedrawMenuCursor( + gMenu.left + gMenu.columnXCoords[gMenu.cursorPos % gMenu.width], + 2 * (gMenu.cursorPos / gMenu.width) + gMenu.top); + + return gMenu.cursorPos; +} + +bool8 sub_80723D4(void) +{ + if ((gMain.newKeys & DPAD_UP) && gMenu.cursorPos < gMenu.width) + return TRUE; + + if ((gMain.newKeys & DPAD_DOWN) && gMenu.cursorPos >= (gMenu.maxCursorPos + 1) - gMenu.width) + return TRUE; + + if ((gMain.newKeys & DPAD_LEFT) + && ((gMenu.cursorPos - (gMenu.cursorPos % gMenu.width)) % gMenu.width == 1 // always false + || gMenu.cursorPos == 0 + || gMenu.cursorPos % gMenu.width == 0)) + return TRUE; + + if ((gMain.newKeys & DPAD_RIGHT) && gMenu.cursorPos % gMenu.width == gMenu.width - 1) + return TRUE; + + return FALSE; +} + +u8 sub_8072484(u8 a1, u8 a2, u8 menuItemCount, u8 a4, u8 width, u8 a6, u32 a7) +{ + u8 v7; + + gMenu.width = width; + gMenu.height = menuItemCount / width; + InitMenu(0, a1, a2, menuItemCount, a4, a6); + v7 = 0; + if (a7) + v7 = -1; + gMenu.menu_field_7 = v7; + return a4; +} + +#ifdef NONMATCHING +u8 sub_80724F4(u8 left, u8 top, u8 menuItemCount, u8 *menuItems[][2], u8 columnCount) +{ + u8 i; + u8 maxWidth; + s32 height; + + for (i = 0; i < 7; i++) + gMenu.columnXCoords[i] = 0; + + maxWidth = 0; + for (i = 0; i < menuItemCount; i++) + { + u8 width = (sub_8072CA4(menuItems[i][0]) + 7) / 8; + + if (width > maxWidth) + maxWidth = width; + } + + for (i = 1; i <= columnCount; i++) + gMenu.columnXCoords[i] = maxWidth; + + for (i = 1; i <= columnCount; i++) + gMenu.columnXCoords[i] += 1 + gMenu.columnXCoords[i - 1]; + + gMenu.columnXCoords[columnCount]--; + + if (!((menuItemCount / 2) < columnCount || (menuItemCount % 2 != 0)) + || columnCount == 1 + || columnCount == menuItemCount) + { + height = 2 * (menuItemCount / columnCount) + 1; + } + else + { + height = 2 * ((menuItemCount / columnCount) + 1) + 1; + } + + { + u8 right; + u8 bottom; + u32 totalWidth; + register s32 val asm("r1"); + + val = (s8)top + height; + bottom = val; + + totalWidth = (gMenu.columnXCoords[columnCount] + 1); + right = left + totalWidth; + + DrawDefaultWindow(left, top, right, bottom); + } + + return maxWidth; +} +#else +__attribute__((naked)) +u8 sub_80724F4(u8 left, u8 top, u8 menuItemCount, u8 *menuItems[][2], u8 columnCount) +{ + asm("push {r4-r7,lr}\n\ + mov r7, r10\n\ + mov r6, r9\n\ + mov r5, r8\n\ + push {r5-r7}\n\ + sub sp, #0xC\n\ + mov r8, r3\n\ + ldr r3, [sp, #0x2C]\n\ + lsl r0, #24\n\ + lsr r0, #24\n\ + str r0, [sp]\n\ + lsl r1, #24\n\ + lsr r1, #24\n\ + str r1, [sp, #0x4]\n\ + lsl r2, #24\n\ + lsr r6, r2, #24\n\ + lsl r3, #24\n\ + lsr r5, r3, #24\n\ + movs r4, #0\n\ + ldr r0, _080725D4\n\ + mov r9, r0\n\ + mov r1, r9\n\ + add r1, #0x8\n\ + movs r2, #0\n\ +_08072524:\n\ + add r0, r4, r1\n\ + strb r2, [r0]\n\ + add r0, r4, #0x1\n\ + lsl r0, #24\n\ + lsr r4, r0, #24\n\ + cmp r4, #0x6\n\ + bls _08072524\n\ + movs r7, #0\n\ + movs r4, #0\n\ + lsr r2, r6, #1\n\ + mov r10, r2\n\ + ldr r0, [sp, #0x4]\n\ + lsl r0, #24\n\ + str r0, [sp, #0x8]\n\ + cmp r7, r6\n\ + bcs _08072566\n\ +_08072544:\n\ + lsl r0, r4, #3\n\ + add r0, r8\n\ + ldr r0, [r0]\n\ + bl sub_8072CA4\n\ + lsl r0, #24\n\ + lsr r0, #24\n\ + add r1, r0, #0x7\n\ + lsr r0, r1, #3\n\ + cmp r0, r7\n\ + bls _0807255C\n\ + add r7, r0, #0\n\ +_0807255C:\n\ + add r0, r4, #0x1\n\ + lsl r0, #24\n\ + lsr r4, r0, #24\n\ + cmp r4, r6\n\ + bcc _08072544\n\ +_08072566:\n\ + movs r4, #0x1\n\ + ldr r2, _080725D4\n\ + mov r9, r2\n\ + cmp r4, r5\n\ + bhi _08072582\n\ + mov r1, r9\n\ + add r1, #0x8\n\ +_08072574:\n\ + add r0, r4, r1\n\ + strb r7, [r0]\n\ + add r0, r4, #0x1\n\ + lsl r0, #24\n\ + lsr r4, r0, #24\n\ + cmp r4, r5\n\ + bls _08072574\n\ +_08072582:\n\ + movs r4, #0x1\n\ + cmp r4, r5\n\ + bhi _080725A4\n\ + ldr r3, _080725D8\n\ +_0807258A:\n\ + add r2, r4, r3\n\ + ldrb r1, [r2]\n\ + sub r0, r4, #0x1\n\ + add r0, r3\n\ + add r1, #0x1\n\ + ldrb r0, [r0]\n\ + add r1, r0\n\ + strb r1, [r2]\n\ + add r0, r4, #0x1\n\ + lsl r0, #24\n\ + lsr r4, r0, #24\n\ + cmp r4, r5\n\ + bls _0807258A\n\ +_080725A4:\n\ + mov r1, r9\n\ + add r1, #0x8\n\ + add r1, r5, r1\n\ + ldrb r0, [r1]\n\ + sub r0, #0x1\n\ + strb r0, [r1]\n\ + cmp r10, r5\n\ + bcc _080725BC\n\ + movs r0, #0x1\n\ + and r0, r6\n\ + cmp r0, #0\n\ + beq _080725C4\n\ +_080725BC:\n\ + cmp r5, #0x1\n\ + beq _080725C4\n\ + cmp r5, r6\n\ + bne _080725DC\n\ +_080725C4:\n\ + add r0, r6, #0\n\ + add r1, r5, #0\n\ + bl __udivsi3\n\ + lsl r0, #24\n\ + lsr r0, #23\n\ + add r0, #0x1\n\ + b _080725EA\n\ + .align 2, 0\n\ +_080725D4: .4byte 0x030006b0\n\ +_080725D8: .4byte 0x030006b8\n\ +_080725DC:\n\ + add r0, r6, #0\n\ + add r1, r5, #0\n\ + bl __udivsi3\n\ + lsl r0, #24\n\ + lsr r0, #23\n\ + add r0, #0x3\n\ +_080725EA:\n\ + ldr r2, [sp, #0x8]\n\ + asr r1, r2, #24\n\ + add r1, r0\n\ + lsl r1, #24\n\ + lsr r3, r1, #24\n\ + mov r0, r9\n\ + add r0, #0x8\n\ + add r0, r5, r0\n\ + ldrb r2, [r0]\n\ + add r2, #0x1\n\ + ldr r0, [sp]\n\ + add r2, r0, r2\n\ + lsl r2, #24\n\ + lsr r2, #24\n\ + ldr r1, [sp, #0x4]\n\ + bl DrawDefaultWindow\n\ + add r0, r7, #0\n\ + add sp, #0xC\n\ + pop {r3-r5}\n\ + mov r8, r3\n\ + mov r9, r4\n\ + mov r10, r5\n\ + pop {r4-r7}\n\ + pop {r1}\n\ + bx r1\n"); +} +#endif // NONMATCHING + +void sub_8072620(u8 left, u8 top, u8 menuItemCount, u8 *menuItems[][2], u8 columnCount) +{ + u8 i; + u8 maxWidth; + + for (i = 0; i < 7; i++) + gMenu.columnXCoords[i] = 0; + + maxWidth = 0; + for (i = 0; i < menuItemCount; i++) + { + u8 width = (sub_8072CA4(menuItems[i][0]) + 7) / 8; + + if (width > maxWidth) + maxWidth = width; + } + + for (i = 1; i <= columnCount; i++) + gMenu.columnXCoords[i] = maxWidth; + + for (i = 1; i <= columnCount; i++) + gMenu.columnXCoords[i] += 1 + gMenu.columnXCoords[i - 1]; + + gMenu.columnXCoords[columnCount]--; + + for (i = 0; i < columnCount; i++) + { + u8 row = 0; + u8 j; + for (j = 0; i + j < menuItemCount; j += columnCount, row++) + Print(menuItems[i + j][0], left + gMenu.columnXCoords[i % columnCount], top + 2 * row); + } +} + +void sub_807274C(u8 left, u8 top, u8 menuItemCount, u8 a4, u8 *menuItems[][2], u8 columnCount, u32 a7) +{ + u8 maxWidth = sub_80724F4(left, top, menuItemCount, menuItems, columnCount); + + sub_8072484(left + 1, top + 1, menuItemCount, a4, columnCount, maxWidth, a7); + sub_8072620(left + 1, top + 1, menuItemCount, menuItems, columnCount); +} + +s8 sub_80727CC(void) +{ + if (gMain.newKeys & A_BUTTON) + { + if (gMenu.menu_field_7) + sub_8072DEC(); + audio_play(SE_SELECT); + return GetMenuCursorPos(); + } + + if (gMain.newKeys & B_BUTTON) + { + if (gMenu.menu_field_7) + sub_8072DEC(); + return -1; + } + + if (gMain.newKeys & DPAD_UP) + { + audio_play(SE_SELECT); + MoveMenuCursor4(-gMenu.width); + return -2; + } + else if (gMain.newKeys & DPAD_DOWN) + { + audio_play(SE_SELECT); + MoveMenuCursor4(gMenu.width); + return -2; + } + else if (gMain.newKeys & DPAD_LEFT) + { + audio_play(SE_SELECT); + MoveMenuCursor4(-1); + return -2; + } + else if (gMain.newKeys & DPAD_RIGHT) + { + audio_play(SE_SELECT); + MoveMenuCursor4(1); + return -2; + } + + return -2; +} + +u8 sub_807288C(u8 column) +{ + return gMenu.columnXCoords[column]; +} + +void PrintStringArray(u8 left, u8 top, u8 menuItemCount, u8 *menuItems[][2]) +{ + u8 i; + + for (i = 0; i < menuItemCount; i++) + Print(menuItems[i][0], left, top + 2 * i); +} + +void sub_80728E4(u8 left, u8 top, u8 menuItemCount, u8 *menuItems[][2], u8 *order) +{ + u8 i; + + for (i = 0; i < menuItemCount; i++) + Print(menuItems[order[i]][0], left, top + 2 * i); +} + +void sub_807292C(u8 left, u8 top, u8 a3) +{ + PrintStringArray(left + 1, top + 1, 2, (void *)gUnknown_08376D74); + InitMenu(0, left + 1, top + 1, 2, 0, a3); +} + +void sub_8072974(u8 left, u8 top, u32 a3) +{ + DrawDefaultWindow(left, top, left + 6, top + 5); + sub_807292C(left, top, 5); + gMenu.menu_field_7 = a3 ? -1 : 0; +} + +s8 FillWindowPixelBuffer(void) +{ + return ProcessMenuInputNoWrap(); +} + +u8 sub_80729D8(u8 *a1, u8 a2, u16 a3, u8 a4) +{ + return sub_8004D04(dword_202E9C8, a1, word_202E9CE, a2, a3, a4); +} + +u8 sub_8072A18(u8 *a1, u8 a2, u16 a3, u8 a4, u32 a5) +{ + return sub_8004FD0(dword_202E9C8, 0, a1, word_202E9CE, a2, a3, a4, a5); +} + +u8 unref_sub_8072A5C(u8 *a1, u8 *a2, u8 a3, u16 a4, u8 a5, u32 a6) +{ + return sub_8004FD0(dword_202E9C8, a1, a2, word_202E9CE, a3, a4, a5, a6); +} + +__attribute__((naked)) +int sub_8072AB0(u8 *str, u8 left, u16 top, u8 width, u8 height, u32 a6) +{ + asm("push {r4-r7,lr}\n\ + mov r7, r9\n\ + mov r6, r8\n\ + push {r6,r7}\n\ + sub sp, #0x10\n\ + mov r9, r0\n\ + add r4, r1, #0\n\ + add r5, r2, #0\n\ + ldr r0, [sp, #0x2C]\n\ + ldr r2, [sp, #0x30]\n\ + lsl r4, #24\n\ + lsr r1, r4, #24\n\ + mov r12, r1\n\ + lsl r5, #16\n\ + lsr r7, r5, #16\n\ + lsl r3, #24\n\ + lsr r6, r3, #24\n\ + lsl r0, #24\n\ + lsr r0, #24\n\ + mov r8, r0\n\ + ldr r0, _08072B44\n\ + ldr r0, [r0]\n\ + ldr r1, _08072B48\n\ + ldrh r3, [r1]\n\ + mov r1, r12\n\ + str r1, [sp]\n\ + str r7, [sp, #0x4]\n\ + str r6, [sp, #0x8]\n\ + str r2, [sp, #0xC]\n\ + movs r1, #0\n\ + mov r2, r9\n\ + bl sub_8004FD0\n\ + add r1, r0, #0\n\ + lsl r1, #24\n\ + lsr r2, r1, #24\n\ + lsr r4, #27\n\ + mov r12, r4\n\ + lsr r7, r5, #19\n\ + add r1, r6, #0x7\n\ + lsr r6, r1, #3\n\ + mov r1, r8\n\ + add r1, #0x7\n\ + asr r1, #3\n\ + lsl r1, #24\n\ + lsr r1, #24\n\ + mov r8, r1\n\ + cmp r2, r8\n\ + bcs _08072B34\n\ + lsl r1, r2, #1\n\ + add r1, r7, r1\n\ + lsl r1, #24\n\ + lsr r1, #24\n\ + mov r0, r12\n\ + add r2, r0, r6\n\ + sub r2, #0x1\n\ + lsl r2, #24\n\ + lsr r2, #24\n\ + mov r0, r8\n\ + add r3, r0, r7\n\ + sub r3, #0x1\n\ + lsl r3, #24\n\ + lsr r3, #24\n\ + mov r0, r12\n\ + bl sub_8071EBC\n\ +_08072B34:\n\ + add sp, #0x10\n\ + pop {r3,r4}\n\ + mov r8, r3\n\ + mov r9, r4\n\ + pop {r4-r7}\n\ + pop {r1}\n\ + bx r1\n\ + .align 2, 0\n\ +_08072B44: .4byte 0x0202e9c8\n\ +_08072B48: .4byte 0x0202e9ce\n"); +} + +void PrintCoinsString(u8 *str, u8 left, u8 top) +{ + sub_8004D38(dword_202E9C8, str, word_202E9CE, left, top); +} + +void sub_8072B80(u8 *a1, u8 a2, u8 a3, u8 *a4) +{ + u8 buffer[64]; + u8 width = GetStringWidth(dword_202E9C8, a4); + AlignString(dword_202E9C8, buffer, a1, width, 1); + sub_8003460(dword_202E9C8, buffer, word_202E9CE, a2, a3); +} + +void Free(u8 *a1, u8 a2, u8 a3, u16 a4) +{ + sub_8004DB0(dword_202E9C8, a1, word_202E9CE, a2, a3, a4); +} + +u8 *sub_8072C14(u8 *a1, s32 a2, u8 a3, u8 a4) +{ + return AlignInt1(dword_202E9C8, a1, a2, a3, a4); +} + +u8 *sub_8072C44(u8 *a1, s32 a2, u8 a3, u8 a4) +{ + return AlignInt2(dword_202E9C8, a1, a2, a3, a4); +} + +u8 *sub_8072C74(u8 *a1, u8 *a2, u8 a3, u8 a4) +{ + return AlignString(dword_202E9C8, a1, a2, a3, a4); +} + +u8 sub_8072CA4(u8 *str) +{ + return GetStringWidth(dword_202E9C8, str); +} + +u8 sub_8072CBC() +{ + return sub_8004E24(dword_202E9C8); +} + +void sub_8072CD4(u8 *a1, u8 *a2, u8 *a3) +{ + sub_8004E28(dword_202E9C8, a1, a2, a3); +} + +u32 sub_8072CF4(u8 a1) +{ + return sub_80037C8(dword_202E9C8, a1); +} + +struct Window *unref_sub_8072D0C(void) +{ + return dword_202E9C8; +} + +void sub_8072D18(u8 a1, u8 a2) +{ + sub_814A5C0(a1, 0xFFFF, 12, 11679, 8 * a2); +} + +u8 InitMenu(u8 a1, u8 left, u8 top, u8 numChoices, u8 cursorPos, u8 a6) +{ + s32 pos; + + if (a6) + sub_8072D18(a1, a6); + + gMenu.left = left - 1; + gMenu.top = top; + gMenu.minCursorPos = 0; + gMenu.maxCursorPos = numChoices - 1; + gMenu.menu_field_7 = 0; + + pos = cursorPos; + + if (pos < 0 || pos > gMenu.maxCursorPos) + pos = 0; + + gMenu.cursorPos = pos; + MoveMenuCursor(0); + + return pos; +} + +void RedrawMenuCursor(u8 a1, u8 a2) +{ + sub_814A880((a1 + 1) * 8, 8 * a2); +} + +void unref_sub_8072DC0() +{ + sub_814A904(); +} + +void sub_8072DCC(u8 a1) +{ + sub_814A958(a1); +} + +void sub_8072DDC(u8 a1) +{ + sub_8072DCC(8 * a1); +} + +void sub_8072DEC(void) +{ + sub_814A7FC(); +} diff --git a/src/text.c b/src/text.c index 372d3e7e2..64a302fed 100644 --- a/src/text.c +++ b/src/text.c @@ -2523,7 +2523,7 @@ u8 sub_80037A0(struct Window *win) return retVal; } -u8 sub_80037C8(struct Window *win, u8 lineLength) +u32 sub_80037C8(struct Window *win, u8 lineLength) { u8 retVal; -- cgit v1.2.3 From 55bfe3ca016304235d5d117a35d8973b10ecc657 Mon Sep 17 00:00:00 2001 From: YamaArashi Date: Sun, 4 Sep 2016 01:15:12 -0700 Subject: WIP main_menu.c --- src/main_menu.c | 605 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 605 insertions(+) create mode 100644 src/main_menu.c (limited to 'src') diff --git a/src/main_menu.c b/src/main_menu.c new file mode 100644 index 000000000..d6f62bac8 --- /dev/null +++ b/src/main_menu.c @@ -0,0 +1,605 @@ +#include "global.h" +#include "text.h" +#include "sprite.h" +#include "task.h" +#include "main.h" +#include "rtc.h" +#include "songs.h" +#include "palette.h" + +extern u8 sub_8072080(void); +extern void Print(u8 *, u8, u8); +extern void CB2_ContinueSavedGame(void); +extern void CB2_InitMysteryEventMenu(void); +extern void CB2_InitOptionMenu(void); +extern void CB2_InitTitleScreen(void); +extern void FormatPlayTime(u8 *str, u16 hours, u16 minutes, bool16 colon); +extern u8 *sub_8072C74(u8 *, u8 *, u8, u8); +extern u16 GetPokedexSeenCount(void); +extern u8 *sub_8072C14(u8 *, s32, u8, u8); +extern u8 sub_80729D8(u8 *, u8, u16, u8); +extern u8 GetBadgeCount(void); +extern void Task_Birch1(u8); + +extern struct PaletteFadeControl gPaletteFade; +extern u8 gSaveFileDeletedMessage[]; +extern u8 gSaveFileCorruptMessage[]; +extern u8 gBoardNotInstalledMessage[]; +extern u8 gBatteryDryMessage[]; +extern u16 gSaveFileStatus; +extern u8 gMainMenuString_Continue[]; +extern u8 gMainMenuString_NewGame[]; +extern u8 gMainMenuString_MysteryEvents[]; +extern u8 gMainMenuString_Option[]; +extern u8 gMainMenuString_Player[]; +extern u8 gMainMenuString_Time[]; +extern u8 gMainMenuString_Pokedex[]; +extern u8 gMainMenuString_Badges[]; + +void CB2_MainMenu(void); +void VBlankCB_MainMenu(void); +void CB2_InitMainMenu(void); +static void sub_80096FC(void); +static u32 InitMainMenu(bool8 a1); +static void Task_CheckSave(u8 taskId); +static void Task_WaitForSaveErrorAck(u8 taskId); +static void Task_CheckRtc(u8 taskId); +static void Task_WaitForRtcErrorAck(u8 taskId); +static void Task_DrawMainMenu(u8 taskId); +static void Task_HighlightCurrentMenuItem(u8 taskId); +static bool8 MainMenuProcessKeyInput(u8 taskId); +static void Task_MainMenuProcessKeyInput(u8 taskId); +static void MainMenuPressedA(u8 taskId); +static void MainMenuPressedB(u8 taskId); +static void HighlightCurrentMenuItem(u8, u8); +static void PrintMainMenuItem(u8 *text, u8, u8); +static void PrintSaveFileInfo(void); +static void PrintPlayerName(void); +static void PrintPlayTime(void); +static void PrintPokedexCount(void); +static void PrintBadgeCount(void); + +extern u16 gMainMenuPalette[]; + +void CB2_MainMenu(void) +{ + RunTasks(); + AnimateSprites(); + BuildOamBuffer(); + UpdatePaletteFade(); +} + +void VBlankCB_MainMenu(void) +{ + LoadOam(); + ProcessSpriteCopyRequests(); + TransferPlttBuffer(); +} + +void CB2_InitMainMenu(void) +{ + InitMainMenu(FALSE); +} + +static void sub_80096FC(void) +{ + InitMainMenu(TRUE); +} + +u32 InitMainMenu(u8 a1) +{ + u16 savedIme; + u8 taskId; + + SetVBlankCallback(NULL); + + REG_DISPCNT = 0; + REG_BG2CNT = 0; + REG_BG1CNT = 0; + REG_BG0CNT = 0; + REG_BG2HOFS = 0; + REG_BG2VOFS = 0; + REG_BG1HOFS = 0; + REG_BG1VOFS = 0; + REG_BG0HOFS = 0; + REG_BG0VOFS = 0; + + DmaFill16(3, 0, (void *)VRAM, VRAM_SIZE); + DmaFill32(3, 0, (void *)OAM, OAM_SIZE); + DmaFill16(3, 0, (void *)(PLTT + 2), PLTT_SIZE - 2); + + ResetPaletteFade(); + LoadPalette(gMainMenuPalette, 0, 32); + remove_some_task(); + ResetTasks(); + ResetSpriteData(); + FreeAllSpritePalettes(); + SetUpWindowConfig(&gWindowConfig_81E6C3C); + sub_8071C4C(&gWindowConfig_81E6CE4); + + if (a1) + BeginNormalPaletteFade(-1, 0, 0x10u, 0, 0); + else + BeginNormalPaletteFade(-1, 0, 0x10u, 0, -1); + + REG_WIN0H = 0; + REG_WIN0V = 0; + REG_WININ = 0; + REG_WINOUT = 0; + REG_BLDCNT = 0; + REG_BLDALPHA = 0; + REG_BLDY = 0; + + savedIme = REG_IME; + REG_IME = 0; + REG_IE |= INTR_FLAG_VBLANK; + REG_IME = savedIme; + + SetVBlankCallback(VBlankCB_MainMenu); + SetMainCallback2(CB2_MainMenu); + + REG_DISPCNT = DISPCNT_OBJ_1D_MAP + | DISPCNT_BG0_ON + | DISPCNT_OBJ_ON + | DISPCNT_WIN0_ON; + + taskId = CreateTask(Task_CheckSave, 0); + gTasks[taskId].data[1] = 0; + + return 0; +} + +void Task_CheckSave(u8 taskId) +{ + if (gPaletteFade.active) + return; + + REG_WIN0H = 0; + REG_WIN0V = 0; + REG_WININ = 0x1111; + REG_WINOUT = 49; + REG_BLDCNT = 241; + REG_BLDALPHA = 0; + REG_BLDY = 7; + + switch (gSaveFileStatus) + { + case 1: + if (sub_806918C() == TRUE) + gTasks[taskId].data[0] = 2; + else + gTasks[taskId].data[0] = 1; + + gTasks[taskId].func = Task_CheckRtc; + break; + case 2: + DrawDefaultWindow(2, 14, 27, 19); + AddTextPrinterWithCallbackForMessage(gSaveFileDeletedMessage, 3, 15); + REG_WIN0H = 4575; + REG_WIN0V = 29087; + gTasks[taskId].data[0] = 0; + gTasks[taskId].func = Task_WaitForSaveErrorAck; + break; + case 255: + DrawDefaultWindow(2, 14, 27, 19); + AddTextPrinterWithCallbackForMessage(gSaveFileCorruptMessage, 3, 15); + REG_WIN0H = 4575; + REG_WIN0V = 29087; + gTasks[taskId].data[0] = 1; + gTasks[taskId].func = Task_WaitForSaveErrorAck; + + if (sub_806918C() == TRUE) + gTasks[taskId].data[0] = 2; + else + gTasks[taskId].data[0] = 1; + break; + case 0: + default: + gTasks[taskId].data[0] = 0; + gTasks[taskId].func = Task_CheckRtc; + break; + case 4: + DrawDefaultWindow(2, 14, 27, 19); + AddTextPrinterWithCallbackForMessage(gBoardNotInstalledMessage, 3, 15); + REG_WIN0H = 4575; + REG_WIN0V = 29087; + gTasks[taskId].data[0] = 0; + gTasks[taskId].func = Task_WaitForSaveErrorAck; + return; + } +} + +void Task_WaitForSaveErrorAck(u8 taskId) +{ + if (sub_8072080()) + { + if (gMain.newKeys & A_BUTTON) + { + Reset(2, 14, 27, 19); + gTasks[taskId].func = Task_CheckRtc; + } + } +} + +void Task_CheckRtc(u8 taskId) +{ + if (!gPaletteFade.active) + { + REG_WIN0H = 0; + REG_WIN0V = 0; + REG_WININ = 4369; + REG_WINOUT = 49; + REG_BLDCNT = 241; + REG_BLDALPHA = 0; + REG_BLDY = 7; + + if (!(RtcGetErrorStatus() & RTC_ERR_FLAG_MASK)) + { + gTasks[taskId].func = Task_DrawMainMenu; + } + else + { + DrawDefaultWindow(2, 14, 27, 19); + AddTextPrinterWithCallbackForMessage(gBatteryDryMessage, 3, 15); + REG_WIN0H = 4575; + REG_WIN0V = 29087; + gTasks[taskId].func = Task_WaitForRtcErrorAck; + } + } +} + +void Task_WaitForRtcErrorAck(u8 taskId) +{ + if (sub_8072080()) + { + if ( gMain.newKeys & 1 ) + { + Reset(2, 14, 27, 19); + gTasks[taskId].func = Task_DrawMainMenu; + } + } +} + +void Task_DrawMainMenu(u8 taskId) +{ + u16 palette; + + if (!gPaletteFade.active) + { + REG_WIN0H = 0; + REG_WIN0V = 0; + REG_WININ = 4369; + REG_WINOUT = 49; + REG_BLDCNT = 241; + REG_BLDALPHA = 0; + REG_BLDY = 7; + + palette = RGB(0, 0, 0); + LoadPalette(&palette, 254, 2); + + if (gSaveBlock2.playerGender == MALE) + { + palette = RGB(4, 16, 31); + LoadPalette(&palette, 241, 2); + } + else + { + palette = RGB(31, 3, 21); + LoadPalette(&palette, 241, 2); + } + + switch (gTasks[taskId].data[0]) + { + case 0: + default: + DrawDefaultWindow(1, 0, 28, 3); + PrintMainMenuItem(gMainMenuString_NewGame, 2, 1); + DrawDefaultWindow(1, 4, 28, 7); + PrintMainMenuItem(gMainMenuString_Option, 2, 5); + break; + case 1: + DrawDefaultWindow(1, 0, 28, 7); + PrintMainMenuItem(gMainMenuString_Continue, 2, 1); + DrawDefaultWindow(1, 8, 28, 11); + PrintMainMenuItem(gMainMenuString_NewGame, 2, 9); + DrawDefaultWindow(1, 12, 28, 15); + PrintMainMenuItem(gMainMenuString_Option, 2, 13); + PrintSaveFileInfo(); + break; + case 2: + DrawDefaultWindow(1, 0, 28, 7); + PrintMainMenuItem(gMainMenuString_Continue, 2, 1); + DrawDefaultWindow(1, 8, 28, 11); + PrintMainMenuItem(gMainMenuString_NewGame, 2, 9); + DrawDefaultWindow(1, 12, 28, 15); + PrintMainMenuItem(gMainMenuString_MysteryEvents, 2, 13); + DrawDefaultWindow(1, 16, 28, 19); + PrintMainMenuItem(gMainMenuString_Option, 2, 0x11); + PrintSaveFileInfo(); + break; + } + + gTasks[taskId].func = Task_HighlightCurrentMenuItem; + } +} + +void Task_HighlightCurrentMenuItem(u8 taskId) +{ + HighlightCurrentMenuItem(gTasks[taskId].data[0], gTasks[taskId].data[1]); + gTasks[taskId].func = Task_MainMenuProcessKeyInput; +} + +bool8 MainMenuProcessKeyInput(u8 taskId) +{ + if (gMain.newKeys & A_BUTTON) + { + audio_play(SE_SELECT); + BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 0x10, 0); + gTasks[taskId].func = MainMenuPressedA; + } + else if (gMain.newKeys & B_BUTTON) + { + audio_play(SE_SELECT); + BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 0x10, 0xFFFF); + REG_WIN0H = 240; + REG_WIN0V = 160; + gTasks[taskId].func = MainMenuPressedB; + } + else + { + s32 menuItemCount; + + switch (gTasks[taskId].data[0]) + { + case 0: + default: + menuItemCount = 2; + break; + case 1: + menuItemCount = 3; + break; + case 2: + menuItemCount = 4; + break; + } + + if (gMain.newKeys & DPAD_UP) + { + if (gTasks[taskId].data[1] > 0) + { + gTasks[taskId].data[1]--; + return TRUE; + } + } + if (gMain.newKeys & DPAD_DOWN) + { + if (gTasks[taskId].data[1] < menuItemCount - 1) + { + gTasks[taskId].data[1]++; + return TRUE; + } + } + } + + return FALSE; +} + +void Task_MainMenuProcessKeyInput(u8 taskId) +{ + bool8 currentMenuItemChanged = MainMenuProcessKeyInput(taskId); + if (currentMenuItemChanged) + gTasks[taskId].func = Task_HighlightCurrentMenuItem; +} + +void MainMenuPressedA(u8 taskId) +{ + enum + { + NEW_GAME, + CONTINUE, + OPTION, + MYSTERY_EVENTS, + } action; + + if (gPaletteFade.active) + return; + + switch (gTasks[taskId].data[0]) + { + case 0: + default: + switch (gTasks[taskId].data[1]) + { + case 0: + default: + action = NEW_GAME; + break; + case 1: + action = OPTION; + break; + } + break; + case 1: + switch (gTasks[taskId].data[1]) + { + case 0: + default: + action = CONTINUE; + break; + case 1: + action = NEW_GAME; + break; + case 2: + action = OPTION; + break; + } + break; + case 2: + switch (gTasks[taskId].data[1]) + { + case 0: + default: + action = CONTINUE; + break; + case 1: + action = NEW_GAME; + break; + case 2: + action = MYSTERY_EVENTS; + break; + case 3: + action = OPTION; + break; + } + break; + } + + switch ((int)action) + { + case 0: + default: + gPlttBufferUnfaded[0] = 0; + gPlttBufferFaded[0] = 0; + gTasks[taskId].func = Task_Birch1; + break; + case 1: + gPlttBufferUnfaded[0] = 0; + gPlttBufferFaded[0] = 0; + SetMainCallback2(CB2_ContinueSavedGame); + DestroyTask(taskId); + break; + case 2: + gMain.field_8 = (u32)sub_80096FC; + SetMainCallback2(CB2_InitOptionMenu); + DestroyTask(taskId); + break; + case 3: + SetMainCallback2(CB2_InitMysteryEventMenu); + DestroyTask(taskId); + break; + } +} + +void MainMenuPressedB(u8 taskId) +{ + if (!gPaletteFade.active) + { + SetMainCallback2(CB2_InitTitleScreen); + DestroyTask(taskId); + } +} + +void HighlightCurrentMenuItem(u8 layout, u8 menuItem) +{ + REG_WIN0H = 2535; + + switch (layout) + { + case 0: + default: + switch (menuItem) + { + case 0: + default: + REG_WIN0V = 287; + break; + case 1: + REG_WIN0V = 8511; + break; + } + break; + case 1: + switch (menuItem) + { + case 0: + default: + REG_WIN0V = 319; + break; + case 1: + REG_WIN0V = 16735; + break; + case 2: + REG_WIN0V = 24959; + break; + } + break; + case 2: + switch (menuItem) + { + case 0: + default: + REG_WIN0V = 319; + break; + case 1: + REG_WIN0V = 16735; + break; + case 2: + REG_WIN0V = 24959; + break; + case 3: + REG_WIN0V = 33183; + break; + } + break; + } +} + +void PrintMainMenuItem(u8 *text, u8 left, u8 top) +{ + u8 i; + u8 buffer[32]; + + buffer[0] = 0xFC; + buffer[1] = 1; + buffer[2] = 14; + + for (i = 0; i < 26; i++) + buffer[3 + i] = text[i]; + + buffer[29] = EOS; + + Print(buffer, left, top); +} + +void PrintSaveFileInfo(void) +{ + PrintPlayerName(); + PrintPokedexCount(); + PrintPlayTime(); + PrintBadgeCount(); +} + +void PrintPlayerName(void) +{ + Print(gMainMenuString_Player, 2, 3); + Print(gSaveBlock2.playerName, 9, 3); +} + +void PrintPlayTime(void) +{ + u8 playTime[16]; + u8 alignedPlayTime[32]; + + Print(gMainMenuString_Time, 16, 3); + FormatPlayTime(playTime, gSaveBlock2.playTimeHours, gSaveBlock2.playTimeMinutes, 1); + sub_8072C74(alignedPlayTime, playTime, 48, 1); + Print(alignedPlayTime, 22, 3); +} + +void PrintPokedexCount(void) +{ + u8 buffer[16]; + + Print(gMainMenuString_Pokedex, 2, 5); + sub_8072C14(buffer, GetPokedexSeenCount(), 18, 0); + Print(buffer, 9, 5); +} + +void PrintBadgeCount(void) +{ + u8 buffer[16]; + + Print(gMainMenuString_Badges, 16, 5); + ConvertIntToDecimalString(buffer, GetBadgeCount()); + sub_80729D8(buffer, 205, 40, 1); +} -- cgit v1.2.3 From 411c2dc2d62881e4454833cf556999e311ad9554 Mon Sep 17 00:00:00 2001 From: YamaArashi Date: Sun, 4 Sep 2016 02:21:44 -0700 Subject: WIN_RANGE macro --- src/main_menu.c | 58 ++++++++++++++++++++++++++++----------------------------- 1 file changed, 29 insertions(+), 29 deletions(-) (limited to 'src') diff --git a/src/main_menu.c b/src/main_menu.c index d6f62bac8..87c3a671a 100644 --- a/src/main_menu.c +++ b/src/main_menu.c @@ -118,9 +118,9 @@ u32 InitMainMenu(u8 a1) sub_8071C4C(&gWindowConfig_81E6CE4); if (a1) - BeginNormalPaletteFade(-1, 0, 0x10u, 0, 0); + BeginNormalPaletteFade(-1, 0, 0x10, 0, 0x0000); // fade to black else - BeginNormalPaletteFade(-1, 0, 0x10u, 0, -1); + BeginNormalPaletteFade(-1, 0, 0x10, 0, 0xFFFF); // fade to white REG_WIN0H = 0; REG_WIN0V = 0; @@ -175,16 +175,16 @@ void Task_CheckSave(u8 taskId) case 2: DrawDefaultWindow(2, 14, 27, 19); AddTextPrinterWithCallbackForMessage(gSaveFileDeletedMessage, 3, 15); - REG_WIN0H = 4575; - REG_WIN0V = 29087; + REG_WIN0H = WIN_RANGE(17, 223); + REG_WIN0V = WIN_RANGE(113, 159); gTasks[taskId].data[0] = 0; gTasks[taskId].func = Task_WaitForSaveErrorAck; break; case 255: DrawDefaultWindow(2, 14, 27, 19); AddTextPrinterWithCallbackForMessage(gSaveFileCorruptMessage, 3, 15); - REG_WIN0H = 4575; - REG_WIN0V = 29087; + REG_WIN0H = WIN_RANGE(17, 223); + REG_WIN0V = WIN_RANGE(113, 159); gTasks[taskId].data[0] = 1; gTasks[taskId].func = Task_WaitForSaveErrorAck; @@ -201,8 +201,8 @@ void Task_CheckSave(u8 taskId) case 4: DrawDefaultWindow(2, 14, 27, 19); AddTextPrinterWithCallbackForMessage(gBoardNotInstalledMessage, 3, 15); - REG_WIN0H = 4575; - REG_WIN0V = 29087; + REG_WIN0H = WIN_RANGE(17, 223); + REG_WIN0V = WIN_RANGE(113, 159); gTasks[taskId].data[0] = 0; gTasks[taskId].func = Task_WaitForSaveErrorAck; return; @@ -227,7 +227,7 @@ void Task_CheckRtc(u8 taskId) { REG_WIN0H = 0; REG_WIN0V = 0; - REG_WININ = 4369; + REG_WININ = 0x1111; REG_WINOUT = 49; REG_BLDCNT = 241; REG_BLDALPHA = 0; @@ -241,8 +241,8 @@ void Task_CheckRtc(u8 taskId) { DrawDefaultWindow(2, 14, 27, 19); AddTextPrinterWithCallbackForMessage(gBatteryDryMessage, 3, 15); - REG_WIN0H = 4575; - REG_WIN0V = 29087; + REG_WIN0H = WIN_RANGE(17, 223); + REG_WIN0V = WIN_RANGE(113, 159); gTasks[taskId].func = Task_WaitForRtcErrorAck; } } @@ -268,7 +268,7 @@ void Task_DrawMainMenu(u8 taskId) { REG_WIN0H = 0; REG_WIN0V = 0; - REG_WININ = 4369; + REG_WININ = 0x1111; REG_WINOUT = 49; REG_BLDCNT = 241; REG_BLDALPHA = 0; @@ -334,15 +334,15 @@ bool8 MainMenuProcessKeyInput(u8 taskId) if (gMain.newKeys & A_BUTTON) { audio_play(SE_SELECT); - BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 0x10, 0); + BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 0x10, 0x0000); gTasks[taskId].func = MainMenuPressedA; } else if (gMain.newKeys & B_BUTTON) { audio_play(SE_SELECT); BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 0x10, 0xFFFF); - REG_WIN0H = 240; - REG_WIN0V = 160; + REG_WIN0H = WIN_RANGE(0, 240); + REG_WIN0V = WIN_RANGE(0, 160); gTasks[taskId].func = MainMenuPressedB; } else @@ -456,24 +456,24 @@ void MainMenuPressedA(u8 taskId) switch ((int)action) { - case 0: + case NEW_GAME: default: gPlttBufferUnfaded[0] = 0; gPlttBufferFaded[0] = 0; gTasks[taskId].func = Task_Birch1; break; - case 1: + case CONTINUE: gPlttBufferUnfaded[0] = 0; gPlttBufferFaded[0] = 0; SetMainCallback2(CB2_ContinueSavedGame); DestroyTask(taskId); break; - case 2: + case OPTION: gMain.field_8 = (u32)sub_80096FC; SetMainCallback2(CB2_InitOptionMenu); DestroyTask(taskId); break; - case 3: + case MYSTERY_EVENTS: SetMainCallback2(CB2_InitMysteryEventMenu); DestroyTask(taskId); break; @@ -491,7 +491,7 @@ void MainMenuPressedB(u8 taskId) void HighlightCurrentMenuItem(u8 layout, u8 menuItem) { - REG_WIN0H = 2535; + REG_WIN0H = WIN_RANGE(9, 231); switch (layout) { @@ -501,10 +501,10 @@ void HighlightCurrentMenuItem(u8 layout, u8 menuItem) { case 0: default: - REG_WIN0V = 287; + REG_WIN0V = WIN_RANGE(1, 31); break; case 1: - REG_WIN0V = 8511; + REG_WIN0V = WIN_RANGE(33, 63); break; } break; @@ -513,13 +513,13 @@ void HighlightCurrentMenuItem(u8 layout, u8 menuItem) { case 0: default: - REG_WIN0V = 319; + REG_WIN0V = WIN_RANGE(1, 63); break; case 1: - REG_WIN0V = 16735; + REG_WIN0V = WIN_RANGE(65, 95); break; case 2: - REG_WIN0V = 24959; + REG_WIN0V = WIN_RANGE(97, 127); break; } break; @@ -528,16 +528,16 @@ void HighlightCurrentMenuItem(u8 layout, u8 menuItem) { case 0: default: - REG_WIN0V = 319; + REG_WIN0V = WIN_RANGE(1, 63); break; case 1: - REG_WIN0V = 16735; + REG_WIN0V = WIN_RANGE(65, 95); break; case 2: - REG_WIN0V = 24959; + REG_WIN0V = WIN_RANGE(97, 127); break; case 3: - REG_WIN0V = 33183; + REG_WIN0V = WIN_RANGE(129, 159); break; } break; -- cgit v1.2.3 From 2085d7169e75b1fb417948d6e5167007064df258 Mon Sep 17 00:00:00 2001 From: YamaArashi Date: Mon, 5 Sep 2016 01:41:14 -0700 Subject: incorporate camthesaxman's birch speech decompilation work --- src/main_menu.c | 1061 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1061 insertions(+) (limited to 'src') diff --git a/src/main_menu.c b/src/main_menu.c index 87c3a671a..5e2e61f11 100644 --- a/src/main_menu.c +++ b/src/main_menu.c @@ -6,6 +6,7 @@ #include "rtc.h" #include "songs.h" #include "palette.h" +#include "string_util.h" extern u8 sub_8072080(void); extern void Print(u8 *, u8, u8); @@ -20,6 +21,29 @@ extern u8 *sub_8072C14(u8 *, s32, u8, u8); extern u8 sub_80729D8(u8 *, u8, u16, u8); extern u8 GetBadgeCount(void); extern void Task_Birch1(u8); +void AddTextPrinterWithCallbackForMessage(const u8 *string, u8 a, u8 b); +u8 sub_8072CF4(u8 a); +void sub_8072DEC(void); +u8 sub_8075374(void); +void sub_807206C(u32); +void cry_related(u16, u8); +void audio_play(u8 a); +void Reset(u8 a, u8 b, u8 c, u8 d); +u8 GetMenuCursorPos(void); +void DoNamingScreen(u8 r0, struct SaveBlock2 *r1, u16 r2, u16 r3, u8 s0, MainCallback s4); +void sub_8072974(u8 r0, u8 r1, u32 r2); +s8 FillWindowPixelBuffer(void); +void c2_load_new_map_2(void); +void LZ77UnCompVram(const void *src, void *dest); +void sub_8071C4C(const struct WindowConfig *); +void CB2_MainMenu(void); +void VBlankCB_MainMenu(void); +void DecompressPicFromTable_2(const struct SpriteSheet *, u8, u8, void *, void *, u32); +void LoadCompressedObjectPalette(const struct SpritePalette *); +void gpu_pal_obj_decompress_and_apply(u16, u8); +u8 AddNewGameBirchObject(u8, u8, u8); +u8 sub_80859BC(u8, u16, u16, u8, void *); +void DrawDefaultWindow(u8 a, u8 b, u8 c, u8 d); extern struct PaletteFadeControl gPaletteFade; extern u8 gSaveFileDeletedMessage[]; @@ -603,3 +627,1040 @@ void PrintBadgeCount(void) ConvertIntToDecimalString(buffer, GetBadgeCount()); sub_80729D8(buffer, 205, 40, 1); } + +//Text Strings +extern const u8 gUnknown_081C6D78[]; //Hi! Sorry to keep you waiting!... +extern const u8 gUnknown_081C6DF8[]; +extern const u8 gUnknown_081C6E1A[]; +extern const u8 gUnknown_081C6FCB[]; +extern const u8 gUnknown_081C6FD8[]; +extern const u8 gUnknown_081C6FFA[]; +extern u8 gUnknown_081C7017[]; +extern u8 gUnknown_081C7025[]; +extern u8 gUnknown_081C7074[]; + +struct MonCoords +{ + u8 x, y; +}; + +extern const struct MonCoords gMonFrontPicCoords[]; +extern const struct SpriteSheet gMonFrontPicTable[]; +extern const struct SpritePalette gMonPaletteTable[]; +extern struct SpriteTemplate gUnknown_02024E8C; +extern void * const gUnknown_081FAF4C[]; +extern u16 gUnknown_081E795C[]; +extern u8 * const gUnknown_081E79B0[][2]; +extern u8 * const gUnknown_081E79C0[][2]; +extern u8 * const gUnknown_081E79E8[][2]; + +extern const u8 gUnknown_081E764C[]; +extern const u8 gUnknown_081E768C[]; +extern const u8 gUnknown_081E7834[]; +extern const u8 gUnknown_081E796C[]; +extern const u8 gUnknown_0840DFF7[]; + +extern u8 gSpriteAffineAnimTable_81E79AC[]; + +extern struct Sprite gSprites[]; +extern u8 gStringVar4[]; + +extern u8 unk_2000000[]; + +void task_new_game_prof_birch_speech_2(u8 taskId); +void task_new_game_prof_birch_speech_3(u8 taskId); +void task_new_game_prof_birch_speech_4(u8 taskId); +void task_new_game_prof_birch_speech_5(u8 taskId); +void task_new_game_prof_birch_speech_6(u8 taskId); +void task_new_game_prof_birch_speech_7(u8 taskId); +void task_new_game_prof_birch_speech_8(u8 taskId); +void task_new_game_prof_birch_speech_9(u8 taskId); +void task_new_game_prof_birch_speech_10(u8 taskId); +void task_new_game_prof_birch_speech_11(u8 taskId); +void task_new_game_prof_birch_speech_12(u8 taskId); +void task_new_game_prof_birch_speech_13(u8 taskId); +void task_new_game_prof_birch_speech_14(u8 taskId); +void task_new_game_prof_birch_speech_15(u8 taskId); +void task_new_game_prof_birch_speech_16(u8 taskId); +void task_new_game_prof_birch_speech_17(u8 taskId); +void task_new_game_prof_birch_speech_18(u8 taskId); +void sub_800A974(u8 taskId); +void Task_800A9B4(u8 taskId); +void sub_800A9EC(u8 taskId); +void sub_800AAAC(u8 taskId); +void task_new_game_prof_birch_speech_part2_1(u8 taskId); +void sub_800AB38(u8 taskId); +void task_new_game_prof_birch_speech_part2_4(u8 taskId); +void sub_800AC20(u8 taskId); +void task_new_game_prof_birch_speech_part2_6(u8 taskId); +void task_new_game_prof_birch_speech_part2_7(u8 taskId); +void task_new_game_prof_birch_speech_part2_8(u8 taskId); +void task_new_game_prof_birch_speech_part2_9(u8 taskId); +void task_new_game_prof_birch_speech_part2_10(u8 taskId); +void sub_800AFC0(u8 taskId); +void sub_800B034(u8 taskId); +void new_game_prof_birch_speech_part2_start(); +void nullsub_34(struct Sprite *sprite); +void sub_800B240(struct Sprite *sprite); +u8 sub_800B25C(u8, u8); +void AddBirchSpeechObjects(u8); +void sub_800B3EC(u8); +void sub_800B458(u8, u8); +void sub_800B4C8(u8); +void sub_800B534(u8 taskId, u8 a); +void sub_800B5A8(u8); +void sub_800B614(u8, u8); +void sub_800B654(u8); +void sub_800B6C0(u8 taskId, u8 a); +void CreateGenderMenu(u8 left, u8 top); +s8 GenderMenuProcessInput(void); +void CreateNameMenu(u8 a, u8 b); +s8 NameMenuProcessInput(void); +void set_default_player_name(u8 a); + +void Task_Birch1(u8 taskId) +{ + SetUpWindowConfig(&gWindowConfig_81E6C3C); + sub_8071C4C(&gWindowConfig_81E6CE4); + REG_WIN0H = 0; + REG_WIN0V = 0; + REG_WININ = 0; + REG_WINOUT = 0; + REG_BLDCNT = 0; + REG_BLDALPHA = 0; + REG_BLDY = 0; + LZ77UnCompVram(gUnknown_081E768C, (void *)BG_VRAM); + LZ77UnCompVram(gUnknown_081E7834, (void *)(BG_VRAM + 0x3800)); + LoadPalette(gUnknown_081E764C, 0, 0x40); + LoadPalette(gUnknown_081E796C, 1, 0x10); + remove_some_task(); + ResetSpriteData(); + FreeAllSpritePalettes(); + AddBirchSpeechObjects(taskId); + BeginNormalPaletteFade(-1, 0, 0x10, 0, 0); + REG_BG1CNT = 0x00000703; + REG_DISPCNT = 0x9A << 5; + gTasks[taskId].data[4] = 0; + gTasks[taskId].func = task_new_game_prof_birch_speech_2; + gTasks[taskId].data[2] = 0xFF; + gTasks[taskId].data[3] = 0xFF; + gTasks[taskId].data[7] = 0xD8; + + sub_8075474(0xBB << 1); +} + +void task_new_game_prof_birch_speech_2(u8 taskId) +{ + struct Task *tasks = gTasks; + struct Task *task = &tasks[taskId]; + + if(task->data[7] != 0) + { + task->data[7]--; + } + else + { + u8 spriteId = task->data[8]; + struct Sprite *sprites = gSprites; + struct Sprite *sprite = &sprites[spriteId]; + sprite->pos1.x = 0x88; + sprite->pos1.y = 0x3C; + sprite->invisible = 0; + sprite->oam.objMode = 1; + sub_800B534(taskId, 0xA); + sub_800B6C0(taskId, 0x14); + task->data[7] = 0x50; + task->func = task_new_game_prof_birch_speech_3; + } +} + +void task_new_game_prof_birch_speech_3(u8 taskId) +{ + struct Task *tasks = gTasks; + struct Task *task = &tasks[taskId]; + + if(task->data[5] != 0) + { + struct Sprite *sprites = gSprites; + struct Sprite *sprite = &sprites[(s16)task->data[8]]; + + sprite->oam.objMode = 0; + if((u16)task->data[7]) + { + task->data[7]--; + } + else + { + DrawDefaultWindow(0x2, 0xD, 0x1B, 0x12); + AddTextPrinterWithCallbackForMessage(gUnknown_081C6D78, 0x3, 0xE); + task->func = task_new_game_prof_birch_speech_4; + } + } +} + +void task_new_game_prof_birch_speech_4(u8 taskId) +{ + if(!gPaletteFade.active && sub_8072CF4(0x18)) + { + struct Task *tasks = gTasks; + struct Task *task = &tasks[taskId]; + task->func = task_new_game_prof_birch_speech_5; + AddTextPrinterWithCallbackForMessage(gUnknown_081C6DF8, 0x3, 0xE); + } +} + +void task_new_game_prof_birch_speech_5(u8 taskId) +{ + if(sub_8072CF4(0x18)) + gTasks[taskId].func = task_new_game_prof_birch_speech_6; +} + +void task_new_game_prof_birch_speech_6(u8 taskId) +{ + struct Task *tasks = gTasks; + struct Task *task = &tasks[taskId]; + u8 data = (u8)task->data[9]; + struct Sprite *sprites = gSprites; + struct Sprite *sprite = &sprites[data]; + + sprite->pos1.x = 0x68; + sprite->pos1.y = 0x48; + sprite->invisible = 0; + sprite->data0 = 0; + AddTextPrinterForMessage(data, sprite->oam.paletteNum, 0x70, 0x3A, 0, 0, 0x20, 0x0000FFFF); + task->func = task_new_game_prof_birch_speech_7; + task->data[7] = 0; +} + +void task_new_game_prof_birch_speech_7(u8 taskId) +{ + struct Task *tasks; + struct Task *task; + + if(sub_8075374()) + { + struct Task *tasks = gTasks; + struct Task *task = &tasks[taskId]; //r5 + + if(task->data[7] > 0x5F) + { + sub_807206C((u32)&gUnknown_0840DFF7); + task->func = task_new_game_prof_birch_speech_8; + } + } + //_0800A4E4 + tasks = gTasks; + task = &tasks[taskId]; //r2 + if((s16)task->data[7] <= 0x00003fff) + { + task->data[7]++; + if(task->data[7] == 0x20) + { + cry_related(0xAF << 1, 0); + } + } +} + +void task_new_game_prof_birch_speech_8(u8 taskId) +{ + if(sub_8072CF4(0x18)) + { + AddTextPrinterWithCallbackForMessage(gUnknown_081C6E1A, 0x3, 0xE); + gTasks[taskId].func = task_new_game_prof_birch_speech_9; + } +} + +void task_new_game_prof_birch_speech_9(u8 taskId) +{ + if(sub_8072CF4(0x18)) + { + DrawDefaultWindow(0x2, 0xD, 0x1B, 0x12); + AddTextPrinterWithCallbackForMessage(gUnknown_081C6FCB, 0x3, 0xE); + gTasks[taskId].func = task_new_game_prof_birch_speech_10; + } +} + +void task_new_game_prof_birch_speech_10(u8 taskId) +{ + if(sub_8072CF4(0x18)) + { + struct Sprite *sprites = gSprites; + struct Task *tasks = gTasks; + struct Task *task = &tasks[taskId]; + struct Sprite *sprite = &sprites[task->data[8]]; + struct Sprite *sprite2; + + sprite->oam.objMode = 1; + sprite2 = &sprites[task->data[9]]; + sprite2->oam.objMode = 1; + sub_800B458(taskId, 0x2); + sub_800B614(taskId, 0x1); + task->data[7] = 0x40; + task->func = task_new_game_prof_birch_speech_11; + } +} + +void task_new_game_prof_birch_speech_11(u8 taskId) +{ + struct Task *tasks = gTasks; + struct Task *task = &tasks[taskId]; + + if((s16)task->data[4] != -0x3C) + { + task->data[4] -= 2; + REG_BG1HOFS = task->data[4]; + } + else + { + task->data[4] = 0x0000ffc4; + task->func = task_new_game_prof_birch_speech_12; + } +} + +//Fix Me: Uses a few different registers, and I can't figure out why. +void task_new_game_prof_birch_speech_12(u8 taskId) +{ + if(gTasks[taskId].data[5]) + { + gSprites[gTasks[taskId].data[8]].invisible = 1; + gSprites[gTasks[taskId].data[9]].invisible = 1; + + if(gTasks[taskId].data[7]) + { + gTasks[taskId].data[7]--; + } + else + { + u8 data10 = gTasks[taskId].data[10]; + + gSprites[data10].pos1.x = 0xB4; + gSprites[data10].pos1.y = 0x3C; + gSprites[data10].invisible = 0; + gSprites[data10].oam.objMode = 1; + gTasks[taskId].data[2] = data10; + gTasks[taskId].data[6] = 0; + sub_800B534(taskId, 2); + sub_800B6C0(taskId, 1); + gTasks[taskId].func = task_new_game_prof_birch_speech_13; + } + } +} + +void task_new_game_prof_birch_speech_13(u8 taskId) +{ + struct Task *tasks = gTasks; + struct Task *task = &tasks[taskId]; + + if(task->data[5]) + { + struct Sprite *sprites = gSprites; + struct Sprite *sprite = &sprites[task->data[2]]; + + sprite->oam.objMode = 0; + task->func = task_new_game_prof_birch_speech_14; + } +} + +void task_new_game_prof_birch_speech_14(u8 taskId) +{ + DrawDefaultWindow(2, 0xD, 0x1B, 0x12); + AddTextPrinterWithCallbackForMessage(gUnknown_081C6FD8, 3, 14); + gTasks[taskId].func = task_new_game_prof_birch_speech_15; +} + +void task_new_game_prof_birch_speech_15(u8 taskId) +{ + if(sub_8072CF4(0x18)) + { + CreateGenderMenu(2, 4); + gTasks[taskId].func = task_new_game_prof_birch_speech_16; + } +} + +//Fix Me +void task_new_game_prof_birch_speech_16(u8 taskId) +{ + u8 cursorPos; + + switch (GenderMenuProcessInput()) + { + case MALE: + sub_8072DEC(); + audio_play(5); + gSaveBlock2.playerGender = MALE; + Reset(2, 4, 8, 9); + gTasks[taskId].func = sub_800A974; + break; + case FEMALE: + sub_8072DEC(); + audio_play(5); + gSaveBlock2.playerGender = FEMALE; + Reset(2, 4, 8, 9); + gTasks[taskId].func = sub_800A974; + break; + } + + cursorPos = GetMenuCursorPos(); + + if(cursorPos != (s16)gTasks[taskId].data[6]) + { + gTasks[taskId].data[6] = cursorPos; + gSprites[gTasks[taskId].data[2]].oam.objMode = 1; + sub_800B458(taskId, 0); + gTasks[taskId].func = task_new_game_prof_birch_speech_17; + } +} + +void task_new_game_prof_birch_speech_17(u8 taskId) +{ + u8 spriteId = gTasks[taskId].data[2]; + + if(gTasks[taskId].data[5] == 0) + { + gSprites[spriteId].pos1.x += 4; + } + else + { + gSprites[spriteId].invisible = 1; + if(gTasks[taskId].data[6]) + { + spriteId = gTasks[taskId].data[11]; + } + else + { + spriteId = gTasks[taskId].data[10]; + } + + gSprites[spriteId].pos1.x = 0xF0; + gSprites[spriteId].pos1.y = 0x3C; + gSprites[spriteId].invisible = 0; + gTasks[taskId].data[2] = spriteId; + gSprites[spriteId].oam.objMode = 1; + sub_800B534(taskId, 0); + gTasks[taskId].func = task_new_game_prof_birch_speech_18; + } +} + +void task_new_game_prof_birch_speech_18(u8 taskId) +{ + u8 spriteId = gTasks[taskId].data[2]; + + if(gSprites[spriteId].pos1.x > 0xB4) + { + gSprites[spriteId].pos1.x -= 4; + } + else + { + gSprites[spriteId].pos1.x = 0xB4; + if(gTasks[taskId].data[5]) + { + gSprites[spriteId].oam.objMode = 0; + gTasks[taskId].func = task_new_game_prof_birch_speech_16; + } + } +} + +void sub_800A974(u8 taskId) +{ + DrawDefaultWindow(2, 13, 27, 18); + AddTextPrinterWithCallbackForMessage(gUnknown_081C6FFA, 3, 14); + gTasks[taskId].func = Task_800A9B4; +} + +void Task_800A9B4(u8 taskId) +{ + if(sub_8072CF4(0x18)) + { + CreateNameMenu(2, 1); + gTasks[taskId].func = sub_800A9EC; + } +} + +//Fix Me +void sub_800A9EC(u8 taskId) +{ + s8 n = NameMenuProcessInput(); + + switch (n) + { + case 1: + case 2: + case 3: + case 4: + sub_8072DEC(); + audio_play(5); + Reset(2, 1, 22, 12); + set_default_player_name(n); + gTasks[taskId].func = task_new_game_prof_birch_speech_part2_1; + break; + case 0: + audio_play(5); + BeginNormalPaletteFade(-1, 0, 0, 16, 0); + gTasks[taskId].func = sub_800AAAC; + break; + case -1: + sub_8072DEC(); + audio_play(5); + Reset(2, 1, 22, 12); + gTasks[taskId].func = task_new_game_prof_birch_speech_14; + break; + } +} + +//Fix Me +void sub_800AAAC(u8 taskId) +{ + if (!gPaletteFade.active) + { + set_default_player_name(1); + DoNamingScreen(0, &gSaveBlock2, gSaveBlock2.playerGender, 0, 0, new_game_prof_birch_speech_part2_start); + } +} + +void task_new_game_prof_birch_speech_part2_1(u8 taskId) +{ + DrawDefaultWindow(2, 13, 27, 18); + StringExpandPlaceholders(gStringVar4, gUnknown_081C7017); + AddTextPrinterWithCallbackForMessage(gStringVar4, 3, 14); + gTasks[taskId].func = sub_800AB38; +} + +void sub_800AB38(u8 taskId) +{ + if(sub_8072CF4(0x18)) + { + sub_8072974(2, 1, 1); + gTasks[taskId].func = task_new_game_prof_birch_speech_part2_4; + } +} + +void task_new_game_prof_birch_speech_part2_4(u8 taskId) +{ + switch (FillWindowPixelBuffer()) + { + case 0: + audio_play(5); + Reset(2, 1, 8, 7); + gSprites[gTasks[taskId].data[2]].oam.objMode = ST_OAM_OBJ_BLEND; + sub_800B458(taskId, 2); + sub_800B614(taskId, 1); + gTasks[taskId].func = sub_800AC20; + break; + case -1: + case 1: + audio_play(5); + Reset(2, 1, 8, 7); + gTasks[taskId].func = task_new_game_prof_birch_speech_14; + break; + } +} + +void sub_800AC20(u8 taskId) +{ + if(gTasks[taskId].data[4]) + { + gTasks[taskId].data[4] += 2; + REG_BG1HOFS = gTasks[taskId].data[4]; + } + else + { + gTasks[taskId].func = task_new_game_prof_birch_speech_part2_6; + } +} + +void task_new_game_prof_birch_speech_part2_6(u8 taskId) +{ + if(gTasks[taskId].data[5]) + { + s16 spriteId; + + spriteId = gTasks[taskId].data[10]; + gSprites[spriteId].invisible = 1; + + spriteId = gTasks[taskId].data[11]; + gSprites[spriteId].invisible = 1; + + spriteId = (u8)gTasks[taskId].data[8]; + gSprites[spriteId].pos1.x = 0x88; + gSprites[spriteId].pos1.y = 0x40; + gSprites[spriteId].invisible = 0; + gSprites[spriteId].oam.objMode = 1; + + spriteId = (u8)gTasks[taskId].data[9]; + gSprites[spriteId].pos1.x = 0x68; + gSprites[spriteId].pos1.y = 0x48; + gSprites[spriteId].invisible = 0; + gSprites[spriteId].oam.objMode = 1; + + sub_800B534(taskId, 2); + sub_800B6C0(taskId, 1); + DrawDefaultWindow(2, 13, 27, 18); + StringExpandPlaceholders(gStringVar4, gUnknown_081C7025); + AddTextPrinterWithCallbackForMessage(gStringVar4, 3, 14); + gTasks[taskId].func = task_new_game_prof_birch_speech_part2_7; + } +} + +void task_new_game_prof_birch_speech_part2_7(u8 taskId) +{ + if(gTasks[taskId].data[5]) + { + s16 spriteId; + + spriteId = gTasks[taskId].data[8]; + gSprites[spriteId].oam.objMode = 0; + + spriteId = gTasks[taskId].data[9]; + gSprites[spriteId].oam.objMode = 0; + + if(sub_8072CF4(0x18)) + { + spriteId = gTasks[taskId].data[8]; + gSprites[spriteId].oam.objMode = 1; + + spriteId = gTasks[taskId].data[9]; + gSprites[spriteId].oam.objMode = 1; + + sub_800B458(taskId, 2); + sub_800B614(taskId, 1); + gTasks[taskId].data[7] = 0x40; + gTasks[taskId].func = task_new_game_prof_birch_speech_part2_8; + } + } +} + +void task_new_game_prof_birch_speech_part2_8(u8 taskId) +{ + if(gTasks[taskId].data[5]) + { + s16 spriteId; + + spriteId = gTasks[taskId].data[8]; + gSprites[spriteId].invisible = 1; + + spriteId = gTasks[taskId].data[9]; + gSprites[spriteId].invisible = 1; + + if(gTasks[taskId].data[7]) + { + gTasks[taskId].data[7]--; + } + else + { + u8 spriteId; + + if(gSaveBlock2.playerGender) + spriteId = (u8)gTasks[taskId].data[11]; + else + spriteId = (u8)gTasks[taskId].data[10]; + + gSprites[spriteId].pos1.x = 0x78; + gSprites[spriteId].pos1.y = 0x3C; + gSprites[spriteId].invisible = 0; + gSprites[spriteId].oam.objMode = 1; + gTasks[taskId].data[2] = spriteId; + + sub_800B534(taskId, 2); + sub_800B6C0(taskId, 1); + DrawDefaultWindow(2, 13, 27, 18); + AddTextPrinterWithCallbackForMessage(gUnknown_081C7074, 3, 14); + gTasks[taskId].func = task_new_game_prof_birch_speech_part2_9; + } + } +} + +void task_new_game_prof_birch_speech_part2_9(u8 taskId) +{ + if(gTasks[taskId].data[5]) + { + s16 spriteId; + + spriteId = gTasks[taskId].data[2]; + gSprites[spriteId].oam.objMode = 0; + + if(sub_8072CF4(0x18)) + { + u8 spriteId; + + spriteId = gTasks[taskId].data[2]; + gSprites[spriteId].oam.affineMode = 1; + gSprites[spriteId].affineAnims = (union AffineAnimCmd **)gSpriteAffineAnimTable_81E79AC; + InitSpriteAffineAnim(&gSprites[spriteId]); + StartSpriteAffineAnim(&gSprites[spriteId], 0); + gSprites[spriteId].callback = sub_800B240; + BeginNormalPaletteFade(0x0000ffff, 0, 0, 0x10, 0); + play_sound_effect(4); + gTasks[taskId].func = task_new_game_prof_birch_speech_part2_10; + } + } +} + +void task_new_game_prof_birch_speech_part2_10(u8 taskId) +{ + u8 spriteId = gTasks[taskId].data[2]; + + if (gSprites[spriteId].affineAnimEnded) + gTasks[taskId].func = sub_800AFC0; +} + +void sub_800AFC0(u8 taskId) +{ + if (!gPaletteFade.active) + { + u8 spriteId = gTasks[taskId].data[2]; + gSprites[spriteId].callback = nullsub_34; + REG_DISPCNT = 4160; + BeginNormalPaletteFade(0xFFFF0000, 0, 0, 0x10, 0xFFFF); + gTasks[taskId].func = sub_800B034; + } +} + +void sub_800B034(u8 taskId) +{ + if (!gPaletteFade.active) + { + SetMainCallback2(c2_load_new_map_2); + DestroyTask(taskId); + } +} + +// CB2 +void new_game_prof_birch_speech_part2_start() +{ + u8 taskId; + u8 spriteId; + u16 savedIme; + + SetVBlankCallback(NULL); + + REG_DISPCNT = 0; + REG_BG2CNT = 0; + REG_BG1CNT = 0; + REG_BG0CNT = 0; + REG_BG2HOFS = 0; + REG_BG2VOFS = 0; + REG_BG1HOFS = 0; + REG_BG1VOFS = 0; + REG_BG0HOFS = 0; + REG_BG0VOFS = 0; + + DmaFill16(3, 0, (void *)VRAM, VRAM_SIZE); + DmaFill32(3, 0, (void *)OAM, OAM_SIZE); + DmaFill16(3, 0, (void *)PLTT, PLTT_SIZE); + + ResetPaletteFade(); + + LZ77UnCompVram(gUnknown_081E768C, (void *)BG_VRAM); + LZ77UnCompVram(gUnknown_081E7834, (void *)(BG_VRAM + 0x3800)); + + LoadPalette(gUnknown_081E764C, 0, 0x40); + + ResetTasks(); + + taskId = CreateTask(task_new_game_prof_birch_speech_part2_1, 0); + + gTasks[taskId].data[4] = -60; + + remove_some_task(); + ResetSpriteData(); + FreeAllSpritePalettes(); + AddBirchSpeechObjects(taskId); + + SetUpWindowConfig(&gWindowConfig_81E6C3C); + sub_8071C4C(&gWindowConfig_81E6CE4); + + if (gSaveBlock2.playerGender != MALE) + { + gTasks[taskId].data[6] = FEMALE; + spriteId = gTasks[taskId].data[11]; + } + else + { + gTasks[taskId].data[6] = MALE; + spriteId = gTasks[taskId].data[10]; + } + + gSprites[spriteId].pos1.x = 180; + gSprites[spriteId].pos1.y = 60; + gSprites[spriteId].invisible = 0; + + gTasks[taskId].data[2] = spriteId; + + REG_BG1HOFS = -60; + + BeginNormalPaletteFade(0xFFFFFFFFu, 0, 0x10, 0, 0); + + REG_WIN0H = 0; + REG_WIN0V = 0; + REG_WININ = 0; + REG_WINOUT = 0; + REG_BLDCNT = 0; + REG_BLDALPHA = 0; + REG_BLDY = 0; + + savedIme = REG_IME; + REG_IME = 0; + REG_IE |= INTR_FLAG_VBLANK; + REG_IME = savedIme; + + SetVBlankCallback(VBlankCB_MainMenu); + SetMainCallback2(CB2_MainMenu); + REG_BG1CNT = 1795; + REG_DISPCNT = 4928; +} + +void nullsub_34(struct Sprite *sprite) +{ +} + +void sub_800B240(struct Sprite *sprite) +{ + u32 y = (sprite->pos1.y << 16) + sprite->data0 + 0xC000; + sprite->pos1.y = y >> 16; + sprite->data0 = y; +} + +u8 sub_800B25C(u8 a1, u8 a2) +{ + DecompressPicFromTable_2( + &gMonFrontPicTable[350], + gMonFrontPicCoords[350].x, + gMonFrontPicCoords[350].y, + gUnknown_081FAF4C[0], + gUnknown_081FAF4C[1], + 350); + LoadCompressedObjectPalette(&gMonPaletteTable[350]); + gpu_pal_obj_decompress_and_apply(350, 1); + return CreateSprite(&gUnknown_02024E8C, a1, a2, 0); +} + +void AddBirchSpeechObjects(u8 taskId) +{ + u8 spriteId; + + spriteId = AddNewGameBirchObject(136, 60, 1); + gSprites[spriteId].callback = nullsub_34; + gSprites[spriteId].oam.priority = 0; + gSprites[spriteId].invisible = 1; + gTasks[taskId].data[8] = spriteId; + + spriteId = sub_800B25C(0x68, 0x48); + gSprites[spriteId].callback = nullsub_34; + gSprites[spriteId].oam.priority = 0; + gSprites[spriteId].invisible = 1; + gTasks[taskId].data[9] = spriteId; + + spriteId = sub_80859BC(0, 120, 60, 0, unk_2000000); + gSprites[spriteId].callback = nullsub_34; + gSprites[spriteId].invisible = 1; + gSprites[spriteId].oam.priority = 0; + gTasks[taskId].data[10] = spriteId; + + spriteId = sub_80859BC(1, 120, 60, 0, unk_2000000 + 0x800); + gSprites[spriteId].callback = nullsub_34; + gSprites[spriteId].invisible = 1; + gSprites[spriteId].oam.priority = 0; + gTasks[taskId].data[11] = spriteId; +} + +void sub_800B3EC(u8 taskId) +{ + if (gTasks[taskId].data[1] == 0) + { + gTasks[gTasks[taskId].data[0]].data[5] = 1; + DestroyTask(taskId); + } + else + { + if (gTasks[taskId].data[4]) + { + gTasks[taskId].data[4]--; + } + else + { + gTasks[taskId].data[4] = gTasks[taskId].data[3]; + gTasks[taskId].data[1]--; + gTasks[taskId].data[2]++; + REG_BLDALPHA = gTasks[taskId].data[1] + (gTasks[taskId].data[2] * 256); + } + } +} + +void sub_800B458(u8 taskId, u8 a2) +{ + u8 newTaskId; + + REG_BLDCNT = 592; + REG_BLDALPHA = 16; + REG_BLDY = 0; + gTasks[taskId].data[5] = 0; + newTaskId = CreateTask(sub_800B3EC, 0); + + gTasks[newTaskId].data[0] = taskId; + gTasks[newTaskId].data[1] = 16; + gTasks[newTaskId].data[2] = 0; + gTasks[newTaskId].data[3] = a2; + gTasks[newTaskId].data[4] = a2; +} + +void sub_800B4C8(u8 taskId) +{ + if (gTasks[taskId].data[1] == 16) + { + gTasks[gTasks[taskId].data[0]].data[5] = 1; + DestroyTask(taskId); + } + else if (gTasks[taskId].data[4]) + { + gTasks[taskId].data[4]--; + } + else + { + gTasks[taskId].data[4] = gTasks[taskId].data[3]; + gTasks[taskId].data[1]++; + gTasks[taskId].data[2]--; + REG_BLDALPHA = gTasks[taskId].data[1] + (gTasks[taskId].data[2] * 256); + } +} + +void sub_800B534(u8 taskId, u8 a2) +{ + u8 newTaskId; + + REG_BLDCNT = 592; + REG_BLDALPHA = 4096; + REG_BLDY = 0; + gTasks[taskId].data[5] = 0; + newTaskId = CreateTask(sub_800B4C8, 0); + + gTasks[newTaskId].data[0] = taskId; + gTasks[newTaskId].data[1] = 0; + gTasks[newTaskId].data[2] = 16; + gTasks[newTaskId].data[3] = a2; + gTasks[newTaskId].data[4] = a2; +} + +void sub_800B5A8(u8 taskId) +{ + if (gTasks[taskId].data[2]) + { + gTasks[taskId].data[2]--; + } + else + { + if (gTasks[taskId].data[1] == 8) + { + DestroyTask(taskId); + } + else if (gTasks[taskId].data[4]) + { + gTasks[taskId].data[4]--; + } + else + { + gTasks[taskId].data[4] = gTasks[taskId].data[3]; + gTasks[taskId].data[1]++; + LoadPalette(&gUnknown_081E795C[gTasks[taskId].data[1]], 1, 0x10); + } + } +} + +void sub_800B614(u8 a1, u8 a2) +{ + u8 newTaskId = CreateTask(sub_800B5A8, 0); + gTasks[newTaskId].data[0] = a1; + gTasks[newTaskId].data[1] = 0; + gTasks[newTaskId].data[2] = 8; + gTasks[newTaskId].data[3] = a2; + gTasks[newTaskId].data[4] = a2; +} + +void sub_800B654(u8 taskId) +{ + if (gTasks[taskId].data[2]) + { + gTasks[taskId].data[2]--; + } + else + { + if (gTasks[taskId].data[1] == 0) + { + DestroyTask(taskId); + } + else + { + if (gTasks[taskId].data[4]) + { + gTasks[taskId].data[4]--; + } + else + { + gTasks[taskId].data[4] = gTasks[taskId].data[3]; + gTasks[taskId].data[1]--; + LoadPalette(&gUnknown_081E795C[gTasks[taskId].data[1]], 1, 0x10); + } + } + } +} + +void sub_800B6C0(u8 a1, u8 a2) +{ + u8 newTaskId = CreateTask(sub_800B654, 0); + gTasks[newTaskId].data[0] = a1; + gTasks[newTaskId].data[1] = 8; + gTasks[newTaskId].data[2] = 8; + gTasks[newTaskId].data[3] = a2; + gTasks[newTaskId].data[4] = a2; +} + +void CreateGenderMenu(u8 left, u8 top) +{ + u8 menuLeft, menuTop; + DrawDefaultWindow(left, top, left + 6, top + 5); + menuLeft = left + 1; + menuTop = top + 1; + PrintStringArray(menuLeft, menuTop, 2, gUnknown_081E79B0); + InitMenu(0, menuLeft, menuTop, 2, 0, 5); +} + +s8 GenderMenuProcessInput(void) +{ + return ProcessMenuInputNoWrap(); +} + +void CreateNameMenu(u8 left, u8 top) +{ + DrawDefaultWindow(left, top, left + 10, top + 11); + + if (gSaveBlock2.playerGender == MALE) + { + PrintStringArray((u8)(left + 1), (u8)(top + 1), 5, gUnknown_081E79C0); + } + else + { + PrintStringArray((u8)(left + 1), (u8)(top + 1), 5, gUnknown_081E79E8); + } + + InitMenu(0, (u8)(left + 1), (u8)(top + 1), 5, 0, 9); +} + +s8 NameMenuProcessInput(void) +{ + return ProcessMenuInput(); +} + +void set_default_player_name(u8 index) +{ + u8 i; + u8 *name; + + if (gSaveBlock2.playerGender == MALE) + name = gUnknown_081E79C0[index][0]; + else + name = gUnknown_081E79E8[index][0]; + + for (i = 0; i < 7; i++) + gSaveBlock2.playerName[i] = name[i]; + + gSaveBlock2.playerName[i] = EOS; +} -- cgit v1.2.3 From fcb116339a7cc4bebc478970008171d8dbca3a90 Mon Sep 17 00:00:00 2001 From: YamaArashi Date: Mon, 5 Sep 2016 02:29:10 -0700 Subject: tab to spaces --- src/main_menu.c | 176 ++++++++++++++++++++++++++++---------------------------- 1 file changed, 88 insertions(+), 88 deletions(-) (limited to 'src') diff --git a/src/main_menu.c b/src/main_menu.c index 5e2e61f11..e41aecbb2 100644 --- a/src/main_menu.c +++ b/src/main_menu.c @@ -720,82 +720,82 @@ void set_default_player_name(u8 a); void Task_Birch1(u8 taskId) { - SetUpWindowConfig(&gWindowConfig_81E6C3C); - sub_8071C4C(&gWindowConfig_81E6CE4); - REG_WIN0H = 0; - REG_WIN0V = 0; - REG_WININ = 0; - REG_WINOUT = 0; - REG_BLDCNT = 0; - REG_BLDALPHA = 0; - REG_BLDY = 0; - LZ77UnCompVram(gUnknown_081E768C, (void *)BG_VRAM); + SetUpWindowConfig(&gWindowConfig_81E6C3C); + sub_8071C4C(&gWindowConfig_81E6CE4); + REG_WIN0H = 0; + REG_WIN0V = 0; + REG_WININ = 0; + REG_WINOUT = 0; + REG_BLDCNT = 0; + REG_BLDALPHA = 0; + REG_BLDY = 0; + LZ77UnCompVram(gUnknown_081E768C, (void *)BG_VRAM); LZ77UnCompVram(gUnknown_081E7834, (void *)(BG_VRAM + 0x3800)); - LoadPalette(gUnknown_081E764C, 0, 0x40); - LoadPalette(gUnknown_081E796C, 1, 0x10); - remove_some_task(); - ResetSpriteData(); - FreeAllSpritePalettes(); - AddBirchSpeechObjects(taskId); - BeginNormalPaletteFade(-1, 0, 0x10, 0, 0); - REG_BG1CNT = 0x00000703; - REG_DISPCNT = 0x9A << 5; - gTasks[taskId].data[4] = 0; - gTasks[taskId].func = task_new_game_prof_birch_speech_2; - gTasks[taskId].data[2] = 0xFF; - gTasks[taskId].data[3] = 0xFF; - gTasks[taskId].data[7] = 0xD8; - - sub_8075474(0xBB << 1); + LoadPalette(gUnknown_081E764C, 0, 0x40); + LoadPalette(gUnknown_081E796C, 1, 0x10); + remove_some_task(); + ResetSpriteData(); + FreeAllSpritePalettes(); + AddBirchSpeechObjects(taskId); + BeginNormalPaletteFade(-1, 0, 0x10, 0, 0); + REG_BG1CNT = 0x00000703; + REG_DISPCNT = 0x9A << 5; + gTasks[taskId].data[4] = 0; + gTasks[taskId].func = task_new_game_prof_birch_speech_2; + gTasks[taskId].data[2] = 0xFF; + gTasks[taskId].data[3] = 0xFF; + gTasks[taskId].data[7] = 0xD8; + + sub_8075474(0xBB << 1); } void task_new_game_prof_birch_speech_2(u8 taskId) { - struct Task *tasks = gTasks; - struct Task *task = &tasks[taskId]; - - if(task->data[7] != 0) - { - task->data[7]--; - } - else - { - u8 spriteId = task->data[8]; - struct Sprite *sprites = gSprites; - struct Sprite *sprite = &sprites[spriteId]; - sprite->pos1.x = 0x88; - sprite->pos1.y = 0x3C; - sprite->invisible = 0; - sprite->oam.objMode = 1; - sub_800B534(taskId, 0xA); - sub_800B6C0(taskId, 0x14); - task->data[7] = 0x50; - task->func = task_new_game_prof_birch_speech_3; - } + struct Task *tasks = gTasks; + struct Task *task = &tasks[taskId]; + + if(task->data[7] != 0) + { + task->data[7]--; + } + else + { + u8 spriteId = task->data[8]; + struct Sprite *sprites = gSprites; + struct Sprite *sprite = &sprites[spriteId]; + sprite->pos1.x = 0x88; + sprite->pos1.y = 0x3C; + sprite->invisible = 0; + sprite->oam.objMode = 1; + sub_800B534(taskId, 0xA); + sub_800B6C0(taskId, 0x14); + task->data[7] = 0x50; + task->func = task_new_game_prof_birch_speech_3; + } } void task_new_game_prof_birch_speech_3(u8 taskId) { - struct Task *tasks = gTasks; - struct Task *task = &tasks[taskId]; - - if(task->data[5] != 0) - { - struct Sprite *sprites = gSprites; - struct Sprite *sprite = &sprites[(s16)task->data[8]]; - - sprite->oam.objMode = 0; - if((u16)task->data[7]) - { - task->data[7]--; - } - else - { - DrawDefaultWindow(0x2, 0xD, 0x1B, 0x12); - AddTextPrinterWithCallbackForMessage(gUnknown_081C6D78, 0x3, 0xE); - task->func = task_new_game_prof_birch_speech_4; - } - } + struct Task *tasks = gTasks; + struct Task *task = &tasks[taskId]; + + if(task->data[5] != 0) + { + struct Sprite *sprites = gSprites; + struct Sprite *sprite = &sprites[(s16)task->data[8]]; + + sprite->oam.objMode = 0; + if((u16)task->data[7]) + { + task->data[7]--; + } + else + { + DrawDefaultWindow(0x2, 0xD, 0x1B, 0x12); + AddTextPrinterWithCallbackForMessage(gUnknown_081C6D78, 0x3, 0xE); + task->func = task_new_game_prof_birch_speech_4; + } + } } void task_new_game_prof_birch_speech_4(u8 taskId) @@ -811,30 +811,30 @@ void task_new_game_prof_birch_speech_4(u8 taskId) void task_new_game_prof_birch_speech_5(u8 taskId) { - if(sub_8072CF4(0x18)) - gTasks[taskId].func = task_new_game_prof_birch_speech_6; + if(sub_8072CF4(0x18)) + gTasks[taskId].func = task_new_game_prof_birch_speech_6; } void task_new_game_prof_birch_speech_6(u8 taskId) { - struct Task *tasks = gTasks; - struct Task *task = &tasks[taskId]; - u8 data = (u8)task->data[9]; - struct Sprite *sprites = gSprites; - struct Sprite *sprite = &sprites[data]; - - sprite->pos1.x = 0x68; - sprite->pos1.y = 0x48; - sprite->invisible = 0; - sprite->data0 = 0; - AddTextPrinterForMessage(data, sprite->oam.paletteNum, 0x70, 0x3A, 0, 0, 0x20, 0x0000FFFF); - task->func = task_new_game_prof_birch_speech_7; - task->data[7] = 0; + struct Task *tasks = gTasks; + struct Task *task = &tasks[taskId]; + u8 data = (u8)task->data[9]; + struct Sprite *sprites = gSprites; + struct Sprite *sprite = &sprites[data]; + + sprite->pos1.x = 0x68; + sprite->pos1.y = 0x48; + sprite->invisible = 0; + sprite->data0 = 0; + AddTextPrinterForMessage(data, sprite->oam.paletteNum, 0x70, 0x3A, 0, 0, 0x20, 0x0000FFFF); + task->func = task_new_game_prof_birch_speech_7; + task->data[7] = 0; } void task_new_game_prof_birch_speech_7(u8 taskId) { - struct Task *tasks; + struct Task *tasks; struct Task *task; if(sub_8075374()) @@ -863,7 +863,7 @@ void task_new_game_prof_birch_speech_7(u8 taskId) void task_new_game_prof_birch_speech_8(u8 taskId) { - if(sub_8072CF4(0x18)) + if(sub_8072CF4(0x18)) { AddTextPrinterWithCallbackForMessage(gUnknown_081C6E1A, 0x3, 0xE); gTasks[taskId].func = task_new_game_prof_birch_speech_9; @@ -872,7 +872,7 @@ void task_new_game_prof_birch_speech_8(u8 taskId) void task_new_game_prof_birch_speech_9(u8 taskId) { - if(sub_8072CF4(0x18)) + if(sub_8072CF4(0x18)) { DrawDefaultWindow(0x2, 0xD, 0x1B, 0x12); AddTextPrinterWithCallbackForMessage(gUnknown_081C6FCB, 0x3, 0xE); @@ -903,7 +903,7 @@ void task_new_game_prof_birch_speech_10(u8 taskId) void task_new_game_prof_birch_speech_11(u8 taskId) { struct Task *tasks = gTasks; - struct Task *task = &tasks[taskId]; + struct Task *task = &tasks[taskId]; if((s16)task->data[4] != -0x3C) { @@ -949,7 +949,7 @@ void task_new_game_prof_birch_speech_12(u8 taskId) void task_new_game_prof_birch_speech_13(u8 taskId) { struct Task *tasks = gTasks; - struct Task *task = &tasks[taskId]; + struct Task *task = &tasks[taskId]; if(task->data[5]) { @@ -963,7 +963,7 @@ void task_new_game_prof_birch_speech_13(u8 taskId) void task_new_game_prof_birch_speech_14(u8 taskId) { - DrawDefaultWindow(2, 0xD, 0x1B, 0x12); + DrawDefaultWindow(2, 0xD, 0x1B, 0x12); AddTextPrinterWithCallbackForMessage(gUnknown_081C6FD8, 3, 14); gTasks[taskId].func = task_new_game_prof_birch_speech_15; } -- cgit v1.2.3 From 755784f388a1cbafe6af1dd350eaf340334d325b Mon Sep 17 00:00:00 2001 From: YamaArashi Date: Mon, 5 Sep 2016 02:30:51 -0700 Subject: trailing whitespace --- src/main_menu.c | 68 ++++++++++++++++++++++++++++----------------------------- 1 file changed, 34 insertions(+), 34 deletions(-) (limited to 'src') diff --git a/src/main_menu.c b/src/main_menu.c index e41aecbb2..e2520f031 100644 --- a/src/main_menu.c +++ b/src/main_menu.c @@ -745,7 +745,7 @@ void Task_Birch1(u8 taskId) gTasks[taskId].data[2] = 0xFF; gTasks[taskId].data[3] = 0xFF; gTasks[taskId].data[7] = 0xD8; - + sub_8075474(0xBB << 1); } @@ -753,7 +753,7 @@ void task_new_game_prof_birch_speech_2(u8 taskId) { struct Task *tasks = gTasks; struct Task *task = &tasks[taskId]; - + if(task->data[7] != 0) { task->data[7]--; @@ -778,12 +778,12 @@ void task_new_game_prof_birch_speech_3(u8 taskId) { struct Task *tasks = gTasks; struct Task *task = &tasks[taskId]; - + if(task->data[5] != 0) { struct Sprite *sprites = gSprites; struct Sprite *sprite = &sprites[(s16)task->data[8]]; - + sprite->oam.objMode = 0; if((u16)task->data[7]) { @@ -822,7 +822,7 @@ void task_new_game_prof_birch_speech_6(u8 taskId) u8 data = (u8)task->data[9]; struct Sprite *sprites = gSprites; struct Sprite *sprite = &sprites[data]; - + sprite->pos1.x = 0x68; sprite->pos1.y = 0x48; sprite->invisible = 0; @@ -836,12 +836,12 @@ void task_new_game_prof_birch_speech_7(u8 taskId) { struct Task *tasks; struct Task *task; - + if(sub_8075374()) { struct Task *tasks = gTasks; struct Task *task = &tasks[taskId]; //r5 - + if(task->data[7] > 0x5F) { sub_807206C((u32)&gUnknown_0840DFF7); @@ -889,7 +889,7 @@ void task_new_game_prof_birch_speech_10(u8 taskId) struct Task *task = &tasks[taskId]; struct Sprite *sprite = &sprites[task->data[8]]; struct Sprite *sprite2; - + sprite->oam.objMode = 1; sprite2 = &sprites[task->data[9]]; sprite2->oam.objMode = 1; @@ -904,7 +904,7 @@ void task_new_game_prof_birch_speech_11(u8 taskId) { struct Task *tasks = gTasks; struct Task *task = &tasks[taskId]; - + if((s16)task->data[4] != -0x3C) { task->data[4] -= 2; @@ -932,7 +932,7 @@ void task_new_game_prof_birch_speech_12(u8 taskId) else { u8 data10 = gTasks[taskId].data[10]; - + gSprites[data10].pos1.x = 0xB4; gSprites[data10].pos1.y = 0x3C; gSprites[data10].invisible = 0; @@ -950,12 +950,12 @@ void task_new_game_prof_birch_speech_13(u8 taskId) { struct Task *tasks = gTasks; struct Task *task = &tasks[taskId]; - + if(task->data[5]) { struct Sprite *sprites = gSprites; struct Sprite *sprite = &sprites[task->data[2]]; - + sprite->oam.objMode = 0; task->func = task_new_game_prof_birch_speech_14; } @@ -1014,7 +1014,7 @@ void task_new_game_prof_birch_speech_16(u8 taskId) void task_new_game_prof_birch_speech_17(u8 taskId) { u8 spriteId = gTasks[taskId].data[2]; - + if(gTasks[taskId].data[5] == 0) { gSprites[spriteId].pos1.x += 4; @@ -1030,7 +1030,7 @@ void task_new_game_prof_birch_speech_17(u8 taskId) { spriteId = gTasks[taskId].data[10]; } - + gSprites[spriteId].pos1.x = 0xF0; gSprites[spriteId].pos1.y = 0x3C; gSprites[spriteId].invisible = 0; @@ -1044,7 +1044,7 @@ void task_new_game_prof_birch_speech_17(u8 taskId) void task_new_game_prof_birch_speech_18(u8 taskId) { u8 spriteId = gTasks[taskId].data[2]; - + if(gSprites[spriteId].pos1.x > 0xB4) { gSprites[spriteId].pos1.x -= 4; @@ -1173,25 +1173,25 @@ void task_new_game_prof_birch_speech_part2_6(u8 taskId) if(gTasks[taskId].data[5]) { s16 spriteId; - + spriteId = gTasks[taskId].data[10]; gSprites[spriteId].invisible = 1; - + spriteId = gTasks[taskId].data[11]; gSprites[spriteId].invisible = 1; - + spriteId = (u8)gTasks[taskId].data[8]; gSprites[spriteId].pos1.x = 0x88; gSprites[spriteId].pos1.y = 0x40; gSprites[spriteId].invisible = 0; gSprites[spriteId].oam.objMode = 1; - + spriteId = (u8)gTasks[taskId].data[9]; gSprites[spriteId].pos1.x = 0x68; gSprites[spriteId].pos1.y = 0x48; gSprites[spriteId].invisible = 0; gSprites[spriteId].oam.objMode = 1; - + sub_800B534(taskId, 2); sub_800B6C0(taskId, 1); DrawDefaultWindow(2, 13, 27, 18); @@ -1206,21 +1206,21 @@ void task_new_game_prof_birch_speech_part2_7(u8 taskId) if(gTasks[taskId].data[5]) { s16 spriteId; - + spriteId = gTasks[taskId].data[8]; gSprites[spriteId].oam.objMode = 0; - + spriteId = gTasks[taskId].data[9]; gSprites[spriteId].oam.objMode = 0; - + if(sub_8072CF4(0x18)) { spriteId = gTasks[taskId].data[8]; gSprites[spriteId].oam.objMode = 1; - + spriteId = gTasks[taskId].data[9]; gSprites[spriteId].oam.objMode = 1; - + sub_800B458(taskId, 2); sub_800B614(taskId, 1); gTasks[taskId].data[7] = 0x40; @@ -1234,13 +1234,13 @@ void task_new_game_prof_birch_speech_part2_8(u8 taskId) if(gTasks[taskId].data[5]) { s16 spriteId; - + spriteId = gTasks[taskId].data[8]; gSprites[spriteId].invisible = 1; - + spriteId = gTasks[taskId].data[9]; gSprites[spriteId].invisible = 1; - + if(gTasks[taskId].data[7]) { gTasks[taskId].data[7]--; @@ -1248,18 +1248,18 @@ void task_new_game_prof_birch_speech_part2_8(u8 taskId) else { u8 spriteId; - + if(gSaveBlock2.playerGender) spriteId = (u8)gTasks[taskId].data[11]; else spriteId = (u8)gTasks[taskId].data[10]; - + gSprites[spriteId].pos1.x = 0x78; gSprites[spriteId].pos1.y = 0x3C; gSprites[spriteId].invisible = 0; gSprites[spriteId].oam.objMode = 1; gTasks[taskId].data[2] = spriteId; - + sub_800B534(taskId, 2); sub_800B6C0(taskId, 1); DrawDefaultWindow(2, 13, 27, 18); @@ -1274,14 +1274,14 @@ void task_new_game_prof_birch_speech_part2_9(u8 taskId) if(gTasks[taskId].data[5]) { s16 spriteId; - + spriteId = gTasks[taskId].data[2]; gSprites[spriteId].oam.objMode = 0; - + if(sub_8072CF4(0x18)) { u8 spriteId; - + spriteId = gTasks[taskId].data[2]; gSprites[spriteId].oam.affineMode = 1; gSprites[spriteId].affineAnims = (union AffineAnimCmd **)gSpriteAffineAnimTable_81E79AC; -- cgit v1.2.3 From 3d10fc8c40fdbbb763288bf4083cd1eed80d20e5 Mon Sep 17 00:00:00 2001 From: YamaArashi Date: Mon, 5 Sep 2016 02:32:12 -0700 Subject: remove obsolete fixme comments --- src/main_menu.c | 4 ---- 1 file changed, 4 deletions(-) (limited to 'src') diff --git a/src/main_menu.c b/src/main_menu.c index e2520f031..830894c7b 100644 --- a/src/main_menu.c +++ b/src/main_menu.c @@ -917,7 +917,6 @@ void task_new_game_prof_birch_speech_11(u8 taskId) } } -//Fix Me: Uses a few different registers, and I can't figure out why. void task_new_game_prof_birch_speech_12(u8 taskId) { if(gTasks[taskId].data[5]) @@ -977,7 +976,6 @@ void task_new_game_prof_birch_speech_15(u8 taskId) } } -//Fix Me void task_new_game_prof_birch_speech_16(u8 taskId) { u8 cursorPos; @@ -1076,7 +1074,6 @@ void Task_800A9B4(u8 taskId) } } -//Fix Me void sub_800A9EC(u8 taskId) { s8 n = NameMenuProcessInput(); @@ -1107,7 +1104,6 @@ void sub_800A9EC(u8 taskId) } } -//Fix Me void sub_800AAAC(u8 taskId) { if (!gPaletteFade.active) -- cgit v1.2.3 From 110fc301e1fcc8ed132323bf10c9464e826af37e Mon Sep 17 00:00:00 2001 From: YamaArashi Date: Mon, 5 Sep 2016 13:09:52 -0700 Subject: text_window.c --- src/text_window.c | 195 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 195 insertions(+) create mode 100644 src/text_window.c (limited to 'src') diff --git a/src/text_window.c b/src/text_window.c new file mode 100644 index 000000000..6a24fc67d --- /dev/null +++ b/src/text_window.c @@ -0,0 +1,195 @@ +#include "global.h" +#include "main.h" +#include "text.h" + +u16 sub_8064EF4(u16); +void sub_8064F08(struct Window *); +void sub_8064F38(struct Window *, u8); +void sub_8064F6C(struct Window *, u8); +void AddTextPrinterParametrized(struct Window *win, u8 left, u8 top, u8 right, u8 bottom); +const struct FrameGraphics *sub_8064FD4(u8 frameType); +static void sub_8064FF8(u8, void *); +static void sub_8065014(u8, u8); +static void DrawWindowInternal(u16 *dest, u16 baseTileNum, u8 left, u8 top, u8 right, u8 bottom); +u16 sub_80651C8(u16); +void unref_sub_80651DC(struct Window *, u8 *); +void copy_textbox_border_tile_patterns_to_vram(struct Window *); +static u16 draw_win_3(u16 tilemapEntry, u8 x, u8 y, u8 width, u8 height); +static void draw_win_2(struct Window *win, u8 left, u8 top, u8 width, u8 height); +void draw_win(struct Window *win); +void sub_8065348(struct Window *win); +void sub_806536C(struct Window *win); + +static u16 sTextWindowBaseTileNum; +static u16 sMessageBoxBaseTileNum; + +struct FrameGraphics +{ + u8 *tiles; + u16 *palette; +}; + +extern const struct FrameGraphics gUnknown_083761F0[20]; + +extern const u16 gMessageBoxTilemap[5][7]; +extern const u8 gMessageBox_Gfx[]; + +u16 sub_8064EF4(u16 baseTileNum) +{ + sTextWindowBaseTileNum = baseTileNum; + return baseTileNum + 9; +} + +void sub_8064F08(struct Window *win) +{ + u8 *tileData = win->config->tileData + TILE_SIZE_4BPP * sTextWindowBaseTileNum; + sub_8064FF8(gSaveBlock2.optionsWindowFrameType, tileData); + sub_8065014(gSaveBlock2.optionsWindowFrameType, 0xE); +} + +void sub_8064F38(struct Window *win, u8 a2) +{ + u8 *tileData = win->config->tileData + TILE_SIZE_4BPP * sTextWindowBaseTileNum; + sub_8064FF8(gSaveBlock2.optionsWindowFrameType, tileData); + sub_8065014(gSaveBlock2.optionsWindowFrameType, a2); +} + +void sub_8064F6C(struct Window *win, u8 frameType) +{ + u8 *tileData = win->config->tileData + TILE_SIZE_4BPP * sTextWindowBaseTileNum; + sub_8064FF8(frameType, tileData); + sub_8065014(frameType, 0xE); +} + +void AddTextPrinterParametrized(struct Window *win, u8 left, u8 top, u8 right, u8 bottom) +{ + DrawWindowInternal(win->config->tilemap, sTextWindowBaseTileNum, left, top, right, bottom); +} + +const struct FrameGraphics *sub_8064FD4(u8 frameType) +{ + if (frameType > 19) + return &gUnknown_083761F0[0]; + else + return &gUnknown_083761F0[frameType]; +} + +static void sub_8064FF8(u8 frameType, void *dest) +{ + const struct FrameGraphics *frameGraphics = sub_8064FD4(frameType); + CpuFastCopy(frameGraphics->tiles, dest, 9 * TILE_SIZE_4BPP); +} + +static void sub_8065014(u8 frameType, u8 palSlot) +{ + const struct FrameGraphics *frameGraphics = sub_8064FD4(frameType); + LoadPalette(frameGraphics->palette, 16 * palSlot, 0x20); +} + +static void DrawWindowInternal(u16 *dest, u16 baseTileNum, u8 left, u8 top, u8 right, u8 bottom) +{ + u8 x, y; + u8 startX, endX; + u8 startY, endY; + + startX = (left < right) ? left : right; + endX = (right > left) ? right : left; + + startY = (top < bottom) ? top : bottom; + endY = (bottom > top) ? bottom : top; + + dest[32 * startY + startX] = baseTileNum | 0xE000; + + for (x = startX + 1; x < endX; x++) + dest[32 * startY + x] = (baseTileNum + 1) | 0xE000; + + dest[32 * startY + endX] = (baseTileNum + 2) | 0xE000; + + for (y = startY + 1; y < endY; y++) + { + dest[32 * y + startX] = (baseTileNum + 3) | 0xE000; + + for (x = startX + 1; x < endX; x++) + dest[32 * y + x] = (baseTileNum + 4) | 0xE000; + + dest[32 * y + endX] = (baseTileNum + 5) | 0xE000; + } + + dest[32 * endY + startX] = (baseTileNum + 6) | 0xE000; + + for (x = startX + 1; x < endX; x++) + dest[32 * endY + x] = (baseTileNum + 7) | 0xE000; + + dest[32 * endY + endX] = (baseTileNum + 8) | 0xE000; +} + +u16 sub_80651C8(u16 a1) +{ + sMessageBoxBaseTileNum = a1; + return a1 + 14; +} + +void unref_sub_80651DC(struct Window *win, u8 *text) +{ + sub_8002EB0(win, text, sMessageBoxBaseTileNum + 14, 2, 15); +} + +void copy_textbox_border_tile_patterns_to_vram(struct Window *win) +{ + sub_8065348(win); + draw_win(win); +} + +static u16 draw_win_3(u16 baseTilemapEntry, u8 x, u8 y, u8 width, u8 height) +{ + u16 tilemapEntry = 9; + + if (y >= height) + y = y - height + 3; + else if (y > 1) + y = 2; + + if (x >= width + 2) + x = x - (width + 2) + 4; + else if (x > 2) + x = 3; + + if (x <= 6 && y <= 4) + tilemapEntry = gMessageBoxTilemap[y][x]; + + tilemapEntry += baseTilemapEntry; + + return tilemapEntry; +} + +static void draw_win_2(struct Window *win, u8 left, u8 top, u8 width, u8 height) +{ + u8 i, j; + u16 tilemapEntry = (win->paletteNum << 12) | sMessageBoxBaseTileNum; + u16 *tilemap = win->config->tilemap; + + for (i = 0; i < height + 2; i++) + for (j = 0; j < width + 6; j++) + tilemap[(left + j) + 32 * (top + i)] = (win->paletteNum << 12) | draw_win_3(tilemapEntry, j, i, width, height); +} + +void draw_win(struct Window *win) +{ + draw_win_2(win, 0, 14, 26, 4); +} + +void sub_8065348(struct Window *win) +{ + u8 *tileData = win->config->tileData; + CpuFastCopy(gMessageBox_Gfx, tileData + 32 * sMessageBoxBaseTileNum, 14 * TILE_SIZE_4BPP); +} + +void sub_806536C(struct Window *win) +{ + u8 i; + u16 *tilemap = win->config->tilemap + 0x1C0; + u16 tilemapEntry = win->paletteNum << 12; + + for (i = 0; i < 0xC0; i++) + tilemap[i] = tilemapEntry; +} -- cgit v1.2.3 From 80b3dc30e6784c40791997dc6284c5069caeb27c Mon Sep 17 00:00:00 2001 From: YamaArashi Date: Mon, 5 Sep 2016 13:09:52 -0700 Subject: rename text window functions --- src/menu.c | 33 +++++++++----------- src/text_window.c | 93 ++++++++++++++++++++++++++++--------------------------- 2 files changed, 61 insertions(+), 65 deletions(-) (limited to 'src') diff --git a/src/menu.c b/src/menu.c index aff3655da..0e9c34c69 100644 --- a/src/menu.c +++ b/src/menu.c @@ -2,6 +2,7 @@ #include "main.h" #include "text.h" #include "songs.h" +#include "text_window.h" struct Menu { @@ -83,12 +84,6 @@ void sub_8072DCC(u8); void sub_8072DDC(u8); void sub_8072DEC(void); -extern u16 sub_8064EF4(u16); -extern void sub_8064F08(struct Window *); -extern void sub_8064F6C(struct Window *, u8); -extern u16 sub_80651C8(u16); -extern void AddTextPrinterParametrized(struct Window *win, u8 left, u8 top, u8 right, u8 bottom); -extern void copy_textbox_border_tile_patterns_to_vram(struct Window *); extern void sub_814A5C0(u8, u16, u8, u16, u8); extern void sub_814A880(u8, u8); extern void sub_814A904(void); @@ -140,13 +135,13 @@ bool32 sub_8071C94(void) goto fail; goto next; case 3: - word_202E9D2 = sub_8064EF4(word_202E9D0); + word_202E9D2 = SetTextWindowBaseTileNum(word_202E9D0); next: byte_202E9CC++; return 0; case 4: - sub_8064F08(dword_202E9C8); - word_202E9D4 = sub_80651C8(word_202E9D2); + LoadTextWindowGraphics(dword_202E9C8); + word_202E9D4 = SetMessageBoxBaseTileNum(word_202E9D2); return 1; default: fail: @@ -160,9 +155,9 @@ void sub_8071D48(struct WindowConfig *a1, u16 a2) InitWindowFromConfig(&stru_202E908, a1); word_202E9CE = a2; word_202E9D0 = InitWindowTileData(dword_202E9C8, word_202E9CE); - word_202E9D2 = sub_8064EF4(word_202E9D0); - sub_8064F08(dword_202E9C8); - word_202E9D4 = sub_80651C8(word_202E9D2); + word_202E9D2 = SetTextWindowBaseTileNum(word_202E9D0); + LoadTextWindowGraphics(dword_202E9C8); + word_202E9D4 = SetMessageBoxBaseTileNum(word_202E9D2); } void unref_sub_8071DA4(struct WindowConfig *a1, u16 a2) @@ -170,20 +165,20 @@ void unref_sub_8071DA4(struct WindowConfig *a1, u16 a2) dword_202E9C8 = &stru_202E908; InitWindowFromConfig(&stru_202E908, a1); word_202E9D0 = a2; - word_202E9D2 = sub_8064EF4(word_202E9D0); - sub_8064F08(dword_202E9C8); - word_202E9CE = sub_80651C8(word_202E9D2); + word_202E9D2 = SetTextWindowBaseTileNum(word_202E9D0); + LoadTextWindowGraphics(dword_202E9C8); + word_202E9CE = SetMessageBoxBaseTileNum(word_202E9D2); word_202E9D4 = InitWindowTileData(dword_202E9C8, word_202E9CE); } void sub_8071E00(u8 a1) { - sub_8064F6C(dword_202E9C8, a1); + LoadTextWindowGraphics_OverrideFrameType(dword_202E9C8, a1); } void GetMapNamePopUpWindowId(void) { - sub_8064F08(dword_202E9C8); + LoadTextWindowGraphics(dword_202E9C8); } void sub_8071E2C(struct WindowConfig *a1) @@ -214,7 +209,7 @@ void sub_8071EF4(void) void DrawDefaultWindow(u8 left, u8 top, u8 right, u8 bottom) { - AddTextPrinterParametrized(dword_202E9C8, left, top, right, bottom); + DrawTextWindow(dword_202E9C8, left, top, right, bottom); } void sub_8071F40(u8 *str) @@ -240,7 +235,7 @@ void unref_sub_8071FBC(u16 a1, u8 a2, u8 a3, u8 a4, u8 a5) void sub_8071FFC(void) { - copy_textbox_border_tile_patterns_to_vram(dword_202E9C8); + DisplayMessageBox(dword_202E9C8); } void AddTextPrinterWithCallbackForMessage(u8 *str, u8 a2, u8 a3) diff --git a/src/text_window.c b/src/text_window.c index 6a24fc67d..ab14fe1fb 100644 --- a/src/text_window.c +++ b/src/text_window.c @@ -1,23 +1,24 @@ #include "global.h" #include "main.h" #include "text.h" - -u16 sub_8064EF4(u16); -void sub_8064F08(struct Window *); -void sub_8064F38(struct Window *, u8); -void sub_8064F6C(struct Window *, u8); -void AddTextPrinterParametrized(struct Window *win, u8 left, u8 top, u8 right, u8 bottom); -const struct FrameGraphics *sub_8064FD4(u8 frameType); -static void sub_8064FF8(u8, void *); -static void sub_8065014(u8, u8); -static void DrawWindowInternal(u16 *dest, u16 baseTileNum, u8 left, u8 top, u8 right, u8 bottom); -u16 sub_80651C8(u16); +#include "text_window.h" + +u16 SetTextWindowBaseTileNum(u16); +void LoadTextWindowGraphics(struct Window *); +void LoadTextWindowGraphics_OverridePalSlot(struct Window *, u8); +void LoadTextWindowGraphics_OverrideFrameType(struct Window *, u8); +void DrawTextWindow(struct Window *win, u8 left, u8 top, u8 right, u8 bottom); +const struct FrameGraphics *GetTextWindowFrameGraphics(u8 frameType); +static void LoadTextWindowTiles(u8, void *); +static void LoadTextWindowPalette(u8, u8); +static void DrawTextWindowInternal(u16 *dest, u16 baseTileNum, u8 left, u8 top, u8 right, u8 bottom); +u16 SetMessageBoxBaseTileNum(u16); void unref_sub_80651DC(struct Window *, u8 *); -void copy_textbox_border_tile_patterns_to_vram(struct Window *); -static u16 draw_win_3(u16 tilemapEntry, u8 x, u8 y, u8 width, u8 height); -static void draw_win_2(struct Window *win, u8 left, u8 top, u8 width, u8 height); -void draw_win(struct Window *win); -void sub_8065348(struct Window *win); +void DisplayMessageBox(struct Window *); +static u16 GetMessageBoxTilemapEntry(u16 tilemapEntry, u8 x, u8 y, u8 width, u8 height); +static void DrawMessageBox(struct Window *win, u8 left, u8 top, u8 width, u8 height); +void DrawStandardMessageBox(struct Window *win); +void LoadMessageBoxTiles(struct Window *win); void sub_806536C(struct Window *win); static u16 sTextWindowBaseTileNum; @@ -34,39 +35,39 @@ extern const struct FrameGraphics gUnknown_083761F0[20]; extern const u16 gMessageBoxTilemap[5][7]; extern const u8 gMessageBox_Gfx[]; -u16 sub_8064EF4(u16 baseTileNum) +u16 SetTextWindowBaseTileNum(u16 baseTileNum) { sTextWindowBaseTileNum = baseTileNum; return baseTileNum + 9; } -void sub_8064F08(struct Window *win) +void LoadTextWindowGraphics(struct Window *win) { u8 *tileData = win->config->tileData + TILE_SIZE_4BPP * sTextWindowBaseTileNum; - sub_8064FF8(gSaveBlock2.optionsWindowFrameType, tileData); - sub_8065014(gSaveBlock2.optionsWindowFrameType, 0xE); + LoadTextWindowTiles(gSaveBlock2.optionsWindowFrameType, tileData); + LoadTextWindowPalette(gSaveBlock2.optionsWindowFrameType, 0xE); } -void sub_8064F38(struct Window *win, u8 a2) +void LoadTextWindowGraphics_OverridePalSlot(struct Window *win, u8 palSlot) { u8 *tileData = win->config->tileData + TILE_SIZE_4BPP * sTextWindowBaseTileNum; - sub_8064FF8(gSaveBlock2.optionsWindowFrameType, tileData); - sub_8065014(gSaveBlock2.optionsWindowFrameType, a2); + LoadTextWindowTiles(gSaveBlock2.optionsWindowFrameType, tileData); + LoadTextWindowPalette(gSaveBlock2.optionsWindowFrameType, palSlot); } -void sub_8064F6C(struct Window *win, u8 frameType) +void LoadTextWindowGraphics_OverrideFrameType(struct Window *win, u8 frameType) { u8 *tileData = win->config->tileData + TILE_SIZE_4BPP * sTextWindowBaseTileNum; - sub_8064FF8(frameType, tileData); - sub_8065014(frameType, 0xE); + LoadTextWindowTiles(frameType, tileData); + LoadTextWindowPalette(frameType, 0xE); } -void AddTextPrinterParametrized(struct Window *win, u8 left, u8 top, u8 right, u8 bottom) +void DrawTextWindow(struct Window *win, u8 left, u8 top, u8 right, u8 bottom) { - DrawWindowInternal(win->config->tilemap, sTextWindowBaseTileNum, left, top, right, bottom); + DrawTextWindowInternal(win->config->tilemap, sTextWindowBaseTileNum, left, top, right, bottom); } -const struct FrameGraphics *sub_8064FD4(u8 frameType) +const struct FrameGraphics *GetTextWindowFrameGraphics(u8 frameType) { if (frameType > 19) return &gUnknown_083761F0[0]; @@ -74,19 +75,19 @@ const struct FrameGraphics *sub_8064FD4(u8 frameType) return &gUnknown_083761F0[frameType]; } -static void sub_8064FF8(u8 frameType, void *dest) +static void LoadTextWindowTiles(u8 frameType, void *dest) { - const struct FrameGraphics *frameGraphics = sub_8064FD4(frameType); + const struct FrameGraphics *frameGraphics = GetTextWindowFrameGraphics(frameType); CpuFastCopy(frameGraphics->tiles, dest, 9 * TILE_SIZE_4BPP); } -static void sub_8065014(u8 frameType, u8 palSlot) +static void LoadTextWindowPalette(u8 frameType, u8 palSlot) { - const struct FrameGraphics *frameGraphics = sub_8064FD4(frameType); + const struct FrameGraphics *frameGraphics = GetTextWindowFrameGraphics(frameType); LoadPalette(frameGraphics->palette, 16 * palSlot, 0x20); } -static void DrawWindowInternal(u16 *dest, u16 baseTileNum, u8 left, u8 top, u8 right, u8 bottom) +static void DrawTextWindowInternal(u16 *dest, u16 baseTileNum, u8 left, u8 top, u8 right, u8 bottom) { u8 x, y; u8 startX, endX; @@ -123,10 +124,10 @@ static void DrawWindowInternal(u16 *dest, u16 baseTileNum, u8 left, u8 top, u8 r dest[32 * endY + endX] = (baseTileNum + 8) | 0xE000; } -u16 sub_80651C8(u16 a1) +u16 SetMessageBoxBaseTileNum(u16 baseTileNum) { - sMessageBoxBaseTileNum = a1; - return a1 + 14; + sMessageBoxBaseTileNum = baseTileNum; + return baseTileNum + 14; } void unref_sub_80651DC(struct Window *win, u8 *text) @@ -134,13 +135,13 @@ void unref_sub_80651DC(struct Window *win, u8 *text) sub_8002EB0(win, text, sMessageBoxBaseTileNum + 14, 2, 15); } -void copy_textbox_border_tile_patterns_to_vram(struct Window *win) +void DisplayMessageBox(struct Window *win) { - sub_8065348(win); - draw_win(win); + LoadMessageBoxTiles(win); + DrawStandardMessageBox(win); } -static u16 draw_win_3(u16 baseTilemapEntry, u8 x, u8 y, u8 width, u8 height) +static u16 GetMessageBoxTilemapEntry(u16 baseTilemapEntry, u8 x, u8 y, u8 width, u8 height) { u16 tilemapEntry = 9; @@ -162,7 +163,7 @@ static u16 draw_win_3(u16 baseTilemapEntry, u8 x, u8 y, u8 width, u8 height) return tilemapEntry; } -static void draw_win_2(struct Window *win, u8 left, u8 top, u8 width, u8 height) +static void DrawMessageBox(struct Window *win, u8 left, u8 top, u8 width, u8 height) { u8 i, j; u16 tilemapEntry = (win->paletteNum << 12) | sMessageBoxBaseTileNum; @@ -170,15 +171,15 @@ static void draw_win_2(struct Window *win, u8 left, u8 top, u8 width, u8 height) for (i = 0; i < height + 2; i++) for (j = 0; j < width + 6; j++) - tilemap[(left + j) + 32 * (top + i)] = (win->paletteNum << 12) | draw_win_3(tilemapEntry, j, i, width, height); + tilemap[(left + j) + 32 * (top + i)] = (win->paletteNum << 12) | GetMessageBoxTilemapEntry(tilemapEntry, j, i, width, height); } -void draw_win(struct Window *win) +void DrawStandardMessageBox(struct Window *win) { - draw_win_2(win, 0, 14, 26, 4); + DrawMessageBox(win, 0, 14, 26, 4); } -void sub_8065348(struct Window *win) +void LoadMessageBoxTiles(struct Window *win) { u8 *tileData = win->config->tileData; CpuFastCopy(gMessageBox_Gfx, tileData + 32 * sMessageBoxBaseTileNum, 14 * TILE_SIZE_4BPP); -- cgit v1.2.3 From 079989e1bb3333381d3e90246550d20a2f46caa9 Mon Sep 17 00:00:00 2001 From: YamaArashi Date: Mon, 5 Sep 2016 19:41:05 -0700 Subject: rename menu functions --- src/link.c | 8 +- src/main_menu.c | 142 ++++++++++++++--------------- src/menu.c | 274 ++++++++++++++++++++++++++++---------------------------- 3 files changed, 212 insertions(+), 212 deletions(-) (limited to 'src') diff --git a/src/link.c b/src/link.c index a5d848b83..0fa1f4673 100644 --- a/src/link.c +++ b/src/link.c @@ -27,7 +27,7 @@ struct LinkTestBGInfo u32 dummy_C; }; -extern void sub_8071C4C(const struct WindowConfig *); +extern void InitMenuWindowConfig(const struct WindowConfig *); extern void sub_80516C4(u8, u16); extern u8 unk_2000000[]; @@ -237,7 +237,7 @@ static void LinkTestScreen(void) ResetTasks(); SetVBlankCallback(VBlankCB_LinkTest); SetUpWindowConfig(&gWindowConfig_81E6CE4); - sub_8071C4C(&gWindowConfig_81E6CE4); + InitMenuWindowConfig(&gWindowConfig_81E6CE4); ResetBlockSend(); gLinkType = 0x1111; OpenLink(); @@ -1224,8 +1224,8 @@ void CB2_LinkError(void) ResetTasks(); SetVBlankCallback(VBlankCB_LinkTest); SetUpWindowConfig(&gWindowConfig_81E7198); - sub_8071C4C(&gWindowConfig_81E7198); - sub_8071EF4(); + InitMenuWindowConfig(&gWindowConfig_81E7198); + MenuZeroFillScreen(); REG_BLDALPHA = 0; REG_BG0VOFS = 0; REG_BG0HOFS = 0; diff --git a/src/main_menu.c b/src/main_menu.c index 830894c7b..246cf72a3 100644 --- a/src/main_menu.c +++ b/src/main_menu.c @@ -8,8 +8,8 @@ #include "palette.h" #include "string_util.h" -extern u8 sub_8072080(void); -extern void Print(u8 *, u8, u8); +extern u8 MenuUpdateWindowText(void); +extern void MenuPrint(u8 *, u8, u8); extern void CB2_ContinueSavedGame(void); extern void CB2_InitMysteryEventMenu(void); extern void CB2_InitOptionMenu(void); @@ -21,21 +21,21 @@ extern u8 *sub_8072C14(u8 *, s32, u8, u8); extern u8 sub_80729D8(u8 *, u8, u16, u8); extern u8 GetBadgeCount(void); extern void Task_Birch1(u8); -void AddTextPrinterWithCallbackForMessage(const u8 *string, u8 a, u8 b); +void MenuPrintMessage(const u8 *string, u8 a, u8 b); u8 sub_8072CF4(u8 a); void sub_8072DEC(void); u8 sub_8075374(void); -void sub_807206C(u32); +void MenuSetText(u32); void cry_related(u16, u8); void audio_play(u8 a); -void Reset(u8 a, u8 b, u8 c, u8 d); +void MenuZeroFillWindowRect(u8 a, u8 b, u8 c, u8 d); u8 GetMenuCursorPos(void); void DoNamingScreen(u8 r0, struct SaveBlock2 *r1, u16 r2, u16 r3, u8 s0, MainCallback s4); -void sub_8072974(u8 r0, u8 r1, u32 r2); -s8 FillWindowPixelBuffer(void); +void DisplayYesNoMenu(u8 r0, u8 r1, u32 r2); +s8 ProcessMenuInputNoWrap_(void); void c2_load_new_map_2(void); void LZ77UnCompVram(const void *src, void *dest); -void sub_8071C4C(const struct WindowConfig *); +void InitMenuWindowConfig(const struct WindowConfig *); void CB2_MainMenu(void); void VBlankCB_MainMenu(void); void DecompressPicFromTable_2(const struct SpriteSheet *, u8, u8, void *, void *, u32); @@ -43,7 +43,7 @@ void LoadCompressedObjectPalette(const struct SpritePalette *); void gpu_pal_obj_decompress_and_apply(u16, u8); u8 AddNewGameBirchObject(u8, u8, u8); u8 sub_80859BC(u8, u16, u16, u8, void *); -void DrawDefaultWindow(u8 a, u8 b, u8 c, u8 d); +void MenuDrawTextWindow(u8 a, u8 b, u8 c, u8 d); extern struct PaletteFadeControl gPaletteFade; extern u8 gSaveFileDeletedMessage[]; @@ -139,7 +139,7 @@ u32 InitMainMenu(u8 a1) ResetSpriteData(); FreeAllSpritePalettes(); SetUpWindowConfig(&gWindowConfig_81E6C3C); - sub_8071C4C(&gWindowConfig_81E6CE4); + InitMenuWindowConfig(&gWindowConfig_81E6CE4); if (a1) BeginNormalPaletteFade(-1, 0, 0x10, 0, 0x0000); // fade to black @@ -197,16 +197,16 @@ void Task_CheckSave(u8 taskId) gTasks[taskId].func = Task_CheckRtc; break; case 2: - DrawDefaultWindow(2, 14, 27, 19); - AddTextPrinterWithCallbackForMessage(gSaveFileDeletedMessage, 3, 15); + MenuDrawTextWindow(2, 14, 27, 19); + MenuPrintMessage(gSaveFileDeletedMessage, 3, 15); REG_WIN0H = WIN_RANGE(17, 223); REG_WIN0V = WIN_RANGE(113, 159); gTasks[taskId].data[0] = 0; gTasks[taskId].func = Task_WaitForSaveErrorAck; break; case 255: - DrawDefaultWindow(2, 14, 27, 19); - AddTextPrinterWithCallbackForMessage(gSaveFileCorruptMessage, 3, 15); + MenuDrawTextWindow(2, 14, 27, 19); + MenuPrintMessage(gSaveFileCorruptMessage, 3, 15); REG_WIN0H = WIN_RANGE(17, 223); REG_WIN0V = WIN_RANGE(113, 159); gTasks[taskId].data[0] = 1; @@ -223,8 +223,8 @@ void Task_CheckSave(u8 taskId) gTasks[taskId].func = Task_CheckRtc; break; case 4: - DrawDefaultWindow(2, 14, 27, 19); - AddTextPrinterWithCallbackForMessage(gBoardNotInstalledMessage, 3, 15); + MenuDrawTextWindow(2, 14, 27, 19); + MenuPrintMessage(gBoardNotInstalledMessage, 3, 15); REG_WIN0H = WIN_RANGE(17, 223); REG_WIN0V = WIN_RANGE(113, 159); gTasks[taskId].data[0] = 0; @@ -235,11 +235,11 @@ void Task_CheckSave(u8 taskId) void Task_WaitForSaveErrorAck(u8 taskId) { - if (sub_8072080()) + if (MenuUpdateWindowText()) { if (gMain.newKeys & A_BUTTON) { - Reset(2, 14, 27, 19); + MenuZeroFillWindowRect(2, 14, 27, 19); gTasks[taskId].func = Task_CheckRtc; } } @@ -263,8 +263,8 @@ void Task_CheckRtc(u8 taskId) } else { - DrawDefaultWindow(2, 14, 27, 19); - AddTextPrinterWithCallbackForMessage(gBatteryDryMessage, 3, 15); + MenuDrawTextWindow(2, 14, 27, 19); + MenuPrintMessage(gBatteryDryMessage, 3, 15); REG_WIN0H = WIN_RANGE(17, 223); REG_WIN0V = WIN_RANGE(113, 159); gTasks[taskId].func = Task_WaitForRtcErrorAck; @@ -274,11 +274,11 @@ void Task_CheckRtc(u8 taskId) void Task_WaitForRtcErrorAck(u8 taskId) { - if (sub_8072080()) + if (MenuUpdateWindowText()) { if ( gMain.newKeys & 1 ) { - Reset(2, 14, 27, 19); + MenuZeroFillWindowRect(2, 14, 27, 19); gTasks[taskId].func = Task_DrawMainMenu; } } @@ -316,28 +316,28 @@ void Task_DrawMainMenu(u8 taskId) { case 0: default: - DrawDefaultWindow(1, 0, 28, 3); + MenuDrawTextWindow(1, 0, 28, 3); PrintMainMenuItem(gMainMenuString_NewGame, 2, 1); - DrawDefaultWindow(1, 4, 28, 7); + MenuDrawTextWindow(1, 4, 28, 7); PrintMainMenuItem(gMainMenuString_Option, 2, 5); break; case 1: - DrawDefaultWindow(1, 0, 28, 7); + MenuDrawTextWindow(1, 0, 28, 7); PrintMainMenuItem(gMainMenuString_Continue, 2, 1); - DrawDefaultWindow(1, 8, 28, 11); + MenuDrawTextWindow(1, 8, 28, 11); PrintMainMenuItem(gMainMenuString_NewGame, 2, 9); - DrawDefaultWindow(1, 12, 28, 15); + MenuDrawTextWindow(1, 12, 28, 15); PrintMainMenuItem(gMainMenuString_Option, 2, 13); PrintSaveFileInfo(); break; case 2: - DrawDefaultWindow(1, 0, 28, 7); + MenuDrawTextWindow(1, 0, 28, 7); PrintMainMenuItem(gMainMenuString_Continue, 2, 1); - DrawDefaultWindow(1, 8, 28, 11); + MenuDrawTextWindow(1, 8, 28, 11); PrintMainMenuItem(gMainMenuString_NewGame, 2, 9); - DrawDefaultWindow(1, 12, 28, 15); + MenuDrawTextWindow(1, 12, 28, 15); PrintMainMenuItem(gMainMenuString_MysteryEvents, 2, 13); - DrawDefaultWindow(1, 16, 28, 19); + MenuDrawTextWindow(1, 16, 28, 19); PrintMainMenuItem(gMainMenuString_Option, 2, 0x11); PrintSaveFileInfo(); break; @@ -582,7 +582,7 @@ void PrintMainMenuItem(u8 *text, u8 left, u8 top) buffer[29] = EOS; - Print(buffer, left, top); + MenuPrint(buffer, left, top); } void PrintSaveFileInfo(void) @@ -595,8 +595,8 @@ void PrintSaveFileInfo(void) void PrintPlayerName(void) { - Print(gMainMenuString_Player, 2, 3); - Print(gSaveBlock2.playerName, 9, 3); + MenuPrint(gMainMenuString_Player, 2, 3); + MenuPrint(gSaveBlock2.playerName, 9, 3); } void PrintPlayTime(void) @@ -604,26 +604,26 @@ void PrintPlayTime(void) u8 playTime[16]; u8 alignedPlayTime[32]; - Print(gMainMenuString_Time, 16, 3); + MenuPrint(gMainMenuString_Time, 16, 3); FormatPlayTime(playTime, gSaveBlock2.playTimeHours, gSaveBlock2.playTimeMinutes, 1); sub_8072C74(alignedPlayTime, playTime, 48, 1); - Print(alignedPlayTime, 22, 3); + MenuPrint(alignedPlayTime, 22, 3); } void PrintPokedexCount(void) { u8 buffer[16]; - Print(gMainMenuString_Pokedex, 2, 5); + MenuPrint(gMainMenuString_Pokedex, 2, 5); sub_8072C14(buffer, GetPokedexSeenCount(), 18, 0); - Print(buffer, 9, 5); + MenuPrint(buffer, 9, 5); } void PrintBadgeCount(void) { u8 buffer[16]; - Print(gMainMenuString_Badges, 16, 5); + MenuPrint(gMainMenuString_Badges, 16, 5); ConvertIntToDecimalString(buffer, GetBadgeCount()); sub_80729D8(buffer, 205, 40, 1); } @@ -721,7 +721,7 @@ void set_default_player_name(u8 a); void Task_Birch1(u8 taskId) { SetUpWindowConfig(&gWindowConfig_81E6C3C); - sub_8071C4C(&gWindowConfig_81E6CE4); + InitMenuWindowConfig(&gWindowConfig_81E6CE4); REG_WIN0H = 0; REG_WIN0V = 0; REG_WININ = 0; @@ -791,8 +791,8 @@ void task_new_game_prof_birch_speech_3(u8 taskId) } else { - DrawDefaultWindow(0x2, 0xD, 0x1B, 0x12); - AddTextPrinterWithCallbackForMessage(gUnknown_081C6D78, 0x3, 0xE); + MenuDrawTextWindow(0x2, 0xD, 0x1B, 0x12); + MenuPrintMessage(gUnknown_081C6D78, 0x3, 0xE); task->func = task_new_game_prof_birch_speech_4; } } @@ -805,7 +805,7 @@ void task_new_game_prof_birch_speech_4(u8 taskId) struct Task *tasks = gTasks; struct Task *task = &tasks[taskId]; task->func = task_new_game_prof_birch_speech_5; - AddTextPrinterWithCallbackForMessage(gUnknown_081C6DF8, 0x3, 0xE); + MenuPrintMessage(gUnknown_081C6DF8, 0x3, 0xE); } } @@ -844,7 +844,7 @@ void task_new_game_prof_birch_speech_7(u8 taskId) if(task->data[7] > 0x5F) { - sub_807206C((u32)&gUnknown_0840DFF7); + MenuSetText((u32)&gUnknown_0840DFF7); task->func = task_new_game_prof_birch_speech_8; } } @@ -865,7 +865,7 @@ void task_new_game_prof_birch_speech_8(u8 taskId) { if(sub_8072CF4(0x18)) { - AddTextPrinterWithCallbackForMessage(gUnknown_081C6E1A, 0x3, 0xE); + MenuPrintMessage(gUnknown_081C6E1A, 0x3, 0xE); gTasks[taskId].func = task_new_game_prof_birch_speech_9; } } @@ -874,8 +874,8 @@ void task_new_game_prof_birch_speech_9(u8 taskId) { if(sub_8072CF4(0x18)) { - DrawDefaultWindow(0x2, 0xD, 0x1B, 0x12); - AddTextPrinterWithCallbackForMessage(gUnknown_081C6FCB, 0x3, 0xE); + MenuDrawTextWindow(0x2, 0xD, 0x1B, 0x12); + MenuPrintMessage(gUnknown_081C6FCB, 0x3, 0xE); gTasks[taskId].func = task_new_game_prof_birch_speech_10; } } @@ -962,8 +962,8 @@ void task_new_game_prof_birch_speech_13(u8 taskId) void task_new_game_prof_birch_speech_14(u8 taskId) { - DrawDefaultWindow(2, 0xD, 0x1B, 0x12); - AddTextPrinterWithCallbackForMessage(gUnknown_081C6FD8, 3, 14); + MenuDrawTextWindow(2, 0xD, 0x1B, 0x12); + MenuPrintMessage(gUnknown_081C6FD8, 3, 14); gTasks[taskId].func = task_new_game_prof_birch_speech_15; } @@ -986,14 +986,14 @@ void task_new_game_prof_birch_speech_16(u8 taskId) sub_8072DEC(); audio_play(5); gSaveBlock2.playerGender = MALE; - Reset(2, 4, 8, 9); + MenuZeroFillWindowRect(2, 4, 8, 9); gTasks[taskId].func = sub_800A974; break; case FEMALE: sub_8072DEC(); audio_play(5); gSaveBlock2.playerGender = FEMALE; - Reset(2, 4, 8, 9); + MenuZeroFillWindowRect(2, 4, 8, 9); gTasks[taskId].func = sub_800A974; break; } @@ -1060,8 +1060,8 @@ void task_new_game_prof_birch_speech_18(u8 taskId) void sub_800A974(u8 taskId) { - DrawDefaultWindow(2, 13, 27, 18); - AddTextPrinterWithCallbackForMessage(gUnknown_081C6FFA, 3, 14); + MenuDrawTextWindow(2, 13, 27, 18); + MenuPrintMessage(gUnknown_081C6FFA, 3, 14); gTasks[taskId].func = Task_800A9B4; } @@ -1086,7 +1086,7 @@ void sub_800A9EC(u8 taskId) case 4: sub_8072DEC(); audio_play(5); - Reset(2, 1, 22, 12); + MenuZeroFillWindowRect(2, 1, 22, 12); set_default_player_name(n); gTasks[taskId].func = task_new_game_prof_birch_speech_part2_1; break; @@ -1098,7 +1098,7 @@ void sub_800A9EC(u8 taskId) case -1: sub_8072DEC(); audio_play(5); - Reset(2, 1, 22, 12); + MenuZeroFillWindowRect(2, 1, 22, 12); gTasks[taskId].func = task_new_game_prof_birch_speech_14; break; } @@ -1115,9 +1115,9 @@ void sub_800AAAC(u8 taskId) void task_new_game_prof_birch_speech_part2_1(u8 taskId) { - DrawDefaultWindow(2, 13, 27, 18); + MenuDrawTextWindow(2, 13, 27, 18); StringExpandPlaceholders(gStringVar4, gUnknown_081C7017); - AddTextPrinterWithCallbackForMessage(gStringVar4, 3, 14); + MenuPrintMessage(gStringVar4, 3, 14); gTasks[taskId].func = sub_800AB38; } @@ -1125,18 +1125,18 @@ void sub_800AB38(u8 taskId) { if(sub_8072CF4(0x18)) { - sub_8072974(2, 1, 1); + DisplayYesNoMenu(2, 1, 1); gTasks[taskId].func = task_new_game_prof_birch_speech_part2_4; } } void task_new_game_prof_birch_speech_part2_4(u8 taskId) { - switch (FillWindowPixelBuffer()) + switch (ProcessMenuInputNoWrap_()) { case 0: audio_play(5); - Reset(2, 1, 8, 7); + MenuZeroFillWindowRect(2, 1, 8, 7); gSprites[gTasks[taskId].data[2]].oam.objMode = ST_OAM_OBJ_BLEND; sub_800B458(taskId, 2); sub_800B614(taskId, 1); @@ -1145,7 +1145,7 @@ void task_new_game_prof_birch_speech_part2_4(u8 taskId) case -1: case 1: audio_play(5); - Reset(2, 1, 8, 7); + MenuZeroFillWindowRect(2, 1, 8, 7); gTasks[taskId].func = task_new_game_prof_birch_speech_14; break; } @@ -1190,9 +1190,9 @@ void task_new_game_prof_birch_speech_part2_6(u8 taskId) sub_800B534(taskId, 2); sub_800B6C0(taskId, 1); - DrawDefaultWindow(2, 13, 27, 18); + MenuDrawTextWindow(2, 13, 27, 18); StringExpandPlaceholders(gStringVar4, gUnknown_081C7025); - AddTextPrinterWithCallbackForMessage(gStringVar4, 3, 14); + MenuPrintMessage(gStringVar4, 3, 14); gTasks[taskId].func = task_new_game_prof_birch_speech_part2_7; } } @@ -1258,8 +1258,8 @@ void task_new_game_prof_birch_speech_part2_8(u8 taskId) sub_800B534(taskId, 2); sub_800B6C0(taskId, 1); - DrawDefaultWindow(2, 13, 27, 18); - AddTextPrinterWithCallbackForMessage(gUnknown_081C7074, 3, 14); + MenuDrawTextWindow(2, 13, 27, 18); + MenuPrintMessage(gUnknown_081C7074, 3, 14); gTasks[taskId].func = task_new_game_prof_birch_speech_part2_9; } } @@ -1363,7 +1363,7 @@ void new_game_prof_birch_speech_part2_start() AddBirchSpeechObjects(taskId); SetUpWindowConfig(&gWindowConfig_81E6C3C); - sub_8071C4C(&gWindowConfig_81E6CE4); + InitMenuWindowConfig(&gWindowConfig_81E6CE4); if (gSaveBlock2.playerGender != MALE) { @@ -1612,10 +1612,10 @@ void sub_800B6C0(u8 a1, u8 a2) void CreateGenderMenu(u8 left, u8 top) { u8 menuLeft, menuTop; - DrawDefaultWindow(left, top, left + 6, top + 5); + MenuDrawTextWindow(left, top, left + 6, top + 5); menuLeft = left + 1; menuTop = top + 1; - PrintStringArray(menuLeft, menuTop, 2, gUnknown_081E79B0); + PrintMenuItems(menuLeft, menuTop, 2, gUnknown_081E79B0); InitMenu(0, menuLeft, menuTop, 2, 0, 5); } @@ -1626,15 +1626,15 @@ s8 GenderMenuProcessInput(void) void CreateNameMenu(u8 left, u8 top) { - DrawDefaultWindow(left, top, left + 10, top + 11); + MenuDrawTextWindow(left, top, left + 10, top + 11); if (gSaveBlock2.playerGender == MALE) { - PrintStringArray((u8)(left + 1), (u8)(top + 1), 5, gUnknown_081E79C0); + PrintMenuItems((u8)(left + 1), (u8)(top + 1), 5, gUnknown_081E79C0); } else { - PrintStringArray((u8)(left + 1), (u8)(top + 1), 5, gUnknown_081E79E8); + PrintMenuItems((u8)(left + 1), (u8)(top + 1), 5, gUnknown_081E79E8); } InitMenu(0, (u8)(left + 1), (u8)(top + 1), 5, 0, 9); diff --git a/src/menu.c b/src/menu.c index 0e9c34c69..6533b59cf 100644 --- a/src/menu.c +++ b/src/menu.c @@ -17,33 +17,33 @@ struct Menu u8 columnXCoords[8]; }; -void sub_8071C4C(struct WindowConfig *); -void sub_8071C58(struct WindowConfig *); -void sub_8071C64(struct WindowConfig *, u16); -bool32 sub_8071C94(void); -void sub_8071D48(struct WindowConfig *, u16); +void InitMenuWindowConfig(struct WindowConfig *); +void MultistepInitMenuWindowConfigBegin(struct WindowConfig *); +void MultistepInitMenuWindowConfigInternal(struct WindowConfig *, u16); +bool32 MultistepInitMenuWindowConfigContinue(void); +void InitMenuWindowConfigInternal(struct WindowConfig *, u16); void unref_sub_8071DA4(struct WindowConfig *, u16); -void sub_8071E00(u8); -void GetMapNamePopUpWindowId(void); -void sub_8071E2C(struct WindowConfig *); -void Print(u8 *, u8, u8); -void Reset(u8, u8, u8, u8); -void sub_8071EBC(u8, u8, u8, u8); -void sub_8071EF4(void); -void DrawDefaultWindow(u8, u8, u8, u8); +void MenuLoadTextWindowGraphics_OverrideFrameType(u8); +void MenuLoadTextWindowGraphics(void); +void BasicInitMenuWindowConfig(struct WindowConfig *); +void MenuPrint(u8 *, u8, u8); +void MenuZeroFillWindowRect(u8, u8, u8, u8); +void MenuFillWindowRectWithBlankTile(u8, u8, u8, u8); +void MenuZeroFillScreen(void); +void MenuDrawTextWindow(u8, u8, u8, u8); void sub_8071F40(u8 *); void sub_8071F60(u8, u8, u8, u8); u16 unref_sub_8071F98(u8, u8); void unref_sub_8071FBC(u16, u8, u8, u8, u8); -void sub_8071FFC(void); -void AddTextPrinterWithCallbackForMessage(u8 *, u8, u8); +void MenuDisplayMessageBox(void); +void MenuPrintMessage(u8 *, u8, u8); void sub_8072044(u8 *); -void sub_807206C(u8 *); -u8 sub_8072080(void); +void MenuSetText(u8 *); +u8 MenuUpdateWindowText(void); u8 unref_sub_8072098(void); void sub_80720B0(void); u8 MoveMenuCursor(s8); -u8 MoveMenuCursorNoWrapAround(s8); +u8 MoveMenuCursorNoWrap(s8); u8 GetMenuCursorPos(void); s8 ProcessMenuInput(void); s8 ProcessMenuInputNoWrap(void); @@ -56,18 +56,18 @@ void sub_8072620(u8, u8, u8, u8*[][2], u8); void sub_807274C(u8, u8, u8, u8, u8*[][2], u8, u32); s8 sub_80727CC(void); u8 sub_807288C(u8); -void PrintStringArray(u8, u8, u8, u8*[][2]); -void sub_80728E4(u8, u8, u8, u8*[][2], u8*); -void sub_807292C(u8, u8, u8); -void sub_8072974(u8, u8, u32); -s8 FillWindowPixelBuffer(void); +void PrintMenuItems(u8, u8, u8, u8*[][2]); +void PrintMenuItemsReordered(u8, u8, u8, u8*[][2], u8*); +void InitYesNoMenu(u8, u8, u8); +void DisplayYesNoMenu(u8, u8, u32); +s8 ProcessMenuInputNoWrap_(void); u8 sub_80729D8(u8 *, u8, u16, u8); u8 sub_8072A18(u8 *, u8, u16, u8, u32); u8 unref_sub_8072A5C(u8 *, u8 *, u8, u16, u8, u32); int sub_8072AB0(u8 *, u8, u16, u8, u8, u32); -void PrintCoinsString(u8 *, u8, u8); +void sub_8072B4C(u8 *, u8, u8); void sub_8072B80(u8 *, u8, u8, u8 *); -void Free(u8 *, u8, u8, u16); +void sub_8072BD8(u8 *, u8, u8, u16); u8 *sub_8072C14(u8 *, s32, u8, u8); u8 *sub_8072C44(u8 *, s32, u8, u8); u8 *sub_8072C74(u8 *, u8 *, u8, u8); @@ -92,56 +92,56 @@ extern void sub_814A7FC(void); static struct Menu gMenu; -extern struct Window stru_202E908; -extern struct Window *dword_202E9C8; -extern u8 byte_202E9CC; -extern u16 word_202E9CE; -extern u16 word_202E9D0; -extern u16 word_202E9D2; -extern u16 word_202E9D4; +extern struct Window gMenuWindow; +extern struct Window *gMenuWindowPtr; +extern u8 gMenuMultistepInitState; +extern u16 gMenuTextTileOffset; +extern u16 gMenuTextWindowTileOffset; +extern u16 gMenuTextWindowContentTileOffset; +extern u16 gMenuMessageBoxContentTileOffset; extern const u8 *gUnknown_08376D74[][2]; -void sub_8071C4C(struct WindowConfig *a1) +void InitMenuWindowConfig(struct WindowConfig *winConfig) { - sub_8071D48(a1, 1); + InitMenuWindowConfigInternal(winConfig, 1); } -void sub_8071C58(struct WindowConfig *a1) +void MultistepInitMenuWindowConfigBegin(struct WindowConfig *winConfig) { - sub_8071C64(a1, 1); + MultistepInitMenuWindowConfigInternal(winConfig, 1); } -void sub_8071C64(struct WindowConfig *a1, u16 a2) +void MultistepInitMenuWindowConfigInternal(struct WindowConfig *winConfig, u16 tileOffset) { - byte_202E9CC = 0; - word_202E9CE = a2; - dword_202E9C8 = &stru_202E908; - InitWindowFromConfig(&stru_202E908, a1); + gMenuMultistepInitState = 0; + gMenuTextTileOffset = tileOffset; + gMenuWindowPtr = &gMenuWindow; + InitWindowFromConfig(&gMenuWindow, winConfig); } -bool32 sub_8071C94(void) +bool32 MultistepInitMenuWindowConfigContinue(void) { - switch (byte_202E9CC) + switch (gMenuMultistepInitState) { case 0: - byte_202E9CC++; + gMenuMultistepInitState++; return 0; case 1: - word_202E9D0 = MultistepInitWindowTileData(dword_202E9C8, word_202E9CE); + gMenuTextWindowTileOffset = MultistepInitWindowTileData(gMenuWindowPtr, gMenuTextTileOffset); goto next; case 2: if (!MultistepLoadFont()) goto fail; goto next; case 3: - word_202E9D2 = SetTextWindowBaseTileNum(word_202E9D0); + gMenuTextWindowContentTileOffset = SetTextWindowBaseTileNum(gMenuTextWindowTileOffset); next: - byte_202E9CC++; + gMenuMultistepInitState++; return 0; case 4: - LoadTextWindowGraphics(dword_202E9C8); - word_202E9D4 = SetMessageBoxBaseTileNum(word_202E9D2); + LoadTextWindowGraphics(gMenuWindowPtr); + gMenuMessageBoxContentTileOffset = SetMessageBoxBaseTileNum(gMenuTextWindowContentTileOffset); return 1; default: fail: @@ -149,123 +149,123 @@ bool32 sub_8071C94(void) } } -void sub_8071D48(struct WindowConfig *a1, u16 a2) +void InitMenuWindowConfigInternal(struct WindowConfig *winConfig, u16 tileOffset) { - dword_202E9C8 = &stru_202E908; - InitWindowFromConfig(&stru_202E908, a1); - word_202E9CE = a2; - word_202E9D0 = InitWindowTileData(dword_202E9C8, word_202E9CE); - word_202E9D2 = SetTextWindowBaseTileNum(word_202E9D0); - LoadTextWindowGraphics(dword_202E9C8); - word_202E9D4 = SetMessageBoxBaseTileNum(word_202E9D2); + gMenuWindowPtr = &gMenuWindow; + InitWindowFromConfig(&gMenuWindow, winConfig); + gMenuTextTileOffset = tileOffset; + gMenuTextWindowTileOffset = InitWindowTileData(gMenuWindowPtr, gMenuTextTileOffset); + gMenuTextWindowContentTileOffset = SetTextWindowBaseTileNum(gMenuTextWindowTileOffset); + LoadTextWindowGraphics(gMenuWindowPtr); + gMenuMessageBoxContentTileOffset = SetMessageBoxBaseTileNum(gMenuTextWindowContentTileOffset); } -void unref_sub_8071DA4(struct WindowConfig *a1, u16 a2) +void unref_sub_8071DA4(struct WindowConfig *winConfig, u16 tileOffset) { - dword_202E9C8 = &stru_202E908; - InitWindowFromConfig(&stru_202E908, a1); - word_202E9D0 = a2; - word_202E9D2 = SetTextWindowBaseTileNum(word_202E9D0); - LoadTextWindowGraphics(dword_202E9C8); - word_202E9CE = SetMessageBoxBaseTileNum(word_202E9D2); - word_202E9D4 = InitWindowTileData(dword_202E9C8, word_202E9CE); + gMenuWindowPtr = &gMenuWindow; + InitWindowFromConfig(&gMenuWindow, winConfig); + gMenuTextWindowTileOffset = tileOffset; + gMenuTextWindowContentTileOffset = SetTextWindowBaseTileNum(gMenuTextWindowTileOffset); + LoadTextWindowGraphics(gMenuWindowPtr); + gMenuTextTileOffset = SetMessageBoxBaseTileNum(gMenuTextWindowContentTileOffset); + gMenuMessageBoxContentTileOffset = InitWindowTileData(gMenuWindowPtr, gMenuTextTileOffset); } -void sub_8071E00(u8 a1) +void MenuLoadTextWindowGraphics_OverrideFrameType(u8 frameType) { - LoadTextWindowGraphics_OverrideFrameType(dword_202E9C8, a1); + LoadTextWindowGraphics_OverrideFrameType(gMenuWindowPtr, frameType); } -void GetMapNamePopUpWindowId(void) +void MenuLoadTextWindowGraphics(void) { - LoadTextWindowGraphics(dword_202E9C8); + LoadTextWindowGraphics(gMenuWindowPtr); } -void sub_8071E2C(struct WindowConfig *a1) +void BasicInitMenuWindowConfig(struct WindowConfig *winConfig) { - InitWindowFromConfig(dword_202E9C8, a1); - dword_202E9C8->tileDataStartOffset = word_202E9CE; + InitWindowFromConfig(gMenuWindowPtr, winConfig); + gMenuWindowPtr->tileDataStartOffset = gMenuTextTileOffset; } -void Print(u8 *str, u8 left, u8 top) +void MenuPrint(u8 *str, u8 left, u8 top) { - sub_8003460(dword_202E9C8, str, word_202E9CE, left, top); + sub_8003460(gMenuWindowPtr, str, gMenuTextTileOffset, left, top); } -void Reset(u8 a1, u8 a2, u8 a3, u8 a4) +void MenuZeroFillWindowRect(u8 a1, u8 a2, u8 a3, u8 a4) { - ZeroFillWindowRect(dword_202E9C8, a1, a2, a3, a4); + ZeroFillWindowRect(gMenuWindowPtr, a1, a2, a3, a4); } -void sub_8071EBC(u8 left, u8 top, u8 right, u8 bottom) +void MenuFillWindowRectWithBlankTile(u8 left, u8 top, u8 right, u8 bottom) { - FillWindowRectWithBlankTile(dword_202E9C8, left, top, right, bottom); + FillWindowRectWithBlankTile(gMenuWindowPtr, left, top, right, bottom); } -void sub_8071EF4(void) +void MenuZeroFillScreen(void) { - Reset(0, 0, 29, 19); + MenuZeroFillWindowRect(0, 0, 29, 19); } -void DrawDefaultWindow(u8 left, u8 top, u8 right, u8 bottom) +void MenuDrawTextWindow(u8 left, u8 top, u8 right, u8 bottom) { - DrawTextWindow(dword_202E9C8, left, top, right, bottom); + DrawTextWindow(gMenuWindowPtr, left, top, right, bottom); } void sub_8071F40(u8 *str) { - DrawDefaultWindow(2, 14, 28, 19); - Print(str, 3, 15); + MenuDrawTextWindow(2, 14, 28, 19); + MenuPrint(str, 3, 15); } void sub_8071F60(u8 a1, u8 a2, u8 a3, u8 a4) { - sub_8003490(dword_202E9C8, a1, word_202E9CE, a2, a3); + sub_8003490(gMenuWindowPtr, a1, gMenuTextTileOffset, a2, a3); } u16 unref_sub_8071F98(u8 x, u8 y) { - return GetWindowTilemapEntry(dword_202E9C8, x, y); + return GetWindowTilemapEntry(gMenuWindowPtr, x, y); } void unref_sub_8071FBC(u16 a1, u8 a2, u8 a3, u8 a4, u8 a5) { - DrawWindowRect(dword_202E9C8, a1, a2, a3, a4, a5); + DrawWindowRect(gMenuWindowPtr, a1, a2, a3, a4, a5); } -void sub_8071FFC(void) +void MenuDisplayMessageBox(void) { - DisplayMessageBox(dword_202E9C8); + DisplayMessageBox(gMenuWindowPtr); } -void AddTextPrinterWithCallbackForMessage(u8 *str, u8 a2, u8 a3) +void MenuPrintMessage(u8 *str, u8 left, u8 top) { - sub_8002EB0(dword_202E9C8, str, word_202E9CE, a2, a3); + sub_8002EB0(gMenuWindowPtr, str, gMenuTextTileOffset, left, top); } void sub_8072044(u8 *str) { - sub_8002EB0(dword_202E9C8, str, word_202E9CE, 2, 15); + sub_8002EB0(gMenuWindowPtr, str, gMenuTextTileOffset, 2, 15); } -void sub_807206C(u8 *str) +void MenuSetText(u8 *str) { - sub_8002E90(dword_202E9C8, str); + sub_8002E90(gMenuWindowPtr, str); } -u8 sub_8072080(void) +u8 MenuUpdateWindowText(void) { - return sub_80035AC(dword_202E9C8); + return sub_80035AC(gMenuWindowPtr); } u8 unref_sub_8072098(void) { - return sub_8003418(dword_202E9C8); + return sub_8003418(gMenuWindowPtr); } void sub_80720B0(void) { - ClearWindowTextLines(dword_202E9C8); + ClearWindowTextLines(gMenuWindowPtr); } u8 MoveMenuCursor(s8 delta) @@ -283,7 +283,7 @@ u8 MoveMenuCursor(s8 delta) return gMenu.cursorPos; } -u8 MoveMenuCursorNoWrapAround(s8 delta) +u8 MoveMenuCursorNoWrap(s8 delta) { s32 newPos = gMenu.cursorPos + delta; @@ -357,18 +357,18 @@ s8 ProcessMenuInputNoWrap(void) if (gMain.newKeys & DPAD_UP) { - if (cursorPos != MoveMenuCursorNoWrapAround(-1)) + if (cursorPos != MoveMenuCursorNoWrap(-1)) audio_play(SE_SELECT); return -2; } else if (gMain.newKeys & DPAD_DOWN) { - if (cursorPos != MoveMenuCursorNoWrapAround(1)) + if (cursorPos != MoveMenuCursorNoWrap(1)) audio_play(SE_SELECT); return -2; } - MoveMenuCursorNoWrapAround(0); + MoveMenuCursorNoWrap(0); return -2; } @@ -501,7 +501,7 @@ u8 sub_80724F4(u8 left, u8 top, u8 menuItemCount, u8 *menuItems[][2], u8 columnC totalWidth = (gMenu.columnXCoords[columnCount] + 1); right = left + totalWidth; - DrawDefaultWindow(left, top, right, bottom); + MenuDrawTextWindow(left, top, right, bottom); } return maxWidth; @@ -656,7 +656,7 @@ _080725EA:\n\ lsl r2, #24\n\ lsr r2, #24\n\ ldr r1, [sp, #0x4]\n\ - bl DrawDefaultWindow\n\ + bl MenuDrawTextWindow\n\ add r0, r7, #0\n\ add sp, #0xC\n\ pop {r3-r5}\n\ @@ -699,7 +699,7 @@ void sub_8072620(u8 left, u8 top, u8 menuItemCount, u8 *menuItems[][2], u8 colum u8 row = 0; u8 j; for (j = 0; i + j < menuItemCount; j += columnCount, row++) - Print(menuItems[i + j][0], left + gMenu.columnXCoords[i % columnCount], top + 2 * row); + MenuPrint(menuItems[i + j][0], left + gMenu.columnXCoords[i % columnCount], top + 2 * row); } } @@ -761,53 +761,53 @@ u8 sub_807288C(u8 column) return gMenu.columnXCoords[column]; } -void PrintStringArray(u8 left, u8 top, u8 menuItemCount, u8 *menuItems[][2]) +void PrintMenuItems(u8 left, u8 top, u8 menuItemCount, u8 *menuItems[][2]) { u8 i; for (i = 0; i < menuItemCount; i++) - Print(menuItems[i][0], left, top + 2 * i); + MenuPrint(menuItems[i][0], left, top + 2 * i); } -void sub_80728E4(u8 left, u8 top, u8 menuItemCount, u8 *menuItems[][2], u8 *order) +void PrintMenuItemsReordered(u8 left, u8 top, u8 menuItemCount, u8 *menuItems[][2], u8 *order) { u8 i; for (i = 0; i < menuItemCount; i++) - Print(menuItems[order[i]][0], left, top + 2 * i); + MenuPrint(menuItems[order[i]][0], left, top + 2 * i); } -void sub_807292C(u8 left, u8 top, u8 a3) +void InitYesNoMenu(u8 left, u8 top, u8 a3) { - PrintStringArray(left + 1, top + 1, 2, (void *)gUnknown_08376D74); + PrintMenuItems(left + 1, top + 1, 2, (void *)gUnknown_08376D74); InitMenu(0, left + 1, top + 1, 2, 0, a3); } -void sub_8072974(u8 left, u8 top, u32 a3) +void DisplayYesNoMenu(u8 left, u8 top, u32 a3) { - DrawDefaultWindow(left, top, left + 6, top + 5); - sub_807292C(left, top, 5); + MenuDrawTextWindow(left, top, left + 6, top + 5); + InitYesNoMenu(left, top, 5); gMenu.menu_field_7 = a3 ? -1 : 0; } -s8 FillWindowPixelBuffer(void) +s8 ProcessMenuInputNoWrap_(void) { return ProcessMenuInputNoWrap(); } -u8 sub_80729D8(u8 *a1, u8 a2, u16 a3, u8 a4) +u8 sub_80729D8(u8 *text, u8 left, u16 top, u8 a4) { - return sub_8004D04(dword_202E9C8, a1, word_202E9CE, a2, a3, a4); + return sub_8004D04(gMenuWindowPtr, text, gMenuTextTileOffset, left, top, a4); } -u8 sub_8072A18(u8 *a1, u8 a2, u16 a3, u8 a4, u32 a5) +u8 sub_8072A18(u8 *text, u8 left, u16 top, u8 width, u32 a5) { - return sub_8004FD0(dword_202E9C8, 0, a1, word_202E9CE, a2, a3, a4, a5); + return sub_8004FD0(gMenuWindowPtr, 0, text, gMenuTextTileOffset, left, top, width, a5); } -u8 unref_sub_8072A5C(u8 *a1, u8 *a2, u8 a3, u16 a4, u8 a5, u32 a6) +u8 unref_sub_8072A5C(u8 *dest, u8 *src, u8 left, u16 top, u8 width, u32 a6) { - return sub_8004FD0(dword_202E9C8, a1, a2, word_202E9CE, a3, a4, a5, a6); + return sub_8004FD0(gMenuWindowPtr, dest, src, gMenuTextTileOffset, left, top, width, a6); } __attribute__((naked)) @@ -876,7 +876,7 @@ int sub_8072AB0(u8 *str, u8 left, u16 top, u8 width, u8 height, u32 a6) lsl r3, #24\n\ lsr r3, #24\n\ mov r0, r12\n\ - bl sub_8071EBC\n\ + bl MenuFillWindowRectWithBlankTile\n\ _08072B34:\n\ add sp, #0x10\n\ pop {r3,r4}\n\ @@ -890,62 +890,62 @@ _08072B44: .4byte 0x0202e9c8\n\ _08072B48: .4byte 0x0202e9ce\n"); } -void PrintCoinsString(u8 *str, u8 left, u8 top) +void sub_8072B4C(u8 *str, u8 left, u8 top) { - sub_8004D38(dword_202E9C8, str, word_202E9CE, left, top); + sub_8004D38(gMenuWindowPtr, str, gMenuTextTileOffset, left, top); } void sub_8072B80(u8 *a1, u8 a2, u8 a3, u8 *a4) { u8 buffer[64]; - u8 width = GetStringWidth(dword_202E9C8, a4); - AlignString(dword_202E9C8, buffer, a1, width, 1); - sub_8003460(dword_202E9C8, buffer, word_202E9CE, a2, a3); + u8 width = GetStringWidth(gMenuWindowPtr, a4); + AlignString(gMenuWindowPtr, buffer, a1, width, 1); + sub_8003460(gMenuWindowPtr, buffer, gMenuTextTileOffset, a2, a3); } -void Free(u8 *a1, u8 a2, u8 a3, u16 a4) +void sub_8072BD8(u8 *a1, u8 a2, u8 a3, u16 a4) { - sub_8004DB0(dword_202E9C8, a1, word_202E9CE, a2, a3, a4); + sub_8004DB0(gMenuWindowPtr, a1, gMenuTextTileOffset, a2, a3, a4); } u8 *sub_8072C14(u8 *a1, s32 a2, u8 a3, u8 a4) { - return AlignInt1(dword_202E9C8, a1, a2, a3, a4); + return AlignInt1(gMenuWindowPtr, a1, a2, a3, a4); } u8 *sub_8072C44(u8 *a1, s32 a2, u8 a3, u8 a4) { - return AlignInt2(dword_202E9C8, a1, a2, a3, a4); + return AlignInt2(gMenuWindowPtr, a1, a2, a3, a4); } u8 *sub_8072C74(u8 *a1, u8 *a2, u8 a3, u8 a4) { - return AlignString(dword_202E9C8, a1, a2, a3, a4); + return AlignString(gMenuWindowPtr, a1, a2, a3, a4); } u8 sub_8072CA4(u8 *str) { - return GetStringWidth(dword_202E9C8, str); + return GetStringWidth(gMenuWindowPtr, str); } u8 sub_8072CBC() { - return sub_8004E24(dword_202E9C8); + return sub_8004E24(gMenuWindowPtr); } void sub_8072CD4(u8 *a1, u8 *a2, u8 *a3) { - sub_8004E28(dword_202E9C8, a1, a2, a3); + sub_8004E28(gMenuWindowPtr, a1, a2, a3); } u32 sub_8072CF4(u8 a1) { - return sub_80037C8(dword_202E9C8, a1); + return sub_80037C8(gMenuWindowPtr, a1); } struct Window *unref_sub_8072D0C(void) { - return dword_202E9C8; + return gMenuWindowPtr; } void sub_8072D18(u8 a1, u8 a2) -- cgit v1.2.3 From 306c907472ccf77198e1b05bc0020cf0bff4539b Mon Sep 17 00:00:00 2001 From: YamaArashi Date: Mon, 5 Sep 2016 19:48:25 -0700 Subject: simplify function names --- src/link.c | 6 +++--- src/main_menu.c | 8 ++++---- src/menu.c | 28 ++++++++++++++-------------- 3 files changed, 21 insertions(+), 21 deletions(-) (limited to 'src') diff --git a/src/link.c b/src/link.c index 0fa1f4673..13fcf8c05 100644 --- a/src/link.c +++ b/src/link.c @@ -27,7 +27,7 @@ struct LinkTestBGInfo u32 dummy_C; }; -extern void InitMenuWindowConfig(const struct WindowConfig *); +extern void InitMenuWindow(const struct WindowConfig *); extern void sub_80516C4(u8, u16); extern u8 unk_2000000[]; @@ -237,7 +237,7 @@ static void LinkTestScreen(void) ResetTasks(); SetVBlankCallback(VBlankCB_LinkTest); SetUpWindowConfig(&gWindowConfig_81E6CE4); - InitMenuWindowConfig(&gWindowConfig_81E6CE4); + InitMenuWindow(&gWindowConfig_81E6CE4); ResetBlockSend(); gLinkType = 0x1111; OpenLink(); @@ -1224,7 +1224,7 @@ void CB2_LinkError(void) ResetTasks(); SetVBlankCallback(VBlankCB_LinkTest); SetUpWindowConfig(&gWindowConfig_81E7198); - InitMenuWindowConfig(&gWindowConfig_81E7198); + InitMenuWindow(&gWindowConfig_81E7198); MenuZeroFillScreen(); REG_BLDALPHA = 0; REG_BG0VOFS = 0; diff --git a/src/main_menu.c b/src/main_menu.c index 246cf72a3..721c7090e 100644 --- a/src/main_menu.c +++ b/src/main_menu.c @@ -35,7 +35,7 @@ void DisplayYesNoMenu(u8 r0, u8 r1, u32 r2); s8 ProcessMenuInputNoWrap_(void); void c2_load_new_map_2(void); void LZ77UnCompVram(const void *src, void *dest); -void InitMenuWindowConfig(const struct WindowConfig *); +void InitMenuWindow(const struct WindowConfig *); void CB2_MainMenu(void); void VBlankCB_MainMenu(void); void DecompressPicFromTable_2(const struct SpriteSheet *, u8, u8, void *, void *, u32); @@ -139,7 +139,7 @@ u32 InitMainMenu(u8 a1) ResetSpriteData(); FreeAllSpritePalettes(); SetUpWindowConfig(&gWindowConfig_81E6C3C); - InitMenuWindowConfig(&gWindowConfig_81E6CE4); + InitMenuWindow(&gWindowConfig_81E6CE4); if (a1) BeginNormalPaletteFade(-1, 0, 0x10, 0, 0x0000); // fade to black @@ -721,7 +721,7 @@ void set_default_player_name(u8 a); void Task_Birch1(u8 taskId) { SetUpWindowConfig(&gWindowConfig_81E6C3C); - InitMenuWindowConfig(&gWindowConfig_81E6CE4); + InitMenuWindow(&gWindowConfig_81E6CE4); REG_WIN0H = 0; REG_WIN0V = 0; REG_WININ = 0; @@ -1363,7 +1363,7 @@ void new_game_prof_birch_speech_part2_start() AddBirchSpeechObjects(taskId); SetUpWindowConfig(&gWindowConfig_81E6C3C); - InitMenuWindowConfig(&gWindowConfig_81E6CE4); + InitMenuWindow(&gWindowConfig_81E6CE4); if (gSaveBlock2.playerGender != MALE) { diff --git a/src/menu.c b/src/menu.c index 6533b59cf..1ced7d517 100644 --- a/src/menu.c +++ b/src/menu.c @@ -17,15 +17,15 @@ struct Menu u8 columnXCoords[8]; }; -void InitMenuWindowConfig(struct WindowConfig *); -void MultistepInitMenuWindowConfigBegin(struct WindowConfig *); -void MultistepInitMenuWindowConfigInternal(struct WindowConfig *, u16); -bool32 MultistepInitMenuWindowConfigContinue(void); -void InitMenuWindowConfigInternal(struct WindowConfig *, u16); +void InitMenuWindow(struct WindowConfig *); +void MultistepInitMenuWindowBegin(struct WindowConfig *); +void MultistepInitMenuWindowInternal(struct WindowConfig *, u16); +bool32 MultistepInitMenuWindowContinue(void); +void InitMenuWindowInternal(struct WindowConfig *, u16); void unref_sub_8071DA4(struct WindowConfig *, u16); void MenuLoadTextWindowGraphics_OverrideFrameType(u8); void MenuLoadTextWindowGraphics(void); -void BasicInitMenuWindowConfig(struct WindowConfig *); +void BasicInitMenuWindow(struct WindowConfig *); void MenuPrint(u8 *, u8, u8); void MenuZeroFillWindowRect(u8, u8, u8, u8); void MenuFillWindowRectWithBlankTile(u8, u8, u8, u8); @@ -102,17 +102,17 @@ extern u16 gMenuMessageBoxContentTileOffset; extern const u8 *gUnknown_08376D74[][2]; -void InitMenuWindowConfig(struct WindowConfig *winConfig) +void InitMenuWindow(struct WindowConfig *winConfig) { - InitMenuWindowConfigInternal(winConfig, 1); + InitMenuWindowInternal(winConfig, 1); } -void MultistepInitMenuWindowConfigBegin(struct WindowConfig *winConfig) +void MultistepInitMenuWindowBegin(struct WindowConfig *winConfig) { - MultistepInitMenuWindowConfigInternal(winConfig, 1); + MultistepInitMenuWindowInternal(winConfig, 1); } -void MultistepInitMenuWindowConfigInternal(struct WindowConfig *winConfig, u16 tileOffset) +void MultistepInitMenuWindowInternal(struct WindowConfig *winConfig, u16 tileOffset) { gMenuMultistepInitState = 0; gMenuTextTileOffset = tileOffset; @@ -120,7 +120,7 @@ void MultistepInitMenuWindowConfigInternal(struct WindowConfig *winConfig, u16 t InitWindowFromConfig(&gMenuWindow, winConfig); } -bool32 MultistepInitMenuWindowConfigContinue(void) +bool32 MultistepInitMenuWindowContinue(void) { switch (gMenuMultistepInitState) { @@ -149,7 +149,7 @@ bool32 MultistepInitMenuWindowConfigContinue(void) } } -void InitMenuWindowConfigInternal(struct WindowConfig *winConfig, u16 tileOffset) +void InitMenuWindowInternal(struct WindowConfig *winConfig, u16 tileOffset) { gMenuWindowPtr = &gMenuWindow; InitWindowFromConfig(&gMenuWindow, winConfig); @@ -181,7 +181,7 @@ void MenuLoadTextWindowGraphics(void) LoadTextWindowGraphics(gMenuWindowPtr); } -void BasicInitMenuWindowConfig(struct WindowConfig *winConfig) +void BasicInitMenuWindow(struct WindowConfig *winConfig) { InitWindowFromConfig(gMenuWindowPtr, winConfig); gMenuWindowPtr->tileDataStartOffset = gMenuTextTileOffset; -- cgit v1.2.3 From 023b8e5bb5f2038edad1c4b5a11a44ff898928a3 Mon Sep 17 00:00:00 2001 From: YamaArashi Date: Mon, 5 Sep 2016 19:59:02 -0700 Subject: space after 'if' keyword --- src/main_menu.c | 66 ++++++++++++++++++++++++++++----------------------------- 1 file changed, 33 insertions(+), 33 deletions(-) (limited to 'src') diff --git a/src/main_menu.c b/src/main_menu.c index 721c7090e..60e9fdc98 100644 --- a/src/main_menu.c +++ b/src/main_menu.c @@ -754,7 +754,7 @@ void task_new_game_prof_birch_speech_2(u8 taskId) struct Task *tasks = gTasks; struct Task *task = &tasks[taskId]; - if(task->data[7] != 0) + if (task->data[7] != 0) { task->data[7]--; } @@ -779,13 +779,13 @@ void task_new_game_prof_birch_speech_3(u8 taskId) struct Task *tasks = gTasks; struct Task *task = &tasks[taskId]; - if(task->data[5] != 0) + if (task->data[5] != 0) { struct Sprite *sprites = gSprites; struct Sprite *sprite = &sprites[(s16)task->data[8]]; sprite->oam.objMode = 0; - if((u16)task->data[7]) + if ((u16)task->data[7]) { task->data[7]--; } @@ -800,7 +800,7 @@ void task_new_game_prof_birch_speech_3(u8 taskId) void task_new_game_prof_birch_speech_4(u8 taskId) { - if(!gPaletteFade.active && sub_8072CF4(0x18)) + if (!gPaletteFade.active && sub_8072CF4(0x18)) { struct Task *tasks = gTasks; struct Task *task = &tasks[taskId]; @@ -811,7 +811,7 @@ void task_new_game_prof_birch_speech_4(u8 taskId) void task_new_game_prof_birch_speech_5(u8 taskId) { - if(sub_8072CF4(0x18)) + if (sub_8072CF4(0x18)) gTasks[taskId].func = task_new_game_prof_birch_speech_6; } @@ -837,12 +837,12 @@ void task_new_game_prof_birch_speech_7(u8 taskId) struct Task *tasks; struct Task *task; - if(sub_8075374()) + if (sub_8075374()) { struct Task *tasks = gTasks; struct Task *task = &tasks[taskId]; //r5 - if(task->data[7] > 0x5F) + if (task->data[7] > 0x5F) { MenuSetText((u32)&gUnknown_0840DFF7); task->func = task_new_game_prof_birch_speech_8; @@ -851,10 +851,10 @@ void task_new_game_prof_birch_speech_7(u8 taskId) //_0800A4E4 tasks = gTasks; task = &tasks[taskId]; //r2 - if((s16)task->data[7] <= 0x00003fff) + if ((s16)task->data[7] <= 0x00003fff) { task->data[7]++; - if(task->data[7] == 0x20) + if (task->data[7] == 0x20) { cry_related(0xAF << 1, 0); } @@ -863,7 +863,7 @@ void task_new_game_prof_birch_speech_7(u8 taskId) void task_new_game_prof_birch_speech_8(u8 taskId) { - if(sub_8072CF4(0x18)) + if (sub_8072CF4(0x18)) { MenuPrintMessage(gUnknown_081C6E1A, 0x3, 0xE); gTasks[taskId].func = task_new_game_prof_birch_speech_9; @@ -872,7 +872,7 @@ void task_new_game_prof_birch_speech_8(u8 taskId) void task_new_game_prof_birch_speech_9(u8 taskId) { - if(sub_8072CF4(0x18)) + if (sub_8072CF4(0x18)) { MenuDrawTextWindow(0x2, 0xD, 0x1B, 0x12); MenuPrintMessage(gUnknown_081C6FCB, 0x3, 0xE); @@ -882,7 +882,7 @@ void task_new_game_prof_birch_speech_9(u8 taskId) void task_new_game_prof_birch_speech_10(u8 taskId) { - if(sub_8072CF4(0x18)) + if (sub_8072CF4(0x18)) { struct Sprite *sprites = gSprites; struct Task *tasks = gTasks; @@ -905,7 +905,7 @@ void task_new_game_prof_birch_speech_11(u8 taskId) struct Task *tasks = gTasks; struct Task *task = &tasks[taskId]; - if((s16)task->data[4] != -0x3C) + if ((s16)task->data[4] != -0x3C) { task->data[4] -= 2; REG_BG1HOFS = task->data[4]; @@ -919,12 +919,12 @@ void task_new_game_prof_birch_speech_11(u8 taskId) void task_new_game_prof_birch_speech_12(u8 taskId) { - if(gTasks[taskId].data[5]) + if (gTasks[taskId].data[5]) { gSprites[gTasks[taskId].data[8]].invisible = 1; gSprites[gTasks[taskId].data[9]].invisible = 1; - if(gTasks[taskId].data[7]) + if (gTasks[taskId].data[7]) { gTasks[taskId].data[7]--; } @@ -950,7 +950,7 @@ void task_new_game_prof_birch_speech_13(u8 taskId) struct Task *tasks = gTasks; struct Task *task = &tasks[taskId]; - if(task->data[5]) + if (task->data[5]) { struct Sprite *sprites = gSprites; struct Sprite *sprite = &sprites[task->data[2]]; @@ -969,7 +969,7 @@ void task_new_game_prof_birch_speech_14(u8 taskId) void task_new_game_prof_birch_speech_15(u8 taskId) { - if(sub_8072CF4(0x18)) + if (sub_8072CF4(0x18)) { CreateGenderMenu(2, 4); gTasks[taskId].func = task_new_game_prof_birch_speech_16; @@ -1000,7 +1000,7 @@ void task_new_game_prof_birch_speech_16(u8 taskId) cursorPos = GetMenuCursorPos(); - if(cursorPos != (s16)gTasks[taskId].data[6]) + if (cursorPos != (s16)gTasks[taskId].data[6]) { gTasks[taskId].data[6] = cursorPos; gSprites[gTasks[taskId].data[2]].oam.objMode = 1; @@ -1013,14 +1013,14 @@ void task_new_game_prof_birch_speech_17(u8 taskId) { u8 spriteId = gTasks[taskId].data[2]; - if(gTasks[taskId].data[5] == 0) + if (gTasks[taskId].data[5] == 0) { gSprites[spriteId].pos1.x += 4; } else { gSprites[spriteId].invisible = 1; - if(gTasks[taskId].data[6]) + if (gTasks[taskId].data[6]) { spriteId = gTasks[taskId].data[11]; } @@ -1043,14 +1043,14 @@ void task_new_game_prof_birch_speech_18(u8 taskId) { u8 spriteId = gTasks[taskId].data[2]; - if(gSprites[spriteId].pos1.x > 0xB4) + if (gSprites[spriteId].pos1.x > 0xB4) { gSprites[spriteId].pos1.x -= 4; } else { gSprites[spriteId].pos1.x = 0xB4; - if(gTasks[taskId].data[5]) + if (gTasks[taskId].data[5]) { gSprites[spriteId].oam.objMode = 0; gTasks[taskId].func = task_new_game_prof_birch_speech_16; @@ -1067,7 +1067,7 @@ void sub_800A974(u8 taskId) void Task_800A9B4(u8 taskId) { - if(sub_8072CF4(0x18)) + if (sub_8072CF4(0x18)) { CreateNameMenu(2, 1); gTasks[taskId].func = sub_800A9EC; @@ -1123,7 +1123,7 @@ void task_new_game_prof_birch_speech_part2_1(u8 taskId) void sub_800AB38(u8 taskId) { - if(sub_8072CF4(0x18)) + if (sub_8072CF4(0x18)) { DisplayYesNoMenu(2, 1, 1); gTasks[taskId].func = task_new_game_prof_birch_speech_part2_4; @@ -1153,7 +1153,7 @@ void task_new_game_prof_birch_speech_part2_4(u8 taskId) void sub_800AC20(u8 taskId) { - if(gTasks[taskId].data[4]) + if (gTasks[taskId].data[4]) { gTasks[taskId].data[4] += 2; REG_BG1HOFS = gTasks[taskId].data[4]; @@ -1166,7 +1166,7 @@ void sub_800AC20(u8 taskId) void task_new_game_prof_birch_speech_part2_6(u8 taskId) { - if(gTasks[taskId].data[5]) + if (gTasks[taskId].data[5]) { s16 spriteId; @@ -1199,7 +1199,7 @@ void task_new_game_prof_birch_speech_part2_6(u8 taskId) void task_new_game_prof_birch_speech_part2_7(u8 taskId) { - if(gTasks[taskId].data[5]) + if (gTasks[taskId].data[5]) { s16 spriteId; @@ -1209,7 +1209,7 @@ void task_new_game_prof_birch_speech_part2_7(u8 taskId) spriteId = gTasks[taskId].data[9]; gSprites[spriteId].oam.objMode = 0; - if(sub_8072CF4(0x18)) + if (sub_8072CF4(0x18)) { spriteId = gTasks[taskId].data[8]; gSprites[spriteId].oam.objMode = 1; @@ -1227,7 +1227,7 @@ void task_new_game_prof_birch_speech_part2_7(u8 taskId) void task_new_game_prof_birch_speech_part2_8(u8 taskId) { - if(gTasks[taskId].data[5]) + if (gTasks[taskId].data[5]) { s16 spriteId; @@ -1237,7 +1237,7 @@ void task_new_game_prof_birch_speech_part2_8(u8 taskId) spriteId = gTasks[taskId].data[9]; gSprites[spriteId].invisible = 1; - if(gTasks[taskId].data[7]) + if (gTasks[taskId].data[7]) { gTasks[taskId].data[7]--; } @@ -1245,7 +1245,7 @@ void task_new_game_prof_birch_speech_part2_8(u8 taskId) { u8 spriteId; - if(gSaveBlock2.playerGender) + if (gSaveBlock2.playerGender) spriteId = (u8)gTasks[taskId].data[11]; else spriteId = (u8)gTasks[taskId].data[10]; @@ -1267,14 +1267,14 @@ void task_new_game_prof_birch_speech_part2_8(u8 taskId) void task_new_game_prof_birch_speech_part2_9(u8 taskId) { - if(gTasks[taskId].data[5]) + if (gTasks[taskId].data[5]) { s16 spriteId; spriteId = gTasks[taskId].data[2]; gSprites[spriteId].oam.objMode = 0; - if(sub_8072CF4(0x18)) + if (sub_8072CF4(0x18)) { u8 spriteId; -- cgit v1.2.3 From 9ba7169baaee0645f406d95b426f1b2bf750c72e Mon Sep 17 00:00:00 2001 From: YamaArashi Date: Mon, 5 Sep 2016 21:00:02 -0700 Subject: clean up main_menu.c --- src/main_menu.c | 94 ++++++++++++++++++++++++++++----------------------------- src/menu.c | 6 ++-- 2 files changed, 50 insertions(+), 50 deletions(-) (limited to 'src') diff --git a/src/main_menu.c b/src/main_menu.c index 60e9fdc98..559bf5a0a 100644 --- a/src/main_menu.c +++ b/src/main_menu.c @@ -7,6 +7,7 @@ #include "songs.h" #include "palette.h" #include "string_util.h" +#include "species.h" extern u8 MenuUpdateWindowText(void); extern void MenuPrint(u8 *, u8, u8); @@ -22,7 +23,7 @@ extern u8 sub_80729D8(u8 *, u8, u16, u8); extern u8 GetBadgeCount(void); extern void Task_Birch1(u8); void MenuPrintMessage(const u8 *string, u8 a, u8 b); -u8 sub_8072CF4(u8 a); +u8 MenuUpdateWindowText_OverrideLineLength(u8 a); void sub_8072DEC(void); u8 sub_8075374(void); void MenuSetText(u32); @@ -702,7 +703,7 @@ void sub_800B034(u8 taskId); void new_game_prof_birch_speech_part2_start(); void nullsub_34(struct Sprite *sprite); void sub_800B240(struct Sprite *sprite); -u8 sub_800B25C(u8, u8); +u8 CreateAzurillSprite(u8, u8); void AddBirchSpeechObjects(u8); void sub_800B3EC(u8); void sub_800B458(u8, u8); @@ -739,14 +740,14 @@ void Task_Birch1(u8 taskId) AddBirchSpeechObjects(taskId); BeginNormalPaletteFade(-1, 0, 0x10, 0, 0); REG_BG1CNT = 0x00000703; - REG_DISPCNT = 0x9A << 5; + REG_DISPCNT = DISPCNT_BG0_ON | DISPCNT_BG1_ON | DISPCNT_OBJ_ON | DISPCNT_OBJ_1D_MAP; gTasks[taskId].data[4] = 0; gTasks[taskId].func = task_new_game_prof_birch_speech_2; gTasks[taskId].data[2] = 0xFF; gTasks[taskId].data[3] = 0xFF; gTasks[taskId].data[7] = 0xD8; - sub_8075474(0xBB << 1); + sub_8075474(BGM_DOORO_X4); } void task_new_game_prof_birch_speech_2(u8 taskId) @@ -782,17 +783,17 @@ void task_new_game_prof_birch_speech_3(u8 taskId) if (task->data[5] != 0) { struct Sprite *sprites = gSprites; - struct Sprite *sprite = &sprites[(s16)task->data[8]]; + struct Sprite *sprite = &sprites[task->data[8]]; sprite->oam.objMode = 0; - if ((u16)task->data[7]) + if (task->data[7]) { task->data[7]--; } else { MenuDrawTextWindow(0x2, 0xD, 0x1B, 0x12); - MenuPrintMessage(gUnknown_081C6D78, 0x3, 0xE); + MenuPrintMessage(gUnknown_081C6D78, 3, 14); task->func = task_new_game_prof_birch_speech_4; } } @@ -800,18 +801,16 @@ void task_new_game_prof_birch_speech_3(u8 taskId) void task_new_game_prof_birch_speech_4(u8 taskId) { - if (!gPaletteFade.active && sub_8072CF4(0x18)) + if (!gPaletteFade.active && MenuUpdateWindowText_OverrideLineLength(24)) { - struct Task *tasks = gTasks; - struct Task *task = &tasks[taskId]; - task->func = task_new_game_prof_birch_speech_5; - MenuPrintMessage(gUnknown_081C6DF8, 0x3, 0xE); + gTasks[taskId].func = task_new_game_prof_birch_speech_5; + MenuPrintMessage(gUnknown_081C6DF8, 3, 14); } } void task_new_game_prof_birch_speech_5(u8 taskId) { - if (sub_8072CF4(0x18)) + if (MenuUpdateWindowText_OverrideLineLength(24)) gTasks[taskId].func = task_new_game_prof_birch_speech_6; } @@ -819,7 +818,7 @@ void task_new_game_prof_birch_speech_6(u8 taskId) { struct Task *tasks = gTasks; struct Task *task = &tasks[taskId]; - u8 data = (u8)task->data[9]; + u8 data = task->data[9]; struct Sprite *sprites = gSprites; struct Sprite *sprite = &sprites[data]; @@ -827,7 +826,7 @@ void task_new_game_prof_birch_speech_6(u8 taskId) sprite->pos1.y = 0x48; sprite->invisible = 0; sprite->data0 = 0; - AddTextPrinterForMessage(data, sprite->oam.paletteNum, 0x70, 0x3A, 0, 0, 0x20, 0x0000FFFF); + CreatePokeballSprite(data, sprite->oam.paletteNum, 0x70, 0x3A, 0, 0, 0x20, 0x0000FFFF); task->func = task_new_game_prof_birch_speech_7; task->data[7] = 0; } @@ -840,7 +839,7 @@ void task_new_game_prof_birch_speech_7(u8 taskId) if (sub_8075374()) { struct Task *tasks = gTasks; - struct Task *task = &tasks[taskId]; //r5 + struct Task *task = &tasks[taskId]; if (task->data[7] > 0x5F) { @@ -848,41 +847,42 @@ void task_new_game_prof_birch_speech_7(u8 taskId) task->func = task_new_game_prof_birch_speech_8; } } - //_0800A4E4 + tasks = gTasks; - task = &tasks[taskId]; //r2 - if ((s16)task->data[7] <= 0x00003fff) + task = &tasks[taskId]; + + if (task->data[7] < 0x4000) { task->data[7]++; if (task->data[7] == 0x20) { - cry_related(0xAF << 1, 0); + cry_related(SPECIES_AZURILL, 0); } } } void task_new_game_prof_birch_speech_8(u8 taskId) { - if (sub_8072CF4(0x18)) + if (MenuUpdateWindowText_OverrideLineLength(24)) { - MenuPrintMessage(gUnknown_081C6E1A, 0x3, 0xE); + MenuPrintMessage(gUnknown_081C6E1A, 3, 14); gTasks[taskId].func = task_new_game_prof_birch_speech_9; } } void task_new_game_prof_birch_speech_9(u8 taskId) { - if (sub_8072CF4(0x18)) + if (MenuUpdateWindowText_OverrideLineLength(24)) { MenuDrawTextWindow(0x2, 0xD, 0x1B, 0x12); - MenuPrintMessage(gUnknown_081C6FCB, 0x3, 0xE); + MenuPrintMessage(gUnknown_081C6FCB, 3, 14); gTasks[taskId].func = task_new_game_prof_birch_speech_10; } } void task_new_game_prof_birch_speech_10(u8 taskId) { - if (sub_8072CF4(0x18)) + if (MenuUpdateWindowText_OverrideLineLength(24)) { struct Sprite *sprites = gSprites; struct Task *tasks = gTasks; @@ -905,7 +905,7 @@ void task_new_game_prof_birch_speech_11(u8 taskId) struct Task *tasks = gTasks; struct Task *task = &tasks[taskId]; - if ((s16)task->data[4] != -0x3C) + if (task->data[4] != -0x3C) { task->data[4] -= 2; REG_BG1HOFS = task->data[4]; @@ -969,7 +969,7 @@ void task_new_game_prof_birch_speech_14(u8 taskId) void task_new_game_prof_birch_speech_15(u8 taskId) { - if (sub_8072CF4(0x18)) + if (MenuUpdateWindowText_OverrideLineLength(24)) { CreateGenderMenu(2, 4); gTasks[taskId].func = task_new_game_prof_birch_speech_16; @@ -984,14 +984,14 @@ void task_new_game_prof_birch_speech_16(u8 taskId) { case MALE: sub_8072DEC(); - audio_play(5); + audio_play(SE_SELECT); gSaveBlock2.playerGender = MALE; MenuZeroFillWindowRect(2, 4, 8, 9); gTasks[taskId].func = sub_800A974; break; case FEMALE: sub_8072DEC(); - audio_play(5); + audio_play(SE_SELECT); gSaveBlock2.playerGender = FEMALE; MenuZeroFillWindowRect(2, 4, 8, 9); gTasks[taskId].func = sub_800A974; @@ -1000,7 +1000,7 @@ void task_new_game_prof_birch_speech_16(u8 taskId) cursorPos = GetMenuCursorPos(); - if (cursorPos != (s16)gTasks[taskId].data[6]) + if (cursorPos != gTasks[taskId].data[6]) { gTasks[taskId].data[6] = cursorPos; gSprites[gTasks[taskId].data[2]].oam.objMode = 1; @@ -1067,7 +1067,7 @@ void sub_800A974(u8 taskId) void Task_800A9B4(u8 taskId) { - if (sub_8072CF4(0x18)) + if (MenuUpdateWindowText_OverrideLineLength(24)) { CreateNameMenu(2, 1); gTasks[taskId].func = sub_800A9EC; @@ -1085,19 +1085,19 @@ void sub_800A9EC(u8 taskId) case 3: case 4: sub_8072DEC(); - audio_play(5); + audio_play(SE_SELECT); MenuZeroFillWindowRect(2, 1, 22, 12); set_default_player_name(n); gTasks[taskId].func = task_new_game_prof_birch_speech_part2_1; break; case 0: - audio_play(5); + audio_play(SE_SELECT); BeginNormalPaletteFade(-1, 0, 0, 16, 0); gTasks[taskId].func = sub_800AAAC; break; case -1: sub_8072DEC(); - audio_play(5); + audio_play(SE_SELECT); MenuZeroFillWindowRect(2, 1, 22, 12); gTasks[taskId].func = task_new_game_prof_birch_speech_14; break; @@ -1123,7 +1123,7 @@ void task_new_game_prof_birch_speech_part2_1(u8 taskId) void sub_800AB38(u8 taskId) { - if (sub_8072CF4(0x18)) + if (MenuUpdateWindowText_OverrideLineLength(24)) { DisplayYesNoMenu(2, 1, 1); gTasks[taskId].func = task_new_game_prof_birch_speech_part2_4; @@ -1135,7 +1135,7 @@ void task_new_game_prof_birch_speech_part2_4(u8 taskId) switch (ProcessMenuInputNoWrap_()) { case 0: - audio_play(5); + audio_play(SE_SELECT); MenuZeroFillWindowRect(2, 1, 8, 7); gSprites[gTasks[taskId].data[2]].oam.objMode = ST_OAM_OBJ_BLEND; sub_800B458(taskId, 2); @@ -1144,7 +1144,7 @@ void task_new_game_prof_birch_speech_part2_4(u8 taskId) break; case -1: case 1: - audio_play(5); + audio_play(SE_SELECT); MenuZeroFillWindowRect(2, 1, 8, 7); gTasks[taskId].func = task_new_game_prof_birch_speech_14; break; @@ -1209,7 +1209,7 @@ void task_new_game_prof_birch_speech_part2_7(u8 taskId) spriteId = gTasks[taskId].data[9]; gSprites[spriteId].oam.objMode = 0; - if (sub_8072CF4(0x18)) + if (MenuUpdateWindowText_OverrideLineLength(24)) { spriteId = gTasks[taskId].data[8]; gSprites[spriteId].oam.objMode = 1; @@ -1274,7 +1274,7 @@ void task_new_game_prof_birch_speech_part2_9(u8 taskId) spriteId = gTasks[taskId].data[2]; gSprites[spriteId].oam.objMode = 0; - if (sub_8072CF4(0x18)) + if (MenuUpdateWindowText_OverrideLineLength(24)) { u8 spriteId; @@ -1416,17 +1416,17 @@ void sub_800B240(struct Sprite *sprite) sprite->data0 = y; } -u8 sub_800B25C(u8 a1, u8 a2) +u8 CreateAzurillSprite(u8 a1, u8 a2) { DecompressPicFromTable_2( - &gMonFrontPicTable[350], - gMonFrontPicCoords[350].x, - gMonFrontPicCoords[350].y, + &gMonFrontPicTable[SPECIES_AZURILL], + gMonFrontPicCoords[SPECIES_AZURILL].x, + gMonFrontPicCoords[SPECIES_AZURILL].y, gUnknown_081FAF4C[0], gUnknown_081FAF4C[1], - 350); - LoadCompressedObjectPalette(&gMonPaletteTable[350]); - gpu_pal_obj_decompress_and_apply(350, 1); + SPECIES_AZURILL); + LoadCompressedObjectPalette(&gMonPaletteTable[SPECIES_AZURILL]); + gpu_pal_obj_decompress_and_apply(SPECIES_AZURILL, 1); return CreateSprite(&gUnknown_02024E8C, a1, a2, 0); } @@ -1440,7 +1440,7 @@ void AddBirchSpeechObjects(u8 taskId) gSprites[spriteId].invisible = 1; gTasks[taskId].data[8] = spriteId; - spriteId = sub_800B25C(0x68, 0x48); + spriteId = CreateAzurillSprite(0x68, 0x48); gSprites[spriteId].callback = nullsub_34; gSprites[spriteId].oam.priority = 0; gSprites[spriteId].invisible = 1; diff --git a/src/menu.c b/src/menu.c index 1ced7d517..b101165f2 100644 --- a/src/menu.c +++ b/src/menu.c @@ -74,7 +74,7 @@ u8 *sub_8072C74(u8 *, u8 *, u8, u8); u8 sub_8072CA4(u8 *s); u8 sub_8072CBC(void); void sub_8072CD4(u8 *, u8 *, u8 *); -u32 sub_8072CF4(u8); +u32 MenuUpdateWindowText_OverrideLineLength(u8); struct Window * unref_sub_8072D0C(void); void sub_8072D18(u8, u8); u8 InitMenu(u8, u8, u8, u8, u8, u8); @@ -938,9 +938,9 @@ void sub_8072CD4(u8 *a1, u8 *a2, u8 *a3) sub_8004E28(gMenuWindowPtr, a1, a2, a3); } -u32 sub_8072CF4(u8 a1) +u32 MenuUpdateWindowText_OverrideLineLength(u8 lineLength) { - return sub_80037C8(gMenuWindowPtr, a1); + return sub_80037C8(gMenuWindowPtr, lineLength); } struct Window *unref_sub_8072D0C(void) -- cgit v1.2.3 From 06bed8be90c865057378482f2b179749b082619c Mon Sep 17 00:00:00 2001 From: YamaArashi Date: Thu, 8 Sep 2016 20:25:40 -0700 Subject: starting decompliation of pokemon functions --- src/pokemon.c | 607 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 607 insertions(+) create mode 100644 src/pokemon.c (limited to 'src') diff --git a/src/pokemon.c b/src/pokemon.c new file mode 100644 index 000000000..a2c98a71b --- /dev/null +++ b/src/pokemon.c @@ -0,0 +1,607 @@ +#include "global.h" +#include "text.h" +#include "string_util.h" +#include "pokemon.h" + +struct PokemonSubstruct0 +{ + u16 species; + u16 heldItem; + u32 experience; + u8 ppBonuses; + u8 friendship; +}; + +struct PokemonSubstruct1 +{ + u16 moves[4]; + u8 pp[4]; +}; + +struct PokemonSubstruct2 +{ + u8 hpEV; + u8 attackEV; + u8 defenseEV; + u8 speedEV; + u8 spAttackEV; + u8 spDefenseEV; + u8 cool; + u8 beauty; + u8 cute; + u8 smart; + u8 tough; + u8 sheen; +}; + +struct PokemonSubstruct3 +{ + u8 pokerus; + u8 metLocation; + + u16 metLevel:7; + u16 metGame:4; + u16 pokeball:4; + u16 otGender:1; + + u32 hpIV:5; + u32 attackIV:5; + u32 defenseIV:5; + u32 speedIV:5; + u32 spAttackIV:5; + u32 spDefenseIV:5; + u32 isEgg:1; + u32 altAbility:1; + + u32 coolRibbon:3; + u32 beautyRibbon:3; + u32 cuteRibbon:3; + u32 smartRibbon:3; + u32 toughRibbon:3; + u32 championRibbon:1; + u32 winningRibbon:1; + u32 victoryRibbon:1; + u32 artistRibbon:1; + u32 effortRibbon:1; + u32 giftRibbon1:1; + u32 giftRibbon2:1; + u32 giftRibbon3:1; + u32 giftRibbon4:1; + u32 giftRibbon5:1; + u32 giftRibbon6:1; + u32 giftRibbon7:1; + u32 fatefulEncounter:5; // unused in Ruby/Sapphire, but the high bit must be set for Mew/Deoxys to obey in FR/LG/Emerald +}; + +union PokemonSubstruct +{ + struct PokemonSubstruct0 type0; + struct PokemonSubstruct1 type1; + struct PokemonSubstruct2 type2; + struct PokemonSubstruct3 type3; +}; + +struct BoxPokemon +{ + u32 personality; + u32 otId; + u8 nickname[10]; + u8 language; + u8 isBadEgg:1; + u8 sanity2:1; + u8 sanity3:1; + u8 unused:5; + u8 otName[7]; + u8 markings; + u16 checksum; + u16 unknown; + + union + { + u32 raw[12]; + union PokemonSubstruct substructs[4]; + } secure; +}; + +struct Pokemon +{ + struct BoxPokemon box; + u32 status; + u8 level; + u8 pokerus; + u16 hp; + u16 maxHP; + u16 attack; + u16 defense; + u16 speed; + u16 spAttack; + u16 spDefense; +}; + +void ZeroPokemonBoxData(struct BoxPokemon *mon); + +u16 pokemon_calc_checksum(struct Pokemon *mon); + +void EncryptMon(struct Pokemon *mon); +void DecryptMon(struct Pokemon *mon); +union PokemonSubstruct *GetSubstruct(struct Pokemon *mon, u32 personality, u8 substructType); +u32 GetMonData(struct Pokemon *mon, s32 field, u8 *data); +u32 GetMonBoxData(struct Pokemon *mon, s32 field, u8 *data); + +extern u8 gBadEggNickname[]; +extern u8 gEggNickname[]; +extern u32 gBitTable[]; + +/* +void ZeroPokemonBoxData(struct BoxPokemon *mon) +{ + u8 *raw = (u8 *)mon; + u32 i; + for (i = 0; i < sizeof(struct BoxPokemon); i++) + raw[i] = 0; +} +*/ + +void EncryptMon(struct Pokemon *mon) +{ + u32 i; + for (i = 0; i < 12; i++) + { + mon->box.secure.raw[i] ^= mon->box.personality; + mon->box.secure.raw[i] ^= mon->box.otId; + } +} + +void DecryptMon(struct Pokemon *mon) +{ + u32 i; + for (i = 0; i < 12; i++) + { + mon->box.secure.raw[i] ^= mon->box.otId; + mon->box.secure.raw[i] ^= mon->box.personality; + } +} + +#define SUBSTRUCT_CASE(n, v1, v2, v3, v4) \ +case n: \ + switch (substructType) \ + { \ + case 0: \ + substruct = &substructs ## n [v1]; \ + break; \ + case 1: \ + substruct = &substructs ## n [v2]; \ + break; \ + case 2: \ + substruct = &substructs ## n [v3]; \ + break; \ + case 3: \ + substruct = &substructs ## n [v4]; \ + break; \ + } \ + break; + +union PokemonSubstruct *GetSubstruct(struct Pokemon *mon, u32 personality, u8 substructType) +{ + union PokemonSubstruct *substruct = NULL; + + union PokemonSubstruct *substructs0 = mon->box.secure.substructs; + union PokemonSubstruct *substructs1 = mon->box.secure.substructs; + union PokemonSubstruct *substructs2 = mon->box.secure.substructs; + union PokemonSubstruct *substructs3 = mon->box.secure.substructs; + union PokemonSubstruct *substructs4 = mon->box.secure.substructs; + union PokemonSubstruct *substructs5 = mon->box.secure.substructs; + union PokemonSubstruct *substructs6 = mon->box.secure.substructs; + union PokemonSubstruct *substructs7 = mon->box.secure.substructs; + union PokemonSubstruct *substructs8 = mon->box.secure.substructs; + union PokemonSubstruct *substructs9 = mon->box.secure.substructs; + union PokemonSubstruct *substructs10 = mon->box.secure.substructs; + union PokemonSubstruct *substructs11 = mon->box.secure.substructs; + union PokemonSubstruct *substructs12 = mon->box.secure.substructs; + union PokemonSubstruct *substructs13 = mon->box.secure.substructs; + union PokemonSubstruct *substructs14 = mon->box.secure.substructs; + union PokemonSubstruct *substructs15 = mon->box.secure.substructs; + union PokemonSubstruct *substructs16 = mon->box.secure.substructs; + union PokemonSubstruct *substructs17 = mon->box.secure.substructs; + union PokemonSubstruct *substructs18 = mon->box.secure.substructs; + union PokemonSubstruct *substructs19 = mon->box.secure.substructs; + union PokemonSubstruct *substructs20 = mon->box.secure.substructs; + union PokemonSubstruct *substructs21 = mon->box.secure.substructs; + union PokemonSubstruct *substructs22 = mon->box.secure.substructs; + union PokemonSubstruct *substructs23 = mon->box.secure.substructs; + + switch (personality % 24) + { + SUBSTRUCT_CASE( 0,0,1,2,3) + SUBSTRUCT_CASE( 1,0,1,3,2) + SUBSTRUCT_CASE( 2,0,2,1,3) + SUBSTRUCT_CASE( 3,0,3,1,2) + SUBSTRUCT_CASE( 4,0,2,3,1) + SUBSTRUCT_CASE( 5,0,3,2,1) + SUBSTRUCT_CASE( 6,1,0,2,3) + SUBSTRUCT_CASE( 7,1,0,3,2) + SUBSTRUCT_CASE( 8,2,0,1,3) + SUBSTRUCT_CASE( 9,3,0,1,2) + SUBSTRUCT_CASE(10,2,0,3,1) + SUBSTRUCT_CASE(11,3,0,2,1) + SUBSTRUCT_CASE(12,1,2,0,3) + SUBSTRUCT_CASE(13,1,3,0,2) + SUBSTRUCT_CASE(14,2,1,0,3) + SUBSTRUCT_CASE(15,3,1,0,2) + SUBSTRUCT_CASE(16,2,3,0,1) + SUBSTRUCT_CASE(17,3,2,0,1) + SUBSTRUCT_CASE(18,1,2,3,0) + SUBSTRUCT_CASE(19,1,3,2,0) + SUBSTRUCT_CASE(20,2,1,3,0) + SUBSTRUCT_CASE(21,3,1,2,0) + SUBSTRUCT_CASE(22,2,3,1,0) + SUBSTRUCT_CASE(23,3,2,1,0) + } + + return substruct; +} + +u32 GetMonData(struct Pokemon *mon, s32 field, u8 *data) +{ + switch (field) + { + case MON_DATA_STATUS: + return mon->status; + case MON_DATA_LEVEL: + return mon->level; + case MON_DATA_HP: + return mon->hp; + case MON_DATA_MAX_HP: + return mon->maxHP; + case MON_DATA_ATK: + return mon->attack; + case MON_DATA_DEF: + return mon->defense; + case MON_DATA_SPD: + return mon->speed; + case MON_DATA_SPATK: + return mon->spAttack; + case MON_DATA_SPDEF: + return mon->spDefense; + case MON_DATA_64: + return mon->pokerus; + default: + return GetMonBoxData(mon, field, data); + } +} + +u32 GetMonBoxData(struct Pokemon *mon, s32 field, u8 *data) +{ + u32 retVal = 0; + struct PokemonSubstruct0 *substruct0 = NULL; + struct PokemonSubstruct1 *substruct1 = NULL; + struct PokemonSubstruct2 *substruct2 = NULL; + struct PokemonSubstruct3 *substruct3 = NULL; + + if (field > MON_DATA_10) + { + substruct0 = &(GetSubstruct(mon, mon->box.personality, 0)->type0); + substruct1 = &(GetSubstruct(mon, mon->box.personality, 1)->type1); + substruct2 = &(GetSubstruct(mon, mon->box.personality, 2)->type2); + substruct3 = &(GetSubstruct(mon, mon->box.personality, 3)->type3); + + DecryptMon(mon); + + if (pokemon_calc_checksum(mon) != mon->box.checksum) + { + mon->box.isBadEgg = 1; + mon->box.sanity3 = 1; + substruct3->isEgg = 1; + } + } + + switch (field) + { + case MON_DATA_PERSONALITY: + retVal = mon->box.personality; + break; + case MON_DATA_OT_ID: + retVal = mon->box.otId; + break; + case MON_DATA_NICKNAME: + { + if (mon->box.isBadEgg) + { + StringCopy(data, gBadEggNickname); + retVal = StringLength(data); + } + else if (mon->box.sanity3) + { + StringCopy(data, gEggNickname); + retVal = StringLength(data); + } + else + { + retVal = 0; + + while (retVal < 10 && mon->box.nickname[retVal] != EOS) + { + data[retVal] = mon->box.nickname[retVal]; + retVal++; + } + + data[retVal] = EOS; + ConvertInternationalString(data, mon->box.language); + retVal = StringLength(data); + } + break; + } + case MON_DATA_LANGUAGE: + retVal = mon->box.language; + break; + case MON_DATA_SANITY_BIT1: + retVal = mon->box.isBadEgg; + break; + case MON_DATA_SANITY_BIT2: + retVal = mon->box.sanity2; + break; + case MON_DATA_SANITY_BIT3: + retVal = mon->box.sanity3; + break; + case MON_DATA_OT_NAME: + { + retVal = 0; + + while (retVal < 7 && mon->box.otName[retVal] != EOS) + { + data[retVal] = mon->box.otName[retVal]; + retVal++; + } + + data[retVal] = EOS; + break; + } + case MON_DATA_MARKINGS: + retVal = mon->box.markings; + break; + case MON_DATA_CHECKSUM: + retVal = mon->box.checksum; + break; + case MON_DATA_10: + retVal = mon->box.unknown; + break; + case MON_DATA_SPECIES: + retVal = mon->box.isBadEgg ? 412 : substruct0->species; + break; + case MON_DATA_HELD_ITEM: + retVal = substruct0->heldItem; + break; + case MON_DATA_EXP: + retVal = substruct0->experience; + break; + case MON_DATA_PP_BONUSES: + retVal = substruct0->ppBonuses; + break; + case MON_DATA_FRIENDSHIP: + retVal = substruct0->friendship; + break; + case MON_DATA_MOVE1: + case MON_DATA_MOVE2: + case MON_DATA_MOVE3: + case MON_DATA_MOVE4: + retVal = substruct1->moves[field - MON_DATA_MOVE1]; + break; + case MON_DATA_PP1: + case MON_DATA_PP2: + case MON_DATA_PP3: + case MON_DATA_PP4: + retVal = substruct1->pp[field - MON_DATA_PP1]; + break; + case MON_DATA_HP_EV: + retVal = substruct2->hpEV; + break; + case MON_DATA_ATK_EV: + retVal = substruct2->attackEV; + break; + case MON_DATA_DEF_EV: + retVal = substruct2->defenseEV; + break; + case MON_DATA_SPD_EV: + retVal = substruct2->speedEV; + break; + case MON_DATA_SPATK_EV: + retVal = substruct2->spAttackEV; + break; + case MON_DATA_SPDEF_EV: + retVal = substruct2->spDefenseEV; + break; + case MON_DATA_COOL: + retVal = substruct2->cool; + break; + case MON_DATA_BEAUTY: + retVal = substruct2->beauty; + break; + case MON_DATA_CUTE: + retVal = substruct2->cute; + break; + case MON_DATA_SMART: + retVal = substruct2->smart; + break; + case MON_DATA_TOUGH: + retVal = substruct2->tough; + break; + case MON_DATA_SHEEN: + retVal = substruct2->sheen; + break; + case MON_DATA_POKERUS: + retVal = substruct3->pokerus; + break; + case MON_DATA_MET_LOCATION: + retVal = substruct3->metLocation; + break; + case MON_DATA_MET_LEVEL: + retVal = substruct3->metLevel; + break; + case MON_DATA_MET_GAME: + retVal = substruct3->metGame; + break; + case MON_DATA_POKEBALL: + retVal = substruct3->pokeball; + break; + case MON_DATA_OT_GENDER: + retVal = substruct3->otGender; + break; + case MON_DATA_HP_IV: + retVal = substruct3->hpIV; + break; + case MON_DATA_ATK_IV: + retVal = substruct3->attackIV; + break; + case MON_DATA_DEF_IV: + retVal = substruct3->defenseIV; + break; + case MON_DATA_SPD_IV: + retVal = substruct3->speedIV; + break; + case MON_DATA_SPATK_IV: + retVal = substruct3->spAttackIV; + break; + case MON_DATA_SPDEF_IV: + retVal = substruct3->spDefenseIV; + break; + case MON_DATA_IS_EGG: + retVal = substruct3->isEgg; + break; + case MON_DATA_ALT_ABILITY: + retVal = substruct3->altAbility; + break; + case MON_DATA_COOL_RIBBON: + retVal = substruct3->coolRibbon; + break; + case MON_DATA_BEAUTY_RIBBON: + retVal = substruct3->beautyRibbon; + break; + case MON_DATA_CUTE_RIBBON: + retVal = substruct3->cuteRibbon; + break; + case MON_DATA_SMART_RIBBON: + retVal = substruct3->smartRibbon; + break; + case MON_DATA_TOUGH_RIBBON: + retVal = substruct3->toughRibbon; + break; + case MON_DATA_CHAMPION_RIBBON: + retVal = substruct3->championRibbon; + break; + case MON_DATA_WINNING_RIBBON: + retVal = substruct3->winningRibbon; + break; + case MON_DATA_VICTORY_RIBBON: + retVal = substruct3->victoryRibbon; + break; + case MON_DATA_ARTIST_RIBBON: + retVal = substruct3->artistRibbon; + break; + case MON_DATA_EFFORT_RIBBON: + retVal = substruct3->effortRibbon; + break; + case MON_DATA_GIFT_RIBBON_1: + retVal = substruct3->giftRibbon1; + break; + case MON_DATA_GIFT_RIBBON_2: + retVal = substruct3->giftRibbon2; + break; + case MON_DATA_GIFT_RIBBON_3: + retVal = substruct3->giftRibbon3; + break; + case MON_DATA_GIFT_RIBBON_4: + retVal = substruct3->giftRibbon4; + break; + case MON_DATA_GIFT_RIBBON_5: + retVal = substruct3->giftRibbon5; + break; + case MON_DATA_GIFT_RIBBON_6: + retVal = substruct3->giftRibbon6; + break; + case MON_DATA_GIFT_RIBBON_7: + retVal = substruct3->giftRibbon7; + break; + case MON_DATA_FATEFUL_ENCOUNTER: + retVal = substruct3->fatefulEncounter; + break; + case MON_DATA_SPECIES2: + retVal = substruct0->species; + if (substruct0->species && (substruct3->isEgg || mon->box.isBadEgg)) + retVal = 412; + break; + case MON_DATA_IVS: + retVal = substruct3->hpIV | (substruct3->attackIV << 5) | (substruct3->defenseIV << 10) | (substruct3->speedIV << 15) | (substruct3->spAttackIV << 20) | (substruct3->spDefenseIV << 25); + break; + case MON_DATA_KNOWN_MOVES: + if (substruct0->species && !substruct3->isEgg) + { + u16 *moves = (u16 *)data; + s32 i = 0; + + while (moves[i] != 355) + { + u16 move = moves[i]; + if (substruct1->moves[0] == move + || substruct1->moves[1] == move + || substruct1->moves[2] == move + || substruct1->moves[3] == move) + retVal |= gBitTable[i]; + i++; + } + } + break; + case MON_DATA_RIBBON_COUNT: + retVal = 0; + if (substruct0->species && !substruct3->isEgg) + { + retVal += substruct3->coolRibbon; + retVal += substruct3->beautyRibbon; + retVal += substruct3->cuteRibbon; + retVal += substruct3->smartRibbon; + retVal += substruct3->toughRibbon; + retVal += substruct3->championRibbon; + retVal += substruct3->winningRibbon; + retVal += substruct3->victoryRibbon; + retVal += substruct3->artistRibbon; + retVal += substruct3->effortRibbon; + retVal += substruct3->giftRibbon1; + retVal += substruct3->giftRibbon2; + retVal += substruct3->giftRibbon3; + retVal += substruct3->giftRibbon4; + retVal += substruct3->giftRibbon5; + retVal += substruct3->giftRibbon6; + retVal += substruct3->giftRibbon7; + } + break; + case MON_DATA_RIBBONS: + retVal = 0; + if (substruct0->species && !substruct3->isEgg) + { + retVal = substruct3->championRibbon + | (substruct3->coolRibbon << 1) + | (substruct3->beautyRibbon << 4) + | (substruct3->cuteRibbon << 7) + | (substruct3->smartRibbon << 10) + | (substruct3->toughRibbon << 13) + | (substruct3->winningRibbon << 16) + | (substruct3->victoryRibbon << 17) + | (substruct3->artistRibbon << 18) + | (substruct3->effortRibbon << 19) + | (substruct3->giftRibbon1 << 20) + | (substruct3->giftRibbon2 << 21) + | (substruct3->giftRibbon3 << 22) + | (substruct3->giftRibbon4 << 23) + | (substruct3->giftRibbon5 << 24) + | (substruct3->giftRibbon6 << 25) + | (substruct3->giftRibbon7 << 26); + } + break; + default: + break; + } + + if (field > MON_DATA_10) + EncryptMon(mon); + + return retVal; +} -- cgit v1.2.3 From 0b48cbfed8a3332d6b164c51a224b154fef858e6 Mon Sep 17 00:00:00 2001 From: YamaArashi Date: Fri, 9 Sep 2016 21:18:37 -0700 Subject: more decompilation of pokemon functions --- src/pokemon.c | 607 -------------------------------------------------- src/pokemon_1.c | 678 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ src/pokemon_2.c | 474 +++++++++++++++++++++++++++++++++++++++ 3 files changed, 1152 insertions(+), 607 deletions(-) delete mode 100644 src/pokemon.c create mode 100644 src/pokemon_1.c create mode 100644 src/pokemon_2.c (limited to 'src') diff --git a/src/pokemon.c b/src/pokemon.c deleted file mode 100644 index a2c98a71b..000000000 --- a/src/pokemon.c +++ /dev/null @@ -1,607 +0,0 @@ -#include "global.h" -#include "text.h" -#include "string_util.h" -#include "pokemon.h" - -struct PokemonSubstruct0 -{ - u16 species; - u16 heldItem; - u32 experience; - u8 ppBonuses; - u8 friendship; -}; - -struct PokemonSubstruct1 -{ - u16 moves[4]; - u8 pp[4]; -}; - -struct PokemonSubstruct2 -{ - u8 hpEV; - u8 attackEV; - u8 defenseEV; - u8 speedEV; - u8 spAttackEV; - u8 spDefenseEV; - u8 cool; - u8 beauty; - u8 cute; - u8 smart; - u8 tough; - u8 sheen; -}; - -struct PokemonSubstruct3 -{ - u8 pokerus; - u8 metLocation; - - u16 metLevel:7; - u16 metGame:4; - u16 pokeball:4; - u16 otGender:1; - - u32 hpIV:5; - u32 attackIV:5; - u32 defenseIV:5; - u32 speedIV:5; - u32 spAttackIV:5; - u32 spDefenseIV:5; - u32 isEgg:1; - u32 altAbility:1; - - u32 coolRibbon:3; - u32 beautyRibbon:3; - u32 cuteRibbon:3; - u32 smartRibbon:3; - u32 toughRibbon:3; - u32 championRibbon:1; - u32 winningRibbon:1; - u32 victoryRibbon:1; - u32 artistRibbon:1; - u32 effortRibbon:1; - u32 giftRibbon1:1; - u32 giftRibbon2:1; - u32 giftRibbon3:1; - u32 giftRibbon4:1; - u32 giftRibbon5:1; - u32 giftRibbon6:1; - u32 giftRibbon7:1; - u32 fatefulEncounter:5; // unused in Ruby/Sapphire, but the high bit must be set for Mew/Deoxys to obey in FR/LG/Emerald -}; - -union PokemonSubstruct -{ - struct PokemonSubstruct0 type0; - struct PokemonSubstruct1 type1; - struct PokemonSubstruct2 type2; - struct PokemonSubstruct3 type3; -}; - -struct BoxPokemon -{ - u32 personality; - u32 otId; - u8 nickname[10]; - u8 language; - u8 isBadEgg:1; - u8 sanity2:1; - u8 sanity3:1; - u8 unused:5; - u8 otName[7]; - u8 markings; - u16 checksum; - u16 unknown; - - union - { - u32 raw[12]; - union PokemonSubstruct substructs[4]; - } secure; -}; - -struct Pokemon -{ - struct BoxPokemon box; - u32 status; - u8 level; - u8 pokerus; - u16 hp; - u16 maxHP; - u16 attack; - u16 defense; - u16 speed; - u16 spAttack; - u16 spDefense; -}; - -void ZeroPokemonBoxData(struct BoxPokemon *mon); - -u16 pokemon_calc_checksum(struct Pokemon *mon); - -void EncryptMon(struct Pokemon *mon); -void DecryptMon(struct Pokemon *mon); -union PokemonSubstruct *GetSubstruct(struct Pokemon *mon, u32 personality, u8 substructType); -u32 GetMonData(struct Pokemon *mon, s32 field, u8 *data); -u32 GetMonBoxData(struct Pokemon *mon, s32 field, u8 *data); - -extern u8 gBadEggNickname[]; -extern u8 gEggNickname[]; -extern u32 gBitTable[]; - -/* -void ZeroPokemonBoxData(struct BoxPokemon *mon) -{ - u8 *raw = (u8 *)mon; - u32 i; - for (i = 0; i < sizeof(struct BoxPokemon); i++) - raw[i] = 0; -} -*/ - -void EncryptMon(struct Pokemon *mon) -{ - u32 i; - for (i = 0; i < 12; i++) - { - mon->box.secure.raw[i] ^= mon->box.personality; - mon->box.secure.raw[i] ^= mon->box.otId; - } -} - -void DecryptMon(struct Pokemon *mon) -{ - u32 i; - for (i = 0; i < 12; i++) - { - mon->box.secure.raw[i] ^= mon->box.otId; - mon->box.secure.raw[i] ^= mon->box.personality; - } -} - -#define SUBSTRUCT_CASE(n, v1, v2, v3, v4) \ -case n: \ - switch (substructType) \ - { \ - case 0: \ - substruct = &substructs ## n [v1]; \ - break; \ - case 1: \ - substruct = &substructs ## n [v2]; \ - break; \ - case 2: \ - substruct = &substructs ## n [v3]; \ - break; \ - case 3: \ - substruct = &substructs ## n [v4]; \ - break; \ - } \ - break; - -union PokemonSubstruct *GetSubstruct(struct Pokemon *mon, u32 personality, u8 substructType) -{ - union PokemonSubstruct *substruct = NULL; - - union PokemonSubstruct *substructs0 = mon->box.secure.substructs; - union PokemonSubstruct *substructs1 = mon->box.secure.substructs; - union PokemonSubstruct *substructs2 = mon->box.secure.substructs; - union PokemonSubstruct *substructs3 = mon->box.secure.substructs; - union PokemonSubstruct *substructs4 = mon->box.secure.substructs; - union PokemonSubstruct *substructs5 = mon->box.secure.substructs; - union PokemonSubstruct *substructs6 = mon->box.secure.substructs; - union PokemonSubstruct *substructs7 = mon->box.secure.substructs; - union PokemonSubstruct *substructs8 = mon->box.secure.substructs; - union PokemonSubstruct *substructs9 = mon->box.secure.substructs; - union PokemonSubstruct *substructs10 = mon->box.secure.substructs; - union PokemonSubstruct *substructs11 = mon->box.secure.substructs; - union PokemonSubstruct *substructs12 = mon->box.secure.substructs; - union PokemonSubstruct *substructs13 = mon->box.secure.substructs; - union PokemonSubstruct *substructs14 = mon->box.secure.substructs; - union PokemonSubstruct *substructs15 = mon->box.secure.substructs; - union PokemonSubstruct *substructs16 = mon->box.secure.substructs; - union PokemonSubstruct *substructs17 = mon->box.secure.substructs; - union PokemonSubstruct *substructs18 = mon->box.secure.substructs; - union PokemonSubstruct *substructs19 = mon->box.secure.substructs; - union PokemonSubstruct *substructs20 = mon->box.secure.substructs; - union PokemonSubstruct *substructs21 = mon->box.secure.substructs; - union PokemonSubstruct *substructs22 = mon->box.secure.substructs; - union PokemonSubstruct *substructs23 = mon->box.secure.substructs; - - switch (personality % 24) - { - SUBSTRUCT_CASE( 0,0,1,2,3) - SUBSTRUCT_CASE( 1,0,1,3,2) - SUBSTRUCT_CASE( 2,0,2,1,3) - SUBSTRUCT_CASE( 3,0,3,1,2) - SUBSTRUCT_CASE( 4,0,2,3,1) - SUBSTRUCT_CASE( 5,0,3,2,1) - SUBSTRUCT_CASE( 6,1,0,2,3) - SUBSTRUCT_CASE( 7,1,0,3,2) - SUBSTRUCT_CASE( 8,2,0,1,3) - SUBSTRUCT_CASE( 9,3,0,1,2) - SUBSTRUCT_CASE(10,2,0,3,1) - SUBSTRUCT_CASE(11,3,0,2,1) - SUBSTRUCT_CASE(12,1,2,0,3) - SUBSTRUCT_CASE(13,1,3,0,2) - SUBSTRUCT_CASE(14,2,1,0,3) - SUBSTRUCT_CASE(15,3,1,0,2) - SUBSTRUCT_CASE(16,2,3,0,1) - SUBSTRUCT_CASE(17,3,2,0,1) - SUBSTRUCT_CASE(18,1,2,3,0) - SUBSTRUCT_CASE(19,1,3,2,0) - SUBSTRUCT_CASE(20,2,1,3,0) - SUBSTRUCT_CASE(21,3,1,2,0) - SUBSTRUCT_CASE(22,2,3,1,0) - SUBSTRUCT_CASE(23,3,2,1,0) - } - - return substruct; -} - -u32 GetMonData(struct Pokemon *mon, s32 field, u8 *data) -{ - switch (field) - { - case MON_DATA_STATUS: - return mon->status; - case MON_DATA_LEVEL: - return mon->level; - case MON_DATA_HP: - return mon->hp; - case MON_DATA_MAX_HP: - return mon->maxHP; - case MON_DATA_ATK: - return mon->attack; - case MON_DATA_DEF: - return mon->defense; - case MON_DATA_SPD: - return mon->speed; - case MON_DATA_SPATK: - return mon->spAttack; - case MON_DATA_SPDEF: - return mon->spDefense; - case MON_DATA_64: - return mon->pokerus; - default: - return GetMonBoxData(mon, field, data); - } -} - -u32 GetMonBoxData(struct Pokemon *mon, s32 field, u8 *data) -{ - u32 retVal = 0; - struct PokemonSubstruct0 *substruct0 = NULL; - struct PokemonSubstruct1 *substruct1 = NULL; - struct PokemonSubstruct2 *substruct2 = NULL; - struct PokemonSubstruct3 *substruct3 = NULL; - - if (field > MON_DATA_10) - { - substruct0 = &(GetSubstruct(mon, mon->box.personality, 0)->type0); - substruct1 = &(GetSubstruct(mon, mon->box.personality, 1)->type1); - substruct2 = &(GetSubstruct(mon, mon->box.personality, 2)->type2); - substruct3 = &(GetSubstruct(mon, mon->box.personality, 3)->type3); - - DecryptMon(mon); - - if (pokemon_calc_checksum(mon) != mon->box.checksum) - { - mon->box.isBadEgg = 1; - mon->box.sanity3 = 1; - substruct3->isEgg = 1; - } - } - - switch (field) - { - case MON_DATA_PERSONALITY: - retVal = mon->box.personality; - break; - case MON_DATA_OT_ID: - retVal = mon->box.otId; - break; - case MON_DATA_NICKNAME: - { - if (mon->box.isBadEgg) - { - StringCopy(data, gBadEggNickname); - retVal = StringLength(data); - } - else if (mon->box.sanity3) - { - StringCopy(data, gEggNickname); - retVal = StringLength(data); - } - else - { - retVal = 0; - - while (retVal < 10 && mon->box.nickname[retVal] != EOS) - { - data[retVal] = mon->box.nickname[retVal]; - retVal++; - } - - data[retVal] = EOS; - ConvertInternationalString(data, mon->box.language); - retVal = StringLength(data); - } - break; - } - case MON_DATA_LANGUAGE: - retVal = mon->box.language; - break; - case MON_DATA_SANITY_BIT1: - retVal = mon->box.isBadEgg; - break; - case MON_DATA_SANITY_BIT2: - retVal = mon->box.sanity2; - break; - case MON_DATA_SANITY_BIT3: - retVal = mon->box.sanity3; - break; - case MON_DATA_OT_NAME: - { - retVal = 0; - - while (retVal < 7 && mon->box.otName[retVal] != EOS) - { - data[retVal] = mon->box.otName[retVal]; - retVal++; - } - - data[retVal] = EOS; - break; - } - case MON_DATA_MARKINGS: - retVal = mon->box.markings; - break; - case MON_DATA_CHECKSUM: - retVal = mon->box.checksum; - break; - case MON_DATA_10: - retVal = mon->box.unknown; - break; - case MON_DATA_SPECIES: - retVal = mon->box.isBadEgg ? 412 : substruct0->species; - break; - case MON_DATA_HELD_ITEM: - retVal = substruct0->heldItem; - break; - case MON_DATA_EXP: - retVal = substruct0->experience; - break; - case MON_DATA_PP_BONUSES: - retVal = substruct0->ppBonuses; - break; - case MON_DATA_FRIENDSHIP: - retVal = substruct0->friendship; - break; - case MON_DATA_MOVE1: - case MON_DATA_MOVE2: - case MON_DATA_MOVE3: - case MON_DATA_MOVE4: - retVal = substruct1->moves[field - MON_DATA_MOVE1]; - break; - case MON_DATA_PP1: - case MON_DATA_PP2: - case MON_DATA_PP3: - case MON_DATA_PP4: - retVal = substruct1->pp[field - MON_DATA_PP1]; - break; - case MON_DATA_HP_EV: - retVal = substruct2->hpEV; - break; - case MON_DATA_ATK_EV: - retVal = substruct2->attackEV; - break; - case MON_DATA_DEF_EV: - retVal = substruct2->defenseEV; - break; - case MON_DATA_SPD_EV: - retVal = substruct2->speedEV; - break; - case MON_DATA_SPATK_EV: - retVal = substruct2->spAttackEV; - break; - case MON_DATA_SPDEF_EV: - retVal = substruct2->spDefenseEV; - break; - case MON_DATA_COOL: - retVal = substruct2->cool; - break; - case MON_DATA_BEAUTY: - retVal = substruct2->beauty; - break; - case MON_DATA_CUTE: - retVal = substruct2->cute; - break; - case MON_DATA_SMART: - retVal = substruct2->smart; - break; - case MON_DATA_TOUGH: - retVal = substruct2->tough; - break; - case MON_DATA_SHEEN: - retVal = substruct2->sheen; - break; - case MON_DATA_POKERUS: - retVal = substruct3->pokerus; - break; - case MON_DATA_MET_LOCATION: - retVal = substruct3->metLocation; - break; - case MON_DATA_MET_LEVEL: - retVal = substruct3->metLevel; - break; - case MON_DATA_MET_GAME: - retVal = substruct3->metGame; - break; - case MON_DATA_POKEBALL: - retVal = substruct3->pokeball; - break; - case MON_DATA_OT_GENDER: - retVal = substruct3->otGender; - break; - case MON_DATA_HP_IV: - retVal = substruct3->hpIV; - break; - case MON_DATA_ATK_IV: - retVal = substruct3->attackIV; - break; - case MON_DATA_DEF_IV: - retVal = substruct3->defenseIV; - break; - case MON_DATA_SPD_IV: - retVal = substruct3->speedIV; - break; - case MON_DATA_SPATK_IV: - retVal = substruct3->spAttackIV; - break; - case MON_DATA_SPDEF_IV: - retVal = substruct3->spDefenseIV; - break; - case MON_DATA_IS_EGG: - retVal = substruct3->isEgg; - break; - case MON_DATA_ALT_ABILITY: - retVal = substruct3->altAbility; - break; - case MON_DATA_COOL_RIBBON: - retVal = substruct3->coolRibbon; - break; - case MON_DATA_BEAUTY_RIBBON: - retVal = substruct3->beautyRibbon; - break; - case MON_DATA_CUTE_RIBBON: - retVal = substruct3->cuteRibbon; - break; - case MON_DATA_SMART_RIBBON: - retVal = substruct3->smartRibbon; - break; - case MON_DATA_TOUGH_RIBBON: - retVal = substruct3->toughRibbon; - break; - case MON_DATA_CHAMPION_RIBBON: - retVal = substruct3->championRibbon; - break; - case MON_DATA_WINNING_RIBBON: - retVal = substruct3->winningRibbon; - break; - case MON_DATA_VICTORY_RIBBON: - retVal = substruct3->victoryRibbon; - break; - case MON_DATA_ARTIST_RIBBON: - retVal = substruct3->artistRibbon; - break; - case MON_DATA_EFFORT_RIBBON: - retVal = substruct3->effortRibbon; - break; - case MON_DATA_GIFT_RIBBON_1: - retVal = substruct3->giftRibbon1; - break; - case MON_DATA_GIFT_RIBBON_2: - retVal = substruct3->giftRibbon2; - break; - case MON_DATA_GIFT_RIBBON_3: - retVal = substruct3->giftRibbon3; - break; - case MON_DATA_GIFT_RIBBON_4: - retVal = substruct3->giftRibbon4; - break; - case MON_DATA_GIFT_RIBBON_5: - retVal = substruct3->giftRibbon5; - break; - case MON_DATA_GIFT_RIBBON_6: - retVal = substruct3->giftRibbon6; - break; - case MON_DATA_GIFT_RIBBON_7: - retVal = substruct3->giftRibbon7; - break; - case MON_DATA_FATEFUL_ENCOUNTER: - retVal = substruct3->fatefulEncounter; - break; - case MON_DATA_SPECIES2: - retVal = substruct0->species; - if (substruct0->species && (substruct3->isEgg || mon->box.isBadEgg)) - retVal = 412; - break; - case MON_DATA_IVS: - retVal = substruct3->hpIV | (substruct3->attackIV << 5) | (substruct3->defenseIV << 10) | (substruct3->speedIV << 15) | (substruct3->spAttackIV << 20) | (substruct3->spDefenseIV << 25); - break; - case MON_DATA_KNOWN_MOVES: - if (substruct0->species && !substruct3->isEgg) - { - u16 *moves = (u16 *)data; - s32 i = 0; - - while (moves[i] != 355) - { - u16 move = moves[i]; - if (substruct1->moves[0] == move - || substruct1->moves[1] == move - || substruct1->moves[2] == move - || substruct1->moves[3] == move) - retVal |= gBitTable[i]; - i++; - } - } - break; - case MON_DATA_RIBBON_COUNT: - retVal = 0; - if (substruct0->species && !substruct3->isEgg) - { - retVal += substruct3->coolRibbon; - retVal += substruct3->beautyRibbon; - retVal += substruct3->cuteRibbon; - retVal += substruct3->smartRibbon; - retVal += substruct3->toughRibbon; - retVal += substruct3->championRibbon; - retVal += substruct3->winningRibbon; - retVal += substruct3->victoryRibbon; - retVal += substruct3->artistRibbon; - retVal += substruct3->effortRibbon; - retVal += substruct3->giftRibbon1; - retVal += substruct3->giftRibbon2; - retVal += substruct3->giftRibbon3; - retVal += substruct3->giftRibbon4; - retVal += substruct3->giftRibbon5; - retVal += substruct3->giftRibbon6; - retVal += substruct3->giftRibbon7; - } - break; - case MON_DATA_RIBBONS: - retVal = 0; - if (substruct0->species && !substruct3->isEgg) - { - retVal = substruct3->championRibbon - | (substruct3->coolRibbon << 1) - | (substruct3->beautyRibbon << 4) - | (substruct3->cuteRibbon << 7) - | (substruct3->smartRibbon << 10) - | (substruct3->toughRibbon << 13) - | (substruct3->winningRibbon << 16) - | (substruct3->victoryRibbon << 17) - | (substruct3->artistRibbon << 18) - | (substruct3->effortRibbon << 19) - | (substruct3->giftRibbon1 << 20) - | (substruct3->giftRibbon2 << 21) - | (substruct3->giftRibbon3 << 22) - | (substruct3->giftRibbon4 << 23) - | (substruct3->giftRibbon5 << 24) - | (substruct3->giftRibbon6 << 25) - | (substruct3->giftRibbon7 << 26); - } - break; - default: - break; - } - - if (field > MON_DATA_10) - EncryptMon(mon); - - return retVal; -} diff --git a/src/pokemon_1.c b/src/pokemon_1.c new file mode 100644 index 000000000..1d5066c20 --- /dev/null +++ b/src/pokemon_1.c @@ -0,0 +1,678 @@ +#include "global.h" +#include "text.h" +#include "string_util.h" +#include "pokemon.h" +#include "species.h" +#include "main.h" + +extern u8 sav1_map_get_name(); + +extern struct Pokemon gPlayerParty[6]; // 0x3004360 +extern struct Pokemon gEnemyParty[6]; // 0x30045C0 + +extern u8 unk_2000000[]; +extern u16 word_2024E82; +extern u8 byte_2024E88; + +extern u32 gExperienceTables[8][101]; +extern struct BaseStats gBaseStats[]; +extern struct BattleMove gBattleMoves[]; +extern const u16 *gLevelUpLearnsetPointers[]; + +void ZeroPokemonBoxData(struct Pokemon *mon) +{ + u8 *raw = (u8 *)mon; + u32 i; + for (i = 0; i < sizeof(struct BoxPokemon); i++) + raw[i] = 0; +} + +void zero_pokemon_struct(struct Pokemon *mon) +{ + u32 arg; + ZeroPokemonBoxData(mon); + arg = 0; + SetMonData(mon, MON_DATA_STATUS, (u8 *)&arg); + SetMonData(mon, MON_DATA_LEVEL, (u8 *)&arg); + SetMonData(mon, MON_DATA_HP, (u8 *)&arg); + SetMonData(mon, MON_DATA_MAX_HP, (u8 *)&arg); + SetMonData(mon, MON_DATA_ATK, (u8 *)&arg); + SetMonData(mon, MON_DATA_DEF, (u8 *)&arg); + SetMonData(mon, MON_DATA_SPD, (u8 *)&arg); + SetMonData(mon, MON_DATA_SPATK, (u8 *)&arg); + SetMonData(mon, MON_DATA_SPDEF, (u8 *)&arg); + arg = 255; + SetMonData(mon, MON_DATA_64, (u8 *)&arg); +} + +void zero_player_party_data(void) +{ + s32 i; + for (i = 0; i < 6; i++) + zero_pokemon_struct(&gPlayerParty[i]); +} + +void zero_enemy_party_data(void) +{ + s32 i; + for (i = 0; i < 6; i++) + zero_pokemon_struct(&gEnemyParty[i]); +} + +void create_pokemon_set_level(struct Pokemon *mon, u16 species, u8 level, u8 fixedIV, u8 hasFixedPersonality, u32 fixedPersonality, u8 otIdType, u32 fixedOtId) +{ + u32 arg; + zero_pokemon_struct(mon); + create_pokemon(mon, species, level, fixedIV, hasFixedPersonality, fixedPersonality, otIdType, fixedOtId); + SetMonData(mon, MON_DATA_LEVEL, &level); + arg = 255; + SetMonData(mon, MON_DATA_64, (u8 *)&arg); + pokemon_calc_effective_stats(mon); +} + +void create_pokemon(struct Pokemon *mon, u16 species, u8 level, u8 fixedIV, u8 hasFixedPersonality, u32 fixedPersonality, u8 otIdType, u32 fixedOtId) +{ + u8 speciesName[10]; + u32 personality; + u32 value; + u16 checksum; + + ZeroPokemonBoxData(mon); + + if (hasFixedPersonality) + { + personality = fixedPersonality; + } + else + { + u32 r = Random(); + personality = (u16)r | (Random() << 16); + } + + SetMonBoxData(mon, MON_DATA_PERSONALITY, (u8 *)&personality); + + if (otIdType == 2) + { + u32 shinyValue; + do + { + u32 r = Random(); + value = (u16)r | (Random() << 16); + asm(""); // needed to match for some reason + shinyValue = ((value & 0xFFFF0000) >> 16) ^ (value & 0x0000FFFF) ^ ((personality & 0xFFFF0000) >> 16) ^ (personality & 0x0000FFFF); + } while (shinyValue < 8); + } + else if (otIdType == 1) + { + value = fixedOtId; + } + else + { + value = gSaveBlock2.playerTrainerId[0] + | (gSaveBlock2.playerTrainerId[1] << 8) + | (gSaveBlock2.playerTrainerId[2] << 16) + | (gSaveBlock2.playerTrainerId[3] << 24); + } + + SetMonBoxData(mon, MON_DATA_OT_ID, (u8 *)&value); + + checksum = pokemon_calc_checksum(mon); + SetMonBoxData(mon, MON_DATA_CHECKSUM, (u8 *)&checksum); + EncryptMon(mon); + GetSpeciesName(speciesName, species); + SetMonBoxData(mon, MON_DATA_NICKNAME, speciesName); + SetMonBoxData(mon, MON_DATA_LANGUAGE, &gGameLanguage); + SetMonBoxData(mon, MON_DATA_OT_NAME, gSaveBlock2.playerName); + SetMonBoxData(mon, MON_DATA_SPECIES, (u8 *)&species); + SetMonBoxData(mon, MON_DATA_EXP, (u8 *)&gExperienceTables[gBaseStats[species].growthRate][level]); + SetMonBoxData(mon, MON_DATA_FRIENDSHIP, &gBaseStats[species].friendship); + value = sav1_map_get_name(); + SetMonBoxData(mon, MON_DATA_MET_LOCATION, (u8 *)&value); + SetMonBoxData(mon, MON_DATA_MET_LEVEL, &level); + SetMonBoxData(mon, MON_DATA_MET_GAME, &gGameVersion); + value = 4; + SetMonBoxData(mon, MON_DATA_POKEBALL, (u8 *)&value); + SetMonBoxData(mon, MON_DATA_OT_GENDER, &gSaveBlock2.playerGender); + + if (fixedIV < 32) + { + SetMonBoxData(mon, MON_DATA_HP_IV, &fixedIV); + SetMonBoxData(mon, MON_DATA_ATK_IV, &fixedIV); + SetMonBoxData(mon, MON_DATA_DEF_IV, &fixedIV); + SetMonBoxData(mon, MON_DATA_SPD_IV, &fixedIV); + SetMonBoxData(mon, MON_DATA_SPATK_IV, &fixedIV); + SetMonBoxData(mon, MON_DATA_SPDEF_IV, &fixedIV); + } + else + { + u32 iv; + value = (u16)Random(); + + iv = value & 0x1F; + SetMonBoxData(mon, MON_DATA_HP_IV, (u8 *)&iv); + iv = (value & 0x3E0) >> 5; + SetMonBoxData(mon, MON_DATA_ATK_IV, (u8 *)&iv); + iv = (value &0x7C00) >> 10; + SetMonBoxData(mon, MON_DATA_DEF_IV, (u8 *)&iv); + + value = (u16)Random(); + + iv = value & 0x1F; + SetMonBoxData(mon, MON_DATA_SPD_IV, (u8 *)&iv); + iv = (value & 0x3E0) >> 5; + SetMonBoxData(mon, MON_DATA_SPATK_IV, (u8 *)&iv); + iv = (value &0x7C00) >> 10; + SetMonBoxData(mon, MON_DATA_SPDEF_IV, (u8 *)&iv); + } + + if (gBaseStats[species].ability2) + { + value = personality & 1; + SetMonBoxData(mon, MON_DATA_ALT_ABILITY, (u8 *)&value); + } + + sub_803B720(mon); +} + +void pokemon_make_with_nature(struct Pokemon *mon, u16 species, u8 level, u8 fixedIV, u8 nature) +{ + u32 personality; + + do + { + u32 r = Random(); + personality = (u16)r | (Random() << 16); + } + while (nature != GetNatureFromPersonality(personality)); + + create_pokemon_set_level(mon, species, level, fixedIV, 1, personality, 0, 0); +} + +void unref_sub_803AB44(struct Pokemon *mon, u16 species, u8 level, u8 fixedIV, u8 gender, u8 nature, u8 unownLetter) +{ + u32 personality; + + if ((u8)(unownLetter - 1) < 28) + { + u16 actualLetter; + + do + { + u32 r = Random(); + personality = (u16)r | (Random() << 16); + actualLetter = ((((personality & 0x3000000) >> 18) | ((personality & 0x30000) >> 12) | ((personality & 0x300) >> 6) | personality & 0x3) % 28); + } + while (nature != GetNatureFromPersonality(personality) + || gender != pokemon_species_get_gender_info(species, personality) + || actualLetter != unownLetter - 1); + } + else + { + do + { + u32 r = Random(); + personality = (u16)r | (Random() << 16); + } + while (nature != GetNatureFromPersonality(personality) + || gender != pokemon_species_get_gender_info(species, personality)); + } + + create_pokemon_set_level(mon, species, level, fixedIV, 1, personality, 0, 0); +} + +void sub_803AC44(struct Pokemon *mon, u16 species, u8 level) +{ + u32 personality; + u32 otId; + + do + { + u32 r1, r2; + r1 = Random(); + otId = (u16)r1 | (Random() << 16); + r2 = Random(); + personality = (u16)r2 | (Random() << 16); + } + while (pokemon_species_get_gender_info(species, personality) != MALE); + create_pokemon_set_level(mon, species, level, 32, 1, personality, 1, otId); +} + +void sub_803ACAC(struct Pokemon *mon, u16 species, u8 level, u32 ivs, u32 personality) +{ + create_pokemon_set_level(mon, species, level, 0, 1, personality, 0, 0); + SetMonData(mon, MON_DATA_IVS, (u8 *)&ivs); + pokemon_calc_effective_stats(mon); +} + +void unref_sub_803ACEC(struct Pokemon *mon, u16 species, u8 level, u8 *ivs, u32 otId) +{ + create_pokemon_set_level(mon, species, level, 0, 0, 0, 1, otId); + SetMonData(mon, MON_DATA_HP_IV, &ivs[0]); + SetMonData(mon, MON_DATA_ATK_IV, &ivs[1]); + SetMonData(mon, MON_DATA_DEF_IV, &ivs[2]); + SetMonData(mon, MON_DATA_SPD_IV, &ivs[3]); + SetMonData(mon, MON_DATA_SPATK_IV, &ivs[4]); + SetMonData(mon, MON_DATA_SPDEF_IV, &ivs[5]); + pokemon_calc_effective_stats(mon); +} + +void pokemon_make_ev_something(struct Pokemon *mon, u16 species, u8 level, u8 fixedIV, u8 evSpread) +{ + register s32 i asm("r5"); + register u32 temp asm("r4"); + s32 statCount = 0; + u16 evAmount; + register u32 mask1 asm("r1"); + u8 mask2; + + create_pokemon_set_level(mon, species, level, fixedIV, 0, 0, 0, 0); + + temp = evSpread; + mask1 = 1; + i = 5; + do + { + if (temp & mask1) + statCount++; + temp >>= 1; + i--; + } while (i >= 0); + + + evAmount = 510 / statCount; + mask2 = 1; + i = 0; + do + { + if (evSpread & mask2) + SetMonData(mon, MON_DATA_HP_EV + i, (u8 *)&evAmount); + mask2 <<= 1; + i++; + } while (i < 6); + + pokemon_calc_effective_stats(mon); +} + +void sub_803ADE8(struct Pokemon *mon, struct UnknownPokemonStruct *src) +{ + s32 i; + u8 nickname[11]; + u8 language; + u8 value; + + create_pokemon_set_level(mon, src->species, src->level, 0, 1, src->personality, 1, src->otId); + + for (i = 0; i < 4; i++) + sub_803B6A4(mon, src->moves[i], i); + + SetMonData(mon, MON_DATA_PP_BONUSES, (u8 *)&(src->ppBonuses)); + SetMonData(mon, MON_DATA_HELD_ITEM, (u8 *)&(src->heldItem)); + + StringCopy(nickname, src->nickname); + + if (nickname[0] == 0xFC && nickname[1] == 0x15) + language = 1; + else + language = 2; + + SetMonData(mon, MON_DATA_LANGUAGE, &language); + SkipExtCtrlCodes(nickname); + SetMonData(mon, MON_DATA_NICKNAME, nickname); + SetMonData(mon, MON_DATA_FRIENDSHIP, (u8 *)&(src->friendship)); + SetMonData(mon, MON_DATA_HP_EV, (u8 *)&(src->hpEV)); + SetMonData(mon, MON_DATA_ATK_EV, (u8 *)&(src->attackEV)); + SetMonData(mon, MON_DATA_DEF_EV, (u8 *)&(src->defenseEV)); + SetMonData(mon, MON_DATA_SPD_EV, (u8 *)&(src->speedEV)); + SetMonData(mon, MON_DATA_SPATK_EV, (u8 *)&(src->spAttackEV)); + SetMonData(mon, MON_DATA_SPDEF_EV, (u8 *)&(src->spDefenseEV)); + value = src->altAbility; + SetMonData(mon, MON_DATA_ALT_ABILITY, &value); + value = src->hpIV; + SetMonData(mon, MON_DATA_HP_IV, &value); + value = src->attackIV; + SetMonData(mon, MON_DATA_ATK_IV, &value); + value = src->defenseIV; + SetMonData(mon, MON_DATA_DEF_IV, &value); + value = src->speedIV; + SetMonData(mon, MON_DATA_SPD_IV, &value); + value = src->spAttackIV; + SetMonData(mon, MON_DATA_SPATK_IV, &value); + value = src->spDefenseIV; + SetMonData(mon, MON_DATA_SPDEF_IV, &value); + pokemon_calc_effective_stats(mon); +} + +void sub_803AF78(struct Pokemon *mon, struct UnknownPokemonStruct *dest) +{ + s32 i; + u16 heldItem; + + dest->species = GetMonData(mon, MON_DATA_SPECIES, NULL); + heldItem = GetMonData(mon, MON_DATA_HELD_ITEM, NULL); + + if (heldItem == 175) + heldItem = 0; + + dest->heldItem = heldItem; + + for (i = 0; i < 4; i++) + dest->moves[i] = GetMonData(mon, MON_DATA_MOVE1 + i, NULL); + + dest->level = GetMonData(mon, MON_DATA_LEVEL, NULL); + dest->ppBonuses = GetMonData(mon, MON_DATA_PP_BONUSES, NULL); + dest->otId = GetMonData(mon, MON_DATA_OT_ID, NULL); + dest->hpEV = GetMonData(mon, MON_DATA_HP_EV, NULL); + dest->attackEV = GetMonData(mon, MON_DATA_ATK_EV, NULL); + dest->defenseEV = GetMonData(mon, MON_DATA_DEF_EV, NULL); + dest->speedEV = GetMonData(mon, MON_DATA_SPD_EV, NULL); + dest->spAttackEV = GetMonData(mon, MON_DATA_SPATK_EV, NULL); + dest->spDefenseEV = GetMonData(mon, MON_DATA_SPDEF_EV, NULL); + dest->friendship = GetMonData(mon, MON_DATA_FRIENDSHIP, NULL); + dest->hpIV = GetMonData(mon, MON_DATA_HP_IV, NULL); + dest->attackIV = GetMonData(mon, MON_DATA_ATK_IV, NULL); + dest->defenseIV = GetMonData(mon, MON_DATA_DEF_IV, NULL); + dest->speedIV = GetMonData(mon, MON_DATA_SPD_IV, NULL); + dest->spAttackIV = GetMonData(mon, MON_DATA_SPATK_IV, NULL); + dest->spDefenseIV = GetMonData(mon, MON_DATA_SPDEF_IV, NULL); + dest->altAbility = GetMonData(mon, MON_DATA_ALT_ABILITY, NULL); + dest->personality = GetMonData(mon, MON_DATA_PERSONALITY, NULL); + GetMonData(mon, MON_DATA_NICKNAME, dest->nickname); +} + +u16 pokemon_calc_checksum(struct Pokemon *mon) +{ + u16 checksum = 0; + union PokemonSubstruct *substruct0 = GetSubstruct(mon, mon->box.personality, 0); + union PokemonSubstruct *substruct1 = GetSubstruct(mon, mon->box.personality, 1); + union PokemonSubstruct *substruct2 = GetSubstruct(mon, mon->box.personality, 2); + union PokemonSubstruct *substruct3 = GetSubstruct(mon, mon->box.personality, 3); + s32 i; + + for (i = 0; i < 6; i++) + checksum += substruct0->raw[i]; + + for (i = 0; i < 6; i++) + checksum += substruct1->raw[i]; + + for (i = 0; i < 6; i++) + checksum += substruct2->raw[i]; + + for (i = 0; i < 6; i++) + checksum += substruct3->raw[i]; + + return checksum; +} + +#define CALC_STAT(base, iv, ev, statIndex, field) \ +{ \ + u8 baseStat = gBaseStats[species].base; \ + s32 n = (((2 * baseStat + iv + ev / 4) * level) / 100) + 5; \ + u8 nature = GetNature(mon); \ + n = nature_stat_mod(nature, n, statIndex); \ + SetMonData(mon, field, (u8 *)&n); \ +} + +void pokemon_calc_effective_stats(struct Pokemon *mon) +{ + s32 oldMaxHP = GetMonData(mon, MON_DATA_MAX_HP, NULL); + s32 currentHP = GetMonData(mon, MON_DATA_HP, NULL); + s32 hpIV = GetMonData(mon, MON_DATA_HP_IV, NULL); + s32 hpEV = GetMonData(mon, MON_DATA_HP_EV, NULL); + s32 attackIV = GetMonData(mon, MON_DATA_ATK_IV, NULL); + s32 attackEV = GetMonData(mon, MON_DATA_ATK_EV, NULL); + s32 defenseIV = GetMonData(mon, MON_DATA_DEF_IV, NULL); + s32 defenseEV = GetMonData(mon, MON_DATA_DEF_EV, NULL); + s32 speedIV = GetMonData(mon, MON_DATA_SPD_IV, NULL); + s32 speedEV = GetMonData(mon, MON_DATA_SPD_EV, NULL); + s32 spAttackIV = GetMonData(mon, MON_DATA_SPATK_IV, NULL); + s32 spAttackEV = GetMonData(mon, MON_DATA_SPATK_EV, NULL); + s32 spDefenseIV = GetMonData(mon, MON_DATA_SPDEF_IV, NULL); + s32 spDefenseEV = GetMonData(mon, MON_DATA_SPDEF_EV, NULL); + u16 species = GetMonData(mon, MON_DATA_SPECIES, NULL); + s32 level = level_by_exp(mon); + s32 newMaxHP; + u8 nature; + + SetMonData(mon, MON_DATA_LEVEL, (u8 *)&level); + + if (species == SPECIES_SHEDINJA) + { + newMaxHP = 1; + } + else + { + s32 n = 2 * gBaseStats[species].baseHP + hpIV; + newMaxHP = (((n + hpEV / 4) * level) / 100) + level + 10; + } + + unk_2000000[0x160FA] = newMaxHP - oldMaxHP; + if (unk_2000000[0x160FA] == 0) + unk_2000000[0x160FA] = 1; + + SetMonData(mon, MON_DATA_MAX_HP, (u8 *)&newMaxHP); + + CALC_STAT(baseAttack, attackIV, attackEV, 1, MON_DATA_ATK) + CALC_STAT(baseDefense, defenseIV, defenseEV, 2, MON_DATA_DEF) + CALC_STAT(baseSpeed, speedIV, speedEV, 3, MON_DATA_SPD) + CALC_STAT(baseSpAttack, spAttackIV, spAttackEV, 4, MON_DATA_SPATK) + CALC_STAT(baseSpDefense, spDefenseIV, spDefenseEV, 5, MON_DATA_SPDEF) + + if (species == SPECIES_SHEDINJA) + { + if (currentHP != 0 || oldMaxHP == 0) + { + currentHP = 1; + goto set_hp; + } + } + else + { + if (currentHP != 0 || oldMaxHP == 0) + { + if (currentHP != 0) + currentHP += newMaxHP - oldMaxHP; + else if (oldMaxHP == 0) + currentHP = newMaxHP; + set_hp: + SetMonData(mon, MON_DATA_HP, (u8 *)¤tHP); + } + } +} + +void sub_803B4B4(struct Pokemon *src, struct Pokemon *dest) +{ + u32 value = 0; + memcpy(&(dest->box), &(src->box), sizeof(struct BoxPokemon)); + SetMonData(dest, MON_DATA_STATUS, (u8 *)&value); + SetMonData(dest, MON_DATA_HP, (u8 *)&value); + SetMonData(dest, MON_DATA_MAX_HP, (u8 *)&value); + value = 255; + SetMonData(dest, MON_DATA_64, (u8 *)&value); + pokemon_calc_effective_stats(dest); +} + +u8 level_by_exp(struct Pokemon *mon) +{ + u16 species = GetMonData(mon, MON_DATA_SPECIES, NULL); + u32 exp = GetMonData(mon, MON_DATA_EXP, NULL); + s32 level = 1; + + while (level <= 100 && gExperienceTables[gBaseStats[species].growthRate][level] <= exp) + level++; + + return level - 1; +} + +u8 sub_803B570(struct BoxPokemon *mon) +{ + u16 species = GetMonBoxData(mon, MON_DATA_SPECIES, NULL); + u32 exp = GetMonBoxData(mon, MON_DATA_EXP, NULL); + s32 level = 1; + + while (level <= 100 && gExperienceTables[gBaseStats[species].growthRate][level] <= exp) + level++; + + return level - 1; +} + +u16 pokemon_moveset_pad_(struct Pokemon *mon, u16 value) +{ + return pokemon_moveset_pad(mon, value); +} + +u16 pokemon_moveset_pad(struct Pokemon *mon, u16 value) +{ + s32 i; + for (i = 0; i < 4; i++) + { + u16 move = GetMonBoxData(&(mon->box), MON_DATA_MOVE1 + i, NULL); + if (!move) + { + SetMonBoxData(mon, MON_DATA_MOVE1 + i, (u8 *)&value); + SetMonBoxData(mon, MON_DATA_PP1 + i, &(gBattleMoves[value].pp)); + return value; + } + if (move == value) + return -2; + } + return -1; +} + +u16 sub_803B660(struct BattlePokemon *mon, u16 value) +{ + s32 i; + + for (i = 0; i < 4; i++) + { + if (!mon->moves[i]) + { + mon->moves[i] = value; + mon->pp[i] = gBattleMoves[value].pp; + return value; + } + } + + return -1; +} + +void sub_803B6A4(struct Pokemon *mon, u16 move, u8 slot) +{ + SetMonData(mon, MON_DATA_MOVE1 + slot, (u8 *)&move); + SetMonData(mon, MON_DATA_PP1 + slot, &(gBattleMoves[move].pp)); +} + +void sub_803B6E4(struct BattlePokemon *mon, u16 move, u8 slot) +{ + mon->moves[slot] = move; + mon->pp[slot] = gBattleMoves[move].pp; +} + +void unref_sub_803B714(struct Pokemon *mon) +{ + sub_803B720(mon); +} + +void sub_803B720(struct Pokemon *mon) +{ + u16 species = GetMonBoxData(&(mon->box), MON_DATA_SPECIES, NULL); + s32 level = sub_803B570(&(mon->box)); + s32 i; + + for (i = 0; gLevelUpLearnsetPointers[species][i] != (u16)-1; i++) + { + u16 moveLevel; + u16 move; + + moveLevel = (gLevelUpLearnsetPointers[species][i] & 0xFE00); + + if (moveLevel > (level << 9)) + break; + + move = (gLevelUpLearnsetPointers[species][i] & 0x1FF); + + if (pokemon_moveset_pad(mon, move) == (u16)-1) + sub_803B980(mon, move); + } +} + +u16 sub_803B7C8(struct Pokemon *mon, u8 a2) +{ + u32 retVal = 0; + u16 species = GetMonData(mon, MON_DATA_SPECIES, NULL); + u8 level = GetMonData(mon, MON_DATA_LEVEL, NULL); + + if (a2) + { + byte_2024E88 = retVal; + + while ((gLevelUpLearnsetPointers[species][byte_2024E88] & 0xFE00) != (level << 9)) + { + byte_2024E88++; + if (gLevelUpLearnsetPointers[species][byte_2024E88] == (u16)-1) + return 0; + } + } + + if ((gLevelUpLearnsetPointers[species][byte_2024E88] & 0xFE00) == (level << 9)) + { + word_2024E82 = (gLevelUpLearnsetPointers[species][byte_2024E88] & 0x1FF); + byte_2024E88++; + retVal = pokemon_moveset_pad_(mon, word_2024E82); + } + + return retVal; +} + +void sub_803B8D4(struct Pokemon *mon, u16 move) +{ + s32 i; + u16 moves[4]; + u8 pp[4]; + u8 ppBonuses; + + for (i = 0; i < 3; i++) + { + moves[i] = GetMonData(mon, MON_DATA_MOVE2 + i, NULL); + pp[i]= GetMonData(mon, MON_DATA_PP2 + i, NULL); + } + + ppBonuses = GetMonData(mon, MON_DATA_PP_BONUSES, NULL); + ppBonuses >>= 2; + moves[3] = move; + pp[3] = gBattleMoves[move].pp; + + for (i = 0; i < 4; i++) + { + SetMonData(mon, MON_DATA_MOVE1 + i, (u8 *)&moves[i]); + SetMonData(mon, MON_DATA_PP1 + i, &pp[i]); + } + + SetMonData(mon, MON_DATA_PP_BONUSES, &ppBonuses); +} + +void sub_803B980(struct Pokemon *mon, u16 move) +{ + s32 i; + u16 moves[4]; + u8 pp[4]; + u8 ppBonuses; + + for (i = 0; i < 3; i++) + { + moves[i] = GetMonBoxData(mon, MON_DATA_MOVE2 + i, NULL); + pp[i]= GetMonBoxData(mon, MON_DATA_PP2 + i, NULL); + } + + ppBonuses = GetMonBoxData(mon, MON_DATA_PP_BONUSES, NULL); + ppBonuses >>= 2; + moves[3] = move; + pp[3] = gBattleMoves[move].pp; + + for (i = 0; i < 4; i++) + { + SetMonBoxData(mon, MON_DATA_MOVE1 + i, (u8 *)&moves[i]); + SetMonBoxData(mon, MON_DATA_PP1 + i, &pp[i]); + } + + SetMonBoxData(mon, MON_DATA_PP_BONUSES, &ppBonuses); +} diff --git a/src/pokemon_2.c b/src/pokemon_2.c new file mode 100644 index 000000000..eb18f8840 --- /dev/null +++ b/src/pokemon_2.c @@ -0,0 +1,474 @@ +#include "global.h" +#include "text.h" +#include "string_util.h" +#include "pokemon.h" +#include "species.h" +#include "main.h" + +extern u8 gBadEggNickname[]; +extern u8 gEggNickname[]; +extern u32 gBitTable[]; + +void EncryptMon(struct Pokemon *mon) +{ + u32 i; + for (i = 0; i < 12; i++) + { + mon->box.secure.raw[i] ^= mon->box.personality; + mon->box.secure.raw[i] ^= mon->box.otId; + } +} + +void DecryptMon(struct Pokemon *mon) +{ + u32 i; + for (i = 0; i < 12; i++) + { + mon->box.secure.raw[i] ^= mon->box.otId; + mon->box.secure.raw[i] ^= mon->box.personality; + } +} + +#define SUBSTRUCT_CASE(n, v1, v2, v3, v4) \ +case n: \ + switch (substructType) \ + { \ + case 0: \ + substruct = &substructs ## n [v1]; \ + break; \ + case 1: \ + substruct = &substructs ## n [v2]; \ + break; \ + case 2: \ + substruct = &substructs ## n [v3]; \ + break; \ + case 3: \ + substruct = &substructs ## n [v4]; \ + break; \ + } \ + break; + +union PokemonSubstruct *GetSubstruct(struct Pokemon *mon, u32 personality, u8 substructType) +{ + union PokemonSubstruct *substruct = NULL; + + union PokemonSubstruct *substructs0 = mon->box.secure.substructs; + union PokemonSubstruct *substructs1 = mon->box.secure.substructs; + union PokemonSubstruct *substructs2 = mon->box.secure.substructs; + union PokemonSubstruct *substructs3 = mon->box.secure.substructs; + union PokemonSubstruct *substructs4 = mon->box.secure.substructs; + union PokemonSubstruct *substructs5 = mon->box.secure.substructs; + union PokemonSubstruct *substructs6 = mon->box.secure.substructs; + union PokemonSubstruct *substructs7 = mon->box.secure.substructs; + union PokemonSubstruct *substructs8 = mon->box.secure.substructs; + union PokemonSubstruct *substructs9 = mon->box.secure.substructs; + union PokemonSubstruct *substructs10 = mon->box.secure.substructs; + union PokemonSubstruct *substructs11 = mon->box.secure.substructs; + union PokemonSubstruct *substructs12 = mon->box.secure.substructs; + union PokemonSubstruct *substructs13 = mon->box.secure.substructs; + union PokemonSubstruct *substructs14 = mon->box.secure.substructs; + union PokemonSubstruct *substructs15 = mon->box.secure.substructs; + union PokemonSubstruct *substructs16 = mon->box.secure.substructs; + union PokemonSubstruct *substructs17 = mon->box.secure.substructs; + union PokemonSubstruct *substructs18 = mon->box.secure.substructs; + union PokemonSubstruct *substructs19 = mon->box.secure.substructs; + union PokemonSubstruct *substructs20 = mon->box.secure.substructs; + union PokemonSubstruct *substructs21 = mon->box.secure.substructs; + union PokemonSubstruct *substructs22 = mon->box.secure.substructs; + union PokemonSubstruct *substructs23 = mon->box.secure.substructs; + + switch (personality % 24) + { + SUBSTRUCT_CASE( 0,0,1,2,3) + SUBSTRUCT_CASE( 1,0,1,3,2) + SUBSTRUCT_CASE( 2,0,2,1,3) + SUBSTRUCT_CASE( 3,0,3,1,2) + SUBSTRUCT_CASE( 4,0,2,3,1) + SUBSTRUCT_CASE( 5,0,3,2,1) + SUBSTRUCT_CASE( 6,1,0,2,3) + SUBSTRUCT_CASE( 7,1,0,3,2) + SUBSTRUCT_CASE( 8,2,0,1,3) + SUBSTRUCT_CASE( 9,3,0,1,2) + SUBSTRUCT_CASE(10,2,0,3,1) + SUBSTRUCT_CASE(11,3,0,2,1) + SUBSTRUCT_CASE(12,1,2,0,3) + SUBSTRUCT_CASE(13,1,3,0,2) + SUBSTRUCT_CASE(14,2,1,0,3) + SUBSTRUCT_CASE(15,3,1,0,2) + SUBSTRUCT_CASE(16,2,3,0,1) + SUBSTRUCT_CASE(17,3,2,0,1) + SUBSTRUCT_CASE(18,1,2,3,0) + SUBSTRUCT_CASE(19,1,3,2,0) + SUBSTRUCT_CASE(20,2,1,3,0) + SUBSTRUCT_CASE(21,3,1,2,0) + SUBSTRUCT_CASE(22,2,3,1,0) + SUBSTRUCT_CASE(23,3,2,1,0) + } + + return substruct; +} + +u32 GetMonData(struct Pokemon *mon, s32 field, u8 *data) +{ + switch (field) + { + case MON_DATA_STATUS: + return mon->status; + case MON_DATA_LEVEL: + return mon->level; + case MON_DATA_HP: + return mon->hp; + case MON_DATA_MAX_HP: + return mon->maxHP; + case MON_DATA_ATK: + return mon->attack; + case MON_DATA_DEF: + return mon->defense; + case MON_DATA_SPD: + return mon->speed; + case MON_DATA_SPATK: + return mon->spAttack; + case MON_DATA_SPDEF: + return mon->spDefense; + case MON_DATA_64: + return mon->pokerus; + default: + return GetMonBoxData(mon, field, data); + } +} + +u32 GetMonBoxData(struct Pokemon *mon, s32 field, u8 *data) +{ + u32 retVal = 0; + struct PokemonSubstruct0 *substruct0 = NULL; + struct PokemonSubstruct1 *substruct1 = NULL; + struct PokemonSubstruct2 *substruct2 = NULL; + struct PokemonSubstruct3 *substruct3 = NULL; + + if (field > MON_DATA_10) + { + substruct0 = &(GetSubstruct(mon, mon->box.personality, 0)->type0); + substruct1 = &(GetSubstruct(mon, mon->box.personality, 1)->type1); + substruct2 = &(GetSubstruct(mon, mon->box.personality, 2)->type2); + substruct3 = &(GetSubstruct(mon, mon->box.personality, 3)->type3); + + DecryptMon(mon); + + if (pokemon_calc_checksum(mon) != mon->box.checksum) + { + mon->box.isBadEgg = 1; + mon->box.sanity3 = 1; + substruct3->isEgg = 1; + } + } + + switch (field) + { + case MON_DATA_PERSONALITY: + retVal = mon->box.personality; + break; + case MON_DATA_OT_ID: + retVal = mon->box.otId; + break; + case MON_DATA_NICKNAME: + { + if (mon->box.isBadEgg) + { + StringCopy(data, gBadEggNickname); + retVal = StringLength(data); + } + else if (mon->box.sanity3) + { + StringCopy(data, gEggNickname); + retVal = StringLength(data); + } + else + { + retVal = 0; + + while (retVal < 10 && mon->box.nickname[retVal] != EOS) + { + data[retVal] = mon->box.nickname[retVal]; + retVal++; + } + + data[retVal] = EOS; + ConvertInternationalString(data, mon->box.language); + retVal = StringLength(data); + } + break; + } + case MON_DATA_LANGUAGE: + retVal = mon->box.language; + break; + case MON_DATA_SANITY_BIT1: + retVal = mon->box.isBadEgg; + break; + case MON_DATA_SANITY_BIT2: + retVal = mon->box.sanity2; + break; + case MON_DATA_SANITY_BIT3: + retVal = mon->box.sanity3; + break; + case MON_DATA_OT_NAME: + { + retVal = 0; + + while (retVal < 7 && mon->box.otName[retVal] != EOS) + { + data[retVal] = mon->box.otName[retVal]; + retVal++; + } + + data[retVal] = EOS; + break; + } + case MON_DATA_MARKINGS: + retVal = mon->box.markings; + break; + case MON_DATA_CHECKSUM: + retVal = mon->box.checksum; + break; + case MON_DATA_10: + retVal = mon->box.unknown; + break; + case MON_DATA_SPECIES: + retVal = mon->box.isBadEgg ? 412 : substruct0->species; + break; + case MON_DATA_HELD_ITEM: + retVal = substruct0->heldItem; + break; + case MON_DATA_EXP: + retVal = substruct0->experience; + break; + case MON_DATA_PP_BONUSES: + retVal = substruct0->ppBonuses; + break; + case MON_DATA_FRIENDSHIP: + retVal = substruct0->friendship; + break; + case MON_DATA_MOVE1: + case MON_DATA_MOVE2: + case MON_DATA_MOVE3: + case MON_DATA_MOVE4: + retVal = substruct1->moves[field - MON_DATA_MOVE1]; + break; + case MON_DATA_PP1: + case MON_DATA_PP2: + case MON_DATA_PP3: + case MON_DATA_PP4: + retVal = substruct1->pp[field - MON_DATA_PP1]; + break; + case MON_DATA_HP_EV: + retVal = substruct2->hpEV; + break; + case MON_DATA_ATK_EV: + retVal = substruct2->attackEV; + break; + case MON_DATA_DEF_EV: + retVal = substruct2->defenseEV; + break; + case MON_DATA_SPD_EV: + retVal = substruct2->speedEV; + break; + case MON_DATA_SPATK_EV: + retVal = substruct2->spAttackEV; + break; + case MON_DATA_SPDEF_EV: + retVal = substruct2->spDefenseEV; + break; + case MON_DATA_COOL: + retVal = substruct2->cool; + break; + case MON_DATA_BEAUTY: + retVal = substruct2->beauty; + break; + case MON_DATA_CUTE: + retVal = substruct2->cute; + break; + case MON_DATA_SMART: + retVal = substruct2->smart; + break; + case MON_DATA_TOUGH: + retVal = substruct2->tough; + break; + case MON_DATA_SHEEN: + retVal = substruct2->sheen; + break; + case MON_DATA_POKERUS: + retVal = substruct3->pokerus; + break; + case MON_DATA_MET_LOCATION: + retVal = substruct3->metLocation; + break; + case MON_DATA_MET_LEVEL: + retVal = substruct3->metLevel; + break; + case MON_DATA_MET_GAME: + retVal = substruct3->metGame; + break; + case MON_DATA_POKEBALL: + retVal = substruct3->pokeball; + break; + case MON_DATA_OT_GENDER: + retVal = substruct3->otGender; + break; + case MON_DATA_HP_IV: + retVal = substruct3->hpIV; + break; + case MON_DATA_ATK_IV: + retVal = substruct3->attackIV; + break; + case MON_DATA_DEF_IV: + retVal = substruct3->defenseIV; + break; + case MON_DATA_SPD_IV: + retVal = substruct3->speedIV; + break; + case MON_DATA_SPATK_IV: + retVal = substruct3->spAttackIV; + break; + case MON_DATA_SPDEF_IV: + retVal = substruct3->spDefenseIV; + break; + case MON_DATA_IS_EGG: + retVal = substruct3->isEgg; + break; + case MON_DATA_ALT_ABILITY: + retVal = substruct3->altAbility; + break; + case MON_DATA_COOL_RIBBON: + retVal = substruct3->coolRibbon; + break; + case MON_DATA_BEAUTY_RIBBON: + retVal = substruct3->beautyRibbon; + break; + case MON_DATA_CUTE_RIBBON: + retVal = substruct3->cuteRibbon; + break; + case MON_DATA_SMART_RIBBON: + retVal = substruct3->smartRibbon; + break; + case MON_DATA_TOUGH_RIBBON: + retVal = substruct3->toughRibbon; + break; + case MON_DATA_CHAMPION_RIBBON: + retVal = substruct3->championRibbon; + break; + case MON_DATA_WINNING_RIBBON: + retVal = substruct3->winningRibbon; + break; + case MON_DATA_VICTORY_RIBBON: + retVal = substruct3->victoryRibbon; + break; + case MON_DATA_ARTIST_RIBBON: + retVal = substruct3->artistRibbon; + break; + case MON_DATA_EFFORT_RIBBON: + retVal = substruct3->effortRibbon; + break; + case MON_DATA_GIFT_RIBBON_1: + retVal = substruct3->giftRibbon1; + break; + case MON_DATA_GIFT_RIBBON_2: + retVal = substruct3->giftRibbon2; + break; + case MON_DATA_GIFT_RIBBON_3: + retVal = substruct3->giftRibbon3; + break; + case MON_DATA_GIFT_RIBBON_4: + retVal = substruct3->giftRibbon4; + break; + case MON_DATA_GIFT_RIBBON_5: + retVal = substruct3->giftRibbon5; + break; + case MON_DATA_GIFT_RIBBON_6: + retVal = substruct3->giftRibbon6; + break; + case MON_DATA_GIFT_RIBBON_7: + retVal = substruct3->giftRibbon7; + break; + case MON_DATA_FATEFUL_ENCOUNTER: + retVal = substruct3->fatefulEncounter; + break; + case MON_DATA_SPECIES2: + retVal = substruct0->species; + if (substruct0->species && (substruct3->isEgg || mon->box.isBadEgg)) + retVal = 412; + break; + case MON_DATA_IVS: + retVal = substruct3->hpIV | (substruct3->attackIV << 5) | (substruct3->defenseIV << 10) | (substruct3->speedIV << 15) | (substruct3->spAttackIV << 20) | (substruct3->spDefenseIV << 25); + break; + case MON_DATA_KNOWN_MOVES: + if (substruct0->species && !substruct3->isEgg) + { + u16 *moves = (u16 *)data; + s32 i = 0; + + while (moves[i] != 355) + { + u16 move = moves[i]; + if (substruct1->moves[0] == move + || substruct1->moves[1] == move + || substruct1->moves[2] == move + || substruct1->moves[3] == move) + retVal |= gBitTable[i]; + i++; + } + } + break; + case MON_DATA_RIBBON_COUNT: + retVal = 0; + if (substruct0->species && !substruct3->isEgg) + { + retVal += substruct3->coolRibbon; + retVal += substruct3->beautyRibbon; + retVal += substruct3->cuteRibbon; + retVal += substruct3->smartRibbon; + retVal += substruct3->toughRibbon; + retVal += substruct3->championRibbon; + retVal += substruct3->winningRibbon; + retVal += substruct3->victoryRibbon; + retVal += substruct3->artistRibbon; + retVal += substruct3->effortRibbon; + retVal += substruct3->giftRibbon1; + retVal += substruct3->giftRibbon2; + retVal += substruct3->giftRibbon3; + retVal += substruct3->giftRibbon4; + retVal += substruct3->giftRibbon5; + retVal += substruct3->giftRibbon6; + retVal += substruct3->giftRibbon7; + } + break; + case MON_DATA_RIBBONS: + retVal = 0; + if (substruct0->species && !substruct3->isEgg) + { + retVal = substruct3->championRibbon + | (substruct3->coolRibbon << 1) + | (substruct3->beautyRibbon << 4) + | (substruct3->cuteRibbon << 7) + | (substruct3->smartRibbon << 10) + | (substruct3->toughRibbon << 13) + | (substruct3->winningRibbon << 16) + | (substruct3->victoryRibbon << 17) + | (substruct3->artistRibbon << 18) + | (substruct3->effortRibbon << 19) + | (substruct3->giftRibbon1 << 20) + | (substruct3->giftRibbon2 << 21) + | (substruct3->giftRibbon3 << 22) + | (substruct3->giftRibbon4 << 23) + | (substruct3->giftRibbon5 << 24) + | (substruct3->giftRibbon6 << 25) + | (substruct3->giftRibbon7 << 26); + } + break; + default: + break; + } + + if (field > MON_DATA_10) + EncryptMon(mon); + + return retVal; +} -- cgit v1.2.3 From 873594614b5ad2d0202abd64b3ebce90cef4494f Mon Sep 17 00:00:00 2001 From: YamaArashi Date: Fri, 9 Sep 2016 22:46:55 -0700 Subject: clean up types in pokemon code --- src/pokemon_1.c | 146 ++++++++++++++++++++++++++++---------------------------- src/pokemon_2.c | 120 +++++++++++++++++++++++----------------------- 2 files changed, 133 insertions(+), 133 deletions(-) (limited to 'src') diff --git a/src/pokemon_1.c b/src/pokemon_1.c index 1d5066c20..e9d6a998d 100644 --- a/src/pokemon_1.c +++ b/src/pokemon_1.c @@ -19,9 +19,9 @@ extern struct BaseStats gBaseStats[]; extern struct BattleMove gBattleMoves[]; extern const u16 *gLevelUpLearnsetPointers[]; -void ZeroPokemonBoxData(struct Pokemon *mon) +void ZeroPokemonBoxData(struct BoxPokemon *boxMon) { - u8 *raw = (u8 *)mon; + u8 *raw = (u8 *)boxMon; u32 i; for (i = 0; i < sizeof(struct BoxPokemon); i++) raw[i] = 0; @@ -30,7 +30,7 @@ void ZeroPokemonBoxData(struct Pokemon *mon) void zero_pokemon_struct(struct Pokemon *mon) { u32 arg; - ZeroPokemonBoxData(mon); + ZeroPokemonBoxData(&mon->box); arg = 0; SetMonData(mon, MON_DATA_STATUS, (u8 *)&arg); SetMonData(mon, MON_DATA_LEVEL, (u8 *)&arg); @@ -63,21 +63,21 @@ void create_pokemon_set_level(struct Pokemon *mon, u16 species, u8 level, u8 fix { u32 arg; zero_pokemon_struct(mon); - create_pokemon(mon, species, level, fixedIV, hasFixedPersonality, fixedPersonality, otIdType, fixedOtId); + create_pokemon(&mon->box, species, level, fixedIV, hasFixedPersonality, fixedPersonality, otIdType, fixedOtId); SetMonData(mon, MON_DATA_LEVEL, &level); arg = 255; SetMonData(mon, MON_DATA_64, (u8 *)&arg); pokemon_calc_effective_stats(mon); } -void create_pokemon(struct Pokemon *mon, u16 species, u8 level, u8 fixedIV, u8 hasFixedPersonality, u32 fixedPersonality, u8 otIdType, u32 fixedOtId) +void create_pokemon(struct BoxPokemon *boxMon, u16 species, u8 level, u8 fixedIV, u8 hasFixedPersonality, u32 fixedPersonality, u8 otIdType, u32 fixedOtId) { u8 speciesName[10]; u32 personality; u32 value; u16 checksum; - ZeroPokemonBoxData(mon); + ZeroPokemonBoxData(boxMon); if (hasFixedPersonality) { @@ -89,7 +89,7 @@ void create_pokemon(struct Pokemon *mon, u16 species, u8 level, u8 fixedIV, u8 h personality = (u16)r | (Random() << 16); } - SetMonBoxData(mon, MON_DATA_PERSONALITY, (u8 *)&personality); + SetMonBoxData(boxMon, MON_DATA_PERSONALITY, (u8 *)&personality); if (otIdType == 2) { @@ -114,34 +114,34 @@ void create_pokemon(struct Pokemon *mon, u16 species, u8 level, u8 fixedIV, u8 h | (gSaveBlock2.playerTrainerId[3] << 24); } - SetMonBoxData(mon, MON_DATA_OT_ID, (u8 *)&value); + SetMonBoxData(boxMon, MON_DATA_OT_ID, (u8 *)&value); - checksum = pokemon_calc_checksum(mon); - SetMonBoxData(mon, MON_DATA_CHECKSUM, (u8 *)&checksum); - EncryptMon(mon); + checksum = pokemon_calc_checksum(boxMon); + SetMonBoxData(boxMon, MON_DATA_CHECKSUM, (u8 *)&checksum); + EncryptMon(boxMon); GetSpeciesName(speciesName, species); - SetMonBoxData(mon, MON_DATA_NICKNAME, speciesName); - SetMonBoxData(mon, MON_DATA_LANGUAGE, &gGameLanguage); - SetMonBoxData(mon, MON_DATA_OT_NAME, gSaveBlock2.playerName); - SetMonBoxData(mon, MON_DATA_SPECIES, (u8 *)&species); - SetMonBoxData(mon, MON_DATA_EXP, (u8 *)&gExperienceTables[gBaseStats[species].growthRate][level]); - SetMonBoxData(mon, MON_DATA_FRIENDSHIP, &gBaseStats[species].friendship); + SetMonBoxData(boxMon, MON_DATA_NICKNAME, speciesName); + SetMonBoxData(boxMon, MON_DATA_LANGUAGE, &gGameLanguage); + SetMonBoxData(boxMon, MON_DATA_OT_NAME, gSaveBlock2.playerName); + SetMonBoxData(boxMon, MON_DATA_SPECIES, (u8 *)&species); + SetMonBoxData(boxMon, MON_DATA_EXP, (u8 *)&gExperienceTables[gBaseStats[species].growthRate][level]); + SetMonBoxData(boxMon, MON_DATA_FRIENDSHIP, &gBaseStats[species].friendship); value = sav1_map_get_name(); - SetMonBoxData(mon, MON_DATA_MET_LOCATION, (u8 *)&value); - SetMonBoxData(mon, MON_DATA_MET_LEVEL, &level); - SetMonBoxData(mon, MON_DATA_MET_GAME, &gGameVersion); + SetMonBoxData(boxMon, MON_DATA_MET_LOCATION, (u8 *)&value); + SetMonBoxData(boxMon, MON_DATA_MET_LEVEL, &level); + SetMonBoxData(boxMon, MON_DATA_MET_GAME, &gGameVersion); value = 4; - SetMonBoxData(mon, MON_DATA_POKEBALL, (u8 *)&value); - SetMonBoxData(mon, MON_DATA_OT_GENDER, &gSaveBlock2.playerGender); + SetMonBoxData(boxMon, MON_DATA_POKEBALL, (u8 *)&value); + SetMonBoxData(boxMon, MON_DATA_OT_GENDER, &gSaveBlock2.playerGender); if (fixedIV < 32) { - SetMonBoxData(mon, MON_DATA_HP_IV, &fixedIV); - SetMonBoxData(mon, MON_DATA_ATK_IV, &fixedIV); - SetMonBoxData(mon, MON_DATA_DEF_IV, &fixedIV); - SetMonBoxData(mon, MON_DATA_SPD_IV, &fixedIV); - SetMonBoxData(mon, MON_DATA_SPATK_IV, &fixedIV); - SetMonBoxData(mon, MON_DATA_SPDEF_IV, &fixedIV); + SetMonBoxData(boxMon, MON_DATA_HP_IV, &fixedIV); + SetMonBoxData(boxMon, MON_DATA_ATK_IV, &fixedIV); + SetMonBoxData(boxMon, MON_DATA_DEF_IV, &fixedIV); + SetMonBoxData(boxMon, MON_DATA_SPD_IV, &fixedIV); + SetMonBoxData(boxMon, MON_DATA_SPATK_IV, &fixedIV); + SetMonBoxData(boxMon, MON_DATA_SPDEF_IV, &fixedIV); } else { @@ -149,29 +149,29 @@ void create_pokemon(struct Pokemon *mon, u16 species, u8 level, u8 fixedIV, u8 h value = (u16)Random(); iv = value & 0x1F; - SetMonBoxData(mon, MON_DATA_HP_IV, (u8 *)&iv); + SetMonBoxData(boxMon, MON_DATA_HP_IV, (u8 *)&iv); iv = (value & 0x3E0) >> 5; - SetMonBoxData(mon, MON_DATA_ATK_IV, (u8 *)&iv); + SetMonBoxData(boxMon, MON_DATA_ATK_IV, (u8 *)&iv); iv = (value &0x7C00) >> 10; - SetMonBoxData(mon, MON_DATA_DEF_IV, (u8 *)&iv); + SetMonBoxData(boxMon, MON_DATA_DEF_IV, (u8 *)&iv); value = (u16)Random(); iv = value & 0x1F; - SetMonBoxData(mon, MON_DATA_SPD_IV, (u8 *)&iv); + SetMonBoxData(boxMon, MON_DATA_SPD_IV, (u8 *)&iv); iv = (value & 0x3E0) >> 5; - SetMonBoxData(mon, MON_DATA_SPATK_IV, (u8 *)&iv); + SetMonBoxData(boxMon, MON_DATA_SPATK_IV, (u8 *)&iv); iv = (value &0x7C00) >> 10; - SetMonBoxData(mon, MON_DATA_SPDEF_IV, (u8 *)&iv); + SetMonBoxData(boxMon, MON_DATA_SPDEF_IV, (u8 *)&iv); } if (gBaseStats[species].ability2) { value = personality & 1; - SetMonBoxData(mon, MON_DATA_ALT_ABILITY, (u8 *)&value); + SetMonBoxData(boxMon, MON_DATA_ALT_ABILITY, (u8 *)&value); } - sub_803B720(mon); + sub_803B720(boxMon); } void pokemon_make_with_nature(struct Pokemon *mon, u16 species, u8 level, u8 fixedIV, u8 nature) @@ -305,8 +305,8 @@ void sub_803ADE8(struct Pokemon *mon, struct UnknownPokemonStruct *src) for (i = 0; i < 4; i++) sub_803B6A4(mon, src->moves[i], i); - SetMonData(mon, MON_DATA_PP_BONUSES, (u8 *)&(src->ppBonuses)); - SetMonData(mon, MON_DATA_HELD_ITEM, (u8 *)&(src->heldItem)); + SetMonData(mon, MON_DATA_PP_BONUSES, (u8 *)&src->ppBonuses); + SetMonData(mon, MON_DATA_HELD_ITEM, (u8 *)&src->heldItem); StringCopy(nickname, src->nickname); @@ -318,13 +318,13 @@ void sub_803ADE8(struct Pokemon *mon, struct UnknownPokemonStruct *src) SetMonData(mon, MON_DATA_LANGUAGE, &language); SkipExtCtrlCodes(nickname); SetMonData(mon, MON_DATA_NICKNAME, nickname); - SetMonData(mon, MON_DATA_FRIENDSHIP, (u8 *)&(src->friendship)); - SetMonData(mon, MON_DATA_HP_EV, (u8 *)&(src->hpEV)); - SetMonData(mon, MON_DATA_ATK_EV, (u8 *)&(src->attackEV)); - SetMonData(mon, MON_DATA_DEF_EV, (u8 *)&(src->defenseEV)); - SetMonData(mon, MON_DATA_SPD_EV, (u8 *)&(src->speedEV)); - SetMonData(mon, MON_DATA_SPATK_EV, (u8 *)&(src->spAttackEV)); - SetMonData(mon, MON_DATA_SPDEF_EV, (u8 *)&(src->spDefenseEV)); + SetMonData(mon, MON_DATA_FRIENDSHIP, (u8 *)&src->friendship); + SetMonData(mon, MON_DATA_HP_EV, (u8 *)&src->hpEV); + SetMonData(mon, MON_DATA_ATK_EV, (u8 *)&src->attackEV); + SetMonData(mon, MON_DATA_DEF_EV, (u8 *)&src->defenseEV); + SetMonData(mon, MON_DATA_SPD_EV, (u8 *)&src->speedEV); + SetMonData(mon, MON_DATA_SPATK_EV, (u8 *)&src->spAttackEV); + SetMonData(mon, MON_DATA_SPDEF_EV, (u8 *)&src->spDefenseEV); value = src->altAbility; SetMonData(mon, MON_DATA_ALT_ABILITY, &value); value = src->hpIV; @@ -379,13 +379,13 @@ void sub_803AF78(struct Pokemon *mon, struct UnknownPokemonStruct *dest) GetMonData(mon, MON_DATA_NICKNAME, dest->nickname); } -u16 pokemon_calc_checksum(struct Pokemon *mon) +u16 pokemon_calc_checksum(struct BoxPokemon *boxMon) { u16 checksum = 0; - union PokemonSubstruct *substruct0 = GetSubstruct(mon, mon->box.personality, 0); - union PokemonSubstruct *substruct1 = GetSubstruct(mon, mon->box.personality, 1); - union PokemonSubstruct *substruct2 = GetSubstruct(mon, mon->box.personality, 2); - union PokemonSubstruct *substruct3 = GetSubstruct(mon, mon->box.personality, 3); + union PokemonSubstruct *substruct0 = GetSubstruct(boxMon, boxMon->personality, 0); + union PokemonSubstruct *substruct1 = GetSubstruct(boxMon, boxMon->personality, 1); + union PokemonSubstruct *substruct2 = GetSubstruct(boxMon, boxMon->personality, 2); + union PokemonSubstruct *substruct3 = GetSubstruct(boxMon, boxMon->personality, 3); s32 i; for (i = 0; i < 6; i++) @@ -482,7 +482,7 @@ void pokemon_calc_effective_stats(struct Pokemon *mon) void sub_803B4B4(struct Pokemon *src, struct Pokemon *dest) { u32 value = 0; - memcpy(&(dest->box), &(src->box), sizeof(struct BoxPokemon)); + memcpy(&dest->box, &src->box, sizeof(struct BoxPokemon)); SetMonData(dest, MON_DATA_STATUS, (u8 *)&value); SetMonData(dest, MON_DATA_HP, (u8 *)&value); SetMonData(dest, MON_DATA_MAX_HP, (u8 *)&value); @@ -503,10 +503,10 @@ u8 level_by_exp(struct Pokemon *mon) return level - 1; } -u8 sub_803B570(struct BoxPokemon *mon) +u8 sub_803B570(struct BoxPokemon *boxMon) { - u16 species = GetMonBoxData(mon, MON_DATA_SPECIES, NULL); - u32 exp = GetMonBoxData(mon, MON_DATA_EXP, NULL); + u16 species = GetMonBoxData(boxMon, MON_DATA_SPECIES, NULL); + u32 exp = GetMonBoxData(boxMon, MON_DATA_EXP, NULL); s32 level = 1; while (level <= 100 && gExperienceTables[gBaseStats[species].growthRate][level] <= exp) @@ -517,19 +517,19 @@ u8 sub_803B570(struct BoxPokemon *mon) u16 pokemon_moveset_pad_(struct Pokemon *mon, u16 value) { - return pokemon_moveset_pad(mon, value); + return pokemon_moveset_pad(&mon->box, value); } -u16 pokemon_moveset_pad(struct Pokemon *mon, u16 value) +u16 pokemon_moveset_pad(struct BoxPokemon *boxMon, u16 value) { s32 i; for (i = 0; i < 4; i++) { - u16 move = GetMonBoxData(&(mon->box), MON_DATA_MOVE1 + i, NULL); + u16 move = GetMonBoxData(boxMon, MON_DATA_MOVE1 + i, NULL); if (!move) { - SetMonBoxData(mon, MON_DATA_MOVE1 + i, (u8 *)&value); - SetMonBoxData(mon, MON_DATA_PP1 + i, &(gBattleMoves[value].pp)); + SetMonBoxData(boxMon, MON_DATA_MOVE1 + i, (u8 *)&value); + SetMonBoxData(boxMon, MON_DATA_PP1 + i, &gBattleMoves[value].pp); return value; } if (move == value) @@ -558,7 +558,7 @@ u16 sub_803B660(struct BattlePokemon *mon, u16 value) void sub_803B6A4(struct Pokemon *mon, u16 move, u8 slot) { SetMonData(mon, MON_DATA_MOVE1 + slot, (u8 *)&move); - SetMonData(mon, MON_DATA_PP1 + slot, &(gBattleMoves[move].pp)); + SetMonData(mon, MON_DATA_PP1 + slot, &gBattleMoves[move].pp); } void sub_803B6E4(struct BattlePokemon *mon, u16 move, u8 slot) @@ -569,13 +569,13 @@ void sub_803B6E4(struct BattlePokemon *mon, u16 move, u8 slot) void unref_sub_803B714(struct Pokemon *mon) { - sub_803B720(mon); + sub_803B720(&mon->box); } -void sub_803B720(struct Pokemon *mon) +void sub_803B720(struct BoxPokemon *boxMon) { - u16 species = GetMonBoxData(&(mon->box), MON_DATA_SPECIES, NULL); - s32 level = sub_803B570(&(mon->box)); + u16 species = GetMonBoxData(boxMon, MON_DATA_SPECIES, NULL); + s32 level = sub_803B570(boxMon); s32 i; for (i = 0; gLevelUpLearnsetPointers[species][i] != (u16)-1; i++) @@ -590,8 +590,8 @@ void sub_803B720(struct Pokemon *mon) move = (gLevelUpLearnsetPointers[species][i] & 0x1FF); - if (pokemon_moveset_pad(mon, move) == (u16)-1) - sub_803B980(mon, move); + if (pokemon_moveset_pad(boxMon, move) == (u16)-1) + sub_803B980(boxMon, move); } } @@ -650,7 +650,7 @@ void sub_803B8D4(struct Pokemon *mon, u16 move) SetMonData(mon, MON_DATA_PP_BONUSES, &ppBonuses); } -void sub_803B980(struct Pokemon *mon, u16 move) +void sub_803B980(struct BoxPokemon *boxMon, u16 move) { s32 i; u16 moves[4]; @@ -659,20 +659,20 @@ void sub_803B980(struct Pokemon *mon, u16 move) for (i = 0; i < 3; i++) { - moves[i] = GetMonBoxData(mon, MON_DATA_MOVE2 + i, NULL); - pp[i]= GetMonBoxData(mon, MON_DATA_PP2 + i, NULL); + moves[i] = GetMonBoxData(boxMon, MON_DATA_MOVE2 + i, NULL); + pp[i]= GetMonBoxData(boxMon, MON_DATA_PP2 + i, NULL); } - ppBonuses = GetMonBoxData(mon, MON_DATA_PP_BONUSES, NULL); + ppBonuses = GetMonBoxData(boxMon, MON_DATA_PP_BONUSES, NULL); ppBonuses >>= 2; moves[3] = move; pp[3] = gBattleMoves[move].pp; for (i = 0; i < 4; i++) { - SetMonBoxData(mon, MON_DATA_MOVE1 + i, (u8 *)&moves[i]); - SetMonBoxData(mon, MON_DATA_PP1 + i, &pp[i]); + SetMonBoxData(boxMon, MON_DATA_MOVE1 + i, (u8 *)&moves[i]); + SetMonBoxData(boxMon, MON_DATA_PP1 + i, &pp[i]); } - SetMonBoxData(mon, MON_DATA_PP_BONUSES, &ppBonuses); + SetMonBoxData(boxMon, MON_DATA_PP_BONUSES, &ppBonuses); } diff --git a/src/pokemon_2.c b/src/pokemon_2.c index eb18f8840..e3f93645a 100644 --- a/src/pokemon_2.c +++ b/src/pokemon_2.c @@ -9,23 +9,23 @@ extern u8 gBadEggNickname[]; extern u8 gEggNickname[]; extern u32 gBitTable[]; -void EncryptMon(struct Pokemon *mon) +void EncryptMon(struct BoxPokemon *boxMon) { u32 i; for (i = 0; i < 12; i++) { - mon->box.secure.raw[i] ^= mon->box.personality; - mon->box.secure.raw[i] ^= mon->box.otId; + boxMon->secure.raw[i] ^= boxMon->personality; + boxMon->secure.raw[i] ^= boxMon->otId; } } -void DecryptMon(struct Pokemon *mon) +void DecryptMon(struct BoxPokemon *boxMon) { u32 i; for (i = 0; i < 12; i++) { - mon->box.secure.raw[i] ^= mon->box.otId; - mon->box.secure.raw[i] ^= mon->box.personality; + boxMon->secure.raw[i] ^= boxMon->otId; + boxMon->secure.raw[i] ^= boxMon->personality; } } @@ -48,34 +48,34 @@ case n: \ } \ break; -union PokemonSubstruct *GetSubstruct(struct Pokemon *mon, u32 personality, u8 substructType) +union PokemonSubstruct *GetSubstruct(struct BoxPokemon *boxMon, u32 personality, u8 substructType) { union PokemonSubstruct *substruct = NULL; - union PokemonSubstruct *substructs0 = mon->box.secure.substructs; - union PokemonSubstruct *substructs1 = mon->box.secure.substructs; - union PokemonSubstruct *substructs2 = mon->box.secure.substructs; - union PokemonSubstruct *substructs3 = mon->box.secure.substructs; - union PokemonSubstruct *substructs4 = mon->box.secure.substructs; - union PokemonSubstruct *substructs5 = mon->box.secure.substructs; - union PokemonSubstruct *substructs6 = mon->box.secure.substructs; - union PokemonSubstruct *substructs7 = mon->box.secure.substructs; - union PokemonSubstruct *substructs8 = mon->box.secure.substructs; - union PokemonSubstruct *substructs9 = mon->box.secure.substructs; - union PokemonSubstruct *substructs10 = mon->box.secure.substructs; - union PokemonSubstruct *substructs11 = mon->box.secure.substructs; - union PokemonSubstruct *substructs12 = mon->box.secure.substructs; - union PokemonSubstruct *substructs13 = mon->box.secure.substructs; - union PokemonSubstruct *substructs14 = mon->box.secure.substructs; - union PokemonSubstruct *substructs15 = mon->box.secure.substructs; - union PokemonSubstruct *substructs16 = mon->box.secure.substructs; - union PokemonSubstruct *substructs17 = mon->box.secure.substructs; - union PokemonSubstruct *substructs18 = mon->box.secure.substructs; - union PokemonSubstruct *substructs19 = mon->box.secure.substructs; - union PokemonSubstruct *substructs20 = mon->box.secure.substructs; - union PokemonSubstruct *substructs21 = mon->box.secure.substructs; - union PokemonSubstruct *substructs22 = mon->box.secure.substructs; - union PokemonSubstruct *substructs23 = mon->box.secure.substructs; + union PokemonSubstruct *substructs0 = boxMon->secure.substructs; + union PokemonSubstruct *substructs1 = boxMon->secure.substructs; + union PokemonSubstruct *substructs2 = boxMon->secure.substructs; + union PokemonSubstruct *substructs3 = boxMon->secure.substructs; + union PokemonSubstruct *substructs4 = boxMon->secure.substructs; + union PokemonSubstruct *substructs5 = boxMon->secure.substructs; + union PokemonSubstruct *substructs6 = boxMon->secure.substructs; + union PokemonSubstruct *substructs7 = boxMon->secure.substructs; + union PokemonSubstruct *substructs8 = boxMon->secure.substructs; + union PokemonSubstruct *substructs9 = boxMon->secure.substructs; + union PokemonSubstruct *substructs10 = boxMon->secure.substructs; + union PokemonSubstruct *substructs11 = boxMon->secure.substructs; + union PokemonSubstruct *substructs12 = boxMon->secure.substructs; + union PokemonSubstruct *substructs13 = boxMon->secure.substructs; + union PokemonSubstruct *substructs14 = boxMon->secure.substructs; + union PokemonSubstruct *substructs15 = boxMon->secure.substructs; + union PokemonSubstruct *substructs16 = boxMon->secure.substructs; + union PokemonSubstruct *substructs17 = boxMon->secure.substructs; + union PokemonSubstruct *substructs18 = boxMon->secure.substructs; + union PokemonSubstruct *substructs19 = boxMon->secure.substructs; + union PokemonSubstruct *substructs20 = boxMon->secure.substructs; + union PokemonSubstruct *substructs21 = boxMon->secure.substructs; + union PokemonSubstruct *substructs22 = boxMon->secure.substructs; + union PokemonSubstruct *substructs23 = boxMon->secure.substructs; switch (personality % 24) { @@ -133,11 +133,11 @@ u32 GetMonData(struct Pokemon *mon, s32 field, u8 *data) case MON_DATA_64: return mon->pokerus; default: - return GetMonBoxData(mon, field, data); + return GetMonBoxData(&mon->box, field, data); } } -u32 GetMonBoxData(struct Pokemon *mon, s32 field, u8 *data) +u32 GetMonBoxData(struct BoxPokemon *boxMon, s32 field, u8 *data) { u32 retVal = 0; struct PokemonSubstruct0 *substruct0 = NULL; @@ -147,17 +147,17 @@ u32 GetMonBoxData(struct Pokemon *mon, s32 field, u8 *data) if (field > MON_DATA_10) { - substruct0 = &(GetSubstruct(mon, mon->box.personality, 0)->type0); - substruct1 = &(GetSubstruct(mon, mon->box.personality, 1)->type1); - substruct2 = &(GetSubstruct(mon, mon->box.personality, 2)->type2); - substruct3 = &(GetSubstruct(mon, mon->box.personality, 3)->type3); + substruct0 = &(GetSubstruct(boxMon, boxMon->personality, 0)->type0); + substruct1 = &(GetSubstruct(boxMon, boxMon->personality, 1)->type1); + substruct2 = &(GetSubstruct(boxMon, boxMon->personality, 2)->type2); + substruct3 = &(GetSubstruct(boxMon, boxMon->personality, 3)->type3); - DecryptMon(mon); + DecryptMon(boxMon); - if (pokemon_calc_checksum(mon) != mon->box.checksum) + if (pokemon_calc_checksum(boxMon) != boxMon->checksum) { - mon->box.isBadEgg = 1; - mon->box.sanity3 = 1; + boxMon->isBadEgg = 1; + boxMon->sanity3 = 1; substruct3->isEgg = 1; } } @@ -165,19 +165,19 @@ u32 GetMonBoxData(struct Pokemon *mon, s32 field, u8 *data) switch (field) { case MON_DATA_PERSONALITY: - retVal = mon->box.personality; + retVal = boxMon->personality; break; case MON_DATA_OT_ID: - retVal = mon->box.otId; + retVal = boxMon->otId; break; case MON_DATA_NICKNAME: { - if (mon->box.isBadEgg) + if (boxMon->isBadEgg) { StringCopy(data, gBadEggNickname); retVal = StringLength(data); } - else if (mon->box.sanity3) + else if (boxMon->sanity3) { StringCopy(data, gEggNickname); retVal = StringLength(data); @@ -186,37 +186,37 @@ u32 GetMonBoxData(struct Pokemon *mon, s32 field, u8 *data) { retVal = 0; - while (retVal < 10 && mon->box.nickname[retVal] != EOS) + while (retVal < 10 && boxMon->nickname[retVal] != EOS) { - data[retVal] = mon->box.nickname[retVal]; + data[retVal] = boxMon->nickname[retVal]; retVal++; } data[retVal] = EOS; - ConvertInternationalString(data, mon->box.language); + ConvertInternationalString(data, boxMon->language); retVal = StringLength(data); } break; } case MON_DATA_LANGUAGE: - retVal = mon->box.language; + retVal = boxMon->language; break; case MON_DATA_SANITY_BIT1: - retVal = mon->box.isBadEgg; + retVal = boxMon->isBadEgg; break; case MON_DATA_SANITY_BIT2: - retVal = mon->box.sanity2; + retVal = boxMon->sanity2; break; case MON_DATA_SANITY_BIT3: - retVal = mon->box.sanity3; + retVal = boxMon->sanity3; break; case MON_DATA_OT_NAME: { retVal = 0; - while (retVal < 7 && mon->box.otName[retVal] != EOS) + while (retVal < 7 && boxMon->otName[retVal] != EOS) { - data[retVal] = mon->box.otName[retVal]; + data[retVal] = boxMon->otName[retVal]; retVal++; } @@ -224,16 +224,16 @@ u32 GetMonBoxData(struct Pokemon *mon, s32 field, u8 *data) break; } case MON_DATA_MARKINGS: - retVal = mon->box.markings; + retVal = boxMon->markings; break; case MON_DATA_CHECKSUM: - retVal = mon->box.checksum; + retVal = boxMon->checksum; break; case MON_DATA_10: - retVal = mon->box.unknown; + retVal = boxMon->unknown; break; case MON_DATA_SPECIES: - retVal = mon->box.isBadEgg ? 412 : substruct0->species; + retVal = boxMon->isBadEgg ? 412 : substruct0->species; break; case MON_DATA_HELD_ITEM: retVal = substruct0->heldItem; @@ -393,7 +393,7 @@ u32 GetMonBoxData(struct Pokemon *mon, s32 field, u8 *data) break; case MON_DATA_SPECIES2: retVal = substruct0->species; - if (substruct0->species && (substruct3->isEgg || mon->box.isBadEgg)) + if (substruct0->species && (substruct3->isEgg || boxMon->isBadEgg)) retVal = 412; break; case MON_DATA_IVS: @@ -468,7 +468,7 @@ u32 GetMonBoxData(struct Pokemon *mon, s32 field, u8 *data) } if (field > MON_DATA_10) - EncryptMon(mon); + EncryptMon(boxMon); return retVal; } -- cgit v1.2.3 From 70615f7eef8813d41f9ae94916aed358d23174a0 Mon Sep 17 00:00:00 2001 From: YamaArashi Date: Fri, 9 Sep 2016 22:52:23 -0700 Subject: gLevelUpLearnsetPointers -> gLevelUpLearnsets --- src/pokemon_1.c | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) (limited to 'src') diff --git a/src/pokemon_1.c b/src/pokemon_1.c index e9d6a998d..e07566860 100644 --- a/src/pokemon_1.c +++ b/src/pokemon_1.c @@ -17,7 +17,7 @@ extern u8 byte_2024E88; extern u32 gExperienceTables[8][101]; extern struct BaseStats gBaseStats[]; extern struct BattleMove gBattleMoves[]; -extern const u16 *gLevelUpLearnsetPointers[]; +extern const u16 *gLevelUpLearnsets[]; void ZeroPokemonBoxData(struct BoxPokemon *boxMon) { @@ -578,17 +578,17 @@ void sub_803B720(struct BoxPokemon *boxMon) s32 level = sub_803B570(boxMon); s32 i; - for (i = 0; gLevelUpLearnsetPointers[species][i] != (u16)-1; i++) + for (i = 0; gLevelUpLearnsets[species][i] != (u16)-1; i++) { u16 moveLevel; u16 move; - moveLevel = (gLevelUpLearnsetPointers[species][i] & 0xFE00); + moveLevel = (gLevelUpLearnsets[species][i] & 0xFE00); if (moveLevel > (level << 9)) break; - move = (gLevelUpLearnsetPointers[species][i] & 0x1FF); + move = (gLevelUpLearnsets[species][i] & 0x1FF); if (pokemon_moveset_pad(boxMon, move) == (u16)-1) sub_803B980(boxMon, move); @@ -605,17 +605,17 @@ u16 sub_803B7C8(struct Pokemon *mon, u8 a2) { byte_2024E88 = retVal; - while ((gLevelUpLearnsetPointers[species][byte_2024E88] & 0xFE00) != (level << 9)) + while ((gLevelUpLearnsets[species][byte_2024E88] & 0xFE00) != (level << 9)) { byte_2024E88++; - if (gLevelUpLearnsetPointers[species][byte_2024E88] == (u16)-1) + if (gLevelUpLearnsets[species][byte_2024E88] == (u16)-1) return 0; } } - if ((gLevelUpLearnsetPointers[species][byte_2024E88] & 0xFE00) == (level << 9)) + if ((gLevelUpLearnsets[species][byte_2024E88] & 0xFE00) == (level << 9)) { - word_2024E82 = (gLevelUpLearnsetPointers[species][byte_2024E88] & 0x1FF); + word_2024E82 = (gLevelUpLearnsets[species][byte_2024E88] & 0x1FF); byte_2024E88++; retVal = pokemon_moveset_pad_(mon, word_2024E82); } -- cgit v1.2.3 From 59c69882dc3a61ae93b85a880d9f8a08cbf13a3f Mon Sep 17 00:00:00 2001 From: YamaArashi Date: Fri, 9 Sep 2016 23:40:42 -0700 Subject: rename pokemon functions --- src/pokemon_1.c | 200 ++++++++++++++++++++++++++++---------------------------- src/pokemon_2.c | 14 ++-- 2 files changed, 107 insertions(+), 107 deletions(-) (limited to 'src') diff --git a/src/pokemon_1.c b/src/pokemon_1.c index e07566860..ccfc2c84d 100644 --- a/src/pokemon_1.c +++ b/src/pokemon_1.c @@ -19,7 +19,7 @@ extern struct BaseStats gBaseStats[]; extern struct BattleMove gBattleMoves[]; extern const u16 *gLevelUpLearnsets[]; -void ZeroPokemonBoxData(struct BoxPokemon *boxMon) +void ZeroBoxMonData(struct BoxPokemon *boxMon) { u8 *raw = (u8 *)boxMon; u32 i; @@ -27,10 +27,10 @@ void ZeroPokemonBoxData(struct BoxPokemon *boxMon) raw[i] = 0; } -void zero_pokemon_struct(struct Pokemon *mon) +void ZeroMonData(struct Pokemon *mon) { u32 arg; - ZeroPokemonBoxData(&mon->box); + ZeroBoxMonData(&mon->box); arg = 0; SetMonData(mon, MON_DATA_STATUS, (u8 *)&arg); SetMonData(mon, MON_DATA_LEVEL, (u8 *)&arg); @@ -45,39 +45,39 @@ void zero_pokemon_struct(struct Pokemon *mon) SetMonData(mon, MON_DATA_64, (u8 *)&arg); } -void zero_player_party_data(void) +void ZeroPlayerPartyMons(void) { s32 i; for (i = 0; i < 6; i++) - zero_pokemon_struct(&gPlayerParty[i]); + ZeroMonData(&gPlayerParty[i]); } -void zero_enemy_party_data(void) +void ZeroEnemyPartyMons(void) { s32 i; for (i = 0; i < 6; i++) - zero_pokemon_struct(&gEnemyParty[i]); + ZeroMonData(&gEnemyParty[i]); } -void create_pokemon_set_level(struct Pokemon *mon, u16 species, u8 level, u8 fixedIV, u8 hasFixedPersonality, u32 fixedPersonality, u8 otIdType, u32 fixedOtId) +void CreateMon(struct Pokemon *mon, u16 species, u8 level, u8 fixedIV, u8 hasFixedPersonality, u32 fixedPersonality, u8 otIdType, u32 fixedOtId) { u32 arg; - zero_pokemon_struct(mon); - create_pokemon(&mon->box, species, level, fixedIV, hasFixedPersonality, fixedPersonality, otIdType, fixedOtId); + ZeroMonData(mon); + CreateBoxMon(&mon->box, species, level, fixedIV, hasFixedPersonality, fixedPersonality, otIdType, fixedOtId); SetMonData(mon, MON_DATA_LEVEL, &level); arg = 255; SetMonData(mon, MON_DATA_64, (u8 *)&arg); - pokemon_calc_effective_stats(mon); + CalculateMonStats(mon); } -void create_pokemon(struct BoxPokemon *boxMon, u16 species, u8 level, u8 fixedIV, u8 hasFixedPersonality, u32 fixedPersonality, u8 otIdType, u32 fixedOtId) +void CreateBoxMon(struct BoxPokemon *boxMon, u16 species, u8 level, u8 fixedIV, u8 hasFixedPersonality, u32 fixedPersonality, u8 otIdType, u32 fixedOtId) { u8 speciesName[10]; u32 personality; u32 value; u16 checksum; - ZeroPokemonBoxData(boxMon); + ZeroBoxMonData(boxMon); if (hasFixedPersonality) { @@ -89,7 +89,7 @@ void create_pokemon(struct BoxPokemon *boxMon, u16 species, u8 level, u8 fixedIV personality = (u16)r | (Random() << 16); } - SetMonBoxData(boxMon, MON_DATA_PERSONALITY, (u8 *)&personality); + SetBoxMonData(boxMon, MON_DATA_PERSONALITY, (u8 *)&personality); if (otIdType == 2) { @@ -114,34 +114,34 @@ void create_pokemon(struct BoxPokemon *boxMon, u16 species, u8 level, u8 fixedIV | (gSaveBlock2.playerTrainerId[3] << 24); } - SetMonBoxData(boxMon, MON_DATA_OT_ID, (u8 *)&value); + SetBoxMonData(boxMon, MON_DATA_OT_ID, (u8 *)&value); - checksum = pokemon_calc_checksum(boxMon); - SetMonBoxData(boxMon, MON_DATA_CHECKSUM, (u8 *)&checksum); - EncryptMon(boxMon); + checksum = CalculateBoxMonChecksum(boxMon); + SetBoxMonData(boxMon, MON_DATA_CHECKSUM, (u8 *)&checksum); + EncryptBoxMon(boxMon); GetSpeciesName(speciesName, species); - SetMonBoxData(boxMon, MON_DATA_NICKNAME, speciesName); - SetMonBoxData(boxMon, MON_DATA_LANGUAGE, &gGameLanguage); - SetMonBoxData(boxMon, MON_DATA_OT_NAME, gSaveBlock2.playerName); - SetMonBoxData(boxMon, MON_DATA_SPECIES, (u8 *)&species); - SetMonBoxData(boxMon, MON_DATA_EXP, (u8 *)&gExperienceTables[gBaseStats[species].growthRate][level]); - SetMonBoxData(boxMon, MON_DATA_FRIENDSHIP, &gBaseStats[species].friendship); + SetBoxMonData(boxMon, MON_DATA_NICKNAME, speciesName); + SetBoxMonData(boxMon, MON_DATA_LANGUAGE, &gGameLanguage); + SetBoxMonData(boxMon, MON_DATA_OT_NAME, gSaveBlock2.playerName); + SetBoxMonData(boxMon, MON_DATA_SPECIES, (u8 *)&species); + SetBoxMonData(boxMon, MON_DATA_EXP, (u8 *)&gExperienceTables[gBaseStats[species].growthRate][level]); + SetBoxMonData(boxMon, MON_DATA_FRIENDSHIP, &gBaseStats[species].friendship); value = sav1_map_get_name(); - SetMonBoxData(boxMon, MON_DATA_MET_LOCATION, (u8 *)&value); - SetMonBoxData(boxMon, MON_DATA_MET_LEVEL, &level); - SetMonBoxData(boxMon, MON_DATA_MET_GAME, &gGameVersion); + SetBoxMonData(boxMon, MON_DATA_MET_LOCATION, (u8 *)&value); + SetBoxMonData(boxMon, MON_DATA_MET_LEVEL, &level); + SetBoxMonData(boxMon, MON_DATA_MET_GAME, &gGameVersion); value = 4; - SetMonBoxData(boxMon, MON_DATA_POKEBALL, (u8 *)&value); - SetMonBoxData(boxMon, MON_DATA_OT_GENDER, &gSaveBlock2.playerGender); + SetBoxMonData(boxMon, MON_DATA_POKEBALL, (u8 *)&value); + SetBoxMonData(boxMon, MON_DATA_OT_GENDER, &gSaveBlock2.playerGender); if (fixedIV < 32) { - SetMonBoxData(boxMon, MON_DATA_HP_IV, &fixedIV); - SetMonBoxData(boxMon, MON_DATA_ATK_IV, &fixedIV); - SetMonBoxData(boxMon, MON_DATA_DEF_IV, &fixedIV); - SetMonBoxData(boxMon, MON_DATA_SPD_IV, &fixedIV); - SetMonBoxData(boxMon, MON_DATA_SPATK_IV, &fixedIV); - SetMonBoxData(boxMon, MON_DATA_SPDEF_IV, &fixedIV); + SetBoxMonData(boxMon, MON_DATA_HP_IV, &fixedIV); + SetBoxMonData(boxMon, MON_DATA_ATK_IV, &fixedIV); + SetBoxMonData(boxMon, MON_DATA_DEF_IV, &fixedIV); + SetBoxMonData(boxMon, MON_DATA_SPD_IV, &fixedIV); + SetBoxMonData(boxMon, MON_DATA_SPATK_IV, &fixedIV); + SetBoxMonData(boxMon, MON_DATA_SPDEF_IV, &fixedIV); } else { @@ -149,32 +149,32 @@ void create_pokemon(struct BoxPokemon *boxMon, u16 species, u8 level, u8 fixedIV value = (u16)Random(); iv = value & 0x1F; - SetMonBoxData(boxMon, MON_DATA_HP_IV, (u8 *)&iv); + SetBoxMonData(boxMon, MON_DATA_HP_IV, (u8 *)&iv); iv = (value & 0x3E0) >> 5; - SetMonBoxData(boxMon, MON_DATA_ATK_IV, (u8 *)&iv); + SetBoxMonData(boxMon, MON_DATA_ATK_IV, (u8 *)&iv); iv = (value &0x7C00) >> 10; - SetMonBoxData(boxMon, MON_DATA_DEF_IV, (u8 *)&iv); + SetBoxMonData(boxMon, MON_DATA_DEF_IV, (u8 *)&iv); value = (u16)Random(); iv = value & 0x1F; - SetMonBoxData(boxMon, MON_DATA_SPD_IV, (u8 *)&iv); + SetBoxMonData(boxMon, MON_DATA_SPD_IV, (u8 *)&iv); iv = (value & 0x3E0) >> 5; - SetMonBoxData(boxMon, MON_DATA_SPATK_IV, (u8 *)&iv); + SetBoxMonData(boxMon, MON_DATA_SPATK_IV, (u8 *)&iv); iv = (value &0x7C00) >> 10; - SetMonBoxData(boxMon, MON_DATA_SPDEF_IV, (u8 *)&iv); + SetBoxMonData(boxMon, MON_DATA_SPDEF_IV, (u8 *)&iv); } if (gBaseStats[species].ability2) { value = personality & 1; - SetMonBoxData(boxMon, MON_DATA_ALT_ABILITY, (u8 *)&value); + SetBoxMonData(boxMon, MON_DATA_ALT_ABILITY, (u8 *)&value); } - sub_803B720(boxMon); + GiveBoxMonInitialMoveset(boxMon); } -void pokemon_make_with_nature(struct Pokemon *mon, u16 species, u8 level, u8 fixedIV, u8 nature) +void CreateMonWithNature(struct Pokemon *mon, u16 species, u8 level, u8 fixedIV, u8 nature) { u32 personality; @@ -185,10 +185,10 @@ void pokemon_make_with_nature(struct Pokemon *mon, u16 species, u8 level, u8 fix } while (nature != GetNatureFromPersonality(personality)); - create_pokemon_set_level(mon, species, level, fixedIV, 1, personality, 0, 0); + CreateMon(mon, species, level, fixedIV, 1, personality, 0, 0); } -void unref_sub_803AB44(struct Pokemon *mon, u16 species, u8 level, u8 fixedIV, u8 gender, u8 nature, u8 unownLetter) +void CreateMonWithGenderNatureLetter(struct Pokemon *mon, u16 species, u8 level, u8 fixedIV, u8 gender, u8 nature, u8 unownLetter) { u32 personality; @@ -217,10 +217,10 @@ void unref_sub_803AB44(struct Pokemon *mon, u16 species, u8 level, u8 fixedIV, u || gender != pokemon_species_get_gender_info(species, personality)); } - create_pokemon_set_level(mon, species, level, fixedIV, 1, personality, 0, 0); + CreateMon(mon, species, level, fixedIV, 1, personality, 0, 0); } -void sub_803AC44(struct Pokemon *mon, u16 species, u8 level) +void CreateFemaleMon(struct Pokemon *mon, u16 species, u8 level) { u32 personality; u32 otId; @@ -234,29 +234,29 @@ void sub_803AC44(struct Pokemon *mon, u16 species, u8 level) personality = (u16)r2 | (Random() << 16); } while (pokemon_species_get_gender_info(species, personality) != MALE); - create_pokemon_set_level(mon, species, level, 32, 1, personality, 1, otId); + CreateMon(mon, species, level, 32, 1, personality, 1, otId); } -void sub_803ACAC(struct Pokemon *mon, u16 species, u8 level, u32 ivs, u32 personality) +void CreateMonWithIVsPersonality(struct Pokemon *mon, u16 species, u8 level, u32 ivs, u32 personality) { - create_pokemon_set_level(mon, species, level, 0, 1, personality, 0, 0); + CreateMon(mon, species, level, 0, 1, personality, 0, 0); SetMonData(mon, MON_DATA_IVS, (u8 *)&ivs); - pokemon_calc_effective_stats(mon); + CalculateMonStats(mon); } -void unref_sub_803ACEC(struct Pokemon *mon, u16 species, u8 level, u8 *ivs, u32 otId) +void CreateMonWithIVsOTID(struct Pokemon *mon, u16 species, u8 level, u8 *ivs, u32 otId) { - create_pokemon_set_level(mon, species, level, 0, 0, 0, 1, otId); + CreateMon(mon, species, level, 0, 0, 0, 1, otId); SetMonData(mon, MON_DATA_HP_IV, &ivs[0]); SetMonData(mon, MON_DATA_ATK_IV, &ivs[1]); SetMonData(mon, MON_DATA_DEF_IV, &ivs[2]); SetMonData(mon, MON_DATA_SPD_IV, &ivs[3]); SetMonData(mon, MON_DATA_SPATK_IV, &ivs[4]); SetMonData(mon, MON_DATA_SPDEF_IV, &ivs[5]); - pokemon_calc_effective_stats(mon); + CalculateMonStats(mon); } -void pokemon_make_ev_something(struct Pokemon *mon, u16 species, u8 level, u8 fixedIV, u8 evSpread) +void CreateMonWithEVSpread(struct Pokemon *mon, u16 species, u8 level, u8 fixedIV, u8 evSpread) { register s32 i asm("r5"); register u32 temp asm("r4"); @@ -265,7 +265,7 @@ void pokemon_make_ev_something(struct Pokemon *mon, u16 species, u8 level, u8 fi register u32 mask1 asm("r1"); u8 mask2; - create_pokemon_set_level(mon, species, level, fixedIV, 0, 0, 0, 0); + CreateMon(mon, species, level, fixedIV, 0, 0, 0, 0); temp = evSpread; mask1 = 1; @@ -290,7 +290,7 @@ void pokemon_make_ev_something(struct Pokemon *mon, u16 species, u8 level, u8 fi i++; } while (i < 6); - pokemon_calc_effective_stats(mon); + CalculateMonStats(mon); } void sub_803ADE8(struct Pokemon *mon, struct UnknownPokemonStruct *src) @@ -300,10 +300,10 @@ void sub_803ADE8(struct Pokemon *mon, struct UnknownPokemonStruct *src) u8 language; u8 value; - create_pokemon_set_level(mon, src->species, src->level, 0, 1, src->personality, 1, src->otId); + CreateMon(mon, src->species, src->level, 0, 1, src->personality, 1, src->otId); for (i = 0; i < 4; i++) - sub_803B6A4(mon, src->moves[i], i); + SetMonMoveSlot(mon, src->moves[i], i); SetMonData(mon, MON_DATA_PP_BONUSES, (u8 *)&src->ppBonuses); SetMonData(mon, MON_DATA_HELD_ITEM, (u8 *)&src->heldItem); @@ -339,7 +339,7 @@ void sub_803ADE8(struct Pokemon *mon, struct UnknownPokemonStruct *src) SetMonData(mon, MON_DATA_SPATK_IV, &value); value = src->spDefenseIV; SetMonData(mon, MON_DATA_SPDEF_IV, &value); - pokemon_calc_effective_stats(mon); + CalculateMonStats(mon); } void sub_803AF78(struct Pokemon *mon, struct UnknownPokemonStruct *dest) @@ -379,7 +379,7 @@ void sub_803AF78(struct Pokemon *mon, struct UnknownPokemonStruct *dest) GetMonData(mon, MON_DATA_NICKNAME, dest->nickname); } -u16 pokemon_calc_checksum(struct BoxPokemon *boxMon) +u16 CalculateBoxMonChecksum(struct BoxPokemon *boxMon) { u16 checksum = 0; union PokemonSubstruct *substruct0 = GetSubstruct(boxMon, boxMon->personality, 0); @@ -412,7 +412,7 @@ u16 pokemon_calc_checksum(struct BoxPokemon *boxMon) SetMonData(mon, field, (u8 *)&n); \ } -void pokemon_calc_effective_stats(struct Pokemon *mon) +void CalculateMonStats(struct Pokemon *mon) { s32 oldMaxHP = GetMonData(mon, MON_DATA_MAX_HP, NULL); s32 currentHP = GetMonData(mon, MON_DATA_HP, NULL); @@ -429,7 +429,7 @@ void pokemon_calc_effective_stats(struct Pokemon *mon) s32 spDefenseIV = GetMonData(mon, MON_DATA_SPDEF_IV, NULL); s32 spDefenseEV = GetMonData(mon, MON_DATA_SPDEF_EV, NULL); u16 species = GetMonData(mon, MON_DATA_SPECIES, NULL); - s32 level = level_by_exp(mon); + s32 level = GetLevelFromMonExp(mon); s32 newMaxHP; u8 nature; @@ -488,10 +488,10 @@ void sub_803B4B4(struct Pokemon *src, struct Pokemon *dest) SetMonData(dest, MON_DATA_MAX_HP, (u8 *)&value); value = 255; SetMonData(dest, MON_DATA_64, (u8 *)&value); - pokemon_calc_effective_stats(dest); + CalculateMonStats(dest); } -u8 level_by_exp(struct Pokemon *mon) +u8 GetLevelFromMonExp(struct Pokemon *mon) { u16 species = GetMonData(mon, MON_DATA_SPECIES, NULL); u32 exp = GetMonData(mon, MON_DATA_EXP, NULL); @@ -503,10 +503,10 @@ u8 level_by_exp(struct Pokemon *mon) return level - 1; } -u8 sub_803B570(struct BoxPokemon *boxMon) +u8 GetLevelFromBoxMonExp(struct BoxPokemon *boxMon) { - u16 species = GetMonBoxData(boxMon, MON_DATA_SPECIES, NULL); - u32 exp = GetMonBoxData(boxMon, MON_DATA_EXP, NULL); + u16 species = GetBoxMonData(boxMon, MON_DATA_SPECIES, NULL); + u32 exp = GetBoxMonData(boxMon, MON_DATA_EXP, NULL); s32 level = 1; while (level <= 100 && gExperienceTables[gBaseStats[species].growthRate][level] <= exp) @@ -515,30 +515,30 @@ u8 sub_803B570(struct BoxPokemon *boxMon) return level - 1; } -u16 pokemon_moveset_pad_(struct Pokemon *mon, u16 value) +u16 GiveMoveToMon(struct Pokemon *mon, u16 move) { - return pokemon_moveset_pad(&mon->box, value); + return GiveMoveToBoxMon(&mon->box, move); } -u16 pokemon_moveset_pad(struct BoxPokemon *boxMon, u16 value) +u16 GiveMoveToBoxMon(struct BoxPokemon *boxMon, u16 move) { s32 i; for (i = 0; i < 4; i++) { - u16 move = GetMonBoxData(boxMon, MON_DATA_MOVE1 + i, NULL); - if (!move) + u16 existingMove = GetBoxMonData(boxMon, MON_DATA_MOVE1 + i, NULL); + if (!existingMove) { - SetMonBoxData(boxMon, MON_DATA_MOVE1 + i, (u8 *)&value); - SetMonBoxData(boxMon, MON_DATA_PP1 + i, &gBattleMoves[value].pp); - return value; + SetBoxMonData(boxMon, MON_DATA_MOVE1 + i, (u8 *)&move); + SetBoxMonData(boxMon, MON_DATA_PP1 + i, &gBattleMoves[move].pp); + return move; } - if (move == value) + if (existingMove == move) return -2; } return -1; } -u16 sub_803B660(struct BattlePokemon *mon, u16 value) +u16 GiveMoveToBattleMon(struct BattlePokemon *mon, u16 move) { s32 i; @@ -546,36 +546,36 @@ u16 sub_803B660(struct BattlePokemon *mon, u16 value) { if (!mon->moves[i]) { - mon->moves[i] = value; - mon->pp[i] = gBattleMoves[value].pp; - return value; + mon->moves[i] = move; + mon->pp[i] = gBattleMoves[move].pp; + return move; } } return -1; } -void sub_803B6A4(struct Pokemon *mon, u16 move, u8 slot) +void SetMonMoveSlot(struct Pokemon *mon, u16 move, u8 slot) { SetMonData(mon, MON_DATA_MOVE1 + slot, (u8 *)&move); SetMonData(mon, MON_DATA_PP1 + slot, &gBattleMoves[move].pp); } -void sub_803B6E4(struct BattlePokemon *mon, u16 move, u8 slot) +void SetBattleMonMoveSlot(struct BattlePokemon *mon, u16 move, u8 slot) { mon->moves[slot] = move; mon->pp[slot] = gBattleMoves[move].pp; } -void unref_sub_803B714(struct Pokemon *mon) +void GiveMonInitialMoveset(struct Pokemon *mon) { - sub_803B720(&mon->box); + GiveBoxMonInitialMoveset(&mon->box); } -void sub_803B720(struct BoxPokemon *boxMon) +void GiveBoxMonInitialMoveset(struct BoxPokemon *boxMon) { - u16 species = GetMonBoxData(boxMon, MON_DATA_SPECIES, NULL); - s32 level = sub_803B570(boxMon); + u16 species = GetBoxMonData(boxMon, MON_DATA_SPECIES, NULL); + s32 level = GetLevelFromBoxMonExp(boxMon); s32 i; for (i = 0; gLevelUpLearnsets[species][i] != (u16)-1; i++) @@ -590,8 +590,8 @@ void sub_803B720(struct BoxPokemon *boxMon) move = (gLevelUpLearnsets[species][i] & 0x1FF); - if (pokemon_moveset_pad(boxMon, move) == (u16)-1) - sub_803B980(boxMon, move); + if (GiveMoveToBoxMon(boxMon, move) == (u16)-1) + DeleteFirstMoveAndGiveMoveToBoxMon(boxMon, move); } } @@ -617,13 +617,13 @@ u16 sub_803B7C8(struct Pokemon *mon, u8 a2) { word_2024E82 = (gLevelUpLearnsets[species][byte_2024E88] & 0x1FF); byte_2024E88++; - retVal = pokemon_moveset_pad_(mon, word_2024E82); + retVal = GiveMoveToMon(mon, word_2024E82); } return retVal; } -void sub_803B8D4(struct Pokemon *mon, u16 move) +void DeleteFirstMoveAndGiveMoveToMon(struct Pokemon *mon, u16 move) { s32 i; u16 moves[4]; @@ -650,7 +650,7 @@ void sub_803B8D4(struct Pokemon *mon, u16 move) SetMonData(mon, MON_DATA_PP_BONUSES, &ppBonuses); } -void sub_803B980(struct BoxPokemon *boxMon, u16 move) +void DeleteFirstMoveAndGiveMoveToBoxMon(struct BoxPokemon *boxMon, u16 move) { s32 i; u16 moves[4]; @@ -659,20 +659,20 @@ void sub_803B980(struct BoxPokemon *boxMon, u16 move) for (i = 0; i < 3; i++) { - moves[i] = GetMonBoxData(boxMon, MON_DATA_MOVE2 + i, NULL); - pp[i]= GetMonBoxData(boxMon, MON_DATA_PP2 + i, NULL); + moves[i] = GetBoxMonData(boxMon, MON_DATA_MOVE2 + i, NULL); + pp[i]= GetBoxMonData(boxMon, MON_DATA_PP2 + i, NULL); } - ppBonuses = GetMonBoxData(boxMon, MON_DATA_PP_BONUSES, NULL); + ppBonuses = GetBoxMonData(boxMon, MON_DATA_PP_BONUSES, NULL); ppBonuses >>= 2; moves[3] = move; pp[3] = gBattleMoves[move].pp; for (i = 0; i < 4; i++) { - SetMonBoxData(boxMon, MON_DATA_MOVE1 + i, (u8 *)&moves[i]); - SetMonBoxData(boxMon, MON_DATA_PP1 + i, &pp[i]); + SetBoxMonData(boxMon, MON_DATA_MOVE1 + i, (u8 *)&moves[i]); + SetBoxMonData(boxMon, MON_DATA_PP1 + i, &pp[i]); } - SetMonBoxData(boxMon, MON_DATA_PP_BONUSES, &ppBonuses); + SetBoxMonData(boxMon, MON_DATA_PP_BONUSES, &ppBonuses); } diff --git a/src/pokemon_2.c b/src/pokemon_2.c index e3f93645a..9f9fc3911 100644 --- a/src/pokemon_2.c +++ b/src/pokemon_2.c @@ -9,7 +9,7 @@ extern u8 gBadEggNickname[]; extern u8 gEggNickname[]; extern u32 gBitTable[]; -void EncryptMon(struct BoxPokemon *boxMon) +void EncryptBoxMon(struct BoxPokemon *boxMon) { u32 i; for (i = 0; i < 12; i++) @@ -19,7 +19,7 @@ void EncryptMon(struct BoxPokemon *boxMon) } } -void DecryptMon(struct BoxPokemon *boxMon) +void DecryptBoxMon(struct BoxPokemon *boxMon) { u32 i; for (i = 0; i < 12; i++) @@ -133,11 +133,11 @@ u32 GetMonData(struct Pokemon *mon, s32 field, u8 *data) case MON_DATA_64: return mon->pokerus; default: - return GetMonBoxData(&mon->box, field, data); + return GetBoxMonData(&mon->box, field, data); } } -u32 GetMonBoxData(struct BoxPokemon *boxMon, s32 field, u8 *data) +u32 GetBoxMonData(struct BoxPokemon *boxMon, s32 field, u8 *data) { u32 retVal = 0; struct PokemonSubstruct0 *substruct0 = NULL; @@ -152,9 +152,9 @@ u32 GetMonBoxData(struct BoxPokemon *boxMon, s32 field, u8 *data) substruct2 = &(GetSubstruct(boxMon, boxMon->personality, 2)->type2); substruct3 = &(GetSubstruct(boxMon, boxMon->personality, 3)->type3); - DecryptMon(boxMon); + DecryptBoxMon(boxMon); - if (pokemon_calc_checksum(boxMon) != boxMon->checksum) + if (CalculateBoxMonChecksum(boxMon) != boxMon->checksum) { boxMon->isBadEgg = 1; boxMon->sanity3 = 1; @@ -468,7 +468,7 @@ u32 GetMonBoxData(struct BoxPokemon *boxMon, s32 field, u8 *data) } if (field > MON_DATA_10) - EncryptMon(boxMon); + EncryptBoxMon(boxMon); return retVal; } -- cgit v1.2.3 From 69ca60ca91e3cf0d3dc323bf30bb7d79c77464d8 Mon Sep 17 00:00:00 2001 From: YamaArashi Date: Fri, 9 Sep 2016 23:54:32 -0700 Subject: fix mistake in function name --- src/pokemon_1.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'src') diff --git a/src/pokemon_1.c b/src/pokemon_1.c index ccfc2c84d..02ae1533f 100644 --- a/src/pokemon_1.c +++ b/src/pokemon_1.c @@ -220,7 +220,8 @@ void CreateMonWithGenderNatureLetter(struct Pokemon *mon, u16 species, u8 level, CreateMon(mon, species, level, fixedIV, 1, personality, 0, 0); } -void CreateFemaleMon(struct Pokemon *mon, u16 species, u8 level) +// This is only used to create Wally's Ralts. +void CreateMaleMon(struct Pokemon *mon, u16 species, u8 level) { u32 personality; u32 otId; -- cgit v1.2.3 From 19bffecc4deb401aa51add3b95163b72686f40ee Mon Sep 17 00:00:00 2001 From: YamaArashi Date: Sat, 10 Sep 2016 01:59:10 -0700 Subject: decompile more pokemon functions --- src/main_menu.c | 4 ++-- src/pokemon_1.c | 7 ++++--- src/pokemon_2.c | 65 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 71 insertions(+), 5 deletions(-) (limited to 'src') diff --git a/src/main_menu.c b/src/main_menu.c index 559bf5a0a..692267c64 100644 --- a/src/main_menu.c +++ b/src/main_menu.c @@ -8,6 +8,7 @@ #include "palette.h" #include "string_util.h" #include "species.h" +#include "pokemon.h" extern u8 MenuUpdateWindowText(void); extern void MenuPrint(u8 *, u8, u8); @@ -41,7 +42,6 @@ void CB2_MainMenu(void); void VBlankCB_MainMenu(void); void DecompressPicFromTable_2(const struct SpriteSheet *, u8, u8, void *, void *, u32); void LoadCompressedObjectPalette(const struct SpritePalette *); -void gpu_pal_obj_decompress_and_apply(u16, u8); u8 AddNewGameBirchObject(u8, u8, u8); u8 sub_80859BC(u8, u16, u16, u8, void *); void MenuDrawTextWindow(u8 a, u8 b, u8 c, u8 d); @@ -1426,7 +1426,7 @@ u8 CreateAzurillSprite(u8 a1, u8 a2) gUnknown_081FAF4C[1], SPECIES_AZURILL); LoadCompressedObjectPalette(&gMonPaletteTable[SPECIES_AZURILL]); - gpu_pal_obj_decompress_and_apply(SPECIES_AZURILL, 1); + GetMonSpriteTemplate_803C56C(SPECIES_AZURILL, 1); return CreateSprite(&gUnknown_02024E8C, a1, a2, 0); } diff --git a/src/pokemon_1.c b/src/pokemon_1.c index 02ae1533f..566db2e68 100644 --- a/src/pokemon_1.c +++ b/src/pokemon_1.c @@ -4,6 +4,7 @@ #include "pokemon.h" #include "species.h" #include "main.h" +#include "sprite.h" extern u8 sav1_map_get_name(); @@ -203,7 +204,7 @@ void CreateMonWithGenderNatureLetter(struct Pokemon *mon, u16 species, u8 level, actualLetter = ((((personality & 0x3000000) >> 18) | ((personality & 0x30000) >> 12) | ((personality & 0x300) >> 6) | personality & 0x3) % 28); } while (nature != GetNatureFromPersonality(personality) - || gender != pokemon_species_get_gender_info(species, personality) + || gender != GetGenderFromSpeciesAndPersonality(species, personality) || actualLetter != unownLetter - 1); } else @@ -214,7 +215,7 @@ void CreateMonWithGenderNatureLetter(struct Pokemon *mon, u16 species, u8 level, personality = (u16)r | (Random() << 16); } while (nature != GetNatureFromPersonality(personality) - || gender != pokemon_species_get_gender_info(species, personality)); + || gender != GetGenderFromSpeciesAndPersonality(species, personality)); } CreateMon(mon, species, level, fixedIV, 1, personality, 0, 0); @@ -234,7 +235,7 @@ void CreateMaleMon(struct Pokemon *mon, u16 species, u8 level) r2 = Random(); personality = (u16)r2 | (Random() << 16); } - while (pokemon_species_get_gender_info(species, personality) != MALE); + while (GetGenderFromSpeciesAndPersonality(species, personality) != MON_MALE); CreateMon(mon, species, level, 32, 1, personality, 1, otId); } diff --git a/src/pokemon_2.c b/src/pokemon_2.c index 9f9fc3911..647808d14 100644 --- a/src/pokemon_2.c +++ b/src/pokemon_2.c @@ -4,10 +4,75 @@ #include "pokemon.h" #include "species.h" #include "main.h" +#include "sprite.h" + +extern struct SpriteTemplate gUnknown_02024E8C; extern u8 gBadEggNickname[]; extern u8 gEggNickname[]; extern u32 gBitTable[]; +extern struct BaseStats gBaseStats[]; +extern struct SpriteTemplate gSpriteTemplate_8208288[]; +extern union AmimCmd *gSpriteAnimTable_81E7C64[]; +extern union AnimCmd **gUnknown_081EC2A4[]; +extern union AnimCmd **gUnknown_081ECACC[]; + +u8 GetMonGender(struct Pokemon *mon) +{ + return GetBoxMonGender(&mon->box); +} + +u8 GetBoxMonGender(struct BoxPokemon *boxMon) +{ + u16 species = GetBoxMonData(boxMon, MON_DATA_SPECIES, NULL); + u32 personality = GetBoxMonData(boxMon, MON_DATA_PERSONALITY, NULL); + + switch (gBaseStats[species].genderRatio) + { + case MON_MALE: + case MON_FEMALE: + case MON_GENDERLESS: + return gBaseStats[species].genderRatio; + } + + if (gBaseStats[species].genderRatio > (personality & 0xFF)) + return MON_FEMALE; + else + return MON_MALE; +} + +u8 GetGenderFromSpeciesAndPersonality(u16 species, u32 personality) +{ + switch (gBaseStats[species].genderRatio) + { + case MON_MALE: + case MON_FEMALE: + case MON_GENDERLESS: + return gBaseStats[species].genderRatio; + } + + if (gBaseStats[species].genderRatio > (personality & 0xFF)) + return MON_FEMALE; + else + return MON_MALE; +} + +void GetMonSpriteTemplate_803C56C(u16 species, u8 a2) +{ + gUnknown_02024E8C = gSpriteTemplate_8208288[a2]; + gUnknown_02024E8C.paletteTag = species; + gUnknown_02024E8C.anims = (union AnimCmd **)gSpriteAnimTable_81E7C64; +} + +void GetMonSpriteTemplate_803C5A0(u16 species, u8 a2) +{ + gUnknown_02024E8C = gSpriteTemplate_8208288[a2]; + gUnknown_02024E8C.paletteTag = species; + if (a2 == 0 || a2 == 2) + gUnknown_02024E8C.anims = gUnknown_081ECACC[species]; + else + gUnknown_02024E8C.anims = gUnknown_081EC2A4[species]; +} void EncryptBoxMon(struct BoxPokemon *boxMon) { -- cgit v1.2.3