diff --git a/include/variables.h b/include/variables.h index aacdb7f..7cf343b 100644 --- a/include/variables.h +++ b/include/variables.h @@ -758,6 +758,71 @@ extern u8 D_8C200090[]; extern u8 D_8C200920[]; extern u8 D_8C201070[]; extern u8 D_8C2011C4[]; +extern u8 D_3008380[]; +extern u8 D_3008400[]; +extern u8 D_3008480[]; +extern u8 D_3008500[]; +extern u8 D_3008580[]; +extern u8 D_3008600[]; +extern u8 D_3008680[]; +extern u8 D_3008700[]; +extern u8 D_3000470[]; +extern u8 D_3001F70[]; +extern u8 D_30092C0[]; +extern u8 D_3009560[]; +extern u8 D_3008280[]; +extern u8 D_3006170[]; +extern u8 D_30061D0[]; +extern u8 D_3006230[]; +extern u8 D_1003DB0[]; +extern u8 D_1003E50[]; +extern u8 D_1003EA0[]; +extern u8 D_1003EC8[]; +extern u8 D_1003EF0[]; +extern u8 D_300B870[]; +extern u8 D_3008C00[]; +extern u8 D_3008D80[]; +extern u8 D_3008E40[]; +extern u8 D_3008FC0[]; +extern u8 D_3009080[]; +extern u8 D_3009200[]; +extern u8 D_3008780[]; +extern u8 D_3008900[]; +extern u8 D_30089C0[]; +extern u8 D_3008B40[]; +extern u8 D_3006290[]; +extern u8 D_3006450[]; +extern u8 D_3006530[]; +extern u8 D_30066F0[]; +extern u8 D_30067D0[]; +extern u8 D_3006990[]; +extern u8 D_3006A70[]; +extern u8 D_3006C30[]; +extern u8 D_300B630[]; +extern u8 D_300A1F0[]; +extern u8 D_30096B0[]; +extern u8 D_300AAF0[]; +extern u8 D_300A8B0[]; +extern u8 D_300B3F0[]; +extern u8 D_3009FB0[]; +extern u8 D_30098F0[]; +extern u8 D_300A430[]; +extern u8 D_300B1B0[]; +extern u8 D_300AF70[]; +extern u8 D_300A670[]; +extern u8 D_3009D70[]; +extern u8 D_300AD30[]; +extern u8 D_3009B30[]; +extern u8 D_3006D10[]; +extern u8 D_3007010[]; +extern u8 D_3007310[]; +extern u8 D_3007610[]; +extern u8 D_3007A78[]; +extern u8 D_3007EB0[]; +extern u8 D_3007910[]; +extern u8 D_3008018[]; +extern u8 D_3007BE0[]; +extern u8 D_3007D48[]; extern LEODiskID D_800818E0; diff --git a/linker_scripts/us/symbol_addrs.txt b/linker_scripts/us/symbol_addrs.txt index 4ae3af8..458d6bf 100644 --- a/linker_scripts/us/symbol_addrs.txt +++ b/linker_scripts/us/symbol_addrs.txt @@ -1023,4 +1023,58 @@ D_84390068 = 0x84390068; // size:0x38 D_84390010 = 0x84390010; // size:0x8 D_84390028 = 0x84390028; // size:0x20 D_843901F0 = 0x843901F0; // size:0xC -D_84390048 = 0x84390048; // size:0x20 \ No newline at end of file +D_84390048 = 0x84390048; // size:0x20 +D_3008380 = 0x3008380; +D_3008400 = 0x3008400; +D_3008480 = 0x3008480; +D_3008500 = 0x3008500; +D_3008580 = 0x3008580; +D_3008600 = 0x3008600; +D_3008680 = 0x3008680; +D_3008700 = 0x3008700; +D_3000470 = 0x3000470; +D_3001F70 = 0x3001F70; +D_30092C0 = 0x30092C0; +D_3009560 = 0x3009560; +D_3008280 = 0x3008280; +D_3006170 = 0x3006170; +D_30061D0 = 0x30061D0; +D_3006230 = 0x3006230; +D_300B870 = 0x300B870; +D_3008C00 = 0x3008C00; +D_3008D80 = 0x3008D80; +D_3008E40 = 0x3008E40; +D_3008FC0 = 0x3008FC0; +D_3009080 = 0x3009080; +D_3009200 = 0x3009200; +D_3008780 = 0x3008780; +D_3008900 = 0x3008900; +D_30089C0 = 0x30089C0; +D_3008B40 = 0x3008B40; +D_3006290 = 0x3006290; +D_3006450 = 0x3006450; +D_3006530 = 0x3006530; +D_30066F0 = 0x30066F0; +D_30067D0 = 0x30067D0; +D_3006990 = 0x3006990; +D_3006A70 = 0x3006A70; +D_3006C30 = 0x3006C30; +D_300B630 = 0x300B630; +D_300A1F0 = 0x300A1F0; +D_30096B0 = 0x30096B0; +D_300AAF0 = 0x300AAF0; +D_300A8B0 = 0x300A8B0; +D_300B3F0 = 0x300B3F0; +D_3009FB0 = 0x3009FB0; +D_30098F0 = 0x30098F0; +D_300A430 = 0x300A430; +D_300B1B0 = 0x300B1B0; +D_300AF70 = 0x300AF70; +D_300A670 = 0x300A670; +D_3009D70 = 0x3009D70; +D_300AD30 = 0x300AD30; +D_3009B30 = 0x3009B30; +D_3006D10 = 0x3006D10; +D_3007010 = 0x3007010; +D_3007310 = 0x3007310; +D_3007610 = 0x3007610; \ No newline at end of file diff --git a/linker_scripts/us/undefined_syms.ld b/linker_scripts/us/undefined_syms.ld index 67cd634..53b1fa4 100644 --- a/linker_scripts/us/undefined_syms.ld +++ b/linker_scripts/us/undefined_syms.ld @@ -514,3 +514,79 @@ D_8C200920 = 0x8C200920; D_8C201070 = 0x8C201070; D_8C2011C4 = 0x8C2011C4; D_80070F84 = 0x80070F84; +D_3008380 = 0x3008380; +D_3008400 = 0x3008400; +D_3008480 = 0x3008480; +D_3008500 = 0x3008500; +D_3008580 = 0x3008580; +D_3008600 = 0x3008600; +D_3008680 = 0x3008680; +D_3008700 = 0x3008700; +D_3000470 = 0x3000470; +D_3001F70 = 0x3001F70; +D_30092C0 = 0x30092C0; +D_3009560 = 0x3009560; +D_3008280 = 0x3008280; +D_3006170 = 0x3006170; +D_30061D0 = 0x30061D0; +D_3006230 = 0x3006230; +D_1003DB0 = 0x1003DB0; +D_1003E50 = 0x1003E50; +D_1003EA0 = 0x1003EA0; +D_1003EC8 = 0x1003EC8; +D_1003EF0 = 0x1003EF0; +D_1003DB0 = 0x1003DB0; +D_1003E50 = 0x1003E50; +D_1003EA0 = 0x1003EA0; +D_1003EC8 = 0x1003EC8; +D_1003EF0 = 0x1003EF0; +D_300B870 = 0x300B870; +D_3008C00 = 0x3008C00; +D_3008D80 = 0x3008D80; +D_3008E40 = 0x3008E40; +D_3008FC0 = 0x3008FC0; +D_3009080 = 0x3009080; +D_3009200 = 0x3009200; +D_3008780 = 0x3008780; +D_3008900 = 0x3008900; +D_30089C0 = 0x30089C0; +D_3008B40 = 0x3008B40; +D_3006290 = 0x3006290; +D_3006450 = 0x3006450; +D_3006530 = 0x3006530; +D_30066F0 = 0x30066F0; +D_30067D0 = 0x30067D0; +D_3006990 = 0x3006990; +D_3006A70 = 0x3006A70; +D_3006C30 = 0x3006C30; +D_300B630 = 0x300B630; +D_300A1F0 = 0x300A1F0; +D_30096B0 = 0x30096B0; +D_300AAF0 = 0x300AAF0; +D_300A8B0 = 0x300A8B0; +D_300B3F0 = 0x300B3F0; +D_3009FB0 = 0x3009FB0; +D_30098F0 = 0x30098F0; +D_300A430 = 0x300A430; +D_300B1B0 = 0x300B1B0; +D_300AF70 = 0x300AF70; +D_300A670 = 0x300A670; +D_3009D70 = 0x3009D70; +D_300AD30 = 0x300AD30; +D_3009B30 = 0x3009B30; +D_3006D10 = 0x3006D10; +D_3007010 = 0x3007010; +D_3007310 = 0x3007310; +D_3007610 = 0x3007610; +D_3007A78 = 0x3007A78; +D_3007EB0 = 0x3007EB0; +D_3007910 = 0x3007910; +D_3008018 = 0x3008018; +D_3007BE0 = 0x3007BE0; +D_3007D48 = 0x3007D48; +D_3007A78 = 0x3007A78; +D_3007EB0 = 0x3007EB0; +D_3007910 = 0x3007910; +D_3008018 = 0x3008018; +D_3007BE0 = 0x3007BE0; +D_3007D48 = 0x3007D48; diff --git a/src/29BA0.h b/src/29BA0.h index ae6d19f..dc061db 100644 --- a/src/29BA0.h +++ b/src/29BA0.h @@ -74,8 +74,7 @@ typedef struct unk_D_800AE540_0004 { /* 0x008 */ char unk_008[4]; /* 0x00C */ char unk00C[0xC]; /* 0x018 */ s32 unk_018; - /* 0x01C */ unk_func_80026268_arg0 unk_01C[1]; - /* 0x070 */ char unk070[0x1A4]; + /* 0x01C */ unk_func_80026268_arg0 unk_01C[6]; /* 0x214 */ unk_D_800AE540_0874* unk_214; /* 0x218 */ char unk218[0x4]; } unk_D_800AE540_0004; // size = 0x21C diff --git a/src/3D140.c b/src/3D140.c index 9029fc5..febbac8 100644 --- a/src/3D140.c +++ b/src/3D140.c @@ -96,6 +96,7 @@ extern u8 D_80078400; extern u16 D_80078410[1][9]; extern u16 D_80078446[1][9]; extern u16 D_800784EA[1][9]; +extern u32 D_80078544; extern f64 D_8007C7E0; extern f64 D_8007C7E8; extern f64 D_8007C7F0; @@ -111,9 +112,9 @@ extern AudioInfo* lastInfo; extern s32 min_only_one; extern u8 D_800FC825; extern s32 D_800FC828; - extern s32 D_800FCB28; extern s32 D_800FCB2C; +extern u32 D_800FCCF0[10]; typedef struct unk_D_800FCB48 { /* 0x00 */ u16 unk_00[16]; @@ -1120,7 +1121,13 @@ void func_8003DB84(s32 arg0) { #pragma GLOBAL_ASM("asm/us/nonmatchings/3D140/func_8003F4C0.s") -#pragma GLOBAL_ASM("asm/us/nonmatchings/3D140/func_8003F624.s") +void func_8003F624(u32 arg0) { + D_800FCCF0[D_80078544] = arg0; + D_80078544++; + if (D_80078544 >= 0xA) { + D_80078544--; + } +} #pragma GLOBAL_ASM("asm/us/nonmatchings/3D140/func_8003F660.s") diff --git a/src/3D140.h b/src/3D140.h index c67b9db..e55cafc 100644 --- a/src/3D140.h +++ b/src/3D140.h @@ -44,6 +44,8 @@ s32 func_8003D4A0(s32); void func_8003D68C(s32); void func_8003D918(u32 arg0, u32 arg1); void func_8003DB84(s32 arg0); +void func_8003F624(u32 arg0); +void func_8003F660(s32); void func_80041688(void); void func_800416BC(void); void func_80041A98(void); diff --git a/src/fragments/62/fragment62.h b/src/fragments/62/fragment62.h index 8628c16..3b235d4 100644 --- a/src/fragments/62/fragment62.h +++ b/src/fragments/62/fragment62.h @@ -29,11 +29,14 @@ typedef struct unk_D_84390010_654_038 { /* 0x4A */ char unk4A[0x2]; /* 0x4C */ u8 unk_4C; /* 0x4D */ u8 unk_4D; - /* 0x4E */ char unk4E[0x4]; + /* 0x4E */ u8 unk_4E; + /* 0x4F */ char unk4F[0x3]; /* 0x52 */ u8 unk_52; /* 0x53 */ char unk53[0x3]; /* 0x56 */ u8 unk_56; - /* 0x57 */ char unk57[0x3]; + /* 0x57 */ char unk57[0x1]; + /* 0x58 */ u8 unk_58; + /* 0x59 */ char unk59[0x1]; /* 0x5A */ u8 unk_5A; /* 0x5B */ char unk5B[0x9]; } unk_D_84390010_654_038; // size = 0x64 @@ -72,7 +75,8 @@ typedef struct unk_D_84390010_654 { /* 0x2D */ u8 unk_2D; /* 0x2E */ u8 unk_2E; /* 0x2F */ u8 unk_2F; - /* 0x30 */ char unk30[0x4]; + /* 0x30 */ u16 unk_30; + /* 0x32 */ char unk32[0x2]; /* 0x34 */ u16 unk_34; /* 0x36 */ u16 unk_36; /* 0x38 */ unk_D_84390010_654_038 unk_38; @@ -117,7 +121,11 @@ typedef struct unk_D_84390010_728 { typedef struct unk_D_84390010_8C4 { /* 0x00 */ s32 unk_00; - /* 0x04 */ char unk04[0x84]; + /* 0x04 */ s32 unk_04; + /* 0x08 */ s8 unk_08[4]; + /* 0x0C */ char unk0C[0x3C]; + /* 0x48 */ s8 unk_48[4]; + /* 0x4C */ char unk4C[0x3C]; } unk_D_84390010_8C4; // size = 0x88 typedef struct unk_D_84390010_94C { @@ -220,7 +228,11 @@ typedef struct unk_D_84390240_000 { /* 0x14 */ s32 unk_14; /* 0x18 */ char unk18[0x4]; /* 0x1C */ s32 unk_1C; - /* 0x20 */ char unk20[0x20]; + /* 0x20 */ char unk20[0xC]; + /* 0x2C */ u16 unk_2C; + /* 0x2E */ char unk2E[0x2]; + /* 0x30 */ s32 unk_30; + /* 0x34 */ char unk34[0xC]; /* 0x40 */ s32 unk_40; /* 0x44 */ char unk44[0x4]; /* 0x48 */ s32 unk_48; @@ -305,6 +317,48 @@ typedef struct unk_D_843901B0 { /* 0x00 */char unk00[0x40]; } unk_D_843901B0; // size >= 0x40 +typedef struct unk_D_843901A0_4C8 { + /* 0x00 */ s32 unk_00; + /* 0x04 */ s32 unk_04; + /* 0x08 */ s32 unk_08; + /* 0x0C */ s32 unk_0C; + /* 0x10 */ s32 unk_10; + /* 0x14 */ Vec3f unk_14; + /* 0x20 */ f32 unk_20; + /* 0x24 */ f32 unk_24; + /* 0x28 */ s16 unk_28; + /* 0x2A */ s16 unk_2A; +} unk_D_843901A0_4C8; // size = 0x2C + +typedef struct unk_D_843901A0 { + /* 0x000 */ u8 unk_000; + /* 0x004 */ s32 unk_004; + /* 0x008 */ u8 unk_008[4]; + /* 0x00C */ char unk00C[0x3C]; + /* 0x048 */ u8 unk_048[64]; + /* 0x088 */ s8 unk_088[64]; + /* 0x0C8 */ s8 unk_0C8[64]; + /* 0x148 */ s8 unk_108[64]; + /* 0x148 */ s8 unk_148[64]; + /* 0x188 */ s8 unk_188[64]; + /* 0x1C8 */ s8 unk_1C8[64]; + /* 0x208 */ s8 unk_208[64]; + /* 0x248 */ s8 unk_248[64]; + /* 0x288 */ s8 unk_288[64]; + /* 0x2C8 */ s8 unk_2C8[64]; + /* 0x2C8 */ s8 unk_308[64]; + /* 0x348 */ s8 unk_348[64]; + /* 0x388 */ s8 unk_388[64]; + /* 0x3C8 */ s8 unk_3C8[64]; + /* 0x408 */ s8 unk_408[64]; + /* 0x448 */ s8 unk_448[2][64]; + /* 0x4C8 */ unk_D_843901A0_4C8 unk_4C8; +} unk_D_843901A0; // size = 0x4F4 + +typedef struct unk_D_84385790 { + /* 0x00 */ s32 unk_00; + /* 0x04 */ Color_RGBA8 unk_04; +} unk_D_84385790; // size = 0x8 extern unk_D_8438E7B0* D_84384570[]; extern unk_D_8438FF70* D_84384578[]; @@ -320,6 +374,7 @@ extern s16 D_84384670[]; extern unk_D_843847BC D_843847BC[2]; extern unk_D_84385384_func D_84385380; extern unk_D_84385384 D_84385384[]; +extern u32 D_84385BC0[]; extern u8 D_843C4DA4; extern unk_D_843C4DEC D_843C4DEC; @@ -345,6 +400,8 @@ extern f32 D_84390128; extern u8 D_84390134; extern s32 D_84390174; extern unk_D_84390178 D_84390178; +extern Vec3f D_84390190; +extern unk_D_843901A0* D_843901A0; extern s32 D_8439022C; extern s32 D_84390230; extern s32 D_84390234; @@ -352,8 +409,6 @@ extern unk_D_84390240 D_84390240; extern s32 D_84390288; - - s32 func_84300020(s32 arg0, GraphNode* arg1); s32 func_84300058(s32 arg0, unk_D_86002F34_alt18* arg1); s32 func_843000C0(s32 arg0, unk_D_86002F34_alt18* arg1); @@ -557,7 +612,7 @@ f32 func_84308548(unk_D_84390010* arg0); f32 func_84308598(unk_D_84390010* arg0); unk_D_86002F58_004_000_004* func_843085C4(unk_D_84390010* arg0, s32 arg1); s32 func_843085E0(unk_D_84390010* arg0, UNUSED s32 arg1); -void func_843085F0(unk_D_84390010* arg0); +char* func_843085F0(unk_D_84390010* arg0); u8* func_8430862C(unk_D_84390010* arg0); void func_84308654(unk_D_84390010* arg0, s32 arg1, s32 arg2); void func_84308660(unk_D_84390010* arg0, unk_D_84390010* arg1); @@ -737,13 +792,87 @@ void func_8430F8B8(void); void func_8430FB20(void); void func_8430FB68(void); -void func_843184E4(s32); + +void func_8430FC10(void); +void func_8430FC28(s32 arg0, s32 arg1, s32 arg2, s32 arg3, s32 arg4); +void func_8430FF8C(s32 arg0, s32 arg1, s32 arg2, s32 arg3, Color_RGB8* arg4, Color_RGB8* arg5); +void func_84310334(s32 arg0, s32 arg1, s32 arg2, s32 arg3, Color_RGB8* arg4, Color_RGB8* arg5); +void func_84310360(void); +void func_84310368(s32 arg0, s32 arg1, f32 arg2, s32 arg3); +void func_843109EC(void); +void func_843109F4(s32 arg0, s32 arg1, s32 arg2); +void func_84310B9C(s32 arg0, s32 arg1, s32 arg2, s32 arg3); +void func_84310CE4(s16 arg0, s16 arg1, s32 arg2, char* arg3, s32 arg4); +void func_84310DC4(s16 arg0, s16 arg1, s32 arg2, u8* arg3, s32 arg4, s32 arg5); +void func_84310FA4(unk_D_84390010* arg0, unk_D_800AE540_0004* arg1, s16 arg2, s16 arg3, s32 arg4, u16 arg5, s32 arg6); +void func_84311048(unk_D_84390010* arg0, unk_func_80026268_arg0* arg1, unk_D_84385790* arg2, s32 arg3, s32 arg4, s32 arg5, s32 arg6, s32 arg7, s32 arg8, s32 arg9, s32 argA); +s32 func_843112C4(s32 arg0, s32 arg1, s32 arg2, s32 arg3, u8* arg4); +void func_84311420(void); +void func_84311428(s16 arg0, s16 arg1, s16 arg2, s16 arg3); +void func_843116D8(s16 arg0, s16 arg1); +void func_843118A8(s16 arg0, s16 arg1); +void func_84311A38(unk_D_84390010* arg0, s16 arg1, s16 arg2); +void func_84311F30(unk_D_84390010* arg0, s16 arg1, s16 arg2, u16 arg3, s32 arg4); +void func_843128A0(unk_D_84390010* arg0, s16 arg1, s16 arg2, u16 arg3, s32 arg4); +void func_84313148(unk_D_84390010* arg0, s16 arg1, s16 arg2, s32 arg3); +void func_843133B4(unk_D_84390010* arg0, s16 arg1, s16 arg2, s32 arg3); +void func_843135B8(unk_D_84390010* arg0, s16 arg1, s16 arg2, s32 arg3); +void func_84313750(s32 arg0, s32 arg1, char* arg2); +s32 func_8431379C(s32 arg0, s32 arg1, s32 arg2, s32 arg3); +s32 func_84313908(s32 arg0, s32 arg1, s32 arg2, s32 arg3); +void func_84313A74(unk_D_84390010* arg0, s16 arg1, s16 arg2, s32 arg3); +void func_8431493C(s16 arg0, s16 arg1, s16 arg2, s32 arg3); +void func_84314B20(s16 arg0, s16 arg1, char* arg2); +void func_84314B6C(unk_D_84390010* arg0, unk_D_800AE540_0004* arg1, unk_func_80026268_arg0* arg2, s32 arg3, s32 arg4, s32 arg5); +void func_84314F60(unk_D_84390010* arg0, unk_D_800AE540_0004* arg1, unk_func_80026268_arg0* arg2, s32 arg3, s32 arg4, s32 arg5); +void func_8431524C(unk_D_84390010* arg0, unk_D_800AE540_0004* arg1, s16 arg2, s16 arg3, s32 arg4); +void func_84315550(unk_D_84390010* arg0, s16 arg1, s16 arg2, s32 arg3); +void func_8431595C(unk_D_84390010* arg0, s16 arg1, s16 arg2, s32 arg3); +void func_84315ADC(s32 arg0, s16 arg1, s16 arg2, char* arg3); +s32 func_84315BC0(char* arg0, s16 arg1, s16 arg2); +void func_84315C28(unk_D_843901A0_4C8* arg0, s16 arg1, s16 arg2, Vec3f arg3); +void func_84315D88(unk_D_843901A0_4C8* arg0, s16 arg1, s16 arg2); +s32 func_84315EC0(unk_D_843901A0_4C8* arg0, s16 arg1, s16 arg2); +void func_84315FAC(unk_D_843901A0_4C8* arg0, s16 arg1, s16 arg2, Vec3f arg3); +void func_843160C0(unk_D_843901A0_4C8* arg0, s16 arg1, s16 arg2); +s32 func_843161F8(unk_D_843901A0_4C8* arg0, s16 arg1, s16 arg2); +void func_843162E4(s32 arg0, s16 arg1, s16 arg2, char* arg3); +void func_843163C8(unk_D_84390010* arg0, s16 arg1, s16 arg2, s32 arg3); +void func_84316610(void); +void func_84316640(s16 arg0, s16 arg1, s16 arg2, s16 arg3, s16 arg4, s16 arg5, s16 arg6, s16 arg7); +void func_843167D4(s32 arg0, s32 arg1, s32 arg2, s32 arg3, u8* arg4, s32 arg5); +void func_8431694C(void); +void func_84317004(void); +void func_8431712C(void); +void func_843172A0(unk_D_84390010* arg0, unk_D_84390010_654* arg1); +void func_84317558(unk_D_84390010* arg0, unk_D_84390010_654* arg1); + + +void func_84317810(void); +void func_8431790C(void); +void func_84317940(s8* arg0, s8* arg1, ...); +void func_843179F4(s8* arg0, s8 arg1); +void func_84317AA8(char* arg0, s32 arg1); +void func_84317B38(void); +void func_84317B40(void); +void func_84317BDC(void); +void func_84317EDC(void); +void func_843180AC(void); +void func_843184E4(s32 arg0); void func_843184FC(void); -void func_843193F4(unk_D_84390010*); -void func_84319408(unk_D_84390010*, s32); +void func_84318514(s8* arg0); +void func_84318640(unk_D_843901A0_4C8* arg0, s16 arg1, s16 arg2); +s32 func_84318CE4(unk_D_843901A0_4C8* arg0); +void func_843190A8(s16 arg0, s16 arg1); +void func_843193F4(unk_D_84390010* arg0); +void func_84319408(unk_D_84390010* arg0, s32 arg1); +void func_843194A0(unk_D_84390010* arg0); +void func_84319564(void); void func_8431962C(void); void func_84319668(void); void func_843196A4(void); + + s32 func_8431ADAC(s32); void func_8431AE7C(unk_D_84390010_728_0168*, f32, f32, f32, f32, s16, s16); void func_8431AFB4(s32, s32); @@ -777,6 +906,9 @@ void func_8432D0D8(s32, unk_D_86002F34_00C*); void func_8432E9D8(s32); f32 func_8435E158(f32, f32, f32*); f32 func_8435FCD0(void); +s32 func_8436EF48(void); +void func_8436F664(void); +s32 func_8436F6D8(void); void func_8436F9D8(s32, s32); void func_84370B7C(unk_D_84390010*); void func_843831A0(unk_D_800AE540_0004*, unk_D_800AE540_0004*, unk_D_800AE540_0004*, s32, u8*, s32, s32); diff --git a/src/fragments/62/fragment62_2F23A0.c b/src/fragments/62/fragment62_2F23A0.c index 1a6cb96..fef4597 100644 --- a/src/fragments/62/fragment62_2F23A0.c +++ b/src/fragments/62/fragment62_2F23A0.c @@ -269,8 +269,8 @@ s32 func_843085E0(unk_D_84390010* arg0, UNUSED s32 arg1) { return arg0->unk_720->unk_02; } -void func_843085F0(unk_D_84390010* arg0) { - func_8002D7C0(NULL, 0, D_843900B8, arg0->unk_654.unk_38.unk_5A - 1); +char* func_843085F0(unk_D_84390010* arg0) { + return func_8002D7C0(NULL, 0, D_843900B8, arg0->unk_654.unk_38.unk_5A - 1); } u8* func_8430862C(unk_D_84390010* arg0) { diff --git a/src/fragments/62/fragment62_2FA4D0.c b/src/fragments/62/fragment62_2FA4D0.c index f2ec720..f165619 100644 --- a/src/fragments/62/fragment62_2FA4D0.c +++ b/src/fragments/62/fragment62_2FA4D0.c @@ -1,150 +1,1915 @@ -#include "global.h" +#include "fragment62.h" +#include "src/1CF30.h" +#include "src/20470.h" +#include "src/225A0.h" +#include "src/29BA0.h" +#include "src/2E110.h" +#include "src/3D140.h" +#include "src/6A40.h" +#include "src/6BC0.h" +#include "src/F420.h" +#include "src/controller.h" +#include "src/memmap.h" +#include "src/memory.h" -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_8430FC10.s") +Vec3f D_84390190; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_8430FC28.s") +static unk_D_84385790 D_84385790[] = { + { + 0x00000000, + { + 0xFF, + 0xFF, + 0xFF, + 0xFF, + }, + }, + { + 0x00000001, + { + 0x4D, + 0x4D, + 0x4D, + 0xFF, + }, + }, + { + 0x00000002, + { + 0x9F, + 0x91, + 0xE8, + 0xFF, + }, + }, + { + 0x00000003, + { + 0x96, + 0x50, + 0xFF, + 0xFF, + }, + }, + { + 0x00000004, + { + 0xF0, + 0x5A, + 0x46, + 0xFF, + }, + }, + { + 0x00000005, + { + 0x85, + 0xD5, + 0xF1, + 0xFF, + }, + }, + { + 0x00000006, + { + 0xFF, + 0xFF, + 0x00, + 0xFF, + }, + }, +}; +static u8* D_843857C8[] = { + D_30098F0, D_300B630, D_300A1F0, D_30096B0, D_300AAF0, D_300A8B0, D_30098F0, D_300B3F0, D_3009FB0, D_30098F0, + D_30098F0, D_30098F0, D_30098F0, D_30098F0, D_30098F0, D_30098F0, D_30098F0, D_30098F0, D_30098F0, D_30098F0, + D_300A430, D_300B1B0, D_300AF70, D_300A670, D_3009D70, D_300AD30, D_3009B30, NULL, +}; +static u8* D_84385838[] = { + D_3007A78, D_3007EB0, D_3007910, D_3008018, D_3007BE0, D_3007D48, +}; +static u8* D_84385850[] = { + D_3006D10, + D_3007010, + D_3007310, + D_3007610, +}; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_8430FF8C.s") +static Color_RGB8 D_84385860[] = { + { 0, 0, 0x8B }, { 0, 0x32, 0 }, { 0x1E, 0, 0 }, { 0x65, 0x49, 0x11 }, { 0, 0, 0 }, +}; +static Color_RGB8 D_84385870[] = { + { 0x00, 0x00, 0xEE }, + { 0x00, 0x79, 0x00 }, + { 0x82, 0x00, 0x00 }, + { 0x97, 0x89, 0x13 }, +}; +static Color_RGB8 D_8438587C[] = { + { 0x13, 0x45, 0xFF }, + { 0, 0x99, 0 }, + { 0xCC, 0x51, 0x28 }, + { 0xCC, 0x8F, 0 }, +}; +static Color_RGB8 D_84385888[] = { + { 0x00, 0x00, 0x8B }, + { 0x00, 0x00, 0x8B }, + { 0x00, 0x00, 0x8B }, + { 0x00, 0x00, 0x8B }, +}; +static Color_RGB8 D_84385894[] = { + { 0x00, 0x00, 0xEE }, + { 0x00, 0x00, 0xEE }, + { 0x00, 0x00, 0xEE }, + { 0x00, 0x00, 0xEE }, +}; +static Color_RGB8 D_843858A0[] = { + { 0x00, 0x32, 0x00 }, + { 0x00, 0x32, 0x00 }, + { 0x00, 0x32, 0x00 }, + { 0x00, 0x32, 0x00 }, +}; +static Color_RGB8 D_843858AC[] = { + { 0x00, 0x79, 0x00 }, + { 0x00, 0x79, 0x00 }, + { 0x00, 0x79, 0x00 }, + { 0x00, 0x79, 0x00 }, +}; +static Color_RGB8 D_843858B8[] = { + { 0x1E, 0x00, 0x00 }, + { 0x1E, 0x00, 0x00 }, + { 0x1E, 0x00, 0x00 }, + { 0x1E, 0x00, 0x00 }, +}; +static Color_RGB8 D_843858C4[] = { + { 0x82, 0x00, 0x00 }, + { 0x82, 0x00, 0x00 }, + { 0x82, 0x00, 0x00 }, + { 0x82, 0x00, 0x00 }, +}; +static Color_RGB8 D_843858D0[] = { + { 0x65, 0x49, 0x11 }, + { 0x65, 0x49, 0x11 }, + { 0x65, 0x49, 0x11 }, + { 0x65, 0x49, 0x11 }, +}; +static Color_RGB8 D_843858DC[] = { + { 0x97, 0x89, 0x13 }, + { 0x97, 0x89, 0x13 }, + { 0x97, 0x89, 0x13 }, + { 0x97, 0x89, 0x13 }, +}; +static Gfx D_843858E8[] = { + gsDPPipeSync(), + gsDPSetCycleType(G_CYC_1CYCLE), + gsDPSetTexturePersp(G_TP_NONE), + gsDPSetRenderMode(G_RM_TEX_EDGE, G_RM_TEX_EDGE2), + gsDPSetCombineMode(G_CC_DECALRGBA, G_CC_DECALRGBA), + gsSPClearGeometryMode(G_ZBUFFER | G_LIGHTING), + gsSPEndDisplayList(), +}; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_84310334.s") +void func_8430FC10(void) { +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_84310368.s") +void func_8430FC18(void) { +} + +void func_8430FC20(void) { +} + +void func_8430FC28(s32 arg0, s32 arg1, s32 arg2, s32 arg3, s32 arg4) { + unk_D_80068BB0* temp_s1; + Vtx* temp_s2; + Mtx* sp84; + Vp* sp80; + + temp_s1 = func_8000648C(); + temp_s2 = func_80005F5C(sizeof(Vtx) * 4); + sp84 = func_80005F5C(sizeof(Mtx) * 1); + sp80 = func_80005F5C(sizeof(Vp) * 1); + func_8001E6E8(sp80, temp_s1->width, temp_s1->height); + + gSPViewport(gDisplayListHead++, (u32)sp80 & 0x1FFFFFFF); + + guOrtho(sp84, 0.5f, temp_s1->width - 0.5f, temp_s1->height - 0.5f, 0.5f, -2.0f, 2.0f, 1.0f); + + func_8001E680(&temp_s2[0], arg0, arg1, -1, 0, 0, 0, 0, 0, arg4); + func_8001E680(&temp_s2[1], arg0 + arg2, arg1, -1, 0, 0, 0, 0, 0, arg4); + func_8001E680(&temp_s2[2], arg0, arg1 + arg3, -1, 0, 0, 0, 0, 0, arg4); + func_8001E680(&temp_s2[3], arg0 + arg2, arg1 + arg3, -1, 0, 0, 0, 0, 0, arg4); + + gDPPipeSync(gDisplayListHead++); + gDPSetCycleType(gDisplayListHead++, G_CYC_1CYCLE); + gSPClearGeometryMode(gDisplayListHead++, G_ZBUFFER | G_LIGHTING); + gDPSetCombineMode(gDisplayListHead++, G_CC_SHADE, G_CC_SHADE); + gDPSetRenderMode(gDisplayListHead++, G_RM_XLU_SURF, G_RM_XLU_SURF2); + gSPPerspNormalize(gDisplayListHead++, 0xFFFF); + gSPMatrix(gDisplayListHead++, (u32)sp84 & 0x1FFFFFFF, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION); + gSPMatrix(gDisplayListHead++, (u32)&D_8006F010 & 0x1FFFFFFF, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW); + gSPVertex(gDisplayListHead++, (u32)temp_s2 & 0x1FFFFFFF, 4, 0); + gSP2Triangles(gDisplayListHead++, 0, 2, 3, 0, 0, 3, 1, 0); +} + +void func_8430FF8C(s32 arg0, s32 arg1, s32 arg2, s32 arg3, Color_RGB8* arg4, Color_RGB8* arg5) { + Vtx* temp_s2; + unk_D_80068BB0* temp_s1; + Mtx* sp7C; + Vp* sp78; + + temp_s1 = func_8000648C(); + temp_s2 = func_80005F5C(sizeof(Vtx) * 4); + sp7C = func_80005F5C(sizeof(Mtx) * 1); + sp78 = func_80005F5C(sizeof(Vp) * 1); + func_8001E6E8(sp78, temp_s1->width, temp_s1->height); + + gSPViewport(gDisplayListHead++, (u32)sp78 & 0x1FFFFFFF); + + guOrtho(sp7C, 0.5f, temp_s1->width - 0.5f, temp_s1->height - 0.5f, 0.5f, -2.0f, 2.0f, 1.0f); + func_8001E680(&temp_s2[0], arg0, arg1, -1, 0, 0, arg4->r, arg4->g, arg4->b, 0xFF); + func_8001E680(&temp_s2[1], arg0 + arg2, arg1, -1, 0, 0, arg4->r, arg4->g, arg4->b, 0xFF); + func_8001E680(&temp_s2[2], arg0, arg1 + arg3, -1, 0, 0, arg5->r, arg5->g, arg5->b, 0xFF); + func_8001E680(&temp_s2[3], arg0 + arg2, arg1 + arg3, -1, 0, 0, arg5->r, arg5->g, arg5->b, 0xFF); + + gDPPipeSync(gDisplayListHead++); + gDPSetCycleType(gDisplayListHead++, G_CYC_1CYCLE); + gSPClearGeometryMode(gDisplayListHead++, G_ZBUFFER | G_LIGHTING); + gDPSetCombineMode(gDisplayListHead++, G_CC_SHADE, G_CC_SHADE); + gDPSetRenderMode(gDisplayListHead++, G_RM_OPA_SURF, G_RM_OPA_SURF2); + gSPPerspNormalize(gDisplayListHead++, 0xFFFF); + gSPMatrix(gDisplayListHead++, (u32)sp7C & 0x1FFFFFFF, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION); + gSPMatrix(gDisplayListHead++, (u32)&D_8006F010 & 0x1FFFFFFF, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW); + gSPVertex(gDisplayListHead++, (u32)temp_s2 & 0x1FFFFFFF, 4, 0); + gSP2Triangles(gDisplayListHead++, 0, 2, 3, 0, 0, 3, 1, 0); +} + +void func_84310334(s32 arg0, s32 arg1, s32 arg2, s32 arg3, Color_RGB8* arg4, Color_RGB8* arg5) { + func_8430FF8C(arg0, arg1, arg2, arg3, arg4, arg5); +} + +void func_84310360(void) { +} + +void func_84310368(s32 arg0, s32 arg1, f32 arg2, s32 arg3) { + u8* spCC; + s32 temp_ft2 = ((arg3 - arg2) * 48.0f) / arg3; + s32 sp14 = 0x30 - temp_ft2; + + if ((arg2 * 48.0f) < (arg3 * 0xA)) { + spCC = D_1003EF0; + } else if ((arg2 * 48.0f) < (arg3 * 0x1B)) { + spCC = D_1003EC8; + } else { + spCC = D_1003EA0; + } + + gSPDisplayList(gDisplayListHead++, D_8006F518); + + gDPLoadTextureBlock(gDisplayListHead++, D_1003DB0, G_IM_FMT_RGBA, G_IM_SIZ_16b, 16, 5, 0, + G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD, + G_TX_NOLOD); + gSPTextureRectangle(gDisplayListHead++, arg0 << 2, arg1 << 2, (arg0 + 0x10) << 2, (arg1 + 5) << 2, G_TX_RENDERTILE, + 0, 0, 0x0400, 0x0400); + + gDPLoadTextureBlock(gDisplayListHead++, D_1003E50, G_IM_FMT_RGBA, G_IM_SIZ_16b, 4, 5, 0, G_TX_NOMIRROR | G_TX_CLAMP, + G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD); + gSPTextureRectangle(gDisplayListHead++, (arg0 + 0x40) << 2, arg1 << 2, (arg0 + 0x41) << 2, (arg1 + 5) << 2, + G_TX_RENDERTILE, 0, 0, 0x0400, 0x0400); + + if (sp14 > 0) { + gDPLoadTextureBlock(gDisplayListHead++, spCC, G_IM_FMT_RGBA, G_IM_SIZ_16b, 4, 5, 0, G_TX_NOMIRROR | G_TX_CLAMP, + G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD); + gSPTextureRectangle(gDisplayListHead++, (arg0 + 0x10) << 2, arg1 << 2, ((arg0 + sp14) + 0x10) << 2, + (arg1 + 5) << 2, G_TX_RENDERTILE, 0, 0, 0, 0x0400); + } + + if (temp_ft2 > 0) { + gDPLoadTextureBlock(gDisplayListHead++, D_1003E78, G_IM_FMT_RGBA, G_IM_SIZ_16b, 4, 5, 0, + G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK, G_TX_NOMASK, + G_TX_NOLOD, G_TX_NOLOD); + gSPTextureRectangle(gDisplayListHead++, ((arg0 + sp14) + 0x10) << 2, arg1 << 2, + ((arg0 + sp14) + temp_ft2 + 0x10) << 2, (arg1 + 5) << 2, G_TX_RENDERTILE, 0, 0, 0, 0x0400); + } + + gSPDisplayList(gDisplayListHead++, D_8006F630); +} void func_843109EC(void) { } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_843109F4.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_84310B9C.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_84310CE4.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_84310DC4.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_84310FA4.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_84311048.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_843112C4.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_84311428.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_843116D8.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_843118A8.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_84311A38.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_84311F30.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_843128A0.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_84313148.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_843133B4.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_843135B8.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_84313750.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_8431379C.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_84313908.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_84313A74.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_8431493C.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_84314B20.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_84314B6C.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_84314F60.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_8431524C.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_84315550.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_8431595C.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_84315ADC.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_84315BC0.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_84315C28.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_84315D88.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_84315EC0.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_84315FAC.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_843160C0.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_843161F8.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_843162E4.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_843163C8.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_84316610.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_84316640.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_843167D4.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_8431694C.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_84316A1C.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_84317004.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_8431712C.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_843172A0.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_84317558.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_84317810.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_8431790C.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_84317940.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_843179F4.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_84317AA8.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_84317B40.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_84317BDC.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_84317EDC.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_843180AC.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_843184E4.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_843184FC.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_84318514.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_84318640.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_84318CE4.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_843190A8.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_843193F4.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_84319408.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_843194A0.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_84319564.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_8431962C.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_84319668.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2FA4D0/func_843196A4.s") +void func_843109F4(s32 arg0, s32 arg1, s32 arg2) { + UNUSED s32 pad[2]; + s8* var_s2; + s8 sp58[2]; + u8** temp_s4; + + var_s2 = &sp58; + temp_s4 = Memmap_GetSegmentVaddr(D_300B870); + sprintf(sp58, "%d", arg2); + + gSPDisplayList(gDisplayListHead++, D_8006F518); + + if (arg2 >= 0x64) { + arg0 -= 2; + func_8001C6AC(arg0, arg1, 8, 6, temp_s4[sp58[0] - '0'], 8, 0); + arg0 += 8; + var_s2 = &sp58[1]; + } else { + func_8001C6AC(arg0, arg1, 4, 6, temp_s4[11], 4, 0); + arg0 += 5; + } + + while (*var_s2 != 0) { + func_8001C6AC(arg0, arg1, 8, 6, temp_s4[*var_s2 - '0'], 8, 0); + arg0 += 8; + var_s2++; + } + + gSPDisplayList(gDisplayListHead++, D_8006F630); +} + +void func_84310B9C(s32 arg0, s32 arg1, s32 arg2, s32 arg3) { + UNUSED s32 pad[2]; + s8 sp70[7]; + UNUSED s32 pad2; + u8** temp_s2; + u8* var_v0; + s32 i; + + temp_s2 = Memmap_GetSegmentVaddr(D_300B870); + sprintf(sp70, "%3d/%3d", arg2, arg3); + + gSPDisplayList(gDisplayListHead++, D_8006F518); + + for (i = 0; i < sizeof(sp70); i++) { + switch (sp70[i]) { + case ' ': + var_v0 = NULL; + break; + + case '/': + var_v0 = temp_s2[10]; + break; + + default: + var_v0 = temp_s2[sp70[i] - '0']; + break; + } + + if (var_v0 != NULL) { + func_8001C6AC(arg0, arg1, 8, 6, var_v0, 8, 0); + } + + arg0 += 8; + } + + gSPDisplayList(gDisplayListHead++, D_8006F630); +} + +void func_84310CE4(s16 arg0, s16 arg1, s32 arg2, char* arg3, s32 arg4) { + func_84310334(arg0, arg1, 0x46, 0x11, &D_84385860[arg2], &D_84385870[arg2]); + func_8001F3F4(); + if (arg4 != 0) { + func_8001F324(0xFF, 0x64, 0xFF, 0xFF); + } + func_8001EBE0(2, 0); + func_8001F1E8((arg0 - (func_8001F5B0(2, 0, arg3) / 2)) + 0x23, arg1 + 2, arg3); + func_8001F444(); +} + +void func_84310DC4(s16 arg0, s16 arg1, s32 arg2, u8* arg3, s32 arg4, s32 arg5) { + s32 sp24; + s16 sp22; + s16 sp20; + + sp22 = COSS(arg4) * 255.0f; + sp20 = sp22; + if (sp22 < 0) { + sp20 = sp22 * -1; + } + + func_84310334(arg0, arg1, 0x46, 0x11, &D_84385860[arg2], &D_84385870[arg2]); + func_8001F3F4(); + func_8001EBE0(2, 0); + + if (arg5 != 0) { + func_8001F324(0xFF, 0x64, 0xFF, (s8)sp20); + } else { + func_8001F324(0xFF, 0xFF, 0xFF, (s8)sp20); + } + + if (sp22 > 0) { + sp24 = func_8001F5B0(2, 0, func_8002D7C0(NULL, 0, D_843900B0, 0xAA)) / 2; + func_8001F1E8((arg0 - sp24) + 0x23, arg1 + 2, func_8002D7C0(NULL, 0, D_843900B0, 0xAA)); + } else { + func_8001F1E8((arg0 - (func_8001F5B0(2, 0, arg3) / 2)) + 0x23, arg1 + 2, arg3); + } + + func_8001F444(); +} + +void func_84310FA4(unk_D_84390010* arg0, unk_D_800AE540_0004* arg1, s16 arg2, s16 arg3, s32 arg4, u16 arg5, s32 arg6) { + unk_D_84390010_654* ptr = &arg0->unk_654; + s32 var_t0 = 0; + s32 i; + + for (i = 0; i < 4; i++) { + if (ptr->unk_C1[i] == 1) { + var_t0 = 1; + } + } + + if (arg6 == 0) { + func_84310CE4(arg2, arg3, arg4, &arg1->unk_008, var_t0); + } else { + func_84310DC4(arg2, arg3, arg4, &arg1->unk_008, arg5, var_t0); + } +} + +void func_84311048(unk_D_84390010* arg0, unk_func_80026268_arg0* arg1, unk_D_84385790* arg2, s32 arg3, s32 arg4, + s32 arg5, s32 arg6, s32 arg7, s32 arg8, s32 arg9, s32 argA) { + s32 sp34; + s32 temp_a2; + + if (arg3 < 0) { + temp_a2 = arg5 + arg3; + if (temp_a2 < 0) { + func_8001F504(0, arg4, 0, arg6, arg7, arg8, arg9, argA); + } else { + func_8001F504(0, arg4, temp_a2, arg6, arg7, arg8, arg9, argA); + } + } else { + func_8001F504(arg3, arg4, arg5, arg6, arg7, arg8, arg9, argA); + } + + func_843109F4(arg3 + 3, arg4 + 0x10, arg1->unk_24); + func_84310368(arg3 + 2, arg4 + 0x19, D_843900A8[func_84307F00(arg0)], arg1->unk_26); + func_84310B9C(arg3 + 0xC, arg4 + 0x1F, arg1->unk_02, arg1->unk_26); + func_8001F3F4(); + func_8001EBE0(2, 0); + + sp34 = func_8001F5B0(2, 0, func_8430862C(arg0)) / 2; + func_8001F1E8((arg3 - sp34) + 0x23, arg4 + 2, func_8430862C(arg0)); + sp34 = func_8001F5B0(1, 0, func_8002D7C0(NULL, 0, D_843900BC, arg2->unk_00)); + + if (sp34 >= 0x28) { + func_8001EBE0(1, -1); + sp34 = arg3 + 0x1A; + } else { + func_8001EBE0(1, 0); + sp34 = (arg3 - (sp34 / 2)) + 0x2C; + } + + func_8001F324(arg2->unk_04.r, arg2->unk_04.g, arg2->unk_04.b, 0xFF); + func_8001F1E8(sp34, arg4 + 0xE, func_8002D7C0(NULL, 0, D_843900BC, arg2->unk_00)); + func_8001F444(); +} + +s32 func_843112C4(s32 arg0, s32 arg1, s32 arg2, s32 arg3, u8* arg4) { + UNUSED s32 pad[4]; + s32 sp2C; + s32 sp28; + + if (arg2 < 9) { + sp2C = 0x400; + } else { + sp2C = 0; + } + + // clang-format off + if (arg3 < 9) { sp28 = 0x400; } else { sp28 = 0; } + // clang-format on + + gDPLoadTextureBlock(gDisplayListHead++, arg4, G_IM_FMT_RGBA, G_IM_SIZ_16b, 8, 8, 0, G_TX_NOMIRROR | G_TX_CLAMP, + G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD); + + func_8001C4E4(arg0, arg1, (arg0 + arg2) - 1, (arg1 + arg3) - 1, sp2C, sp28, 0); +} + +void func_84311420(void) { +} + +void func_84311428(s16 arg0, s16 arg1, s16 arg2, s16 arg3) { + s32 i; + + gSPDisplayList(gDisplayListHead++, D_8006F518); + + func_843112C4(arg0, arg1 - 1, 8, 8, D_3008480); + func_843112C4(arg0, (arg1 + arg3) - 6, 8, 8, D_3008400); + func_843112C4((arg0 + arg2) - 6, arg1 - 1, 8, 8, D_3008600); + func_843112C4((arg0 + arg2) - 6, (arg1 + arg3) - 6, 8, 8, D_3008580); + + for (i = 0; i < arg3 / 8; i++) { + if ((arg3 - 4) >= (6 + i * 8)) { + func_843112C4((arg0 + arg2) - 6, arg1 + (i * 8) + 4, 8, 8, D_3008500); + } + } + + for (i = 0; i < arg3 / 8; i++) { + if ((arg3 - 4) >= (6 + i * 8)) { + func_843112C4(arg0, arg1 + (i * 8) + 4, 8, 8, D_3008380); + } + } + + for (i = 0; i < arg2 / 8; i++) { + if ((arg2 - 4) >= (6 + i * 8)) { + func_843112C4(arg0 + (i * 8) + 3, arg1 - 1, 8, 8, D_3008700); + } + + if ((arg2 - 4) >= (6 + i * 8)) { + func_843112C4(arg0 + (i * 8) + 3, (arg1 + arg3) - 6, 8, 8, D_3008680); + } + } + + gSPDisplayList(gDisplayListHead++, D_8006F630); +} + +void func_843116D8(s16 arg0, s16 arg1) { + Color_RGB8 sp54[] = { + // D_84385920 + { 0xB4, 0x00, 0x00 }, + { 0xCC, 0x8F, 0x00 }, + { 0x00, 0xB4, 0x00 }, + { 0x00, 0x00, 0x00 }, + }; + char sp44[16]; + UNUSED s32 pad[4]; + s32 var_v1; + s32 temp_t0; + + temp_t0 = ((s32)((D_84390124 / 30.0f) / 60.0f) * 0x3C) + ((s32)(D_84390124 / 30.0f) % 60); + if (temp_t0 >= 0xB) { + var_v1 = 2; + } else if (temp_t0 >= 4) { + var_v1 = 1; + } else { + var_v1 = 0; + } + + func_8001F504(arg0 - 1, arg1, 0x14, 0xD, sp54[var_v1].r, sp54[var_v1].g, sp54[var_v1].b, 0xBE); + func_84311428(arg0 - 2, arg1 - 1, 0x14, 0xC); + + sprintf(sp44, "%02d", temp_t0); + + func_8001F3F4(); + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + func_8001EBE0(1, 0); + func_8001F1E8(arg0 + 3, arg1, sp44); + func_8001F444(); + func_8430FC28(arg0 - 3, arg1 - 3, 0x19, 0x12, 0); +} + +void func_843118A8(s16 arg0, s16 arg1) { + char sp40[16]; + f32 sp3C = D_84390128 / 30.0f; + UNUSED s32 pad[2]; + + func_8001F504(arg0, arg1, 0x27, 0xC, 0, 0, 0, 0x5A); + func_84311428(arg0 - 2, arg1 - 1, 0x27, 0xC); + func_8001F3F4(); + func_8001EBE0(2, 0); + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + sprintf(sp40, "%02d", (s32)(sp3C / 60.0f)); + func_8001EBE0(1, 0); + func_8001F1E8(arg0 + 3, arg1, sp40); + func_8001F1E8(arg0 + 0x10, arg1, ":"); + sprintf(sp40, "%02d", (s32)sp3C % 60); + func_8001EBE0(1, 0); + func_8001F1E8(arg0 + 0x17, arg1, sp40); + func_8001F444(); + func_8430FC28(arg0 - 3, arg1 - 3, 0x2C, 0x11, 0); +} + +void func_84311A38(unk_D_84390010* arg0, s16 arg1, s16 arg2) { + u8* sp74[] = { D_3006170, D_30061D0, D_3006230 }; // D_8438592C + UNUSED s32 pad; + s32 i; + s32 j; + s32 var_v0_2; + + gSPDisplayList(gDisplayListHead++, D_8006F518); + + if (arg0 == D_84390010[0]) { + if (arg0->unk_720->unk_01 == 1) { + for (i = 0; i < arg0->unk_720->unk_08[0]->unk_002; i++) { + if (arg0->unk_720->unk_08[0]->unk_01C[i].unk_02 == 0) { + var_v0_2 = 2; + } else if (arg0->unk_720->unk_08[0]->unk_01C[i].unk_05 != 0) { + var_v0_2 = 1; + } else { + var_v0_2 = 0; + } + func_8001C6AC(arg1 + i * 7, arg2, 8, 6, sp74[var_v0_2], 8, 0); + } + } else { + for (i = 0; i < arg0->unk_720->unk_08[0]->unk_002; i++) { + if (arg0->unk_720->unk_08[0]->unk_01C[i].unk_02 == 0) { + var_v0_2 = 2; + } else if (arg0->unk_720->unk_08[0]->unk_01C[i].unk_05 != 0) { + var_v0_2 = 1; + } else { + var_v0_2 = 0; + } + func_8001C6AC(arg1 + i * 7, arg2, 8, 6, sp74[var_v0_2], 8, 0); + } + + for (j = 0; j < arg0->unk_720->unk_08[1]->unk_002; j++) { + if (arg0->unk_720->unk_08[1]->unk_01C[j].unk_02 == 0) { + var_v0_2 = 2; + } else if (arg0->unk_720->unk_08[1]->unk_01C[j].unk_05 != 0) { + var_v0_2 = 1; + } else { + var_v0_2 = 0; + } + func_8001C6AC(arg1 + i * 7 + j * 7, arg2, 8, 6, sp74[var_v0_2], 8, 0); + } + } + } + + if (arg0 == D_84390010[1]) { + if (arg0->unk_720->unk_01 == 1) { + for (i = 0; i < arg0->unk_720->unk_08[0]->unk_002; i++) { + if (arg0->unk_720->unk_08[0]->unk_01C[i].unk_02 == 0) { + var_v0_2 = 2; + } else if (arg0->unk_720->unk_08[0]->unk_01C[i].unk_05 != 0) { + var_v0_2 = 1; + } else { + var_v0_2 = 0; + } + func_8001C6AC(arg1 - i * 7, arg2, 8, 6, sp74[var_v0_2], 8, 0); + } + } else { + for (i = 0; i < arg0->unk_720->unk_08[0]->unk_002; i++) { + if (arg0->unk_720->unk_08[0]->unk_01C[i].unk_02 == 0) { + var_v0_2 = 2; + } else if (arg0->unk_720->unk_08[0]->unk_01C[i].unk_05 != 0) { + var_v0_2 = 1; + } else { + var_v0_2 = 0; + } + func_8001C6AC(arg1 - i * 7, arg2, 8, 6, sp74[var_v0_2], 8, 0); + } + + for (j = 0; j < arg0->unk_720->unk_08[1]->unk_002; j++) { + if (arg0->unk_720->unk_08[1]->unk_01C[j].unk_02 == 0) { + var_v0_2 = 2; + } else if (arg0->unk_720->unk_08[1]->unk_01C[j].unk_05 != 0) { + var_v0_2 = 1; + } else { + var_v0_2 = 0; + } + func_8001C6AC(arg1 - i * 7 - j * 7, arg2, 8, 6, sp74[var_v0_2], 8, 0); + } + } + } + + gSPDisplayList(gDisplayListHead++, D_8006F630); +} + +void func_84311F30(unk_D_84390010* arg0, s16 arg1, s16 arg2, u16 arg3, s32 arg4) { + UNUSED s32 pad[3]; + unk_D_800AE540_0004* sp80; + unk_func_80026268_arg0* sp7C; + Color_RGB8* temp_v0_2; + u32 var_v1; + + sp80 = arg0->unk_720->unk_08[arg0->unk_728.unk_16C]; + sp7C = &arg0->unk_720->unk_08[arg0->unk_728.unk_16C]->unk_01C[arg0->unk_654.unk_08]; + + if (sp7C->unk_02 == 0) { + var_v1 = 1; + } else { + var_v1 = func_800219A0(sp7C->unk_05); + } + + temp_v0_2 = &D_84385860[sp80->unk_001]; + func_84311048(arg0, sp7C, &D_84385790[var_v1], arg1 + 1, arg2 + 0x12, 0x46, 0x28, temp_v0_2->r, temp_v0_2->g, + temp_v0_2->b, 0xB2); + func_84310FA4(arg0, sp80, arg1 + 1, arg2 + 1, sp80->unk_001, arg3, arg4); + + gSPDisplayList(gDisplayListHead++, D_8006F518); + + func_843112C4(arg1, arg2, 8, 8, D_3008480); + func_843112C4(arg1, arg2 + 0xF, 8, 8, D_3008200); + func_843112C4(arg1, arg2 + 0x36, 8, 8, D_3008200); + func_843112C4(arg1 + 0x41, arg2, 8, 8, D_3008600); + func_843112C4(arg1 + 0x41, arg2 + 0xF, 8, 8, D_3008280); + func_843112C4(arg1 + 0x41, arg2 + 0x33, 8, 8, D_3008580); + func_843112C4(arg1 + 8, arg2, 8, 8, D_3008700); + func_843112C4(arg1 + 0x10, arg2, 8, 8, D_3008700); + func_843112C4(arg1 + 0x18, arg2, 8, 8, D_3008700); + func_843112C4(arg1 + 0x20, arg2, 8, 8, D_3008700); + func_843112C4(arg1 + 0x28, arg2, 8, 8, D_3008700); + func_843112C4(arg1 + 0x30, arg2, 8, 8, D_3008700); + func_843112C4(arg1 + 0x38, arg2, 8, 8, D_3008700); + func_843112C4(arg1 + 0x39, arg2, 8, 8, D_3008700); + func_843112C4(arg1 + 8, arg2 + 0x12, 8, 8, D_3008700); + func_843112C4(arg1 + 0x10, arg2 + 0x12, 8, 8, D_3008700); + func_843112C4(arg1 + 0x18, arg2 + 0x12, 8, 8, D_3008700); + func_843112C4(arg1 + 0x20, arg2 + 0x12, 8, 8, D_3008700); + func_843112C4(arg1 + 0x28, arg2 + 0x12, 8, 8, D_3008700); + func_843112C4(arg1 + 0x30, arg2 + 0x12, 8, 8, D_3008700); + func_843112C4(arg1 + 0x38, arg2 + 0x12, 8, 8, D_3008700); + func_843112C4(arg1 + 0x39, arg2 + 0x12, 8, 8, D_3008700); + func_843112C4(arg1 + 8, arg2 + 0x33, 8, 8, D_3008680); + func_843112C4(arg1 + 0x10, arg2 + 0x33, 8, 8, D_3008680); + func_843112C4(arg1 + 0x18, arg2 + 0x33, 8, 8, D_3008680); + func_843112C4(arg1 + 0x20, arg2 + 0x33, 8, 8, D_3008680); + func_843112C4(arg1 + 0x28, arg2 + 0x33, 8, 8, D_3008680); + func_843112C4(arg1 + 0x30, arg2 + 0x33, 8, 8, D_3008680); + func_843112C4(arg1 + 0x38, arg2 + 0x33, 8, 8, D_3008680); + func_843112C4(arg1 + 0x39, arg2 + 0x33, 8, 8, D_3008680); + func_843112C4(arg1, arg2 + 8, 8, 8, D_3008380); + func_843112C4(arg1, arg2 + 0x15, 8, 8, D_3008380); + func_843112C4(arg1, arg2 + 0x1D, 8, 8, D_3008380); + func_843112C4(arg1, arg2 + 0x25, 8, 8, D_3008380); + func_843112C4(arg1, arg2 + 0x2D, 8, 8, D_3008380); + func_843112C4(arg1, arg2 + 0x2E, 8, 8, D_3008380); + func_843112C4(arg1 + 0x41, arg2 + 8, 8, 8, D_3008500); + func_843112C4(arg1 + 0x41, arg2 + 0x15, 8, 8, D_3008500); + func_843112C4(arg1 + 0x41, arg2 + 0x1D, 8, 8, D_3008500); + func_843112C4(arg1 + 0x41, arg2 + 0x25, 8, 8, D_3008500); + func_843112C4(arg1 + 0x41, arg2 + 0x2D, 8, 8, D_3008500); + func_843112C4(arg1 + 0x41, arg2 + 0x2F, 8, 8, D_3008500); + func_843112C4(arg1, arg2 + 0x3D, 8, 8, D_3008380); + func_843112C4(arg1, arg2 + 0x45, 8, 8, D_3008380); + func_843112C4(arg1, arg2 + 0x4D, 8, 8, D_3008380); + func_843112C4(arg1, arg2 + 0x55, 8, 8, D_3008380); + func_843112C4(arg1 + 0x21, arg2 + 0x3A, 8, 8, D_3008500); + func_843112C4(arg1 + 0x21, arg2 + 0x3D, 8, 8, D_3008500); + func_843112C4(arg1 + 0x21, arg2 + 0x45, 8, 8, D_3008500); + func_843112C4(arg1 + 0x21, arg2 + 0x4D, 8, 8, D_3008500); + func_843112C4(arg1 + 0x21, arg2 + 0x55, 8, 8, D_3008500); + func_843112C4(arg1 + 0x21, arg2 + 0x59, 8, 8, D_3008580); + func_843112C4(arg1, arg2 + 0x59, 8, 8, D_3008400); + func_843112C4(arg1 + 4, arg2 + 0x59, 8, 8, D_3008680); + func_843112C4(arg1 + 0xC, arg2 + 0x59, 8, 8, D_3008680); + func_843112C4(arg1 + 0x14, arg2 + 0x59, 8, 8, D_3008680); + func_843112C4(arg1 + 0x1C, arg2 + 0x59, 8, 8, D_3008680); + + gSPDisplayList(gDisplayListHead++, D_8006F630); + + func_8430FC28(arg1 - 3, arg2 - 2, 0x4E, 0x3F, 0); + func_8430FC28(arg1 - 3, arg2 + 0x3A, 0x2D, 0x29, 0); + func_84311A38(arg0, arg1, arg2 + 0x62); +} + +void func_843128A0(unk_D_84390010* arg0, s16 arg1, s16 arg2, u16 arg3, s32 arg4) { + UNUSED s32 pad[3]; + unk_D_800AE540_0004* sp80; + unk_func_80026268_arg0* sp7C; + Color_RGB8* temp_v0; + u32 var_v1; + + sp80 = arg0->unk_720->unk_08[arg0->unk_728.unk_16C]; + sp7C = &arg0->unk_720->unk_08[arg0->unk_728.unk_16C]->unk_01C[arg0->unk_654.unk_08]; + + if (sp7C->unk_02 == 0) { + var_v1 = 1; + } else { + var_v1 = func_800219A0(sp7C->unk_05); + } + + temp_v0 = &D_84385860[sp80->unk_001]; + func_84311048(arg0, sp7C, &D_84385790[var_v1], arg1, arg2 + 0x28, 0x46, 0x28, temp_v0->r, temp_v0->g, temp_v0->b, + 0xB2); + func_84310FA4(arg0, sp80, arg1, arg2 + 0x50, sp80->unk_001, arg3, arg4); + + gSPDisplayList(gDisplayListHead++, D_8006F518); + + func_843112C4(arg1, arg2 + 0x4C, 8, 8, D_3008200); + func_843112C4(arg1, arg2 + 0x5B, 8, 8, D_3008400); + func_843112C4(arg1, arg2 + 0x27, 8, 8, D_3008480); + func_843112C4(arg1 + 0x3F, arg2 + 0x24, 8, 8, D_3008280); + func_843112C4(arg1 + 0x3F, arg2 + 0x4C, 8, 8, D_3008280); + func_843112C4(arg1 + 0x3F, arg2 + 0x5B, 8, 8, D_3008580); + func_843112C4(arg1 + 7, arg2 + 0x27, 8, 8, D_3008700); + func_843112C4(arg1 + 8, arg2 + 0x27, 8, 8, D_3008700); + func_843112C4(arg1 + 0x10, arg2 + 0x27, 8, 8, D_3008700); + func_843112C4(arg1 + 0x18, arg2 + 0x27, 8, 8, D_3008700); + func_843112C4(arg1 + 0x20, arg2 + 0x27, 8, 8, D_3008700); + func_843112C4(arg1 + 0x28, arg2 + 0x27, 8, 8, D_3008700); + func_843112C4(arg1 + 0x30, arg2 + 0x27, 8, 8, D_3008700); + func_843112C4(arg1 + 0x38, arg2 + 0x27, 8, 8, D_3008700); + func_843112C4(arg1 + 7, arg2 + 0x4F, 8, 8, D_3008700); + func_843112C4(arg1 + 8, arg2 + 0x4F, 8, 8, D_3008700); + func_843112C4(arg1 + 0x10, arg2 + 0x4F, 8, 8, D_3008700); + func_843112C4(arg1 + 0x18, arg2 + 0x4F, 8, 8, D_3008700); + func_843112C4(arg1 + 0x20, arg2 + 0x4F, 8, 8, D_3008700); + func_843112C4(arg1 + 0x28, arg2 + 0x4F, 8, 8, D_3008700); + func_843112C4(arg1 + 0x30, arg2 + 0x4F, 8, 8, D_3008700); + func_843112C4(arg1 + 0x38, arg2 + 0x4F, 8, 8, D_3008700); + func_843112C4(arg1 + 7, arg2 + 0x5B, 8, 8, D_3008680); + func_843112C4(arg1 + 8, arg2 + 0x5B, 8, 8, D_3008680); + func_843112C4(arg1 + 0x10, arg2 + 0x5B, 8, 8, D_3008680); + func_843112C4(arg1 + 0x18, arg2 + 0x5B, 8, 8, D_3008680); + func_843112C4(arg1 + 0x20, arg2 + 0x5B, 8, 8, D_3008680); + func_843112C4(arg1 + 0x28, arg2 + 0x5B, 8, 8, D_3008680); + func_843112C4(arg1 + 0x30, arg2 + 0x5B, 8, 8, D_3008680); + func_843112C4(arg1 + 0x38, arg2 + 0x5B, 8, 8, D_3008680); + func_843112C4(arg1, arg2 + 0x2C, 8, 8, D_3008380); + func_843112C4(arg1, arg2 + 0x34, 8, 8, D_3008380); + func_843112C4(arg1, arg2 + 0x3C, 8, 8, D_3008380); + func_843112C4(arg1, arg2 + 0x44, 8, 8, D_3008380); + func_843112C4(arg1, arg2 + 0x52, 8, 8, D_3008380); + func_843112C4(arg1, arg2 + 0x53, 8, 8, D_3008380); + func_843112C4(arg1 + 0x3F, arg2 + 0x2C, 8, 8, D_3008500); + func_843112C4(arg1 + 0x3F, arg2 + 0x34, 8, 8, D_3008500); + func_843112C4(arg1 + 0x3F, arg2 + 0x3C, 8, 8, D_3008500); + func_843112C4(arg1 + 0x3F, arg2 + 0x44, 8, 8, D_3008500); + func_843112C4(arg1 + 0x3F, arg2 + 0x52, 8, 8, D_3008500); + func_843112C4(arg1 + 0x3F, arg2 + 0x53, 8, 8, D_3008500); + func_843112C4(arg1 + 0x3F, arg2, 8, 8, D_3008600); + func_843112C4(arg1 + 0x1E, arg2, 8, 8, D_3008480); + func_843112C4(arg1 + 0x3F, arg2 + 8, 8, 8, D_3008500); + func_843112C4(arg1 + 0x3F, arg2 + 0x10, 8, 8, D_3008500); + func_843112C4(arg1 + 0x3F, arg2 + 0x18, 8, 8, D_3008500); + func_843112C4(arg1 + 0x3F, arg2 + 0x20, 8, 8, D_3008500); + func_843112C4(arg1 + 0x1E, arg2 + 8, 8, 8, D_3008380); + func_843112C4(arg1 + 0x1E, arg2 + 0x10, 8, 8, D_3008380); + func_843112C4(arg1 + 0x1E, arg2 + 0x18, 8, 8, D_3008380); + func_843112C4(arg1 + 0x1E, arg2 + 0x1F, 8, 8, D_3008380); + func_843112C4(arg1 + 0x20, arg2, 8, 8, D_3008700); + func_843112C4(arg1 + 0x28, arg2, 8, 8, D_3008700); + func_843112C4(arg1 + 0x30, arg2, 8, 8, D_3008700); + func_843112C4(arg1 + 0x37, arg2, 8, 8, D_3008700); + + gSPDisplayList(gDisplayListHead++, D_8006F630); + + func_8430FC28(arg1 + 0x1B, arg2 - 2, 0x2F, 0x2A, 0); + func_8430FC28(arg1 - 4, arg2 + 0x26, 0x4D, 0x3D, 0); + func_84311A38(arg0, arg1 + 0x41, arg2 - 7); +} + +void func_84313148(unk_D_84390010* arg0, s16 arg1, s16 arg2, s32 arg3) { + UNUSED s32 pad[2]; + + func_84310334(arg1 + 1, arg2 + 1, 0xC6, 0x10, &D_84385860[arg3], &D_84385870[arg3]); + func_84311428(arg1, arg2, 0xC6, 0x10); + + gSPDisplayList(gDisplayListHead++, D_8006F5A0); + + func_8001D560(arg1 + 7, arg2 + 3, 0x10, 0xC, D_3008C00, D_3008D80, 0x10, 0x100000); + func_8001D560(arg1 + 0x46, arg2 + 3, 0x10, 0xC, D_3008E40, D_3008FC0, 0x10, 0x100000); + func_8001D560(arg1 + 0x86, arg2 + 3, 0x10, 0xC, D_3009080, D_3009200, 0x10, 0x100000); + + gSPDisplayList(gDisplayListHead++, D_8006F630); + + func_8001F3F4(); + func_8001EBE0(1, 0); + func_8001F1E8(arg1 + 0x18, arg2 + 3, func_8002D7C0(NULL, 0, D_843900B0, 0x9E)); + func_8001F1E8(arg1 + 0x58, arg2 + 3, func_8002D7C0(NULL, 0, D_843900B0, 0x9F)); + func_8001F1E8(arg1 + 0x98, arg2 + 3, func_8002D7C0(NULL, 0, D_843900B0, 0xA0)); + func_8001F444(); + func_8430FC28(arg1 - 2, arg2 - 2, 0xCC, 0x16, 0); +} + +void func_843133B4(unk_D_84390010* arg0, s16 arg1, s16 arg2, s32 arg3) { + UNUSED s32 pad[2]; + + func_84310334(arg1, arg2, 0x7D, 0x10, &D_84385860[arg3], &D_84385870[arg3]); + func_84311428(arg1, arg2, 0x7D, 0x10); + + gSPDisplayList(gDisplayListHead++, D_8006F5A0); + + func_8001D560(arg1 + 7, arg2 + 3, 0x10, 0xC, D_3008780, D_3008900, 0x10, 0x100000); + func_8001D560(arg1 + 0x40, arg2 + 3, 0x10, 0xC, D_30089C0, D_3008B40, 0x10, 0x100000); + + gSPDisplayList(gDisplayListHead++, D_8006F630); + + func_8001F3F4(); + func_8001EBE0(1, 0); + func_8001F1E8(arg1 + 0x18, arg2 + 3, func_8002D7C0(NULL, 0, D_843900B0, 0xA9)); + func_8001F1E8(arg1 + 0x51, arg2 + 3, func_8002D7C0(NULL, 0, D_843900B0, 0xA8)); + func_8001F444(); + func_8430FC28(arg1 - 2, arg2 - 2, 0x83, 0x16, 0); +} + +void func_843135B8(unk_D_84390010* arg0, s16 arg1, s16 arg2, s32 arg3) { + s32 pad[2]; + + func_84310334(arg1 + 1, arg2 + 1, 0x47, 0x10, &D_84385860[arg3], &D_84385870[arg3]); + func_84311428(arg1, arg2, 0x47, 0x10); + + gSPDisplayList(gDisplayListHead++, D_8006F5A0); + + func_8001D560(arg1 + 7, arg2 + 3, 0x10, 0xC, D_30089C0, D_3008B40, 0x10, 0x100000); + + gSPDisplayList(gDisplayListHead++, D_8006F630); + + func_8001F3F4(); + func_8001EBE0(1, 0); + func_8001F1E8(arg1 + 0x18, arg2 + 3, func_8002D7C0(NULL, 0, D_843900B0, 0xA8)); + func_8001F444(); + func_8430FC28(arg1 - 2, arg2 - 2, 0x4A, 0x16, 0); +} + +void func_84313750(s32 arg0, s32 arg1, char* arg2) { + func_8001F1E8(arg0 - (strlen(arg2) * 6), arg1, arg2); +} + +s32 func_8431379C(s32 arg0, s32 arg1, s32 arg2, s32 arg3) { + UNUSED s32 pad[2]; + s8 sp70[7]; + s32 i; + u8** temp_s2; + u8* var_v1; + + temp_s2 = Memmap_GetSegmentVaddr(D_300B870); + sprintf(sp70, "%3d/%3d", arg2 & 0x3F, arg3); + + gSPDisplayList(gDisplayListHead++, D_8006F518); + + for (i = 0; i < 7; i++) { + s32 c = sp70[i]; + + switch (c) { + case ' ': + var_v1 = NULL; + break; + + case '/': + var_v1 = temp_s2[10]; + break; + + default: + if ((c >= 0x30) && (c < 0x3A)) { + var_v1 = temp_s2[c - '0']; + } else { + var_v1 = NULL; + } + break; + } + + if (var_v1 != NULL) { + func_8001C6AC(arg0, arg1, 8, 6, var_v1, 8, 0); + arg0 += 8; + } + } + + gSPDisplayList(gDisplayListHead++, D_8006F630); + + return arg0; +} + +s32 func_84313908(s32 arg0, s32 arg1, s32 arg2, s32 arg3) { + UNUSED s32 pad[2]; + s8 sp70[7]; + s32 i; + u8** temp_s2; + u8* var_v1; + + temp_s2 = Memmap_GetSegmentVaddr(D_300B870); + sprintf(sp70, "%3d/%3d", arg2 & 0x3F, arg3); + + gSPDisplayList(gDisplayListHead++, D_8006F518); + + for (i = 7; i > 0; i--) { + s32 c = sp70[i]; + + switch (c) { + case ' ': + var_v1 = NULL; + break; + + case '/': + var_v1 = temp_s2[10]; + break; + + default: + if ((c >= 0x30) && (c < 0x3A)) { + var_v1 = temp_s2[c - '0']; + } else { + var_v1 = NULL; + } + break; + } + + if (var_v1 != NULL) { + func_8001C6AC(arg0, arg1, 8, 6, var_v1, 8, 0); + arg0 -= 8; + } + } + + gSPDisplayList(gDisplayListHead++, D_8006F630); + + return arg0; +} + +void func_84313A74(unk_D_84390010* arg0, s16 arg1, s16 arg2, s32 arg3) { + s32 i; + s32 sp64[] = { 0, 0, 0, 0 }; // D_84385938 + u8 sp60[4]; + unk_D_84390010_654_038* temp_s0; + unk_func_80026268_arg0* sp58; + UNUSED s32 pad; + + sp58 = &arg0->unk_720->unk_08[arg0->unk_728.unk_16C]->unk_01C[arg0->unk_654.unk_08]; + temp_s0 = &arg0->unk_654.unk_38; + + func_84310334(arg1 + 1, arg2 + 1, 0xC7, 0x38, &D_84385860[arg3], &D_84385870[arg3]); + func_84311428(arg1, arg2, 0xC7, 0x38); + + for (i = 0; i < 4; i++) { + if (temp_s0->unk_4E & 8) { + sp60[i] = D_80072B00[temp_s0->unk_1F[i] - 1].unk_05 / 5; + if (sp60[i] >= 8) { + sp60[i] = 7; + } + sp60[i] = D_80072B00[temp_s0->unk_1F[i] - 1].unk_05 + (((temp_s0->unk_32[i] & 0xC0) >> 6) * sp60[i]); + } else { + sp60[i] = D_80072B00[sp58->unk_09[i] - 1].unk_05 / 5; + if (sp60[i] >= 8) { + sp60[i] = 7; + } + sp60[i] = D_80072B00[sp58->unk_09[i] - 1].unk_05 + (((sp58->unk_20[i] & 0xC0) >> 6) * sp60[i]); + } + } + + if (temp_s0->unk_4E & 8) { + if ((temp_s0->unk_1F[0] != 0) && (temp_s0->unk_1F[0] < 0xA6)) { + sp64[0] = func_84313908(arg1 + 0x52, arg2 + 0xF, temp_s0->unk_32[0], sp60[0]); + } + + if ((temp_s0->unk_1F[1] != 0) && (temp_s0->unk_1F[1] < 0xA6)) { + sp64[1] = func_8431379C(arg1 + 0x7C, arg2 + 0x1C, temp_s0->unk_32[1], sp60[1]); + } + + if ((temp_s0->unk_1F[2] != 0) && (temp_s0->unk_1F[2] < 0xA6)) { + sp64[2] = func_8431379C(arg1 + 0x70, arg2 + 0x30, temp_s0->unk_32[2], sp60[2]); + } + + if ((temp_s0->unk_1F[3] != 0) && (temp_s0->unk_1F[3] < 0xA6)) { + sp64[3] = func_84313908(arg1 + 0x44, arg2 + 0x23, temp_s0->unk_32[3], sp60[3]); + } + } else { + if ((sp58->unk_09[0] != 0) && (sp58->unk_09[0] < 0xA6)) { + sp64[0] = func_84313908(arg1 + 0x52, arg2 + 0xF, sp58->unk_20[0], sp60[0]); + } + + if ((sp58->unk_09[1] != 0) && (sp58->unk_09[1] < 0xA6)) { + sp64[1] = func_8431379C(arg1 + 0x7C, arg2 + 0x1C, sp58->unk_20[1], sp60[1]); + } + + if ((sp58->unk_09[2] != 0) && (sp58->unk_09[2] < 0xA6)) { + sp64[2] = func_8431379C(arg1 + 0x70, arg2 + 0x30, sp58->unk_20[2], sp60[2]); + } + + if ((sp58->unk_09[3] != 0) && (sp58->unk_09[3] < 0xA6)) { + sp64[3] = func_84313908(arg1 + 0x44, arg2 + 0x23, sp58->unk_20[3], sp60[3]); + } + } + + gSPDisplayList(gDisplayListHead++, D_8006F5A0); + + func_8001D560(arg1 + 0x5D, arg2 + 6, 0x10, 0xE, &D_3006A70, &D_3006C30, 0x10, 0x100000); + func_8001D560(arg1 + 0x6C, arg2 + 0x16, 0x10, 0xE, &D_3006290, &D_3006450, 0x10, 0x100000); + func_8001D560(arg1 + 0x5D, arg2 + 0x26, 0x10, 0xE, &D_3006530, &D_30066F0, 0x10, 0x100000); + func_8001D560(arg1 + 0x4E, arg2 + 0x16, 0x10, 0xE, &D_30067D0, &D_3006990, 0x10, 0x100000); + + gSPDisplayList(gDisplayListHead++, D_8006F630); + gSPDisplayList(gDisplayListHead++, D_8006F518); + + if (temp_s0->unk_4E & 8) { + if ((temp_s0->unk_1F[0] != 0) && (temp_s0->unk_1F[0] < 0xA6)) { + func_8001C6AC(sp64[0] - 0x19, arg2 + 0xE, 0x20, 9, D_843857C8[D_80072B00[temp_s0->unk_1F[0] - 1].unk_03], + 0x20, 0); + } + + if ((temp_s0->unk_1F[1] != 0) && (temp_s0->unk_1F[1] < 0xA6)) { + func_8001C6AC(sp64[1], arg2 + 0x1B, 0x20, 9, D_843857C8[D_80072B00[temp_s0->unk_1F[1] - 1].unk_03], 0x20, + 0); + } + + if ((temp_s0->unk_1F[2] != 0) && (temp_s0->unk_1F[2] < 0xA6)) { + func_8001C6AC(sp64[2], arg2 + 0x2F, 0x20, 9, D_843857C8[D_80072B00[temp_s0->unk_1F[2] - 1].unk_03], 0x20, + 0); + } + + if ((temp_s0->unk_1F[3] != 0) && (temp_s0->unk_1F[3] < 0xA6)) { + func_8001C6AC(sp64[3] - 0x18, arg2 + 0x22, 0x20, 9, D_843857C8[D_80072B00[temp_s0->unk_1F[3] - 1].unk_03], + 0x20, 0); + } + } else { + if ((temp_s0->unk_1F[0] != 0) && (temp_s0->unk_1F[0] < 0xA6)) { + func_8001C6AC(sp64[0] - 0x19, arg2 + 0xE, 0x20, 9, D_843857C8[D_80072B00[temp_s0->unk_1F[0] - 1].unk_03], + 0x20, 0); + } + + if ((temp_s0->unk_1F[1] != 0) && (temp_s0->unk_1F[1] < 0xA6)) { + func_8001C6AC(sp64[1], arg2 + 0x1B, 0x20, 9, D_843857C8[D_80072B00[temp_s0->unk_1F[1] - 1].unk_03], 0x20, + 0); + } + + if ((temp_s0->unk_1F[2] != 0) && (temp_s0->unk_1F[2] < 0xA6)) { + func_8001C6AC(sp64[2], arg2 + 0x2F, 0x20, 9, D_843857C8[D_80072B00[temp_s0->unk_1F[2] - 1].unk_03], 0x20, + 0); + } + + if ((temp_s0->unk_1F[3] != 0) && (temp_s0->unk_1F[3] < 0xA6)) { + func_8001C6AC(sp64[3] - 0x18, arg2 + 0x22, 0x20, 9, D_843857C8[D_80072B00[temp_s0->unk_1F[3] - 1].unk_03], + 0x20, 0); + } + } + + gSPDisplayList(gDisplayListHead++, D_8006F630); + + func_8001F3F4(); + func_8001EBE0(1, 0); + + if (temp_s0->unk_4E & 8) { + if ((temp_s0->unk_1F[0] != 0) && (temp_s0->unk_1F[0] < 0xA6)) { + if (arg0->unk_654.unk_C1[0] == 1) { + func_8001F324(0xFF, 0x64, 0xFF, 0xFF); + } else { + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + } + func_84313750(arg1 + 0x5A, arg2 + 4, func_8002D7C0(NULL, 0, D_843900B8, temp_s0->unk_1F[0] - 1)); + } + + if ((temp_s0->unk_1F[1] != 0) && (temp_s0->unk_1F[1] < 0xA6)) { + if (arg0->unk_654.unk_C1[1] == 1) { + func_8001F324(0xFF, 0x64, 0xFF, 0xFF); + } else { + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + } + func_8001F1E8(arg1 + 0x7C, arg2 + 0x11, func_8002D7C0(NULL, 0, D_843900B8, temp_s0->unk_1F[1] - 1)); + } + + if ((temp_s0->unk_1F[2] != 0) && (temp_s0->unk_1F[2] < 0xA6)) { + if (arg0->unk_654.unk_C1[2] == 1) { + func_8001F324(0xFF, 0x64, 0xFF, 0xFF); + } else { + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + } + func_8001F1E8(arg1 + 0x6E, arg2 + 0x25, func_8002D7C0(NULL, 0, D_843900B8, temp_s0->unk_1F[2] - 1)); + } + + if ((temp_s0->unk_1F[3] != 0) && (temp_s0->unk_1F[3] < 0xA6)) { + if (arg0->unk_654.unk_C1[3] == 1) { + func_8001F324(0xFF, 0x64, 0xFF, 0xFF); + } else { + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + } + func_84313750(arg1 + 0x4C, arg2 + 0x18, func_8002D7C0(NULL, 0, D_843900B8, temp_s0->unk_1F[3] - 1)); + } + } else { + if ((temp_s0->unk_1F[0] != 0) && (temp_s0->unk_1F[0] < 0xA6)) { + if (arg0->unk_654.unk_C1[0] == 1) { + func_8001F324(0xFF, 0x64, 0xFF, 0xFF); + } else { + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + } + func_84313750(arg1 + 0x5A, arg2 + 4, func_8002D7C0(NULL, 0, D_843900B8, temp_s0->unk_1F[0] - 1)); + } + + if ((temp_s0->unk_1F[1] != 0) && (temp_s0->unk_1F[1] < 0xA6)) { + if (arg0->unk_654.unk_C1[1] == 1) { + func_8001F324(0xFF, 0x64, 0xFF, 0xFF); + } else { + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + } + func_8001F1E8(arg1 + 0x7C, arg2 + 0x11, func_8002D7C0(NULL, 0, D_843900B8, temp_s0->unk_1F[1] - 1)); + } + + if ((temp_s0->unk_1F[2] != 0) && (temp_s0->unk_1F[2] < 0xA6)) { + if (arg0->unk_654.unk_C1[2] == 1) { + func_8001F324(0xFF, 0x64, 0xFF, 0xFF); + } else { + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + } + func_8001F1E8(arg1 + 0x6E, arg2 + 0x25, func_8002D7C0(NULL, 0, D_843900B8, temp_s0->unk_1F[2] - 1)); + } + + if ((temp_s0->unk_1F[3] != 0) && (temp_s0->unk_1F[3] < 0xA6)) { + if (arg0->unk_654.unk_C1[3] == 1) { + func_8001F324(0xFF, 0x64, 0xFF, 0xFF); + } else { + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + } + func_84313750(arg1 + 0x4C, arg2 + 0x18, func_8002D7C0(NULL, 0, D_843900B8, temp_s0->unk_1F[3] - 1)); + } + } + + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + + if (temp_s0->unk_1F[0] >= 0xA6) { + // "？？？？？" + static const char D_8438B328[] = { 0xA1, 0xA9, 0xA1, 0xA9, 0xA1, 0xA9, 0xA1, 0xA9, 0xA1, 0xA9 }; + func_84313750(arg1 + 0x5A, arg2 + 4, D_8438B328); + } + + if (temp_s0->unk_1F[1] >= 0xA6) { + // "？？？？？" + static const char D_8438B334[] = { 0xA1, 0xA9, 0xA1, 0xA9, 0xA1, 0xA9, 0xA1, 0xA9, 0xA1, 0xA9 }; + func_8001F1E8(arg1 + 0x7C, arg2 + 0x11, D_8438B334); + } + + if (temp_s0->unk_1F[2] >= 0xA6) { + // "？？？？？" + static const char D_8438B340[] = { 0xA1, 0xA9, 0xA1, 0xA9, 0xA1, 0xA9, 0xA1, 0xA9, 0xA1, 0xA9 }; + func_8001F1E8(arg1 + 0x6E, arg2 + 0x25, D_8438B340); + } + + if (temp_s0->unk_1F[3] >= 0xA6) { + // "？？？？？" + static const char D_8438B34C[] = { 0xA1, 0xA9, 0xA1, 0xA9, 0xA1, 0xA9, 0xA1, 0xA9, 0xA1, 0xA9 }; + func_84313750(arg1 + 0x4C, arg2 + 0x18, D_8438B34C); + } + + func_8001F444(); + func_8430FC28(arg1 - 2, arg2 - 2, 0xCD, 0x3E, 0); +} + +void func_8431493C(s16 arg0, s16 arg1, s16 arg2, s32 arg3) { + // こうさんしますか? + static const char D_8438B358[] = { + 0xa4, 0xb3, 0xa4, 0xa6, 0xa4, 0xb5, 0xa4, 0xf3, 0xa4, 0xb7, 0xa4, 0xde, 0xa4, 0xb9, 0xa4, 0xab, 0x3f, + }; + // "いいえ" + static const char D_8438B36C[] = { 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa8 }; + // "はい" + static const char D_8438B374[] = { 0xa4, 0xcf, 0xa4, 0xa4, 0x00, 0x00 }; + UNUSED s32 pad[2]; + s32 var_v1; + + if (func_80029074()[arg2].unk_000 & 2) { + var_v1 = 4; + } else { + var_v1 = arg2; + } + + func_84310334(arg0 + 1, arg1 + 1, 0xC6, 0x28, &D_84385860[var_v1], &D_84385870[var_v1]); + func_8001F3F4(); + func_8001EBE0(2, 0); + func_8001F1E8(arg0 + 0x2E, arg1 + 6, D_8438B358); + func_8001F1E8(arg0 + 0x38, arg1 + 0x18, D_8438B36C); + func_8001F1E8(arg0 + 0x81, arg1 + 0x18, D_8438B374); + func_8001F444(); + + gSPDisplayList(gDisplayListHead++, D_8006F5A0); + + func_8001D560(arg0 + 0x21, arg1 + 0x17, 0x18, 0xE, D_30092C0, D_3009560, 0x18, 0x100000); + + gSPDisplayList(gDisplayListHead++, D_8006F630); + + func_84311428(arg0, arg1, 0xC6, 0x28); + func_8430FC28(arg0 - 3, arg1 - 2, 0xCC, 0x2D, 0); +} + +void func_84314B20(s16 arg0, s16 arg1, char* arg2) { + func_8001F3F4(); + func_8001EBE0(1, 0); + func_8001F1E8(arg0, arg1, arg2); + func_8001F444(); +} + +void func_84314B6C(unk_D_84390010* arg0, unk_D_800AE540_0004* arg1, unk_func_80026268_arg0* arg2, s32 arg3, s32 arg4, + s32 arg5) { + s32 var_t0; + + func_843109F4(arg3 + 3, arg4 + 4, arg2->unk_24); + func_84310368(arg3 + 0x1E, arg4 + 0xE, arg2->unk_02, arg2->unk_26); + func_84310B9C(arg3 + 0x26, arg4 + 0x14, arg2->unk_02, arg2->unk_26); + + gSPDisplayList(gDisplayListHead++, D_8006F5A0); + + if (arg5 == 0) { + func_8001D560(arg3 + 2, arg4 + 0xD, 0x10, 0xE, D_3006A70, D_3006C30, 0x10, 0x100000); + } + + if (arg5 == 1) { + func_8001D560(arg3 + 2, arg4 + 0xD, 0x10, 0xE, D_30067D0, D_3006990, 0x10, 0x100000); + } + + if (arg5 == 2) { + func_8001D560(arg3 + 2, arg4 + 0xD, 0x10, 0xC, D_3008E40, D_3008FC0, 0x10, 0x100000); + } + + if (arg5 == 3) { + func_8001D560(arg3 + 2, arg4 + 0xD, 0x10, 0xE, D_3006290, D_3006450, 0x10, 0x100000); + } + + if (arg5 == 4) { + func_8001D560(arg3 + 2, arg4 + 0xD, 0x10, 0xE, D_3006530, D_30066F0, 0x10, 0x100000); + } + + if (arg5 == 5) { + func_8001D560(arg3 + 2, arg4 + 0xD, 0x10, 0xC, D_3008C00, D_3008D80, 0x10, 0x100000); + } + + gSPDisplayList(gDisplayListHead++, D_8006F630); + + func_8001F3F4(); + func_8001EBE0(1, 0); + func_8001F1E8(arg3 + 0x1D, arg4 + 2, arg2->unk_30); + func_8001F444(); + + if (arg1->unk_01C[arg5].unk_02 == 0) { + var_t0 = 1; + } else { + var_t0 = func_800219A0(arg1->unk_01C[arg5].unk_05); + } + + if (var_t0 != 0) { + gSPDisplayList(gDisplayListHead++, D_8006F518); + + func_8001C6AC(arg3 + 0x11, arg4 + 0x14, 0x14, 9, D_84385838[var_t0 - 1], 0x14, 0); + gSPDisplayList(gDisplayListHead++, D_8006F630); + } +} + +void func_84314F60(unk_D_84390010* arg0, unk_D_800AE540_0004* arg1, unk_func_80026268_arg0* arg2, s32 arg3, s32 arg4, + s32 arg5) { + s32 var_t0; + + func_843109F4(arg3 + 3, arg4 + 4, arg2->unk_24); + func_84310368(arg3 + 0x1E, arg4 + 0xE, arg2->unk_02, arg2->unk_26); + func_84310B9C(arg3 + 0x26, arg4 + 0x14, arg2->unk_02, arg2->unk_26); + + gSPDisplayList(gDisplayListHead++, D_8006F5A0); + + if (arg5 == 0) { + func_8001D560(arg3 + 2, arg4 + 0xD, 0x10, 0xE, D_3006A70, D_3006C30, 0x10, 0x100000); + } + + if (arg5 == 1) { + func_8001D560(arg3 + 2, arg4 + 0xD, 0x10, 0xE, D_3006290, D_3006450, 0x10, 0x100000); + } + + if (arg5 == 2) { + func_8001D560(arg3 + 2, arg4 + 0xD, 0x10, 0xE, D_3006530, D_30066F0, 0x10, 0x100000); + } + + gSPDisplayList(gDisplayListHead++, D_8006F630); + + func_8001F3F4(); + func_8001EBE0(1, 0); + func_8001F1E8(arg3 + 0x1D, arg4 + 2, arg2->unk_30); + func_8001F444(); + + if (arg1->unk_01C[arg5].unk_02 == 0) { + var_t0 = 1; + } else { + var_t0 = func_800219A0(arg1->unk_01C[arg5].unk_05); + } + + if (var_t0 != 0) { + gSPDisplayList(gDisplayListHead++, D_8006F518); + + func_8001C6AC(arg3 + 0x11, arg4 + 0x14, 0x14, 9, D_84385838[var_t0 - 1], 0x14, 0); + + gSPDisplayList(gDisplayListHead++, D_8006F630); + } +} + +void func_8431524C(unk_D_84390010* arg0, unk_D_800AE540_0004* arg1, s16 arg2, s16 arg3, s32 arg4) { + UNUSED s32 pad[2]; + Color_RGB8* sp88[] = { + // D_84385948 + D_84385888, + D_843858A0, + D_843858B8, + D_843858D0, + }; + Color_RGB8* sp78[] = { + // D_84385958 + D_84385894, + D_843858AC, + D_843858C4, + D_843858DC, + }; + UNUSED s32 pad2[4]; + + func_84310334(arg2 + 1, arg3 + 1, 0x63, 0xF, &sp88[arg4][0], &sp78[arg4][0]); + func_84310334(arg2 + 1, arg3 + 0x10, 0x63, 0x1D, &sp88[arg4][1], &sp78[arg4][1]); + func_84310334(arg2 + 1, arg3 + 0x2D, 0x63, 0x1D, &sp88[arg4][2], &sp78[arg4][2]); + func_84310334(arg2 + 1, arg3 + 0x4A, 0x63, 0x1D, &sp88[arg4][3], &sp78[arg4][3]); + + func_84314B20((arg2 - (func_8001F5B0(1, 0, arg1->unk_008) / 2)) + 0x32, arg3 + 3, arg1->unk_008); + + if (arg1->unk_002 > 0) { + func_84314F60(arg0, arg1, &arg1->unk_01C[0], arg2 + 1, arg3 + 0x10, 0); + } + + if (arg1->unk_002 >= 2) { + func_84314F60(arg0, arg1, &arg1->unk_01C[1], arg2 + 1, arg3 + 0x2D, 1); + } + + if (arg1->unk_002 >= 3) { + func_84314F60(arg0, arg1, &arg1->unk_01C[2], arg2 + 1, arg3 + 0x4A, 2); + } + + gSPDisplayList(gDisplayListHead++, D_8006F518); + + func_8001C6AC(arg2 + 1, arg3, 0x18, 0x10, D_84385850[arg4], 0x18, 0); + + gSPDisplayList(gDisplayListHead++, D_8006F630); + + func_84311428(arg2, arg3, 0x63, 0x66); + func_8430FC28(arg2 - 2, arg3 - 2, 0x69, 0x6A, 0); +} + +void func_84315550(unk_D_84390010* arg0, s16 arg1, s16 arg2, s32 arg3) { + unk_D_800AE540_0004* temp_s0; + unk_D_800AE540_0004* temp_s1; + unk_func_80026268_arg0* ptr = &arg0->unk_724->unk_01C[0]; + s32 i; + Color_RGB8* sp88[] = { + // D_84385968 + D_84385888, + D_843858A0, + D_843858B8, + D_843858D0, + }; + Color_RGB8* sp78[] = { + // D_84385978 + D_84385894, + D_843858AC, + D_843858C4, + D_843858DC, + }; + s32 tmp; + unk_func_80026268_arg0* sp5C[6]; + + temp_s0 = arg0->unk_720->unk_08[arg0->unk_728.unk_16C]; + temp_s1 = arg0->unk_724; + + sp5C[5] = &temp_s1->unk_01C[0]; + sp5C[5] = &temp_s1->unk_01C[0]; + sp5C[4] = &temp_s1->unk_01C[1]; + sp5C[3] = &temp_s1->unk_01C[2]; + sp5C[2] = &temp_s1->unk_01C[3]; + sp5C[1] = &temp_s1->unk_01C[4]; + sp5C[0] = &temp_s1->unk_01C[5]; + + func_84310334(arg1 + 1, arg2 + 1, 0xC8, 0xF, &sp88[arg3][0], &sp78[arg3][0]); + func_84310334(arg1 + 1, arg2 + 0x10, 0xC8, 0x1D, &sp88[arg3][1], &sp78[arg3][1]); + func_84310334(arg1 + 1, arg2 + 0x2D, 0xC8, 0x1D, &sp88[arg3][2], &sp78[arg3][2]); + func_84310334(arg1 + 1, arg2 + 0x4A, 0xC8, 0x1D, &sp88[arg3][3], &sp78[arg3][3]); + tmp = func_8001F5B0(1, 0, temp_s0->unk_008) / 2; + func_84314B20((arg1 - tmp) + 0x32, arg2 + 3, temp_s0->unk_008); + + gSPDisplayList(gDisplayListHead++, D_8006F518); + + func_8001C6AC(arg1 + 1, arg2, 0x18, 0x10, *(D_84385850 + arg3), 0x18, 0); + + gSPDisplayList(gDisplayListHead++, D_8006F630); + + if (temp_s0->unk_002 > 0) { + func_84314B6C(arg0, temp_s0, sp5C[5], arg1 + 1, arg2 + 0x10, 0); + } + + if (temp_s0->unk_002 >= 2) { + func_84314B6C(arg0, temp_s0, sp5C[4], arg1 + 1, arg2 + 0x2D, 1); + } + + if (temp_s0->unk_002 >= 3) { + func_84314B6C(arg0, temp_s0, sp5C[3], arg1 + 1, arg2 + 0x4A, 2); + } + + if (temp_s0->unk_002 >= 4) { + func_84314B6C(arg0, temp_s0, sp5C[2], arg1 + 0x66, arg2 + 0x10, 3); + } + + if (temp_s0->unk_002 >= 5) { + func_84314B6C(arg0, temp_s0, sp5C[1], arg1 + 0x66, arg2 + 0x2D, 4); + } + + if (temp_s0->unk_002 >= 6) { + func_84314B6C(arg0, temp_s0, sp5C[0], arg1 + 0x66, arg2 + 0x4A, 5); + } + + func_84311428(arg1, arg2, 0xC8, 0x66); + func_8430FC28(arg1 - 2, arg2 - 2, 0xCE, 0x6A, 0); +} + +void func_8431595C(unk_D_84390010* arg0, s16 arg1, s16 arg2, s32 arg3) { + UNUSED s32 pad; + Color_RGB8* var_v0; + u32 var_t0; + unk_D_84390010_654* temp_v0; + u16 tmp; + unk_func_80026268_arg0* sp40; + + sp40 = &arg0->unk_720->unk_08[arg0->unk_728.unk_16C]->unk_01C[arg0->unk_654.unk_08]; + temp_v0 = &arg0->unk_654; + + if (sp40->unk_02 == 0) { + var_t0 = 1; + } else { + var_t0 = func_800219A0(sp40->unk_05); + } + + if (temp_v0->unk_30 < 0xFF00) { + temp_v0->unk_30 -= 0x30; + } + + tmp = temp_v0->unk_30; + if ((tmp >> 8) & 1) { + var_v0 = &D_84385860[arg3]; + } else { + var_v0 = &D_8438587C[arg3]; + } + + func_84311048(arg0, sp40, &D_84385790[var_t0], arg1 + 1, arg2 + 1, 0x46, 0x28, var_v0->r, var_v0->g, var_v0->b, + 0xB2); + func_84311428(arg1, arg2, 0x46, 0x28); + func_8430FC28(arg1 - 2, arg2 - 2, 0x4C, 0x2D, 0); +} + +void func_84315ADC(s32 arg0, s16 arg1, s16 arg2, char* arg3) { + func_84310334(arg1 + 1, arg2 + 1, 0xEE, 0x24, &D_84385860[arg0], &D_84385870[arg0]); + func_8001F3F4(); + func_8001EBE0(2, 0); + func_8001F3B4(0x10); + func_8001F1E8(arg1 + 0xA, arg2 + 5, arg3); + func_8001F444(); + func_84311428(arg1, arg2, 0xEE, 0x24); + func_8430FC28(arg1 - 2, arg2 - 1, 0xF4, 0x29, 0); +} + +s32 func_84315BC0(char* arg0, s16 arg1, s16 arg2) { + if (*(s8*)arg0 == 0) { + return 0; + } + func_8001F3F4(); + func_8001EBE0(1, 0); + func_8001F1E8(arg1, arg2, arg0); + func_8001F444(); + return 1; +} + +void func_84315C28(unk_D_843901A0_4C8* arg0, s16 arg1, s16 arg2, Vec3f arg3) { + s16 sp2C; + s16 sp28; + Color_RGB8* temp_v0; + unk_D_84390010* temp_v1; + unk_D_800AE540_0004* tmp; + + temp_v1 = D_84390010[arg0->unk_0C]; + tmp = temp_v1->unk_720->unk_08[temp_v1->unk_728.unk_16C]; + temp_v0 = &D_84385860[tmp->unk_001]; + + sp2C = (arg1 - arg3.x) * 2; + sp28 = (arg2 - arg3.y) * 2; + + func_8001F504(arg3.x, arg3.y, sp2C, sp28, temp_v0->r, temp_v0->g, temp_v0->b, 0x96); + func_84311428(arg3.x, arg3.y, sp2C, sp28); + func_8430FC28(arg0->unk_14.x - 2.0f, arg0->unk_14.y - 1.0f, 0xE0, 0x2B, 0); +} + +void func_84315D88(unk_D_843901A0_4C8* arg0, s16 arg1, s16 arg2) { + Vec3f sp4C; + Vec3f sp40; + Vec3f sp34; + UNUSED s32 pad; + + arg0->unk_08 = 0; + arg0->unk_10 = 0; + func_8000E88C(&sp40, arg1, arg2, 0.0f); + func_8000E88C(&sp34, arg1 - 110.0f, arg2 - 19.0f, 0.0f); + func_800102A4(&sp40, &sp34, &arg0->unk_20, &arg0->unk_28, &arg0->unk_2A); + func_80010354(&sp40, &arg0->unk_14, arg0->unk_20, arg0->unk_28, arg0->unk_2A); + arg0->unk_24 = arg0->unk_20 * 0.3f; + func_80010354(&sp40, &sp4C, arg0->unk_24, arg0->unk_28, arg0->unk_2A); + func_84315C28(arg0, arg1, arg2, sp4C); +} + +s32 func_84315EC0(unk_D_843901A0_4C8* arg0, s16 arg1, s16 arg2) { + Vec3f sp34; + Vec3f sp28; + + func_8000E88C(&sp28, arg1, arg2, 0.0f); + arg0->unk_24 = func_800104AC(arg0->unk_24, arg0->unk_20, 15.0f, 15.0f); + func_80010354(&sp28, &sp34, arg0->unk_24, arg0->unk_28, arg0->unk_2A); + func_84315C28(arg0, arg1, arg2, sp34); + + if (arg0->unk_24 == arg0->unk_20) { + return 1; + } + return 0; +} + +void func_84315FAC(unk_D_843901A0_4C8* arg0, s16 arg1, s16 arg2, Vec3f arg3) { + func_8001F504(arg3.x, arg3.y, (s16)((arg1 - arg3.x) * 2), (s16)((arg2 - arg3.y) * 2), 0, 0, 0, 0x96); + func_84311428(arg3.x, arg3.y, (s16)((arg1 - arg3.x) * 2), (s16)((arg2 - arg3.y) * 2)); + func_8430FC28(arg0->unk_14.x - 2.0f, arg0->unk_14.y - 1.0f, 0xE0, 0x2B, 0); +} + +void func_843160C0(unk_D_843901A0_4C8* arg0, s16 arg1, s16 arg2) { + Vec3f sp4C; + Vec3f sp40; + Vec3f sp34; + UNUSED s32 pad; + + arg0->unk_08 = 0; + arg0->unk_10 = 0; + func_8000E88C(&sp40, arg1, arg2, 0.0f); + func_8000E88C(&sp34, arg1 - 50.0f, arg2 - 10.0f, 0.0f); + func_800102A4(&sp40, &sp34, &arg0->unk_20, &arg0->unk_28, &arg0->unk_2A); + func_80010354(&sp40, &arg0->unk_14, arg0->unk_20, arg0->unk_28, arg0->unk_2A); + arg0->unk_24 = arg0->unk_20 * 0.3f; + func_80010354(&sp40, &sp4C, arg0->unk_24, arg0->unk_28, arg0->unk_2A); + func_84315FAC(arg0, arg1, arg2, sp4C); +} + +s32 func_843161F8(unk_D_843901A0_4C8* arg0, s16 arg1, s16 arg2) { + Vec3f sp34; + Vec3f sp28; + + func_8000E88C(&sp28, arg1, arg2, 0.0f); + arg0->unk_24 = func_800104AC(arg0->unk_24, arg0->unk_20, 15.0f, 15.0f); + func_80010354(&sp28, &sp34, arg0->unk_24, arg0->unk_28, arg0->unk_2A); + func_84315FAC(arg0, arg1, arg2, sp34); + + if (arg0->unk_24 == arg0->unk_20) { + return 1; + } + return 0; +} + +void func_843162E4(s32 arg0, s16 arg1, s16 arg2, char* arg3) { + func_84310334(arg1 + 1, arg2 + 1, 0xC8, 0x24, &D_84385860[arg0], &D_84385870[arg0]); + func_8001F3F4(); + func_8001EBE0(2, 0); + func_8001F3B4(0x10); + func_8001F1E8(arg1 + 0xA, arg2 + 5, arg3); + func_8001F444(); + func_84311428(arg1, arg2, 0xC8, 0x25); + func_8430FC28(arg1 - 2, arg2 - 1, 0xCD, 0x28, 0); +} + +void func_843163C8(unk_D_84390010* arg0, s16 arg1, s16 arg2, s32 arg3) { + UNUSED s32 pad; + s32 sp48; + UNUSED s32 pad2[2]; + + func_84310334(arg1 + 1, arg2 + 1, 0xC8, 0x24, &D_84385860[arg3], &D_84385870[arg3]); + func_8001F3F4(); + func_8001EBE0(2, 0); + sp48 = func_8001F5B0(2, 0, func_8002D7C0(NULL, 0, D_843900B0, 0xA1)) / 2; + func_8001F1E8((arg1 - sp48) + 0x61, arg2 + 5, func_8002D7C0(NULL, 0, D_843900B0, 0xA1)); + func_8001F1E8(arg1 + 0x32, arg2 + 0x14, func_8002D7C0(NULL, 0, D_843900B0, 0xA3)); + func_8001F1E8(arg1 + 0x7A, arg2 + 0x14, func_8002D7C0(NULL, 0, D_843900B0, 0xA2)); + func_8001F444(); + + gSPDisplayList(gDisplayListHead++, D_8006F5A0); + + func_8001D560(arg1 + (arg0->unk_654.unk_2F * 0x49) + 0x1B, arg2 + 0x14, 0x18, 0xE, &D_30092C0, &D_3009560, 0x18, + 0x100000); + + gSPDisplayList(gDisplayListHead++, D_8006F630); + + func_84311428(arg1, arg2, 0xC8, 0x25); + func_8430FC28(arg1 - 2, arg2 - 1, 0xCD, 0x28, 0); +} + +void func_84316610(void) { + if (func_8436EF48() != 0) { + func_8436F664(); + } +} + +void func_84316640(s16 arg0, s16 arg1, s16 arg2, s16 arg3, s16 arg4, s16 arg5, s16 arg6, s16 arg7) { + unk_D_800A7440 sp30; + + func_80005FC0(&sp30, arg0, arg1, (arg0 + arg2) - 1, (arg1 + arg3) - 1); + + if (func_80006030(&sp30) != 0) { + if (arg6 != 0) { + arg4 += ((sp30.x1 - arg0) * arg6) >> 5; + } + + if (arg7 != 0) { + arg5 += ((sp30.y2 - arg1) * arg7) >> 5; + } + + sp30.y1 += 1; + sp30.x2 += 1; + + gSPTextureRectangle(gDisplayListHead++, sp30.x1 << 2, sp30.y2 << 2, sp30.y1 << 2, sp30.x2 << 2, G_TX_RENDERTILE, + arg4, arg5, arg6, arg7); + } +} + +void func_843167D4(s32 arg0, s32 arg1, s32 arg2, s32 arg3, u8* arg4, s32 arg5) { + gDPLoadTextureTile(gDisplayListHead++, arg4, G_IM_FMT_RGBA, G_IM_SIZ_32b, arg2, 0, 0, 0, arg2 - 1, arg3 - 1, 0, + G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD, + G_TX_NOLOD); + + func_84316640(arg0, arg1, arg2, arg3, 0, 0, 0x400, 0); +} + +void func_8431694C(void) { + s32 i; + + gSPDisplayList(gDisplayListHead++, D_8006F518); + + for (i = 0; i < 0x30; i++) { + func_843167D4(0x1E, i + 0x17, 0x58, 1, &D_3001F70[i * 0x160], 0x58); + } + + gSPDisplayList(gDisplayListHead++, D_8006F630); + + func_8430FC28(0x1C, 0x16, 0x5E, 0x34, 0); +} + +void func_84316A1C(u8* arg0, s32 arg1, s32 arg2, s32 arg3, s32 arg4, u8 arg5, u8 arg6, u8 arg7, u8 arg8, u8 arg9, + u8 argA, u8 argB, u8 argC) { + UNUSED s32 pad; + unk_D_80068BB0* temp_s1 = func_8000648C(); + Vtx* temp_s2 = func_80005F5C(sizeof(Vtx) * 4); + Mtx* spC0 = func_80005F5C(sizeof(Mtx) * 1); + Vp* spBC = func_80005F5C(sizeof(Vp)); + + func_8001E6E8(spBC, temp_s1->width, temp_s1->height); + + gSPViewport(gDisplayListHead++, (u32)spBC & 0x1FFFFFFF); + + guOrtho(spC0, 0.5f, temp_s1->width - 0.5f, temp_s1->height - 0.5f, 0.5f, -2.0f, 2.0f, 1.0f); + + func_8001E680(&temp_s2[0], arg1, arg2, -1, argC << 5, 0, 0xFF, 0xF0, 0, 0xFF); + func_8001E680(&temp_s2[1], arg1 + arg3, arg2, -1, argB << 5, 0, 0xFF, 0xF0, 0, 0xFF); + func_8001E680(&temp_s2[2], arg1, arg2 + arg4, -1, argC << 5, arg6 << 5, 0xFF, 0, 0x64, 0xFF); + func_8001E680(&temp_s2[3], arg1 + arg3, arg2 + arg4, -1, argB << 5, arg6 << 5, 0xFF, 0, 0x64, 0xFF); + + gDPPipeSync(gDisplayListHead++); + gDPSetCycleType(gDisplayListHead++, G_CYC_2CYCLE); + gDPSetTexturePersp(gDisplayListHead++, G_TP_PERSP); + gSPClearGeometryMode(gDisplayListHead++, G_ZBUFFER | G_LIGHTING); + gDPSetCombineLERP(gDisplayListHead++, PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, 0, 0, 0, TEXEL0, COMBINED, 0, + SHADE, 0, 0, 0, 0, COMBINED); + gDPSetRenderMode(gDisplayListHead++, G_RM_PASS, G_RM_XLU_SURF2); + gDPSetEnvColor(gDisplayListHead++, 0, 0, 0, 255); + gDPSetPrimColor(gDisplayListHead++, 0, 0, 255, 255, 255, 255); + gDPSetTextureFilter(gDisplayListHead++, G_TF_BILERP); + gSPTexture(gDisplayListHead++, 0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON); + + gDPLoadTextureTile(gDisplayListHead++, arg0, G_IM_FMT_IA, G_IM_SIZ_8b, arg5, 0, arg7, arg8, arg9 - 1, argA - 1, 0, + G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD, + G_TX_NOLOD); + + gSPPerspNormalize(gDisplayListHead++, 0xFFFF); + gSPMatrix(gDisplayListHead++, (u32)spC0 & 0x1FFFFFFF, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION); + gSPMatrix(gDisplayListHead++, (u32)&D_8006F010 & 0x1FFFFFFF, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW); + gSPVertex(gDisplayListHead++, (u32)temp_s2 & 0x1FFFFFFF, 4, 0); + gSP2Triangles(gDisplayListHead++, 0, 2, 3, 0, 0, 3, 1, 0); + gSPDisplayList(gDisplayListHead++, D_8006F630); + gSPTexture(gDisplayListHead++, 0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_OFF); +} + +void func_84317004(void) { + D_84390190.x = func_800104AC(D_84390190.x, 52.0f, 80.0f, 80.0f); + func_84316A1C(D_3000470, D_84390190.x, D_84390190.y, 0x6C, 0x20, 0xD8, 0x20, 0, 0, 0x6C, 0x20, 0x6B, 0); + func_84316A1C(D_3000470, (s32)D_84390190.x + 0x6C, D_84390190.y, 0x6C, 0x20, 0xD8, 0x20, 0x6C, 0, 0xD8, 0x20, 0xD7, + 0x6C); +} + +void func_8431712C(void) { + static s32 D_84385988 = 0; + + s32 sp24; + s16 temp_s0; + + if (!(Cont_GetControllerBits() & 1)) { + sp24 = func_8001F5B0(4, 0, func_8002D7C0(NULL, 0, D_843900C0, 0)); + temp_s0 = 0x50 - D_84385988; + + gDPSetScissor(gDisplayListHead++, G_SC_NON_INTERLACE, 16, 0, 304, 240); + + func_8001F3F4(); + func_8001EBE0(4, 0); + func_8001F1E8(temp_s0, 0xB3, func_8002D7C0(NULL, 0, D_843900C0, 0)); + + temp_s0 += sp24 + 0x1E; + if (temp_s0 < 0x140) { + func_8001F1E8(temp_s0, 0xB3, func_8002D7C0(NULL, 0, D_843900C0, 0)); + } + func_8001F444(); + + gDPSetScissor(gDisplayListHead++, G_SC_NON_INTERLACE, 0, 0, 320, 240); + + D_84385988++; + if (D_84385988 >= (sp24 + 0x50)) { + D_84385988 = 0x32; + } + } +} + +void func_843172A0(unk_D_84390010* arg0, unk_D_84390010_654* arg1) { + unk_D_800AE540_0004* sp34 = arg0->unk_720->unk_08[arg0->unk_728.unk_16C]; + UNUSED s32 pad; + s32 var_v1; + + if (D_800AE540.unk_0000 != 0x10) { + if (arg1->unk_10 == 3) { + func_84311F30(arg0, arg0->unk_728.unk_168->unk_1C - 2, arg0->unk_728.unk_168->unk_1E - 0x3A, arg1->unk_1E, + 1); + } else { + func_84311F30(arg0, arg0->unk_728.unk_168->unk_1C - 2, arg0->unk_728.unk_168->unk_1E - 0x3A, arg1->unk_1E, + 0); + } + + if ((arg1->unk_10 != 3) && (arg0->unk_728.unk_168->unk_1C == 0x17)) { + switch (arg1->unk_10) { + case 2: + if (arg1->unk_1C == 1) { + if (arg0->unk_720->unk_01 == 2) { + if (arg0->unk_720->unk_08[1]->unk_001 < arg0->unk_720->unk_08[0]->unk_001) { + var_v1 = 0; + } else { + var_v1 = 1; + } + func_8431524C(arg0, arg0->unk_720->unk_08[var_v1], 0x60, 0xF, + arg0->unk_720->unk_08[var_v1]->unk_001); + func_8431524C(arg0, arg0->unk_720->unk_08[var_v1 == 0], 0xC6, 0xF, + arg0->unk_720->unk_08[var_v1 == 0]->unk_001); + } else if (arg0->unk_724->unk_002 < 4) { + func_8431524C(arg0, arg0->unk_720->unk_08[0], 0x60, 0xF, sp34->unk_001); + } else { + func_84315550(arg0, 0x60, 0xF, sp34->unk_001); + } + } else if (arg1->unk_2D == 0x10) { + func_843135B8(arg0, 0x60, 0xF, sp34->unk_001); + } else { + func_843133B4(arg0, 0x60, 0xF, sp34->unk_001); + } + break; + + case 1: + if (arg1->unk_1C == 1) { + func_84313A74(arg0, 0x60, 0xF, sp34->unk_001); + } else { + func_843133B4(arg0, 0x60, 0xF, sp34->unk_001); + } + break; + + case 4: + func_843163C8(arg0, 0x5F, 0xE, sp34->unk_001); + break; + + default: + func_84313148(arg0, 0x60, 0xF, sp34->unk_001); + break; + } + } + } +} + +void func_84317558(unk_D_84390010* arg0, unk_D_84390010_654* arg1) { + unk_D_800AE540_0004* sp24 = arg0->unk_720->unk_08[arg0->unk_728.unk_16C]; + s32 sp20; + + if (D_800AE540.unk_0000 != 0x10) { + if (arg1->unk_10 == 3) { + func_843128A0(arg0, arg0->unk_728.unk_168->unk_1C - 0x20, arg0->unk_728.unk_168->unk_1E - 2, arg1->unk_1E, + 1); + } else { + func_843128A0(arg0, arg0->unk_728.unk_168->unk_1C - 0x20, arg0->unk_728.unk_168->unk_1E - 2, arg1->unk_1E, + 0); + } + + if ((arg1->unk_10 != 3) && (arg0->unk_728.unk_168->unk_1C == 0x103)) { + switch (arg1->unk_10) { + case 2: + if (arg1->unk_1C == 1) { + if (arg0->unk_720->unk_01 == 2) { + if (arg0->unk_720->unk_08[1]->unk_001 < arg0->unk_720->unk_08[0]->unk_001) { + sp20 = 0; + } else { + sp20 = 1; + } + func_8431524C(arg0, arg0->unk_720->unk_08[sp20 == 0], 0x16, 0x79, + arg0->unk_720->unk_08[sp20 == 0]->unk_001); + func_8431524C(arg0, arg0->unk_720->unk_08[sp20], 0x7C, 0x79, + arg0->unk_720->unk_08[sp20]->unk_001); + } else if (arg0->unk_724->unk_002 < 4) { + func_8431524C(arg0, arg0->unk_720->unk_08[0], 0x7C, 0x79, sp24->unk_001); + } else { + func_84315550(arg0, 0x18, 0x79, sp24->unk_001); + } + } else if (arg1->unk_2D == 0x10) { + func_843135B8(arg0, 0x98, 0xCE, sp24->unk_001); + } else { + func_843133B4(arg0, 0x62, 0xCE, sp24->unk_001); + } + break; + + case 1: + if (arg1->unk_1C == 1) { + func_84313A74(arg0, 0x19, 0xA6, sp24->unk_001); + } else { + func_843133B4(arg0, 0x62, 0xCE, sp24->unk_001); + } + break; + + case 4: + func_843163C8(arg0, 0x17, 0xBB, sp24->unk_001); + break; + + default: + func_84313148(arg0, 0x18, 0xCE, sp24->unk_001); + break; + } + } + } +} diff --git a/src/fragments/62/fragment62_3020D0.c b/src/fragments/62/fragment62_3020D0.c new file mode 100644 index 0000000..a1a2d00 --- /dev/null +++ b/src/fragments/62/fragment62_3020D0.c @@ -0,0 +1,794 @@ +#include "fragment62.h" +#include "src/1CF30.h" +#include "src/20470.h" +#include "src/225A0.h" +#include "src/29BA0.h" +#include "src/2E110.h" +#include "src/3D140.h" +#include "src/6A40.h" +#include "src/6BC0.h" +#include "src/F420.h" +#include "src/controller.h" +#include "src/memmap.h" +#include "src/memory.h" +#include "stdarg.h" + +unk_D_843901A0* D_843901A0; + +static u8 D_84385990[] = { 0xE, 0x4A }; +static u8 D_84385994[] = { 0x60, 0x69, 0x75, 0x78, 0x85 }; +static u8 D_8438599C[] = { 0x61, 0x64, 0x66, 0x68, 0x8C }; +static u8 D_843859A4[] = { + 1, 0xA, 0xB, 0x11, 0x13, 0x14, 0x15, 0x1E, 0x22, 0x23, 0x25, 0x27, 0x2B, 0x2C, 0x2D, 0x2E, + 0x2F, 0x40, 0x44, 0x46, 0x47, 0x51, 0x59, 0x5A, 0x5B, 0x5C, 0x67, 0x6A, 0x6B, 0x6E, 0x6F, 0x76, + 0x7A, 0x80, 0x84, 0x8B, 0x8D, 0x91, 0x94, 0x96, 0x97, 0x9A, 0x9C, 0x9F, 0xA3, 0xA4, +}; + +void func_84317810(void) { + D_843901A0->unk_088[0] = 0; + D_843901A0->unk_088[1] = 0; + D_843901A0->unk_0C8[0] = 0; + D_843901A0->unk_0C8[1] = 0; + D_843901A0->unk_108[0] = 0; + D_843901A0->unk_108[1] = 0; + D_843901A0->unk_148[0] = 0; + D_843901A0->unk_148[1] = 0; + D_843901A0->unk_188[0] = 0; + D_843901A0->unk_188[1] = 0; + D_843901A0->unk_1C8[0] = 0; + D_843901A0->unk_1C8[1] = 0; + D_843901A0->unk_448[0][0] = 0; + D_843901A0->unk_448[0][1] = 0; + D_843901A0->unk_448[1][0] = 0; + D_843901A0->unk_448[1][1] = 0; + D_843901A0->unk_208[0] = 0; + D_843901A0->unk_208[1] = 0; + D_843901A0->unk_308[0] = 0; + D_843901A0->unk_308[1] = 0; + D_843901A0->unk_2C8[0] = 0; + D_843901A0->unk_2C8[1] = 0; + D_843901A0->unk_348[0] = 0; + D_843901A0->unk_348[1] = 0; + D_843901A0->unk_388[0] = 0; + D_843901A0->unk_388[1] = 0; + D_843901A0->unk_3C8[0] = 0; + D_843901A0->unk_3C8[1] = 0; + D_843901A0->unk_408[0] = 0; + D_843901A0->unk_408[1] = 0; +} + +void func_8431790C(void) { + D_843901A0->unk_004 = 0; + D_843901A0->unk_048[0] = 0; + D_843901A0->unk_048[1] = 0; + D_843901A0->unk_008[0] = 0; + D_843901A0->unk_008[1] = 0; +} + +#ifdef NON_MATCHING +void func_84317940(s8* arg0, s8* arg1, ...) { + va_list args; + s8** temp_v1; + s32 var_v0; + s8* var_a3; + + var_v0 = 0; + temp_v1 = &args; + + while (*arg1 != '\x00') { + if (*arg1 != 0x25) { + arg0[var_v0++] = *arg1; + } else { + arg1++; + if (*arg1 == 0x73) { + temp_v1 = ALIGN4((s32)temp_v1); + var_a3 = *(s8**)temp_v1; + temp_v1++; + + while (*var_a3 != 0) { + arg0[var_v0] = *var_a3; + var_a3++; + var_v0++; + } + } + } + arg1++; + } + arg0[var_v0] = '\x00'; +} +#else +#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_3020D0/func_84317940.s") +#endif + +void func_843179F4(s8* arg0, s8 arg1) { + u8 tmp = arg1; + *arg0 = arg1; + + if (tmp >= 0x80) { + if ((tmp - 0x80) >= 0xB) { + func_8002D7C0(arg0 + 1, 0x40, D_843900B0, tmp - 0x48); + } else { + func_8002D7C0(arg0 + 1, 0x40, D_843900B0, tmp - 0x49); + } + } else { + func_8002D7C0(arg0 + 1, 0x40, D_843900B0, D_84385BC0[arg1]); + } +} + +void func_84317AA8(char* arg0, s32 arg1) { + UNUSED s32 pad[3]; + unk_D_84390010_654* sp28 = &D_84390010[arg1]->unk_654; + UNUSED s32 pad2[2]; + + func_8431790C(); + D_843901A0->unk_000 = D_84390010[arg1]->unk_720->unk_08[sp28->unk_2B]->unk_001; + func_84317940(D_843901A0->unk_048, arg0 + 1); + *arg0 = 0; +} + +void func_84317B38(void) { +} + +void func_84317B40(void) { + unk_D_84390010* ptr1 = D_84390010[0]; + unk_D_84390010* ptr2 = D_84390010[1]; + + if ((D_800AE540.unk_0000 != 0x10) && (D_84390240.unk_00->unk_30 == 0)) { + func_8431595C(ptr1, 0x15, 0xF, ptr1->unk_720->unk_08[ptr1->unk_728.unk_16C]->unk_001); + func_8431595C(ptr2, 0xE1, 0xF, ptr2->unk_720->unk_08[ptr2->unk_728.unk_16C]->unk_001); + } +} + +void func_84317BDC(void) { + u32 sp1C; + unk_D_84390010_654_038* sp18 = &D_84390010[D_84390240.unk_00->unk_2C]->unk_654.unk_38; + + sp18->unk_58 = sp18->unk_44.unk_00; + + if (func_84307AE0(sp18->unk_44.unk_00, D_84385990, 2) != 0) { + sp1C = 0; + } else if (func_84307AE0(sp18->unk_44.unk_00, D_84385994, 5) != 0) { + sp1C = 1; + } else if (func_84307AE0(sp18->unk_44.unk_00, D_8438599C, 5) != 0) { + sp1C = 2; + } else if (func_84307AE0(sp18->unk_44.unk_00, D_843859A4, 0x2E) != 0) { + sp1C = 3; + } else { + sp1C = 4; + } + + if ((sp18->unk_44.unk_00 == 0x76) || (sp18->unk_44.unk_00 == 0x77)) { + func_8002D5D4(0x19, func_8430862C(D_84390010[D_84390240.unk_00->unk_2C])); + func_8002D5D4(0x1D, func_843085F0(D_84390010[D_84390240.unk_00->unk_2C])); + + switch (sp1C) { + case 0: + func_843179F4(D_843901A0->unk_388, 0x14); + break; + + case 1: + func_843179F4(D_843901A0->unk_388, 0x15); + break; + + case 2: + func_843179F4(D_843901A0->unk_388, 0x16); + break; + + case 3: + func_843179F4(D_843901A0->unk_388, 0x17); + break; + + case 4: + func_843179F4(D_843901A0->unk_388, 0x18); + break; + } + } else { + func_8002D5D4(0x19, func_8430862C(D_84390010[D_84390240.unk_00->unk_2C])); + func_8002D5D4(0x1D, func_843085F0(D_84390010[D_84390240.unk_00->unk_2C])); + + switch (sp1C) { + case 0: + func_843179F4(D_843901A0->unk_0C8, 0x14); + break; + + case 1: + func_843179F4(D_843901A0->unk_0C8, 0x15); + break; + + case 2: + func_843179F4(D_843901A0->unk_0C8, 0x16); + break; + + case 3: + func_843179F4(D_843901A0->unk_0C8, 0x17); + break; + + case 4: + func_843179F4(D_843901A0->unk_0C8, 0x18); + break; + } + } +} + +void func_84317EDC(void) { + u32 sp24; + UNUSED s32 pad; + unk_D_84390010_654_038* sp1C = &D_84390010[D_84390240.unk_00->unk_2C]->unk_654.unk_38; + + if (func_84307AE0(sp1C->unk_5A, D_84385990, 2) != 0) { + sp24 = 0; + } else if (func_84307AE0(sp1C->unk_5A, D_84385994, 5) != 0) { + sp24 = 1; + } else if (func_84307AE0(sp1C->unk_5A, D_8438599C, 5) != 0) { + sp24 = 2; + } else if (func_84307AE0(sp1C->unk_5A, D_843859A4, 0x2E) != 0) { + sp24 = 3; + } else { + sp24 = 4; + } + + func_8002D5D4(0x19, func_8430862C(D_84390010[D_84390240.unk_00->unk_2C])); + func_8002D5D4(0x1D, func_843085F0(D_84390010[D_84390240.unk_00->unk_2C])); + + switch (sp24) { + case 0: + func_843179F4(D_843901A0->unk_0C8, 0x14); + break; + + case 1: + func_843179F4(D_843901A0->unk_0C8, 0x15); + break; + + case 2: + func_843179F4(D_843901A0->unk_0C8, 0x16); + break; + + case 3: + func_843179F4(D_843901A0->unk_0C8, 0x17); + break; + + case 4: + func_843179F4(D_843901A0->unk_0C8, 0x18); + break; + } +} + +void func_843180AC(void) { + + s32 sp2C; + s32 tmp; + unk_D_84390010_654_038* sp24; + + sp24 = &D_84390010[D_84390240.unk_00->unk_2C]->unk_654.unk_38; + + if (func_84307AE0(sp24->unk_5A, D_84385990, 2) != 0) { + sp2C = 0; + } else if (func_84307AE0(sp24->unk_5A, D_84385994, 5) != 0) { + sp2C = 1; + } else if (func_84307AE0(sp24->unk_5A, D_8438599C, 5) != 0) { + sp2C = 2; + } else if (func_84307AE0(sp24->unk_5A, D_843859A4, 0x2E) != 0) { + sp2C = 3; + } else { + sp2C = 4; + } + + if (sp24->unk_5A == 0x76) { + do { + tmp = func_8436F6D8(); + } while ((tmp == 0) || (tmp >= 0xA5) || tmp == 0x76); + + sp24->unk_5A = tmp; + + func_8002D5D4(0x19, func_8430862C(D_84390010[D_84390240.unk_00->unk_2C])); + func_8002D5D4(0x1D, func_843085F0(D_84390010[D_84390240.unk_00->unk_2C])); + + switch (sp2C) { + case 0: + func_843179F4(D_843901A0->unk_0C8, 0x14); + break; + + case 1: + func_843179F4(D_843901A0->unk_0C8, 0x15); + break; + + case 2: + func_843179F4(D_843901A0->unk_0C8, 0x16); + break; + + case 3: + func_843179F4(D_843901A0->unk_0C8, 0x17); + break; + + case 4: + func_843179F4(D_843901A0->unk_0C8, 0x18); + break; + } + + sp24->unk_5A = 0x76; + + func_8002D5D4(0x19, func_8430862C(D_84390010[D_84390240.unk_00->unk_2C])); + func_8002D5D4(0x1D, func_843085F0(D_84390010[D_84390240.unk_00->unk_2C])); + + switch (sp2C) { + case 0: + func_843179F4(D_843901A0->unk_388, 0x14); + break; + + case 1: + func_843179F4(D_843901A0->unk_388, 0x15); + break; + + case 2: + func_843179F4(D_843901A0->unk_388, 0x16); + break; + + case 3: + func_843179F4(D_843901A0->unk_388, 0x17); + break; + + case 4: + func_843179F4(D_843901A0->unk_388, 0x18); + break; + } + } else { + func_8002D5D4(0x19, func_8430862C(D_84390010[D_84390240.unk_00->unk_2C])); + func_8002D5D4(0x1D, func_843085F0(D_84390010[D_84390240.unk_00->unk_2C])); + + switch (sp2C) { + case 0: + func_843179F4(D_843901A0->unk_0C8, 0x14); + break; + + case 1: + func_843179F4(D_843901A0->unk_0C8, 0x15); + break; + + case 2: + func_843179F4(D_843901A0->unk_0C8, 0x16); + break; + + case 3: + func_843179F4(D_843901A0->unk_0C8, 0x17); + break; + + case 4: + func_843179F4(D_843901A0->unk_0C8, 0x18); + break; + } + } +} + +void func_843184E4(s32 arg0) { + unk_D_843901A0_4C8* ptr = &D_843901A0->unk_4C8; + + ptr->unk_00 = 0; + ptr->unk_04 = arg0; +} + +void func_843184FC(void) { + unk_D_843901A0_4C8* ptr = &D_843901A0->unk_4C8; + + ptr->unk_00 = 0xFF; +} + +void func_84318514(s8* arg0) { + s32 temp_v0; + + if (arg0[1] == '\x00') { + return; + } + + temp_v0 = arg0[0] & 0x7F; + + if ((arg0[0] & 0x80) == '\x00') { + func_8003F624(arg0[0]); + } else if (temp_v0 == 'Q') { + func_8003F624(0xBC); + } else if (temp_v0 == 'R') { + func_8003F624(0xB5); + } else if (temp_v0 == 'S') { + func_8003F624(0xB6); + } else if (temp_v0 == 'T') { + func_8003F624(0xB7); + } else if (temp_v0 == 'U') { + func_8003F624(0xB8); + } else if (temp_v0 == 'V') { + func_8003F624(0xB9); + } else if (temp_v0 == 'W') { + func_8003F624(0xBA); + } else if (temp_v0 == 'X') { + func_8003F624(0xBB); + } else { + func_8003F624(temp_v0 + 0x64); + } +} + +void func_84318640(unk_D_843901A0_4C8* arg0, s16 arg1, s16 arg2) { + UNUSED s32 pad; + s32 temp_s1; + + if (1) {} + + switch (arg0->unk_04) { + case 0: + if (func_84315BC0(&D_843901A0->unk_388[1], arg1 + 4, arg2 + (arg0->unk_10 * 0xC) + 3) != 0) { + arg0->unk_10 += 1; + } + + if (func_84315BC0(&D_843901A0->unk_0C8[1], arg1 + 4, arg2 + (arg0->unk_10 * 0xC) + 3) != 0) { + arg0->unk_10 += 1; + } + + if (func_84315BC0(&D_843901A0->unk_188[1], arg1 + 4, arg2 + (arg0->unk_10 * 0xC) + 3) != 0) { + arg0->unk_10 += 1; + } + break; + + case 3: + if (func_84315BC0(&D_843901A0->unk_088[1], arg1 + 4, arg2 + (arg0->unk_10 * 0xC) + 3) != 0) { + arg0->unk_10 += 1; + } + + if (func_84315BC0(&D_843901A0->unk_148[1], arg1 + 4, arg2 + (arg0->unk_10 * 0xC) + 3) != 0) { + arg0->unk_10 += 1; + } + + if (func_84315BC0(&D_843901A0->unk_208[1], arg1 + 4, arg2 + (arg0->unk_10 * 0xC) + 3) != 0) { + arg0->unk_10 += 1; + } + break; + + case 1: + if (func_84315BC0(&D_843901A0->unk_3C8[1], arg1 + 4, arg2 + (arg0->unk_10 * 0xC) + 3) != 0) { + arg0->unk_10 += 1; + } + + if (func_84315BC0(&D_843901A0->unk_088[1], arg1 + 4, arg2 + (arg0->unk_10 * 0xC) + 3) != 0) { + arg0->unk_10 += 1; + } + + if (func_84315BC0(&D_843901A0->unk_148[1], arg1 + 4, arg2 + (arg0->unk_10 * 0xC) + 3) != 0) { + arg0->unk_10 += 1; + } + + if ((arg0->unk_10 < 3) && + (func_84315BC0(&D_843901A0->unk_208[1], arg1 + 4, arg2 + (arg0->unk_10 * 0xC) + 3) != 0)) { + arg0->unk_10 += 1; + } + break; + + case 2: + if (func_84315BC0(&D_843901A0->unk_088[1], arg1 + 4, arg2 + (arg0->unk_10 * 0xC) + 3) != 0) { + arg0->unk_10 += 1; + } + + if (func_84315BC0(&D_843901A0->unk_148[1], arg1 + 4, arg2 + (arg0->unk_10 * 0xC) + 3) != 0) { + arg0->unk_10 += 1; + } + + if (func_84315BC0(&D_843901A0->unk_208[1], arg1 + 4, arg2 + (arg0->unk_10 * 0xC) + 3) != 0) { + arg0->unk_10 += 1; + } + break; + + case 4: + func_84315BC0(&D_843901A0->unk_248[1], arg1 + 4, arg2 + 3); + break; + + case 5: + func_84315BC0(&D_843901A0->unk_288[1], arg1 + 4, arg2 + 3); + break; + + case 6: + func_84315BC0(&D_843901A0->unk_408[1], arg1 + 4, arg2 + 3); + break; + + case 7: + func_84315BC0(&D_843901A0->unk_348[1], arg1 + 4, arg2 + 3); + func_84315BC0(&D_843901A0->unk_2C8[1], arg1 + 4, arg2 + 0x10); + break; + + case 8: + func_84315BC0(&D_843901A0->unk_448[arg0->unk_0C][1], arg1 + 4, arg2 + 3); + break; + + case 9: + case 10: + func_84315BC0(&D_843901A0->unk_1C8[1], arg1 + 4, arg2 + 3); + break; + + case 11: + func_84315BC0(&D_843901A0->unk_088[1], arg1 + 4, arg2 + 3); + break; + + case 12: + func_84315BC0(&D_843901A0->unk_088[1], arg1 + 4, arg2 + 3); + break; + + case 13: + temp_s1 = func_8001F5B0(1, 0, func_8002D7C0(NULL, 0, D_843900B0, 0xA4)) / 2; + func_84315BC0(func_8002D7C0(NULL, 0, D_843900B0, 0xA4), 0xA1 - temp_s1, 0x71); + break; + + case 14: + func_84317004(); + break; + + case 15: + func_84315BC0(&D_843901A0->unk_088[1], arg1 + 4, arg2 + (arg0->unk_10 * 0xC) + 3); + break; + } + + arg0->unk_10 = 0; +} + +s32 func_84318CE4(unk_D_843901A0_4C8* arg0) { + unk_D_843901A0* temp_v0; + s32 tmp; + + arg0->unk_10 = 0; + + switch (arg0->unk_04) { + case 0: + if ((D_843901A0->unk_0C8[1] == 0) && (D_843901A0->unk_388[1] == 0) && (D_843901A0->unk_188[1] == 0)) { + arg0->unk_00 = 0xFF; + return 1; + } + + arg0->unk_0C = D_84390240.unk_00->unk_2C; + if (D_843901A0->unk_0C8[1] != 0) { + func_84318514(D_843901A0->unk_0C8); + } + + if (D_843901A0->unk_388[1] != 0) { + func_84318514(D_843901A0->unk_388); + } + + if (D_843901A0->unk_188[1] != 0) { + func_84318514(D_843901A0->unk_188); + } + arg0->unk_00 += 1; + break; + + case 1: + case 3: + arg0->unk_0C = D_84390240.unk_00->unk_2C; + func_84318514(D_843901A0->unk_088); + func_84318514(D_843901A0->unk_148); + func_84318514(D_843901A0->unk_208); + func_84318514(D_843901A0->unk_3C8); + func_84318514(D_843901A0->unk_308); + if ((D_843901A0->unk_088[1] == 0) && (D_843901A0->unk_148[1] == 0) && (D_843901A0->unk_208[1] == 0) && + (D_843901A0->unk_3C8[1] == 0) && (D_843901A0->unk_308[1] == 0)) { + arg0->unk_00 = 0xFF; + return 1; + } + arg0->unk_00 += 1; + break; + + case 2: + arg0->unk_0C = D_84390240.unk_00->unk_2C; + func_84318514(D_843901A0->unk_088); + func_84318514(D_843901A0->unk_148); + func_84318514(D_843901A0->unk_208); + if ((D_843901A0->unk_088[1] == 0) && (D_843901A0->unk_148[1] == 0) && (D_843901A0->unk_208[1] == 0)) { + arg0->unk_00 = 0xFF; + return 1; + } + arg0->unk_00 += 1; + break; + + case 15: + arg0->unk_0C = D_84390240.unk_00->unk_2C; + func_84318514(D_843901A0->unk_088); + if (D_843901A0->unk_088[1] == 0) { + arg0->unk_00 = 0xFF; + return 1; + } + arg0->unk_00 += 1; + break; + + case 8: + if (D_843901A0->unk_448[arg0->unk_0C][1] == 0) { + arg0->unk_00 = 0xFF; + return 1; + } + tmp = D_84390240.unk_00->unk_2C == 0; + arg0->unk_00 += 1; + arg0->unk_0C = tmp; + break; + + case 9: + tmp = D_84390240.unk_00->unk_2C == 0; + arg0->unk_00 += 1; + arg0->unk_0C = tmp; + break; + + case 4: + case 5: + case 6: + func_84318514(D_843901A0->unk_248); + func_84318514(D_843901A0->unk_288); + func_84318514(D_843901A0->unk_408); + arg0->unk_00 += 1; + break; + + case 14: + D_84390190.z = 0.0f; + D_84390190.x = 321.0f; + D_84390190.y = 160.0f; + arg0->unk_0C = D_84390240.unk_00->unk_2C; + arg0->unk_00 += 1; + break; + + default: + arg0->unk_0C = D_84390240.unk_00->unk_2C; + arg0->unk_00 += 1; + break; + } + return 0; +} + +void func_843190A8(s16 arg0, s16 arg1) { + unk_D_843901A0_4C8* temp_s0 = &D_843901A0->unk_4C8; + + if (D_800AE540.unk_0000 == 0x10) { + return; + } + + switch (temp_s0->unk_00) { + case 0: + temp_s0->unk_08 = 0; + if (temp_s0->unk_04 == 0xD) { + func_843160C0(temp_s0, 0xA0, 0x78); + temp_s0->unk_00++; + } else if (temp_s0->unk_04 == 0xE) { + func_84318CE4(temp_s0); + } else if (func_84318CE4(temp_s0) == 0) { + func_84315D88(temp_s0, arg0, arg1); + } + break; + + case 1: + if (temp_s0->unk_04 == 0xD) { + if (func_843161F8(temp_s0, 0xA0, 0x78) != 0) { + func_84318640(temp_s0, temp_s0->unk_14.x, temp_s0->unk_14.y); + temp_s0->unk_00++; + } + } else { + if (temp_s0->unk_04 == 0xE) { + func_8003F660(func_84308D98(D_84390010[temp_s0->unk_0C])); + func_84318640(temp_s0, temp_s0->unk_14.x, temp_s0->unk_14.y); + temp_s0->unk_00++; + } else if (func_84315EC0(temp_s0, arg0, arg1) != 0) { + func_8003F660(func_84308D98(D_84390010[temp_s0->unk_0C])); + func_84318640(temp_s0, temp_s0->unk_14.x, temp_s0->unk_14.y); + temp_s0->unk_00++; + } + } + break; + + case 2: + if (temp_s0->unk_04 == 0xD) { + func_843161F8(temp_s0, 0xA0, 0x78); + func_84318640(temp_s0, temp_s0->unk_14.x, temp_s0->unk_14.y); + + temp_s0->unk_08++; + if (temp_s0->unk_08 == 0x46) { + temp_s0->unk_00++; + } + } else { + if (temp_s0->unk_04 == 0xE) { + func_84318640(temp_s0, temp_s0->unk_14.x, temp_s0->unk_14.y); + } else { + func_84315EC0(temp_s0, arg0, arg1); + func_84318640(temp_s0, temp_s0->unk_14.x, temp_s0->unk_14.y); + + temp_s0->unk_08++; + if (temp_s0->unk_08 == 0x2D) { + temp_s0->unk_00++; + } + } + } + break; + } +} + +void func_843193F4(unk_D_84390010* arg0) { + arg0->unk_8C4.unk_00 = 0; + arg0->unk_8C4.unk_04 = 0; + arg0->unk_8C4.unk_48[0] = 0; + arg0->unk_8C4.unk_08[0] = 0; +} + +void func_84319408(unk_D_84390010* arg0, s32 arg1) { + D_843901A0->unk_000 = arg0->unk_720->unk_08[arg0->unk_654.unk_2C]->unk_001; + arg0->unk_8C4.unk_00 = 1; + func_8002D5D4(0x19, arg0->unk_724->unk_01C[arg0->unk_654.unk_08].unk_30); + func_8002D7C0(arg0->unk_8C4.unk_48, 0x40, D_843900B0, arg1); +} + +void func_843194A0(unk_D_84390010* arg0) { + unk_D_800AE540_0004* temp_t0 = arg0->unk_720->unk_08[arg0->unk_654.unk_2C]; + + if (arg0->unk_8C4.unk_48[arg0->unk_8C4.unk_04] != '\x00') { + arg0->unk_8C4.unk_08[arg0->unk_8C4.unk_04] = arg0->unk_8C4.unk_48[arg0->unk_8C4.unk_04]; + arg0->unk_8C4.unk_04++; + } + + if (arg0->unk_8C4.unk_48[arg0->unk_8C4.unk_04] != '\x00') { + arg0->unk_8C4.unk_08[arg0->unk_8C4.unk_04] = arg0->unk_8C4.unk_48[arg0->unk_8C4.unk_04]; + arg0->unk_8C4.unk_04++; + } + + arg0->unk_8C4.unk_08[arg0->unk_8C4.unk_04] = '\x00'; + + if (arg0->unk_8C4.unk_48[0] != 0) { + if (arg0 == D_84390018) { + func_843162E4(temp_t0->unk_001, 0x5F, 0xE, &arg0->unk_8C4.unk_08); + } else { + func_843162E4(temp_t0->unk_001, 0x17, 0xBB, &arg0->unk_8C4.unk_08); + } + } +} + +void func_84319564(void) { + unk_D_84390010_654* sp1C = &D_84390010[0]->unk_654; + unk_D_84390010_654* sp18 = &D_84390010[1]->unk_654; + + if ((D_800AE540.unk_11ED != 0) && (D_84390010[1]->unk_728.unk_168->unk_1C == 0x103) && + (D_84390010[0]->unk_728.unk_168->unk_1C == 0x17)) { + func_843118A8(0x101, 0x64); + if (D_84390134 == 0) { + if (sp1C->unk_10 != 3) { + func_843116D8(0x46, 0x4D); + } + + if (sp18->unk_10 != 3) { + func_843116D8(0xE8, 0x96); + } + } + } +} + +void func_8431962C(void) { + D_843901A0 = main_pool_alloc(sizeof(unk_D_843901A0), 0); + bzero(D_843901A0, sizeof(unk_D_843901A0)); +} + +void func_84319668(void) { + D_843901A0->unk_004 = 0; + D_843901A0->unk_008[D_843901A0->unk_004] = 0; + func_8431790C(); +} + +void func_843196A4(void) { + unk_D_84390010_654* sp1C = &D_84390010[0]->unk_654; + unk_D_84390010_654* sp18 = &D_84390010[1]->unk_654; + + if (1) {} + + func_843190A8(0xA0, 0xC8); + + if (D_800AE540.unk_0000 == 0x10) { + func_8431712C(); + func_8431694C(); + } + + switch (D_84390240.unk_00->unk_1C) { + case 1: + func_843172A0(D_84390010[0], sp1C); + func_84317558(D_84390010[1], sp18); + func_843194A0(D_84390010[0]); + func_843194A0(D_84390010[1]); + func_84319564(); + func_84316610(); + break; + + case 2: + func_84317B40(); + func_84316610(); + break; + } +} diff --git a/yamls/us/rom.yaml b/yamls/us/rom.yaml index d9c1d9f..7fe4043 100644 --- a/yamls/us/rom.yaml +++ b/yamls/us/rom.yaml @@ -2148,6 +2148,7 @@ - [0x2F6930, c, fragments/62/fragment62_2F6930] - [0x2F74E0, c, fragments/62/fragment62_2F74E0] - [0x2FA4D0, c, fragments/62/fragment62_2FA4D0] + - [0x3020D0, c, fragments/62/fragment62_3020D0] - [0x304060, c, fragments/62/fragment62_304060] - [0x3055E0, c, fragments/62/fragment62_3055E0] - [0x309ED0, c, fragments/62/fragment62_309ED0] @@ -2186,14 +2187,16 @@ - [0x36EE30, .data, fragments/62/fragment62_2EC3C0] - [0x36EEC0, .data, fragments/62/fragment62_2F3CB0] - [0x370010, .data, fragments/62/fragment62_2F74E0] - - [0x370050, data, fragments/62/fragment62_data] + - [0x370050, .data, fragments/62/fragment62_2FA4D0] + - [0x370250, .data, fragments/62/fragment62_3020D0] + - [0x3702A0, data, fragments/62/fragment62_data] - [0x3759C0, .rodata, fragments/62/fragment62_2EC3C0] - [0x375A60, .rodata, fragments/62/fragment62_2F3CB0] - [0x375B60, .rodata, fragments/62/fragment62_2F6930] - [0x375BA0, .rodata, fragments/62/fragment62_2F74E0] - - [0x375BB0, rodata, fragments/62/fragment62_rodata_375BB0] - - [0x375C50, rodata, fragments/62/fragment62_rodata_375C50] + - [0x375BB0, .rodata, fragments/62/fragment62_2FA4D0] + - [0x375C50, .rodata, fragments/62/fragment62_3020D0] - [0x375D50, rodata, fragments/62/fragment62_rodata_375D50] - [0x375EA0, rodata, fragments/62/fragment62_rodata_375EA0] - [0x3764E0, rodata, fragments/62/fragment62_rodata_3764E0] @@ -2227,7 +2230,9 @@ - {vram: 0x843900B0, type: bss, name: fragments/62/fragment62_bss1} - {vram: 0x843900D0, type: .bss, name: fragments/62/fragment62_2F6930} - {vram: 0x84390120, type: .bss, name: fragments/62/fragment62_2F74E0} - - {vram: 0x84390190, type: bss, name: fragments/62/fragment62_bss2} + - {vram: 0x84390190, type: .bss, name: fragments/62/fragment62_2FA4D0} + - {vram: 0x843901A0, type: .bss, name: fragments/62/fragment62_3020D0} + - {vram: 0x843901B0, type: bss, name: fragments/62/fragment62_bss2} - name: fragment62_relocs type: code