From fc4e90cf0706ffffcb92156babca02118f68148a Mon Sep 17 00:00:00 2001 From: Maide Date: Tue, 10 Sep 2024 15:52:07 +0100 Subject: [PATCH] various --- include/functions.h | 4 +- include/global.h | 4 +- include/sections.h | 9 + include/variables.h | 3 + linker_scripts/us/symbol_addrs.txt | 1 + src/20330.c | 62 +- src/20330.h | 2 +- src/22630.h | 26 + src/26820.c | 980 +++++++++++++++++++++++++++-- src/26820.h | 9 +- src/30640.c | 248 +++++++- src/30640.h | 3 +- src/38BB0.h | 1 + src/3FB0.c | 6 +- src/3FB0.h | 6 +- src/45720.c | 42 +- src/45720.h | 2 +- src/49790.c | 196 +++++- src/49790.h | 2 +- src/50860.c | 35 +- src/D470.h | 2 +- src/fragments/43/fragment43.h | 10 + src/fragments/8/fragment8.c | 6 +- src/memory.h | 8 +- src/memory_main.c | 10 +- yamls/us/rom.yaml | 12 +- 26 files changed, 1588 insertions(+), 101 deletions(-) create mode 100644 src/fragments/43/fragment43.h diff --git a/include/functions.h b/include/functions.h index 789c84b6..03b8c394 100644 --- a/include/functions.h +++ b/include/functions.h @@ -7,7 +7,7 @@ void func_80057FD0(void *, int); s32 func_8005A990(OSPiHandle *); // bcopy.s -void _bcopy(void *, void *, u32); +void _bcopy(void *, void *, s32); // 5580.s void func_80004CC0(OSThread *, s32, s32); @@ -37,7 +37,7 @@ void func_8000D970(OSPfs *); void set_watch_lohi(s32); u32 osGetCount(void); -OSIntMask osSetIntMask(OSIntMask);; +OSIntMask osSetIntMask(OSIntMask); unsigned long long __ull_rshift(unsigned long long a0, unsigned long long a1); unsigned long long __ull_rem(unsigned long long a0, unsigned long long a1); diff --git a/include/global.h b/include/global.h index d2cd8aae..cf9ec7dc 100644 --- a/include/global.h +++ b/include/global.h @@ -105,8 +105,8 @@ typedef struct unk_D_86002F34_00C { /* 0x38 */ f32 unk_038; /* 0x3C */ char pad3C[0x24]; /* 0x60 */ MtxF* unk_060; - /* 0x64 */ Vec3f unk_064; - /* 0x70 */ char pad70[0x38]; + /* 0x64 */ MtxF unk_064; + /* 0xA4 */ char padA4[0x4]; /* 0xA8 */ Vec3f unk_0A8; /* 0xB4 */ Vec3f unk_0B4; } unk_D_86002F34_00C; // size >= 0xC0 diff --git a/include/sections.h b/include/sections.h index 542c54cf..8a730002 100644 --- a/include/sections.h +++ b/include/sections.h @@ -80,6 +80,7 @@ extern u8 fragment14_relocs_ROM_END[]; extern u8 fragment15_TEXT_START[]; extern u8 fragment15_ROM_START[]; extern u8 fragment15_ROM_END[]; +extern u8 fragment15_relocs_ROM_END[]; // fragment 16 extern u8 fragment16_TEXT_START[]; @@ -229,42 +230,50 @@ extern u8 fragment41_ROM_END[]; extern u8 fragment42_TEXT_START[]; extern u8 fragment42_ROM_START[]; extern u8 fragment42_ROM_END[]; +extern u8 fragment42_relocs_ROM_END[]; // fragment 43 extern u8 fragment43_TEXT_START[]; extern u8 fragment43_ROM_START[]; extern u8 fragment43_ROM_END[]; extern u8 fragment43_relocs_ROM_END[]; +extern u8 fragment43_relocs_ROM_END[]; // fragment 44 extern u8 fragment44_TEXT_START[]; extern u8 fragment44_ROM_START[]; extern u8 fragment44_ROM_END[]; +extern u8 fragment44_relocs_ROM_END[]; // fragment 45 extern u8 fragment45_TEXT_START[]; extern u8 fragment45_ROM_START[]; extern u8 fragment45_ROM_END[]; +extern u8 fragment45_relocs_ROM_END[]; // fragment 46 extern u8 fragment46_TEXT_START[]; extern u8 fragment46_ROM_START[]; extern u8 fragment46_ROM_END[]; +extern u8 fragment46_relocs_ROM_END[]; // fragment 47 extern u8 fragment47_TEXT_START[]; extern u8 fragment47_ROM_START[]; extern u8 fragment47_ROM_END[]; +extern u8 fragment47_relocs_ROM_END[]; // fragment 48 extern u8 fragment48_TEXT_START[]; extern u8 fragment48_ROM_START[]; extern u8 fragment48_ROM_END[]; +extern u8 fragment48_relocs_ROM_END[]; // fragment 49 extern u8 fragment49_TEXT_START[]; extern u8 fragment49_ROM_START[]; extern u8 fragment49_ROM_END[]; +extern u8 fragment49_relocs_ROM_END[]; // fragment 50 extern u8 fragment50_TEXT_START[]; diff --git a/include/variables.h b/include/variables.h index 045626e8..bfe82c80 100644 --- a/include/variables.h +++ b/include/variables.h @@ -228,4 +228,7 @@ extern u8 D_87B000CC; extern u8 D_87B000D0; extern u8 D_87B000D4; +extern s32 D_800FC820; +extern s32 D_800FF9C0; + #endif diff --git a/linker_scripts/us/symbol_addrs.txt b/linker_scripts/us/symbol_addrs.txt index e5d51b19..c42b9781 100644 --- a/linker_scripts/us/symbol_addrs.txt +++ b/linker_scripts/us/symbol_addrs.txt @@ -259,3 +259,4 @@ D_800A60C0 = 0x800A60C0; D_82100DC0 = 0x82100DC0; D_86106450 = 0x86106450; // size:0x1140 D_862082A0 = 0x862082A0; // size:0x10 +D_800AE4E8 = 0x800AE4E8; // size:0x30 diff --git a/src/20330.c b/src/20330.c index f2676b6d..bddb4601 100644 --- a/src/20330.c +++ b/src/20330.c @@ -1,8 +1,64 @@ #include "global.h" #include "20330.h" -#pragma GLOBAL_ASM("asm/us/nonmatchings/20330/func_8001F730.s") +static s32 pad_D_800AC880[0x2]; +static s32 D_800AC888; +static unk_D_80068BA0* D_800AC88C; -#pragma GLOBAL_ASM("asm/us/nonmatchings/20330/func_8001F738.s") +void func_8001F730(void) { +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/20330/func_8001F750.s") +void func_8001F738(unk_D_80068BA0* arg0) { + D_800AC888 = 0xA; + D_800AC88C = arg0; +} + +s32 func_8001F750(void) { + if (D_800AC88C->unk_08 & 0x800) { + D_800AC888 = 0xA; + return 0x800; + } + + if (D_800AC88C->unk_08 & 0x400) { + D_800AC888 = 0xA; + return 0x400; + } + + if (D_800AC88C->unk_08 & 0x200) { + D_800AC888 = 0xA; + return 0x200; + } + + if (D_800AC88C->unk_08 & 0x100) { + D_800AC888 = 0xA; + return 0x100; + } + + D_800AC888--; + if (D_800AC888 <= 0) { + D_800AC888 = 0; + + // clang-format off + if (D_800AC88C->unk_06 & 0x800) { + D_800AC888 = 2; return 0x800; + } + // clang-format on + + if (D_800AC88C->unk_06 & 0x400) { + D_800AC888 = 2; + return 0x400; + } + + if (D_800AC88C->unk_06 & 0x200) { + D_800AC888 = 2; + return 0x200; + } + + if (D_800AC88C->unk_06 & 0x100) { + D_800AC888 = 2; + return 0x100; + } + } + + return 0; +} diff --git a/src/20330.h b/src/20330.h index 34970f4b..b05274ce 100644 --- a/src/20330.h +++ b/src/20330.h @@ -5,7 +5,7 @@ void func_8001F730(void); void func_8001F738(unk_D_80068BA0*); -void func_8001F750(void); +s32 func_8001F750(void); #endif // _20330_H_ diff --git a/src/22630.h b/src/22630.h index d17ceefe..b86b2e7d 100644 --- a/src/22630.h +++ b/src/22630.h @@ -3,7 +3,33 @@ #include "global.h" +typedef struct unk_func_80026268_arg0 { + /* 0x00 */ char unk00[0x4]; + /* 0x04 */ u8 unk_04; + /* 0x05 */ char unk05[0x1F]; + /* 0x24 */ u8 unk_24; + /* 0x25 */ u8 unk_25; + /* 0x26 */ char unk26[0xA]; + /* 0x30 */ u8 unk_30[11]; + /* 0x3B */ u8 unk_3B[11]; + /* 0x46 */ u8 unk_46[11]; + /* 0x51 */ char unk51[0x1]; + /* 0x52 */ u8 unk_52; + /* 0x52 */ u8 unk_53; +} unk_func_80026268_arg0; // size >= 0x54 + +typedef struct unk_D_800AE4E8_004_1_000_010 { + /* 0x00 */ char unk00[0x21]; + /* 0x21 */ u8 unk_21[11]; + /* 0x2C */ u8 unk_2C[11]; +} unk_D_800AE4E8_004_1_000_010; // size = 0x37 + +void func_80021B7C(u8*, u8*); +void func_80021C40(u8*, u8*); void func_80021CA4(char*, u8); +void func_80021D9C(unk_func_80026268_arg0*, unk_D_800AE4E8_004_1_000_010*); +void func_80021F04(unk_func_80026268_arg0*, unk_D_800AE4E8_004_1_000_010*); +void func_80022338(unk_func_80026268_arg0*); void func_80023068(void); s32 func_8002311C(s32); void func_80024040(s16); diff --git a/src/26820.c b/src/26820.c index 06c14873..d2ca34be 100644 --- a/src/26820.c +++ b/src/26820.c @@ -1,50 +1,653 @@ #include "26820.h" +#include "src/26820.h" +#include "src/22630.h" +#include "src/3FB0.h" +#include "src/memory.h" + +typedef struct unk_D_800AE4E8_004_1_000_000 { + /* 0x00 */ u8 unk_00; + /* 0x01 */ u8 unk_01; + /* 0x02 */ char unk02[0xC]; + /* 0x0E */ s16 unk_0E; +} unk_D_800AE4E8_004_1_000_000; // size >= 0x10 + +typedef struct unk_D_800AE4E8_004_1_000 { + /* 0x000 */ unk_D_800AE4E8_004_1_000_000 unk_000; + /* 0x010 */ unk_D_800AE4E8_004_1_000_010 unk_010[1]; + /* 0x047 */ char unk047[0x119]; +} unk_D_800AE4E8_004_1_000; // size = 0x160 + +typedef struct unk_D_800AE4E8_004_1 { + /* 0x0000 */ unk_D_800AE4E8_004_1_000 unk_0000[4][10]; +} unk_D_800AE4E8_004_1; // size = 0x3700 + +typedef struct unk_D_800AE4E8_004_2_1EA0 { + /* 0x00 */ u8 unk_00; + /* 0x02 */ u16 unk_02; + /* 0x04 */ unk_func_8002A728 unk_04; + /* 0x0C */ unk_func_80027FA0 unk_0C[1]; + /* 0x14 */ char unk14[0xA]; + /* 0x1E */ u8 unk_1E; + /* 0x1F */ char unk1F[0x9]; +} unk_D_800AE4E8_004_2_1EA0; // size = 0x28 + +typedef struct unk_D_800AE4E8_004_2_0DC0_002 { + /* 0x00 */ char unk00[0x18]; + /* 0x18 */ u16 unk_18; +} unk_D_800AE4E8_004_2_0DC0_002; // size = 0x1A + +typedef struct unk_D_800AE4E8_004_2_0DC0 { + /* 0x000 */ u8 unk_000; + /* 0x001 */ char unk001[0x1]; + /* 0x002 */ unk_D_800AE4E8_004_2_0DC0_002 unk_002[1]; + /* 0x01C */ char unk01C[0xF44]; +} unk_D_800AE4E8_004_2_0DC0; // size = 0xF60 + +typedef struct unk_D_800AE4E8_004_2_1D20 { + /* 0x000 */ u8 unk_000; + /* 0x001 */ char unk001[0x17F]; +} unk_D_800AE4E8_004_2_1D20; // size = 0x180 + +typedef struct unk_D_800AE4E8_004_2_1EC8_0002 { + /* 0x00 */ char unk00[0x8C]; +} unk_D_800AE4E8_004_2_1EC8_0002; // size = 0x8C + +typedef struct unk_D_800AE4E8_004_2_1EC8 { + /* 0x0000 */ u8 unk_0000; + /* 0x0001 */ char unk0001[0x1]; + /* 0x0002 */ unk_D_800AE4E8_004_2_1EC8_0002 unk_0002[1]; + /* 0x008E */ char unk008E[0x132A]; +} unk_D_800AE4E8_004_2_1EC8; // size = 0x13B8 + +typedef struct unk_D_800AE4E8_004_2_3280 { + /* 0x0000 */ u8 unk_0000; + /* 0x0001 */ char unk0001[0x1]; + /* 0x0002 */ unk_D_800AE4E8_004_2_1EC8_0002 unk_0002[1]; + /* 0x008E */ char unk008E[0xAF6]; +} unk_D_800AE4E8_004_2_3280; // size = 0xB84 + +typedef struct unk_D_800AE4E8_004_2 { + /* 0x0000 */ char unk0000[0xDC0]; + /* 0x0DC0 */ unk_D_800AE4E8_004_2_0DC0 unk_0DC0; + /* 0x1D20 */ unk_D_800AE4E8_004_2_1D20 unk_1D20; + /* 0x1EA0 */ unk_D_800AE4E8_004_2_1EA0 unk_1EA0; + /* 0x1EC8 */ unk_D_800AE4E8_004_2_1EC8 unk_1EC8; + /* 0x3280 */ unk_D_800AE4E8_004_2_3280 unk_3280; + /* 0x3E04 */ char unk3E04[0x17C]; +} unk_D_800AE4E8_004_2; // size = 0x3F80 + +typedef struct unk_D_800AE4E8_004_3_0000 { + /* 0x0000 */ unk_D_800AE4E8_004_1_000_000 unk_000; + /* 0x0010 */ unk_D_800AE4E8_004_1_000_010 unk_010[1]; + /* 0x0047 */ char unk010[0x421]; +} unk_D_800AE4E8_004_3_0000; // size = 0x468 + +typedef struct unk_D_800AE4E8_004_3_34E0_010 { + /* 0x00 */ u8 unk_00; + /* 0x01 */ u8 unk_01; +} unk_D_800AE4E8_004_3_34E0_010; // size = 0x2 + +typedef struct unk_D_800AE4E8_004_3_34E0 { + /* 0x0000 */ unk_D_800AE4E8_004_1_000_000 unk_00; + /* 0x0000 */ unk_D_800AE4E8_004_3_34E0_010 unk_10[1]; + /* 0x0012 */ char unk12[0xCE]; +} unk_D_800AE4E8_004_3_34E0; // size = 0xE0 + +typedef struct unk_D_800AE4E8_004_3 { + /* 0x0000 */ unk_D_800AE4E8_004_3_0000 unk_0000[12]; + /* 0x34E0 */ unk_D_800AE4E8_004_3_34E0 unk_34E0[4]; + /* 0x3860 */ char unk_3860[0x20]; +} unk_D_800AE4E8_004_3; // size = 0x3880 + +typedef union unk_D_800AE4E8_004 { + unk_D_800AE4E8_004_1* unk1; + unk_D_800AE4E8_004_2* unk2; + unk_D_800AE4E8_004_3* unk3; +} unk_D_800AE4E8_004; + +typedef struct unk_D_800AE4E8 { + /* 0x00 */ s32 unk_00; + /* 0x04 */ unk_D_800AE4E8_004 unk_04; + /* 0x08 */ unk_D_800AE4E8_004 unk_08; +} unk_D_800AE4E8; // size = 0xC + +extern u32 D_80073650[]; + +extern s16 D_800AE4E0; +extern unk_D_800AE4E8 D_800AE4E8[4]; + +void func_80025C20(UNUSED struct MainPoolBlock* arg0, u32 arg1) { + u32 bank_num = arg1 - 'BNK0'; + unk_D_800AE4E8* temp_v0 = &D_800AE4E8[bank_num]; + + if ((arg1 >= 'BNK0') && (arg1 < 'BNK4')) { + temp_v0->unk_00 &= ~3; + temp_v0->unk_04.unk1 = NULL; + temp_v0->unk_08.unk1 = NULL; + } +} + +u16 func_80025C80(u8* arg0, s32 arg1) { + u16 var_v1 = 0; + + while (arg1-- > 2) { + var_v1 += *arg0++; + } + return var_v1; +} + +s32 func_80025CBC(u8* arg0, s32 arg1) { + u16* temp_v1 = arg1 + arg0; + + temp_v1 -= 3; + + if (temp_v1[0] != 'PO') { + return 0; + } + + if (temp_v1[1] != 'KE') { + return 0; + } + + if (temp_v1[2] != func_80025C80(arg0, arg1)) { + return 0; + } + + return 1; +} + +void func_80025D30(u8* arg0, s32 arg1, s32 arg2) { + u16* temp_v1; + + if (arg2 != 0) { + temp_v1 = arg1 + arg0; + + temp_v1 -= 3; + *temp_v1++ = 'PO'; + *temp_v1++ = 'KE'; + *temp_v1++ = func_80025C80(arg0, arg1); + } else { + temp_v1 = arg1 + arg0; + temp_v1 -= 3; + + *temp_v1++ = 'XX'; + *temp_v1++ = 'XX'; + *temp_v1++ = func_80025C80(arg0, arg1) ^ 0xFF; + } +} + +void func_80025DA0(u8* arg0, u8* arg1, s32 arg2, s32 arg3) { + _bcopy(arg0, arg1, arg2); + D_800AE4E8[arg3].unk_00 |= 2; +} + +void func_80025DE4(u8* arg0, s32 arg1, s32 arg2) { + if (*arg0 & 2) { + *arg0 &= ~2; + func_80025D30(arg0, arg1, 1); + D_800AE4E8[arg2].unk_00 |= 2; + } +} + +void func_80025E44(u8* arg0, s32 arg1, s32 arg2) { + if (*arg0 & 2) { + func_80025D30(arg0, arg1, 0); + D_800AE4E8[arg2].unk_00 |= 2; + } +} + +void func_80025EA0(u8* arg0, s32 arg1, s32 arg2) { + u32 tmp = arg0 - (u8*)D_800AE4E8[arg2].unk_04.unk1; + + _bcopy(tmp + (u8*)D_800AE4E8[arg2].unk_08.unk1, arg0, arg1); +} + +void func_80025EF8(u8* arg0, s32 arg1, s32 arg2) { + bzero(arg0, arg1); + *arg0 |= 2; + D_800AE4E8[arg2].unk_00 |= 2; +} + +void func_80025F50(s32 arg0, s32 arg1) { + s32 sp34; + s32 sp30; + UNUSED s32 pad; + s32 idx2; + u8* sp24; + u8* sp20; + + switch (arg0) { + case 16: + sp30 = D_800AE4E0 / 4; + idx2 = D_800AE4E0 % 4; + sp34 = 0x160; + sp24 = (u8*)&D_800AE4E8[sp30].unk_04.unk1->unk_0000[idx2][arg1]; + sp20 = (u8*)&D_800AE4E8[sp30].unk_08.unk1->unk_0000[idx2][arg1]; + break; + + case 17: + sp30 = 3; + sp34 = 0x468; + sp24 = (u8*)&D_800AE4E8[3].unk_04.unk3->unk_0000[arg1]; + sp20 = (u8*)&D_800AE4E8[3].unk_08.unk3->unk_0000[arg1]; + break; + + case 18: + sp30 = 3; + sp34 = 0xE0; + sp24 = (u8*)&D_800AE4E8[3].unk_04.unk3->unk_34E0[arg1]; + sp20 = (u8*)&D_800AE4E8[3].unk_08.unk3->unk_34E0[arg1]; + break; + + case 19: + sp30 = 2; + sp34 = 0xF60; + sp24 = (u8*)&D_800AE4E8[2].unk_04.unk2->unk_0DC0; + sp20 = (u8*)&D_800AE4E8[2].unk_08.unk2->unk_0DC0; + break; + + case 20: + sp30 = 2; + sp34 = 0x28; + sp24 = (u8*)&D_800AE4E8[2].unk_04.unk2->unk_1EA0; + sp20 = (u8*)&D_800AE4E8[2].unk_08.unk2->unk_1EA0; + break; + + case 21: + sp30 = 2; + sp34 = 0x180; + sp24 = (u8*)&D_800AE4E8[2].unk_04.unk2->unk_1D20; + sp20 = (u8*)&D_800AE4E8[2].unk_08.unk2->unk_1D20; + break; + + case 22: + sp30 = 2; + sp34 = 0x13B8; + sp24 = (u8*)&D_800AE4E8[2].unk_04.unk2->unk_1EC8; + sp20 = (u8*)&D_800AE4E8[2].unk_08.unk2->unk_1EC8; + break; + + case 23: + sp30 = 2; + sp34 = 0xB84; + sp24 = (u8*)&D_800AE4E8[2].unk_04.unk2->unk_3280; + sp20 = (u8*)&D_800AE4E8[2].unk_08.unk2->unk_3280; + break; + } + + switch ((func_80025CBC(sp24, sp34) | func_80025CBC(sp20, sp34) << 1)) { + case 0: + func_8002707C(arg0, arg1); + break; + + case 1: + func_80025DA0(sp24, sp20, sp34, sp30); + break; + + case 2: + func_80025DA0(sp20, sp24, sp34, sp30); + break; + } +} + +void func_80026268(unk_func_80026268_arg0* arg0, unk_D_800AE4E8_004_1_000_010* arg1) { + func_80021D9C(arg0, arg1); + func_80022338(arg0); + + arg0->unk_52 = 0; + arg0->unk_53 = 0; + arg0->unk_25 = 0; + + _bcopy(arg1->unk_2C, arg0->unk_46, 0xB); + func_80021C40(arg0->unk_30, arg1->unk_21); + func_80021C40(arg0->unk_3B, arg1->unk_2C); +} + +void func_800262DC(unk_func_80026268_arg0* arg0, unk_D_800AE4E8_004_1_000_010* arg1) { + arg0->unk_04 = arg0->unk_24; + + func_80021F04(arg0, arg1); + func_80021B7C(arg1->unk_21, arg0->unk_30); + + _bcopy(arg0->unk_46, arg1->unk_2C, 0xB); +} + +s32 func_80026338(s32 arg0, s32 arg1, s16 arg2) { + s32 var_v1 = 0; + s16 idx1 = D_800AE4E0 / 4; + s16 idx2 = D_800AE4E0 % 4; + + switch (arg0) { + case 16: + var_v1 = (D_800AE4E8[idx1].unk_04.unk1->unk_0000[idx2][arg1].unk_000.unk_00 & arg2) != 0; + break; + + case 17: + var_v1 = (D_800AE4E8[3].unk_04.unk3->unk_0000[arg1].unk_000.unk_00 & arg2) != 0; + break; + + case 18: + var_v1 = (D_800AE4E8[3].unk_04.unk3->unk_34E0[arg1].unk_00.unk_00 & arg2) != 0; + break; + + case 19: + var_v1 = (D_800AE4E8[2].unk_04.unk2->unk_0DC0.unk_000 & arg2) != 0; + break; + + case 20: + var_v1 = (D_800AE4E8[2].unk_04.unk2->unk_1EA0.unk_00 & arg2) != 0; + break; + + case 21: + var_v1 = (D_800AE4E8[2].unk_04.unk2->unk_1D20.unk_000 & arg2) != 0; + break; + + case 22: + var_v1 = (D_800AE4E8[2].unk_04.unk2->unk_1EC8.unk_0000 & arg2) != 0; + break; + + case 23: + var_v1 = (D_800AE4E8[2].unk_04.unk2->unk_3280.unk_0000 & arg2) != 0; + break; + } + + return var_v1; +} + +void func_800264DC(s32 arg0, s32 arg1, s16 arg2) { + s16 idx1 = D_800AE4E0 / 4; + s16 idx2 = D_800AE4E0 % 4; + + switch (arg0) { + case 16: + D_800AE4E8[idx1].unk_04.unk1->unk_0000[idx2][arg1].unk_000.unk_00 |= arg2; + break; + + case 17: + D_800AE4E8[3].unk_04.unk3->unk_0000[arg1].unk_000.unk_00 |= arg2; + break; + + case 18: + D_800AE4E8[3].unk_04.unk3->unk_34E0[arg1].unk_00.unk_00 |= arg2; + break; + + case 19: + D_800AE4E8[2].unk_04.unk2->unk_0DC0.unk_000 |= arg2; + break; + + case 20: + D_800AE4E8[2].unk_04.unk2->unk_1EA0.unk_00 |= arg2; + break; + + case 21: + D_800AE4E8[2].unk_04.unk2->unk_1D20.unk_000 |= arg2; + break; + + case 22: + D_800AE4E8[2].unk_04.unk2->unk_1EC8.unk_0000 |= arg2; + break; + + case 23: + D_800AE4E8[2].unk_04.unk2->unk_3280.unk_0000 |= arg2; + break; + } +} + +void func_8002667C(void) { +} + +void func_80026684(s32 arg0, s32 arg1) { + s16 idx1 = D_800AE4E0 / 4; + s16 idx2 = D_800AE4E0 % 4; + + switch (arg0) { + case 16: + func_80025DE4((u8*)&D_800AE4E8[idx1].unk_04.unk1->unk_0000[idx2][arg1], 0x160, idx1); + break; + + case 17: + func_80025DE4((u8*)&D_800AE4E8[3].unk_04.unk3->unk_0000[arg1], 0x468, 3); + break; + + case 18: + func_80025DE4((u8*)&D_800AE4E8[3].unk_04.unk3->unk_34E0[arg1], 0xE0, 3); + break; + + case 19: + func_80025DE4((u8*)&D_800AE4E8[2].unk_04.unk2->unk_0DC0, 0xF60, 2); + break; + + case 20: + func_80025DE4((u8*)&D_800AE4E8[2].unk_04.unk2->unk_1EA0, 0x28, 2); + break; + + case 21: + func_80025DE4((u8*)&D_800AE4E8[2].unk_04.unk2->unk_1D20, 0x180, 2); + break; + + case 22: + func_80025DE4((u8*)&D_800AE4E8[2].unk_04.unk2->unk_1EC8, 0x13B8, 2); + break; + + case 23: + func_80025DE4((u8*)&D_800AE4E8[2].unk_04.unk2->unk_3280, 0xB84, 2); + break; + } +} + +void func_8002685C(s32 arg0, s32 arg1) { + s16 idx1 = D_800AE4E0 / 4; + s16 idx2 = D_800AE4E0 % 4; + + switch (arg0) { + case 16: + func_80025E44((u8*)&D_800AE4E8[idx1].unk_04.unk1->unk_0000[idx2][arg1], 0x160, idx1); + break; + + case 17: + func_80025E44((u8*)&D_800AE4E8[3].unk_04.unk3->unk_0000[arg1], 0x468, 3); + break; + + case 18: + func_80025E44((u8*)&D_800AE4E8[3].unk_04.unk3->unk_34E0[arg1], 0xE0, 3); + break; + + case 19: + func_80025E44((u8*)&D_800AE4E8[2].unk_04.unk2->unk_0DC0, 0xF60, 2); + break; + + case 20: + func_80025E44((u8*)&D_800AE4E8[2].unk_04.unk2->unk_1EA0, 0x28, 2); + break; + + case 21: + func_80025E44((u8*)&D_800AE4E8[2].unk_04.unk2->unk_1D20, 0x180, 2); + break; + + case 22: + func_80025E44((u8*)&D_800AE4E8[2].unk_04.unk2->unk_1EC8, 0x13B8, 2); + break; + + case 23: + func_80025E44((u8*)&D_800AE4E8[2].unk_04.unk2->unk_3280, 0xB84, 2); + break; + } +} + +void func_80026A34(s32 arg0, s32 arg1) { + s16 idx1 = D_800AE4E0 / 4; + s16 idx2 = D_800AE4E0 % 4; + + switch (arg0) { + case 16: + func_80025EA0((u8*)&D_800AE4E8[idx1].unk_04.unk1->unk_0000[idx2][arg1], 0x160, idx1); + break; + + case 17: + func_80025EA0((u8*)&D_800AE4E8[3].unk_04.unk3->unk_0000[arg1], 0x468, 3); + break; + + case 18: + func_80025EA0((u8*)&D_800AE4E8[3].unk_04.unk3->unk_34E0[arg1], 0xE0, 3); + break; + + case 19: + func_80025EA0((u8*)&D_800AE4E8[2].unk_04.unk2->unk_0DC0, 0xF60, 2); + break; + + case 20: + func_80025EA0((u8*)&D_800AE4E8[2].unk_04.unk2->unk_1EA0, 0x28, 2); + break; + + case 21: + func_80025EA0((u8*)&D_800AE4E8[2].unk_04.unk2->unk_1D20, 0x180, 2); + break; + + case 22: + func_80025EA0((u8*)&D_800AE4E8[2].unk_04.unk2->unk_1EC8, 0x13B8, 2); + break; + + case 23: + func_80025EA0((u8*)&D_800AE4E8[2].unk_04.unk2->unk_3280, 0xB84, 2); + break; + } +} + +void func_80026C0C(s32 arg0, s32 arg1) { + UNUSED s32 pad; + unk_D_800AE4E8_004_1_000* sp38; + unk_D_800AE4E8_004_3_0000* sp34; + unk_D_800AE4E8_004_3_34E0* sp30; + unk_D_800AE4E8_004_2_0DC0* sp2C; + unk_D_800AE4E8_004_2_1EA0* sp28; + unk_D_800AE4E8_004_2_1D20* sp24; + unk_D_800AE4E8_004_2_1EC8* sp20; + unk_D_800AE4E8_004_2_3280* sp1C; + s16 idx1 = D_800AE4E0 / 4; + s16 idx2 = D_800AE4E0 % 4; + + switch (arg0) { + case 16: + sp38 = &D_800AE4E8[idx1].unk_04.unk1->unk_0000[idx2][arg1]; + func_80025EF8(sp38, 0x160, idx1); + sp38->unk_000.unk_01 = 0x50; + break; + + case 17: + sp34 = &D_800AE4E8[3].unk_04.unk3->unk_0000[arg1]; + func_80025EF8(sp34, 0x468, 3); + sp34->unk_000.unk_01 = 0x50; + break; + + case 18: + sp30 = &D_800AE4E8[3].unk_04.unk3->unk_34E0[arg1]; + func_80025EF8(sp30, 0xE0, 3); + sp30->unk_00.unk_01 = 0x50; + break; + + case 19: + sp2C = &D_800AE4E8[2].unk_04.unk2->unk_0DC0; + func_80025EF8(sp2C, 0xF60, 2); + sp2C->unk_000 |= 1; + break; + + case 20: + sp28 = &D_800AE4E8[2].unk_04.unk2->unk_1EA0; + func_80025EF8(sp28, 0x28, 2); + sp28->unk_00 |= 1; + break; + + case 21: + sp24 = &D_800AE4E8[2].unk_04.unk2->unk_1D20; + func_80025EF8(sp24, 0x180, 2); + break; + + case 22: + sp20 = &D_800AE4E8[2].unk_04.unk2->unk_1EC8; + func_80025EF8(sp20, 0x13B8, 2); + sp20->unk_0000 |= 1; + break; + + case 23: + sp1C = &D_800AE4E8[2].unk_04.unk2->unk_3280; + func_80025EF8(sp1C, 0xB84, 2); + sp1C->unk_0000 |= 1; + break; + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_80025C20.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_80025C80.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_80025CBC.s") +#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_80026E4C.s") -#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_80025D30.s") +#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_80027038.s") -#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_80025DA0.s") +void func_8002707C(s32 arg0, s32 arg1) { + func_80026C0C(arg0, arg1); + func_80026684(arg0, arg1); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_80025DE4.s") +s32 func_800270AC(s32 arg0) { + s32 var_v1 = 0; -#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_80025E44.s") + switch (arg0) { + case 16: + var_v1 = 6; + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_80025EA0.s") + case 17: + var_v1 = 0x14; + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_80025EF8.s") + case 18: + var_v1 = 0x64; + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_80025F50.s") + case 19: + var_v1 = 0x97; + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_80026268.s") + case 22: + var_v1 = 0x24; + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_800262DC.s") + case 23: + var_v1 = 0x15; + break; + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_80026338.s") + return var_v1; +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_800264DC.s") +s32 func_80027108(s32 arg0) { + s32 var_v1 = 0; -#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_80026684.s") + switch (arg0) { + case 16: + var_v1 = 0x54; + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_8002685C.s") + case 17: + var_v1 = 0x54; + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_80026A34.s") + case 18: + var_v1 = 2; + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_80026C0C.s") + case 19: + var_v1 = 0x1A; + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_80026E4C.s") + case 22: + var_v1 = 0x8C; + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_80027038.s") + case 23: + var_v1 = 0x8C; + break; + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_8002707C.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_800270AC.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_80027108.s") + return var_v1; +} #pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_80027164.s") @@ -56,31 +659,156 @@ #pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_80027430.s") -#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_800275E0.s") +s16 func_800275E0(s32 arg0, s32 arg1) { + s16 var_v1 = 0; + s32 idx1 = D_800AE4E0 / 4; + s32 idx2 = D_800AE4E0 % 4; -#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_800276F0.s") + switch (arg0) { + case 16: + var_v1 = D_800AE4E8[idx1].unk_04.unk1->unk_0000[idx2][arg1].unk_000.unk_0E; + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_8002782C.s") + case 17: + var_v1 = D_800AE4E8[3].unk_04.unk3->unk_0000[arg1].unk_000.unk_0E; + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_8002797C.s") + case 18: + var_v1 = D_800AE4E8[3].unk_04.unk3->unk_34E0[arg1].unk_00.unk_0E; + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_80027C24.s") + case 19: + var_v1 = 0x97; + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_80027F24.s") + case 22: + var_v1 = 0x24; + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_80027F40.s") + case 23: + var_v1 = 0x15; + break; + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_80027FA0.s") + return var_v1; +} + +#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_800276F0.s") + +#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_8002782C.s") + +s32 func_8002797C(s32 arg0, s32 arg1, s32 arg2, void* arg3) { + s32 sp2C = 0; + s32 idx1 = D_800AE4E0 / 4; + s32 idx2 = D_800AE4E0 % 4; + + if (arg2 < func_800275E0(arg0, arg1)) { + switch (arg0) { + case 16: + func_80026268(arg3, &D_800AE4E8[idx1].unk_04.unk1->unk_0000[idx2][arg1].unk_010[arg2]); + break; + + case 17: + func_80026268(arg3, &D_800AE4E8[3].unk_04.unk3->unk_0000[arg1].unk_010[arg2]); + break; + + case 18: + *(unk_D_800AE4E8_004_3_34E0_010*)arg3 = D_800AE4E8[3].unk_04.unk3->unk_34E0[arg1].unk_10[arg2]; + break; + + case 19: + *(unk_D_800AE4E8_004_2_0DC0_002*)arg3 = D_800AE4E8[2].unk_04.unk2->unk_0DC0.unk_002[arg2]; + break; + + case 22: + _bcopy(&D_800AE4E8[2].unk_04.unk2->unk_1EC8.unk_0002[arg2], arg3, 0x8C); + break; + + case 23: + _bcopy(&D_800AE4E8[2].unk_04.unk2->unk_3280.unk_0002[arg2], arg3, 0x8C); + break; + } + sp2C = 1; + } + + return sp2C; +} + +void func_8002782C(s32, s32); + +s32 func_80027C24(s32 arg0, s32 arg1, s32 arg2, void* arg3) { + s32 sp34 = 0; + s32 idx1 = D_800AE4E0 / 4; + s32 idx2 = D_800AE4E0 % 4; + s32 sp28 = func_800270AC(arg0); + s32 sp24 = func_800275E0(arg0, arg1); + + if ((arg2 < sp24) || ((arg2 == sp24) && (arg2 < sp28))) { + switch (arg0) { + case 16: + func_800262DC(arg3, &D_800AE4E8[idx1].unk_04.unk1->unk_0000[idx2][arg1].unk_010[arg2]); + break; + case 17: + func_800262DC(arg3, &D_800AE4E8[3].unk_04.unk3->unk_0000[arg1].unk_010[arg2]); + break; + case 18: + D_800AE4E8[3].unk_04.unk3->unk_34E0[arg1].unk_10[arg2] = *(unk_D_800AE4E8_004_3_34E0_010*)arg3; + break; + case 19: + D_800AE4E8[2].unk_04.unk2->unk_0DC0.unk_002[arg2] = *(unk_D_800AE4E8_004_2_0DC0_002*)arg3; + break; + case 22: + _bcopy(arg3, &D_800AE4E8[2].unk_04.unk2->unk_1EC8.unk_0002[arg2], 0x8C); + break; + case 23: + _bcopy(arg3, &D_800AE4E8[2].unk_04.unk2->unk_3280.unk_0002[arg2], 0x8C); + break; + } + + if (arg2 == sp24) { + func_8002782C(arg0, arg1); + } else { + func_800264DC(arg0, arg1, 2); + } + + sp34 = 1; + } + return sp34; +} + +void func_80027F24(unk_func_8002A728* arg0) { + *arg0 = D_800AE4E8[2].unk_04.unk2->unk_1EA0.unk_04; +} + +void func_80027F40(unk_func_8002A728* arg0) { + if (bcmp(arg0, &D_800AE4E8[2].unk_04.unk2->unk_1EA0.unk_04, 8) != 0) { + D_800AE4E8[2].unk_04.unk2->unk_1EA0.unk_04 = *arg0; + func_800264DC(0x14, 0, 2); + } +} + +void func_80027FA0(unk_func_80027FA0* arg0, s16 arg1) { + *arg0 = D_800AE4E8[2].unk_04.unk2->unk_1EA0.unk_0C[arg1]; +} #pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_80027FE0.s") -#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_80028070.s") +void func_80028070(u16* arg0) { + *arg0 = D_800AE4E8[2].unk_04.unk2->unk_1EA0.unk_02; +} #pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_80028084.s") #pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_800280C4.s") -#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_800280D4.s") +void func_800280D4(u8 arg0) { + unk_D_800AE4E8_004_2* temp_v0 = D_800AE4E8[2].unk_04.unk2; + + if (temp_v0->unk_1EA0.unk_1E != arg0) { + temp_v0->unk_1EA0.unk_1E = arg0; + func_800264DC(0x14, 0, 2); + } +} #pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_80028118.s") @@ -96,21 +824,175 @@ #pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_8002847C.s") -#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_800284B4.s") +s32 func_800284B4(s16 arg0) { + s32 sp38; + s32 var_s0; + s16 temp_s5; + + temp_s5 = D_80073650[arg0] >> 7; + + if ((D_800AE4E8[arg0].unk_00 & 1) && (D_800AE4E8[arg0].unk_00 & 2)) { + _bcopy(D_800AE4E8[arg0].unk_04.unk1, D_800AE4E8[arg0].unk_08.unk1, D_80073650[arg0]); + var_s0 = 0; + while (func_80003B04(arg0) == -1) { + var_s0++; + if (var_s0 == 4) { + return -1; + } + } + + var_s0 = 0; + sp38 = arg0 << 7; + while (func_80003A14((u8*)D_800AE4E8[arg0].unk_04.unk1, sp38, temp_s5, 1) == -1) { + var_s0++; + if (var_s0 == 4) { + return -1; + } + } + + var_s0 = 0; + while (func_80003B04(arg0 + 4) == -1) { + var_s0 += 1; + if (var_s0 == 4) { + return -1; + } + } + + sp38 = arg0 << 7; + sp38 += 0x200; + var_s0 = 0; + while (func_80003A14((u8*)D_800AE4E8[arg0].unk_08.unk1, sp38, temp_s5, 1) == -1) { + var_s0++; + if (var_s0 == 4) { + return 0; + } + } + + D_800AE4E8[arg0].unk_00 &= ~2; + } + + return 0; +} #pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_800286D8.s") -#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_8002873C.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_80028840.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_800288F4.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_800289AC.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_80028A74.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_80028AFC.s") +s32 func_8002873C(s16 arg0, u32 arg1) { + s32 sp2C = 0; + u8* sp28; + + if (D_800AE4E8[arg0].unk_04.unk1 == NULL) { + sp28 = main_pool_alloc_with_func(arg1 * 2, 0, 'BNK0' + arg0, func_80025C20); + if (sp28 != NULL) { + bzero(sp28, arg1 * 2); + D_800AE4E8[arg0].unk_04.unk1 = sp28; + D_800AE4E8[arg0].unk_08.unk1 = sp28 + arg1; + func_80003A14(sp28, arg0 << 7, arg1 >> 7, 0); + func_80003A14(D_800AE4E8[arg0].unk_08.unk1, (arg0 << 7) + 0x200, arg1 >> 7, 0); + sp2C = 1; + } + } + + return sp2C; +} + +void func_80028840(void) { + s32 j; + s32 sp28; + + if (func_8002873C(0, 0x3700) != 0) { + sp28 = D_800AE4E0; + + for (D_800AE4E0 = 0; D_800AE4E0 < 4; D_800AE4E0++) { + for (j = 0; j < 10; j++) { + func_80025F50(0x10, j); + } + } + + D_800AE4E8->unk_00 |= 1; + D_800AE4E0 = sp28; + } +} + +void func_800288F4(void) { + s32 i; + s32 sp28; + + if (func_8002873C(1, 0x3700) != 0) { + sp28 = D_800AE4E0; + D_800AE4E0 = 4; + while (D_800AE4E0 < 8) { + for (i = 0; i < 10; i++) { + func_80025F50(16, i); + } + D_800AE4E0++; + } + D_800AE4E8[1].unk_00 |= 1; + D_800AE4E0 = sp28; + } +} + +void func_800289AC(void) { + s32 i; + s32 sp20; + + if (func_8002873C(2, 0x3F80) != 0) { + sp20 = D_800AE4E0; + D_800AE4E0 = 8; + + for (i = 0; i < 10; i++) { + func_80025F50(16, i); + } + + func_80025F50(19, 0); + func_80025F50(20, 0); + func_80025F50(21, 0); + func_80025F50(22, 0); + func_80025F50(23, 0); + + D_800AE4E8[2].unk_00 |= 1; + D_800AE4E0 = sp20; + } +} + +void func_80028A74(void) { + s32 i; + + if (func_8002873C(3, 0x3880) != 0) { + for (i = 0; i < 12; i++) { + func_80025F50(17, i); + } + + for (i = 0; i < 4; i++) { + func_80025F50(18, i); + } + + D_800AE4E8[3].unk_00 |= 1; + } +} + +s32 func_80028AFC(s16 arg0) { + if (!((D_800AE4E8[arg0].unk_00 & 1) != 0)) { + switch (arg0) { + case 0: + func_80028840(); + break; + + case 1: + func_800288F4(); + break; + + case 2: + func_800289AC(); + break; + + case 3: + func_80028A74(); + break; + } + } + + return (D_800AE4E8[arg0].unk_00 & 1) != 0; +} #pragma GLOBAL_ASM("asm/us/nonmatchings/26820/func_80028BE4.s") diff --git a/src/26820.h b/src/26820.h index 48dadca6..da4a16d1 100644 --- a/src/26820.h +++ b/src/26820.h @@ -15,12 +15,13 @@ typedef struct unk_func_80027FA0 { } unk_func_80027FA0; // size = 0x8 void func_80026684(s32, s32); +void func_8002707C(s32 arg0, s32 arg1); void func_80027F24(unk_func_8002A728*); void func_80027F40(unk_func_8002A728*); -void func_80027FA0(unk_func_80027FA0*, s32); +void func_80027FA0(unk_func_80027FA0*, s16); void func_80028070(u16*); -void func_800280D4(s32); -void func_800284B4(s32); -void func_80028AFC(s32); +void func_800280D4(u8); +s32 func_800284B4(s16); +s32 func_80028AFC(s16); #endif // _26820_H_ diff --git a/src/30640.c b/src/30640.c index 30e2e4ef..636a3962 100644 --- a/src/30640.c +++ b/src/30640.c @@ -1,6 +1,187 @@ #include "30640.h" - -#pragma GLOBAL_ASM("asm/us/nonmatchings/30640/func_8002FA40.s") +#include "include/libc/math.h" +#include "src/11BA0.h" +#include "src/12D80.h" +#include "src/17300.h" +#include "src/18140.h" +#include "src/18480.h" +#include "src/19840.h" +#include "src/1C720.h" +#include "src/1CF30.h" +#include "src/29BA0.h" +#include "src/3FB0.h" +#include "src/4BDC0.h" +#include "src/6BC0.h" +#include "src/E890.h" +#include "src/math_util.h" +#include "src/memory.h" +#include "src/fragments/43/fragment43.h" +#include "src/util.h" + +extern u32 D_83407B30; + +void func_8002FA40(void) { + s32 var_s6; + u32* temp_s0; + u32 var_s0; + u32 var_s2; + u32 sp64; + u32 var_s5; + u32 sp5C; + s32 var_v0; + u32* val; + + val = &D_83407B30; + var_s2 = 0; + var_s5 = 0; + + main_pool_push_state('SNPM'); + func_8004B1CC(0x4B); + + FRAGMENT_LOAD(func_80004454, fragment43)(); + FRAGMENT_LOAD(func_80004454, fragment34); + + do { + temp_s0 = Util_ConvertAddrToVirtAddr(val); + var_s6 = 1; + + main_pool_push_state('galy'); + + switch (var_s5) { + case 0: + var_v0 = 0; + if (*temp_s0 != 0) { + var_s0 = 1; + } else { + + switch (var_s2) { + case 4: + var_s0 = 2; + break; + + default: + var_s0 = 0; + if (var_s2 == 7) { + var_v0 = 1; + } + break; + } + } + sp64 = FRAGMENT_LOAD_AND_CALL(fragment42, var_s0, var_v0); + break; + + case 1: + case 6: + FRAGMENT_LOAD(func_80004454, fragment2)(); + ASSET_LOAD(D_3000000, _675FA0, 0); + FRAGMENT_LOAD(func_80004454, fragment3); + FRAGMENT_LOAD(func_80004454, fragment31); + + if (var_s5 == 1) { + var_s0 = 0; + } else { + var_s0 = 1; + } + + switch (FRAGMENT_LOAD_AND_CALL(fragment15, var_s0, 0)) { + case 1: + sp64 = 5; + break; + + case 2: + if (var_s0 == 1) { + sp64 = 5; + } else { + sp64 = 2; + } + break; + + default: + sp64 = 5; + break; + } + break; + + case 2: + if (var_s2 == 4) { + var_s0 = 0; + } else { + var_s0 = 1; + } + sp64 = FRAGMENT_LOAD_AND_CALL(fragment45, var_s0, 0); + break; + + case 3: + var_v0 = 1; + switch (var_s2) { + case 4: + var_s0 = sp5C; + var_v0 = 0; + break; + + case 2: + var_s0 = 1; + break; + + default: + if (*temp_s0 != 0) { + var_s0 = 2; + } else { + var_s0 = 0; + } + break; + } + + sp64 = FRAGMENT_LOAD_AND_CALL(fragment44, var_s0, var_v0); + if (sp64 == 4) { + sp5C = var_s0; + } + break; + + case 4: + FRAGMENT_LOAD_AND_CALL(fragment46, 0, 0); + sp64 = var_s2; + break; + + case 5: + FRAGMENT_LOAD(func_80004454, fragment61); + switch (var_s2) { + case 1: + var_s0 = 1; + break; + + case 6: + var_s0 = 2; + break; + + default: + var_s0 = 0; + break; + } + sp64 = FRAGMENT_LOAD_AND_CALL(fragment47, var_s0, 0); + break; + + case 7: + FRAGMENT_LOAD_AND_CALL(fragment49, 0, 0); + sp64 = 0; + break; + + default: + var_s6 = 0; + break; + } + + var_s2 = var_s5; + var_s5 = sp64; + + main_pool_pop_state('galy'); + + } while (var_s6 != 0); + + ((ret_func_80004454)Util_ConvertAddrToVirtAddr(func_8340051C))(); + + main_pool_pop_state('SNPM'); +} #pragma GLOBAL_ASM("asm/us/nonmatchings/30640/func_8002FF00.s") @@ -60,7 +241,12 @@ #pragma GLOBAL_ASM("asm/us/nonmatchings/30640/func_80031910.s") -#pragma GLOBAL_ASM("asm/us/nonmatchings/30640/func_80031A6C.s") +f32 func_80031A6C(f32 arg0) { + if (arg0 < 0.0) { + arg0 = -arg0; + } + return arg0; +} #pragma GLOBAL_ASM("asm/us/nonmatchings/30640/func_80031A94.s") @@ -74,6 +260,56 @@ #pragma GLOBAL_ASM("asm/us/nonmatchings/30640/func_80031DF8.s") -#pragma GLOBAL_ASM("asm/us/nonmatchings/30640/func_80031EF4.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/30640/func_80032034.s") +void func_80031EF4(MtxF* arg0, MtxF* arg1) { + f32 sp24 = sqrtf(SQ(arg1->mf[0][0]) + SQ(arg1->mf[0][1]) + SQ(arg1->mf[0][2])); + f32 sp20 = sqrtf(SQ(arg1->mf[1][0]) + SQ(arg1->mf[1][1]) + SQ(arg1->mf[1][2])); + f32 sp1C = sqrtf(SQ(arg1->mf[2][0]) + SQ(arg1->mf[2][1]) + SQ(arg1->mf[2][2])); + + arg0->mf[0][0] = arg1->mf[0][0] * sp24; + arg0->mf[0][1] = arg1->mf[1][0] * sp24; + arg0->mf[0][2] = arg1->mf[2][0] * sp24; + arg0->mf[0][3] = 0.0f; + + arg0->mf[1][0] = arg1->mf[0][1] * sp20; + arg0->mf[1][1] = arg1->mf[1][1] * sp20; + arg0->mf[1][2] = arg1->mf[2][1] * sp20; + arg0->mf[1][3] = 0.0f; + + arg0->mf[2][0] = arg1->mf[0][2] * sp1C; + arg0->mf[2][1] = arg1->mf[1][2] * sp1C; + arg0->mf[2][2] = arg1->mf[2][2] * sp1C; + arg0->mf[2][3] = 0.0f; + + arg0->mf[3][0] = 0.0f; + arg0->mf[3][1] = 0.0f; + arg0->mf[3][2] = 0.0f; + arg0->mf[3][3] = 1.0f; +} + +void func_80032034(MtxF* arg0, Vec3f* arg1) { + f32 temp_fa1; + f32 temp_fv0; + f32 temp_fv1; + f32 sp30; + f32 sp2C; + f32 sp28; + f32 sp24; + f32 sp20; + f32 sp1C; + + temp_fv0 = arg0->mf[0][0]; + temp_fv1 = arg0->mf[0][1]; + temp_fa1 = arg0->mf[0][2]; + + sp30 = arg0->mf[1][0]; + sp2C = arg0->mf[1][1]; + sp28 = arg0->mf[1][2]; + + sp24 = arg0->mf[2][0]; + sp20 = arg0->mf[2][1]; + sp1C = arg0->mf[2][2]; + + arg1->x = sqrtf(SQ(temp_fv0) + SQ(temp_fv1) + SQ(temp_fa1)); + arg1->y = sqrtf(SQ(sp30) + SQ(sp2C) + SQ(sp28)); + arg1->z = sqrtf(SQ(sp24) + SQ(sp20) + SQ(sp1C)); +} diff --git a/src/30640.h b/src/30640.h index 820788e3..a546fc8d 100644 --- a/src/30640.h +++ b/src/30640.h @@ -5,6 +5,7 @@ void func_8002FA40(void); f32 func_80031A6C(f32); -void func_80031EF4(f32[4][4], Vec3f*); +void func_80031EF4(MtxF*, MtxF*); +void func_80032034(MtxF* arg0, Vec3f* arg1); #endif // _30640_H_ diff --git a/src/38BB0.h b/src/38BB0.h index a892bc00..0cb2fd71 100644 --- a/src/38BB0.h +++ b/src/38BB0.h @@ -6,6 +6,7 @@ void func_80038E98(s32, s32); s32 func_80038F30(s32, s32); s32 func_80039024(s32, s32, s32, s32, u32, s32); +void func_8003916C(s32, s32); void func_800392A8(s32, s32); s32 func_80039354(s32); void func_800393DC(s32, s32); diff --git a/src/3FB0.c b/src/3FB0.c index e30609e3..5dfde982 100644 --- a/src/3FB0.c +++ b/src/3FB0.c @@ -266,8 +266,8 @@ s32 func_80003A14(u8* arg0, s16 arg1, s16 arg2, s32 arg3) { return 0; } -void func_80003B04(s16 arg0) { - func_8000CDB8(arg0 << 7); +s32 func_80003B04(s16 arg0) { + return func_8000CDB8(arg0 << 7); } void func_80003B30(u8* arg0, u8* arg1, u8* arg2, s32 arg3) { @@ -526,7 +526,7 @@ void func_800043BC(s32 arg0, Fragment* addr) { } } -void* func_80004454(s32 arg0, u8* romStart, u8* romEnd) { +ret_func_80004454 func_80004454(s32 arg0, u8* romStart, u8* romEnd) { void* addr = func_80003DC4(romStart, romEnd, 0, 0); if (addr != NULL) { diff --git a/src/3FB0.h b/src/3FB0.h index 1ce71e02..bb90aa33 100644 --- a/src/3FB0.h +++ b/src/3FB0.h @@ -76,6 +76,8 @@ typedef struct unk_func_80003680_sp90 { /* 0x14 */ s32 unk_14; } unk_func_80003680_sp90; // size >= 0x18 +typedef void (*ret_func_80004454)(void); + s32 func_800033B0(u8* arg0); void func_800033C8(unk_func_80003680_sp300* arg0, u8* arg1); void func_80003558(UnkStruct80001380* arg0, unk_func_80003680_sp90* arg1); @@ -86,7 +88,7 @@ void func_80003860(void); void func_80003890(u8* in_header, u8* memory); void func_80003964(u8* arg0, s32 arg1, s32 arg2, s32 arg3); s32 func_80003A14(u8* arg0, s16 arg1, s16 arg2, s32 arg3); -void func_80003B04(s16 arg0); +s32 func_80003B04(s16 arg0); void func_80003B30(u8* arg0, u8* arg1, u8* arg2, s32 arg3); void func_80003BE0(u8* arg0, u8* arg1, u8* arg2); void* func_80003C80(u8* addr, PRESJPEG* arg1, s32 side); @@ -102,7 +104,7 @@ s32 func_80004258(s32 id, u8* rom_start, u8* rom_end, s32 arg3); struct MainPoolBlock* func_800042E0(s32 arg0, s32 arg1, s32 arg2, s32 arg3); void func_80004364(u32 base_addr, u32 addr); void func_800043BC(s32 arg0, Fragment* addr); -void* func_80004454(s32 arg0, u8* romStart, u8* romEnd); +ret_func_80004454 func_80004454(s32 arg0, u8* romStart, u8* romEnd); void* func_800044A8(s32 arg0, s32 arg1, s32 arg2); void* func_800044F4(u8* romStart, u8* romEnd, s32 arg2, s32 arg3); void* func_80004660(s32 arg0, s32 arg1, s32 arg2, s32 arg3); diff --git a/src/45720.c b/src/45720.c index 41f99108..2955c07d 100644 --- a/src/45720.c +++ b/src/45720.c @@ -1,14 +1,46 @@ #include "45720.h" -#pragma GLOBAL_ASM("asm/us/nonmatchings/45720/func_80044B20.s") +extern u8 D_800FCEF0[2]; +extern u32 D_800FCF00[2]; +extern s16 D_800FCF1C[2]; -#pragma GLOBAL_ASM("asm/us/nonmatchings/45720/func_80044CBC.s") +extern s8 D_800785F0; -#pragma GLOBAL_ASM("asm/us/nonmatchings/45720/func_80044D78.s") +#pragma GLOBAL_ASM("asm/us/nonmatchings/45720/func_80044B20.s") -#pragma GLOBAL_ASM("asm/us/nonmatchings/45720/func_80044E54.s") +#pragma GLOBAL_ASM("asm/us/nonmatchings/45720/func_80044CBC.s") -#pragma GLOBAL_ASM("asm/us/nonmatchings/45720/func_80044E80.s") +void func_80044D78(u32 arg0, u32 arg1) { + u32 temp_a0; + + if (arg0 < 2) { + if (arg1 != 0) { + D_800FCF1C[arg0] = (f32)D_800FCF00[arg0] / arg1; + } + temp_a0 = osSetIntMask(1); + if (arg1 != 0) { + D_800FCEF0[arg0] = 5; + } else { + D_800FCEF0[arg0] = 1; + } + osSetIntMask(temp_a0); + } +} + +s32 func_80044E54(s32 arg0) { + if (D_800FCEF0[arg0] == 2) { + return 0; + } + return 1; +} + +void func_80044E80(s32 arg0) { + if (arg0 != 0) { + D_800785F0 = 0; + } else { + D_800785F0 = 1; + } +} #pragma GLOBAL_ASM("asm/us/nonmatchings/45720/func_80044EA4.s") diff --git a/src/45720.h b/src/45720.h index 966f96b7..24a46971 100644 --- a/src/45720.h +++ b/src/45720.h @@ -3,7 +3,7 @@ #include "global.h" -void func_80044D78(s32, s32); +void func_80044D78(u32, u32); s32 func_80044E54(s32); void func_80044E80(s32); diff --git a/src/49790.c b/src/49790.c index 6e39ec65..480c2847 100644 --- a/src/49790.c +++ b/src/49790.c @@ -1,4 +1,196 @@ -#include "global.h" #include "49790.h" +#include "src/38BB0.h" +#include "src/49790.h" +#include "src/4CBC0.h" -#pragma GLOBAL_ASM("asm/us/nonmatchings/49790/func_80048B90.s") +static s32 D_80078A30 = 0; +static s32 D_80078A34 = 0; +static s32 D_80078A38 = 0; +static s32 D_80078A3C = 0; +static s32 D_80078A40 = 0; +static s32 D_80078A44 = 0; +static s32 D_80078A48 = 0; +static s32 D_80078A4C = 0; +static u8 D_80078A50 = 0; + +s32 func_80048B90(u32 arg0) { + u32 temp_v0_3; + s32 sp28; + f32 sp24; + + temp_v0_3 = arg0 & 0xFFFF0000; + sp28 = 0x80; + sp24 = 0.0f; + + if (temp_v0_3 == 0x01200000) { + return func_8004E304(arg0, 0, 0); + } + + if (temp_v0_3 == 0x01100000) { + return func_8004DF94(arg0, 0, 0); + } + + if (arg0 == 0xF) { + if (!(D_800FC820 & 0x80000000)) { + return 0; + } + D_80078A30 = func_80039024(D_800FF9C0, D_800FC688, 0xF, 0x70, 0x80, -1); + func_800392A8(D_80078E70, 0x28); + return D_80078A30; + } + + if (arg0 == 0x30) { + arg0 = 0x26; + } + + if (arg0 == 0x3C) { + if (D_80078A50 != 0) { + D_80078A50++; + if (D_80078A50 > 0) { + D_80078A50 = 0; + } + return 0; + } + D_80078A50++; + if (1) {} + arg0 = 5; + sp24 = -12.0f; + sp28 = 0x38; + } + + switch (arg0) { + case 0x1: + func_800392A8(D_80078A34, 1); + break; + + case 0x5: + case 0x6: + case 0x7: + case 0x9: + case 0xD: + case 0xE: + case 0x10: + case 0x11: + case 0x12: + case 0x13: + case 0x14: + case 0x15: + case 0x16: + case 0x17: + case 0x18: + case 0x19: + case 0x1A: + case 0x1B: + case 0x1C: + case 0x1D: + case 0x1E: + case 0x1F: + case 0x20: + case 0x21: + case 0x22: + case 0x23: + case 0x24: + case 0x25: + case 0x26: + case 0x27: + case 0x28: + case 0x29: + case 0x2F: + break; + + case 0x2: + func_800392A8(D_80078A3C, 1); + break; + + case 0x3: + func_800392A8(D_80078A38, 1); + break; + + case 0x4: + func_800392A8(D_80078A40, 0x14); + break; + + case 0x8: + func_800392A8(D_80078A44, 2); + break; + + case 0x2C: + func_800392A8(D_80078A48, 2); + sp28 = 0xA0; + break; + + case 0x2D: + func_800392A8(D_80078A48, 2); + break; + + case 0x2E: + func_800392A8(D_80078A4C, 2); + break; + + case 0xA: + sp28 = 0xE0; + break; + + case 0x31: + arg0 -= 1; + break; + + case 0xB: + case 0xC: + sp28 = 0xD0; + break; + + case 0x2A: + case 0x2B: + func_80048B90(0x1B); + break; + + case 0x32: + D_80078A30 = func_8004DDA4(0x01000001, 0, 0); + return D_80078A30; + + case 0x33: + D_80078A30 = func_8004DDA4(0x01000002, 0, 0); + return D_80078A30; + + default: + return 0; + } + + D_80078A30 = func_80039024(D_800FC68C, D_800FC688, arg0, sp28, 0x80, -1); + if (sp24 != 0.0f) { + func_80039534(D_80078A30, sp24); + } + + switch (arg0) { + case 1: + D_80078A34 = D_80078A30; + break; + + case 2: + D_80078A3C = D_80078A30; + break; + + case 3: + D_80078A38 = D_80078A30; + break; + + case 4: + D_80078A40 = D_80078A30; + break; + + case 8: + D_80078A44 = D_80078A30; + break; + + case 44: + D_80078A48 = D_80078A30; + break; + + case 45: + D_80078A4C = D_80078A30; + break; + } + + return D_80078A30; +} diff --git a/src/49790.h b/src/49790.h index 06181f3b..de7ad43e 100644 --- a/src/49790.h +++ b/src/49790.h @@ -3,7 +3,7 @@ #include "global.h" -s32 func_80048B90(s32); +s32 func_80048B90(u32); #endif // _49790_H_ diff --git a/src/50860.c b/src/50860.c index ef5f0f25..a10abc67 100644 --- a/src/50860.c +++ b/src/50860.c @@ -1,9 +1,36 @@ #include "50860.h" +#include "45720.h" +#include "38BB0.h" +#include "3D140.h" -#pragma GLOBAL_ASM("asm/us/nonmatchings/50860/func_8004FC60.s") +void func_8004FC60(s32 arg0, s32 arg1) { + s32 i; -#pragma GLOBAL_ASM("asm/us/nonmatchings/50860/func_8004FCD8.s") + if (arg0 & 4) { + for (i = 0; i < 2; i++) { + func_80044D78(i, arg1); + } + arg0 &= ~4; + } + func_8003916C(arg0, arg1); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/50860/func_8004FD44.s") +void func_8004FCD8(s32 arg0) { + s32 i; -#pragma GLOBAL_ASM("asm/us/nonmatchings/50860/func_8004FD64.s") + D_8007840C = 0; + func_8003DB84(0); + func_8004FC60(3, arg0); + + for (i = 0; i < 2; i++) { + func_80044D78(i, arg0); + } +} + +void func_8004FD44(void) { + func_8004FCD8(1); +} + +void func_8004FD64(s32 arg0) { + func_8004FCD8(arg0); +} diff --git a/src/D470.h b/src/D470.h index dcc1b1b3..82afb4cc 100644 --- a/src/D470.h +++ b/src/D470.h @@ -3,7 +3,7 @@ #include "global.h" -void func_8000CDB8(s32); +s32 func_8000CDB8(s32); s32 func_8000CFB0(s32); #endif // _D470_H_ diff --git a/src/fragments/43/fragment43.h b/src/fragments/43/fragment43.h new file mode 100644 index 00000000..ecad81bc --- /dev/null +++ b/src/fragments/43/fragment43.h @@ -0,0 +1,10 @@ +#ifndef _FRAGMENT43_H_ +#define _FRAGMENT43_H_ + +#include "global.h" + +void func_8340051C(void); + +#endif // _FRAGMENT43_H_ + + diff --git a/src/fragments/8/fragment8.c b/src/fragments/8/fragment8.c index 390a49f5..3a29492d 100644 --- a/src/fragments/8/fragment8.c +++ b/src/fragments/8/fragment8.c @@ -169,13 +169,13 @@ void func_86200020(unk_D_86203E50* arg0) { void func_86200034(void) { UNUSED s32 pad[3]; - f32 spDC[4][4]; + MtxF spDC; Mtx sp98; s32 i; UNUSED s32 pad2[1]; - func_80031EF4(spDC, &D_86203E3C->unk_064); - guMtxF2L(spDC, &sp98); + func_80031EF4(&spDC, &D_86203E3C->unk_064); + guMtxF2L(spDC.mf, &sp98); for (i = 0; i < 4; i++) { D_86204590 = &D_86203E50[i]; diff --git a/src/memory.h b/src/memory.h index 3d09ca2b..f2c4b397 100644 --- a/src/memory.h +++ b/src/memory.h @@ -7,6 +7,8 @@ #define MEMORY_POOL_LEFT 0 #define MEMORY_POOL_RIGHT 1 +typedef void (*AllocateFunc)(struct MainPoolBlock*, u32); + // structs for the main pool. typedef struct MainPoolState { /* 0x00 */ s32 freeSpace; @@ -18,7 +20,7 @@ typedef struct MainPoolState { struct MainPoolBlock { /* 0x00 */ struct MainPoolBlock *prev; /* 0x04 */ struct MainPoolBlock *next; - /* 0x08 */ void (*func)(struct MainPoolBlock *block, s32 arg); + /* 0x08 */ AllocateFunc func; /* 0x0C */ s32 arg; // passed into func as the 2nd argument. }; @@ -51,7 +53,7 @@ struct MemoryPool { void main_pool_init(void *start, void *end); void *main_pool_alloc_from_pool(u32 size, u32 side); u32 main_pool_free(void *addr, u32 runBlockFunc); -void *main_pool_alloc_with_func(u32 size, s32 side, s32 arg, void *func); +void *main_pool_alloc_with_func(u32 size, s32 side, s32 arg, AllocateFunc func); void *main_pool_alloc(u32 size, s32 side); u32 main_pool_try_free(void *addr); void *main_pool_realloc(void *addr, size_t size); @@ -59,7 +61,7 @@ u32 main_pool_get_available(void); u32 main_pool_push_state(u32 arg); u32 main_pool_pop_state(u32 arg); void *main_pool_search(uintptr_t addr, s32 *argPtr); -void main_pool_set_func(void *block, s32 arg, void *func); +void main_pool_set_func(void *block, s32 arg, AllocateFunc func); size_t main_pool_get_block_dist(struct MainPoolBlock *block); struct MainPool *main_pool_get_pool(void); diff --git a/src/memory_main.c b/src/memory_main.c index acd0c4df..29cf80ae 100644 --- a/src/memory_main.c +++ b/src/memory_main.c @@ -86,7 +86,7 @@ u32 main_pool_free(void* addr, u32 runBlockFunc) { block = (sMemPool.listHeadL = sMemPool.listHeadL->prev); if (runBlockFunc) { // TODO: Fakematch - void (*func)(struct MainPoolBlock*, u32) = block->func; + AllocateFunc func = block->func; if (func != 0) { block->func((u8*)block + sizeof(struct MainPoolBlock), block->arg); // TODO: fake here too @@ -101,7 +101,7 @@ u32 main_pool_free(void* addr, u32 runBlockFunc) { if (oldListHead >= block && oldListHead >= block) { do { if (runBlockFunc) { - void (*func)(struct MainPoolBlock*, u32) = block->func; + AllocateFunc func = block->func; if (func != NULL) { func((u8*)block + sizeof(struct MainPoolBlock), block->arg); block = sMemPool.listHeadR; @@ -122,7 +122,7 @@ u32 main_pool_free(void* addr, u32 runBlockFunc) { * Manually allocate and initialize a block given a size and side and its * function+arguments. */ -void* main_pool_alloc_with_func(u32 size, s32 side, s32 arg, void* func) { +void* main_pool_alloc_with_func(u32 size, s32 side, s32 arg, AllocateFunc func) { struct MainPoolBlock* addr; osRecvMesg(&sMemPool.queue, NULL, OS_MESG_BLOCK); @@ -182,7 +182,7 @@ void* main_pool_realloc(void* addr, size_t size) { // is there enough room to expand/realloc the area? if (diff >= size || sMemPool.available >= (size - diff)) { s32 arg = prior->arg; - void* func = prior->func; + AllocateFunc func = prior->func; main_pool_free(addr, FALSE); // do not run the func as we are merely reallocating it. newaddr = main_pool_alloc_from_pool(size, MEMORY_POOL_LEFT); main_pool_set_func(newaddr, arg, func); @@ -377,7 +377,7 @@ void* main_pool_search(uintptr_t addr, s32* argPtr) { /** * Set the block function and its argument(s) for a given block. */ -void main_pool_set_func(void* block, s32 arg, void* func) { +void main_pool_set_func(void* block, s32 arg, AllocateFunc func) { struct MainPoolBlock* node = (void*)((uintptr_t)block - sizeof(struct MainPoolBlock)); node->func = func; node->arg = arg; diff --git a/yamls/us/rom.yaml b/yamls/us/rom.yaml index c7838ac4..c78a439a 100644 --- a/yamls/us/rom.yaml +++ b/yamls/us/rom.yaml @@ -335,6 +335,9 @@ - [0x6FC00, data, rom_data_6FC00] - [0x76260, .data, 29BA0] - [0x76280, data, rom_data_76280] + - [0x79630, .data, 49790] + - [0x79660, data, rom_data_79660] + - [0x79AE0, .data, 4CBC0] - [0x79C70, data, rom_data_79C70] @@ -389,12 +392,12 @@ - [0x7C750, rodata, rom_rodata_7C750] - [0x7CCA0, rodata, rom_rodata_7CCA0] - [0x7CD10, rodata, rom_rodata_7CD10] - - [0x7CD40, rodata, rom_rodata_7CD40] + - [0x7CD40, .rodata, 26820] - [0x7CEC0, .rodata, 29BA0] - [0x7CFD0, rodata, rom_rodata_7CFD0] - [0x7D030, rodata, rom_rodata_7D030] - [0x7D040, rodata, rom_rodata_7D040] - - [0x7D0F0, rodata, rom_rodata_7D0F0] + - [0x7D0F0, .rodata, 30640] - [0x7D110, rodata, rom_rodata_7D110] - [0x7D1B0, rodata, rom_rodata_7D1B0] - [0x7D230, rodata, rom_rodata_7D230] @@ -402,7 +405,8 @@ - [0x7D3E0, rodata, rom_rodata_7D3E0] - [0x7D880, rodata, rom_rodata_7D880] - [0x7DF80, rodata, rom_rodata_7DF80] - - [0x7DFD0, rodata, rom_rodata_7DFD0] + - [0x7DFD0, .rodata, 49790] + - [0x7E0C0, rodata, rom_rodata_7E0C0] - [0x7E0D0, rodata, rom_rodata_7E0D0] - [0x7E0E0, .rodata, 4BA90] - [0x7E110, .rodata, 4BDC0] @@ -458,6 +462,8 @@ - {vram: 0x800A74C0, type: .bss, name: crash_screen} - {vram: 0x800A7EA0, type: .bss, name: profiler} - {vram: 0x800A8100, type: bss, name: unk_bss_2} + - {vram: 0x800AC880, type: .bss, name: 20330} + - {vram: 0x800AC890, type: bss, name: unk_bss_11} - {vram: 0x800AE520, type: .bss, name: 29BA0} - {vram: 0x800AF740, type: bss, name: unk_bss_7} - {vram: 0x800FF990, type: .bss, name: 4B940}