diff --git a/include/macros.h b/include/macros.h index 33bece4..959255c 100644 --- a/include/macros.h +++ b/include/macros.h @@ -43,8 +43,8 @@ #define CLAMP(x, min, max) ((x) < (min) ? (min) : (x) > (max) ? (max) : (x)) //! checks max first #define CLAMP_ALT(x, min, max) ((x) > (max) ? (max) : (x) < (min) ? (min) : (x)) -#define CLAMP_MAX(x, max) ((x) > (max) ? (max) : (x)) -#define CLAMP_MIN(x, min) ((x) < (min) ? (min) : (x)) +#define CLAMP_MAX(x, max) ((x) > (max) ? (x) : (max)) +#define CLAMP_MIN(x, min) ((x) < (min) ? (x) : (min)) #define ROUND_MAX(x) ((x) + ((x) > 0.0f ? 0.5f : -0.5f)) diff --git a/include/variables.h b/include/variables.h index a6f2324..594532d 100644 --- a/include/variables.h +++ b/include/variables.h @@ -350,6 +350,129 @@ extern u8 D_4001FB8[]; extern u8 D_30015E0[]; extern u8 D_30025E0[]; extern u8 D_3002C00[]; +extern u8 D_302F690[]; +extern u8 D_302F588[]; +extern u8 D_302F5C8[]; +extern u8 D_302F608[]; +extern u8 D_302F648[]; +extern u8 D_30387B0[]; +extern u8 D_30387F0[]; +extern u8 D_3038830[]; +extern u8 D_3038870[]; +extern u8 D_302F6E0[]; +extern u8 D_302F740[]; +extern u8 D_302F7A0[]; +extern u8 D_302F800[]; +extern u8 D_302F860[]; +extern u8 D_302F8C0[]; +extern u8 D_302F928[]; +extern u8 D_302F988[]; +extern u8 D_302F9E8[]; +extern u8 D_302FA48[]; +extern u8 D_3038C70[]; +extern u8 D_3038D70[]; +extern u8 D_3038E70[]; +extern u8 D_3038F70[]; +extern u8 D_3027168[]; +extern u8 D_3027EE8[]; +extern u8 D_3039070[]; +extern u8 D_3039540[]; +extern u8 D_3039A10[]; +extern u8 D_3039FB0[]; +extern u8 D_303A550[]; +extern u8 D_303AAF0[]; +extern u8 D_303B090[]; +extern u8 D_303B630[]; +extern u8 D_303BBD0[]; +extern u8 D_303C170[]; +extern u8 D_303C710[]; +extern u8 D_303CCB0[]; +extern u8 D_303D250[]; +extern u8 D_303D7F0[]; +extern u8 D_303DD90[]; +extern u8 D_30388B0[]; +extern u8 D_3038990[]; +extern u8 D_3028C68[]; +extern u8 D_3029468[]; +extern u8 D_3029C68[]; +extern u8 D_302A468[]; +extern u8 D_30386B0[]; +extern u8 D_30386F0[]; +extern u8 D_3038730[]; +extern u8 D_3038770[]; +extern u8 D_3014468[]; +extern u8 D_302DE68[]; +extern u8 D_302E418[]; +extern u8 D_302E9C8[]; +extern u8 D_302EF78[]; +extern u8 D_302F528[]; +extern u8 D_303E330[]; +extern u8 D_303FC30[]; +extern u8 D_3040590[]; +extern u8 D_3040270[]; +extern u8 D_303F910[]; +extern u8 D_303F5F0[]; +extern u8 D_3040590[]; +extern u8 D_303FF50[]; +extern u8 D_3040BD0[]; +extern u8 D_303E650[]; +extern u8 D_303E970[]; +extern u8 D_303EFB0[]; +extern u8 D_303F2D0[]; +extern u8 D_30408B0[]; +extern u8 D_303EC90[]; +extern u8 D_3040EF0[]; +extern u8 D_302F6E0[]; +extern u8 D_302F7A0[]; +extern u8 D_302F800[]; +extern u8 D_302F860[]; +extern u8 D_302F8C0[]; +extern u8 D_302F928[]; +extern u8 D_302F988[]; +extern u8 D_302F9E8[]; +extern u8 D_302FA48[]; +extern u8 D_302FAB0[]; +extern u8 D_302FDB0[]; +extern u8 D_30300B0[]; +extern u8 D_30303B0[]; +extern u8 D_302BE68[]; +extern u8 D_30306B0[]; +extern u8 D_30326B0[]; +extern u8 D_30346B0[]; +extern u8 D_30366B0[]; +extern u8 D_302AC68[]; +extern u8 D_302B568[]; +extern u8 D_3026168[]; +extern u8 D_3026368[]; +extern u8 D_3026568[]; +extern u8 D_3026768[]; +extern u8 D_3026968[]; +extern u8 D_3026B68[]; +extern u8 D_3026D68[]; +extern u8 D_3026F68[]; +extern u8 D_300D868[]; +extern u8 D_300EA68[]; +extern u8 D_300FC68[]; +extern u8 D_3010E68[]; +extern u8 D_3012068[]; +extern u8 D_3013268[]; +extern u8 D_3012068[]; +extern u8 D_3010E68[]; +extern u8 D_300FC68[]; +extern u8 D_300EA68[]; +extern u8 D_3005D28[]; +extern u8 D_300D108[]; +extern u8 D_300D278[]; +extern u8 D_3006000[]; +extern u8 D_3009DC8[]; +extern u8 D_300B768[]; +extern u8 D_30079A0[]; +extern u8 D_3009BC0[]; +extern u8 D_30081A8[]; +extern u8 D_3038A70[]; +extern u8 D_3038AF0[]; +extern u8 D_3038B70[]; +extern u8 D_3038BF0[]; extern LEODiskID D_800818E0; @@ -476,7 +599,9 @@ typedef struct unk_D_80072B00 { extern unk_D_80072B00 D_80072B00[]; typedef struct unk_D_80072338 { - /* 0x00 */ char unk00[0xC]; + /* 0x00 */ char unk00[0x1]; + /* 0x01 */ u8 unk_01; + /* 0x02 */ char unk02[0xA]; } unk_D_80072338; // size = 0xC extern unk_D_80072338 D_80072338[]; diff --git a/linker_scripts/us/symbol_addrs.txt b/linker_scripts/us/symbol_addrs.txt index fa7a2f4..fcce140 100644 --- a/linker_scripts/us/symbol_addrs.txt +++ b/linker_scripts/us/symbol_addrs.txt @@ -601,4 +601,119 @@ D_800FCEB8 = 0x800FCEB8; // size:0x8 D_800FCEB6 = 0x800FCEB6; // size:0x2 D_30015E0 = 0x30015E0; D_30025E0 = 0x30025E0; -D_3002C00 = 0x3002C00; \ No newline at end of file +D_3002C00 = 0x3002C00; +D_82F144D0 = 0x82F144D0; // size:0xC530 +D_302F690 = 0x302F690; +D_302F588 = 0x302F588; +D_302F5C8 = 0x302F5C8; +D_302F608 = 0x302F608; +D_302F648 = 0x302F648; +D_30387B0 = 0x30387B0; +D_30387F0 = 0x30387F0; +D_3038830 = 0x3038830; +D_3038870 = 0x3038870; +D_302F6E0 = 0x302F6E0; +D_302F740 = 0x302F740; +D_302F7A0 = 0x302F7A0; +D_302F800 = 0x302F800; +D_302F860 = 0x302F860; +D_302F8C0 = 0x302F8C0; +D_302F928 = 0x302F928; +D_302F988 = 0x302F988; +D_302F9E8 = 0x302F9E8; +D_302FA48 = 0x302FA48; +D_3038C70 = 0x3038C70; +D_3038D70 = 0x3038D70; +D_3038E70 = 0x3038E70; +D_3038F70 = 0x3038F70; +D_3027168 = 0x3027168; +D_3027EE8 = 0x3027EE8; +D_3039070 = 0x3039070; +D_3039540 = 0x3039540; +D_3039A10 = 0x3039A10; +D_3039FB0 = 0x3039FB0; +D_303A550 = 0x303A550; +D_303AAF0 = 0x303AAF0; +D_303B090 = 0x303B090; +D_303B630 = 0x303B630; +D_303BBD0 = 0x303BBD0; +D_303C170 = 0x303C170; +D_303C710 = 0x303C710; +D_303CCB0 = 0x303CCB0; +D_303D250 = 0x303D250; +D_303D7F0 = 0x303D7F0; +D_303DD90 = 0x303DD90; +D_30388B0 = 0x30388B0; +D_3038990 = 0x3038990; +D_3028C68 = 0x3028C68; +D_3029468 = 0x3029468; +D_3029C68 = 0x3029C68; +D_302A468 = 0x302A468; +D_30386B0 = 0x30386B0; +D_30386F0 = 0x30386F0; +D_3038730 = 0x3038730; +D_3038770 = 0x3038770; +D_3014468 = 0x3014468; +D_302DE68 = 0x302DE68; +D_302E418 = 0x302E418; +D_302E9C8 = 0x302E9C8; +D_302EF78 = 0x302EF78; +D_302F528 = 0x302F528; +D_303E330 = 0x303E330; +D_303FC30 = 0x303FC30; +D_3040590 = 0x3040590; +D_3040270 = 0x3040270; +D_303F910 = 0x303F910; +D_303F5F0 = 0x303F5F0; +D_303FF50 = 0x303FF50; +D_3040BD0 = 0x3040BD0; +D_303E650 = 0x303E650; +D_303E970 = 0x303E970; +D_303EFB0 = 0x303EFB0; +D_303F2D0 = 0x303F2D0; +D_30408B0 = 0x30408B0; +D_303EC90 = 0x303EC90; +D_3040EF0 = 0x3040EF0; +D_302FAB0 = 0x302FAB0; +D_302FDB0 = 0x302FDB0; +D_30300B0 = 0x30300B0; +D_30303B0 = 0x30303B0; +D_302BE68 = 0x302BE68; +D_30306B0 = 0x30306B0; +D_30326B0 = 0x30326B0; +D_30346B0 = 0x30346B0; +D_30366B0 = 0x30366B0; +D_302AC68 = 0x302AC68; +D_302B568 = 0x302B568; +D_82F210E0 = 0x82F210E0; // size:0x3C +D_82F21140 = 0x82F21140; // size:0x1C +D_82F21160 = 0x82F21160; // size:0x40 +D_82F211A0 = 0x82F211A0; // size:0x98 +D_82F21238 = 0x82F21238; // size:0x30 +D_3026168 = 0x3026168; +D_3026368 = 0x3026368; +D_3026568 = 0x3026568; +D_3026768 = 0x3026768; +D_3026968 = 0x3026968; +D_3026B68 = 0x3026B68; +D_3026D68 = 0x3026D68; +D_3026F68 = 0x3026F68; +D_300D868 = 0x300D868; +D_300EA68 = 0x300EA68; +D_300FC68 = 0x300FC68; +D_3010E68 = 0x3010E68; +D_3012068 = 0x3012068; +D_3013268 = 0x3013268; +D_3005D28 = 0x3005D28; +D_300D108 = 0x300D108; +D_300D278 = 0x300D278; +D_3006000 = 0x3006000; +D_3009DC8 = 0x3009DC8; +D_300B768 = 0x300B768; +D_30079A0 = 0x30079A0; +D_3009BC0 = 0x3009BC0; +D_30081A8 = 0x30081A8; +D_3038A70 = 0x3038A70; +D_3038AF0 = 0x3038AF0; +D_3038B70 = 0x3038B70; +D_3038BF0 = 0x3038BF0; \ No newline at end of file diff --git a/linker_scripts/us/undefined_syms.ld b/linker_scripts/us/undefined_syms.ld index b606135..c70ff73 100644 --- a/linker_scripts/us/undefined_syms.ld +++ b/linker_scripts/us/undefined_syms.ld @@ -196,3 +196,112 @@ D_04001C28 = 0x04001C28; D_4001FB8 = 0x4001FB8; D_4001010 = 0x4001010; D_4006AB8 = 0x4006AB8; +D_302F690 = 0x302F690; +D_302F588 = 0x302F588; +D_302F5C8 = 0x302F5C8; +D_302F608 = 0x302F608; +D_302F648 = 0x302F648; +D_30387B0 = 0x30387B0; +D_30387F0 = 0x30387F0; +D_3038830 = 0x3038830; +D_3038870 = 0x3038870; +D_302F6E0 = 0x302F6E0; +D_302F740 = 0x302F740; +D_302F7A0 = 0x302F7A0; +D_302F800 = 0x302F800; +D_302F860 = 0x302F860; +D_302F8C0 = 0x302F8C0; +D_302F928 = 0x302F928; +D_302F988 = 0x302F988; +D_302F9E8 = 0x302F9E8; +D_302FA48 = 0x302FA48; +D_3038C70 = 0x3038C70; +D_3038D70 = 0x3038D70; +D_3038E70 = 0x3038E70; +D_3038F70 = 0x3038F70; +D_3027168 = 0x3027168; +D_3027EE8 = 0x3027EE8; +D_3039070 = 0x3039070; +D_3039540 = 0x3039540; +D_3039A10 = 0x3039A10; +D_3039FB0 = 0x3039FB0; +D_303A550 = 0x303A550; +D_303AAF0 = 0x303AAF0; +D_303B090 = 0x303B090; +D_303B630 = 0x303B630; +D_303BBD0 = 0x303BBD0; +D_303C170 = 0x303C170; +D_303C710 = 0x303C710; +D_303CCB0 = 0x303CCB0; +D_303D250 = 0x303D250; +D_303D7F0 = 0x303D7F0; +D_303DD90 = 0x303DD90; +D_30388B0 = 0x30388B0; +D_3038990 = 0x3038990; +D_3028C68 = 0x3028C68; +D_3029468 = 0x3029468; +D_3029C68 = 0x3029C68; +D_302A468 = 0x302A468; +D_30386B0 = 0x30386B0; +D_30386F0 = 0x30386F0; +D_3038730 = 0x3038730; +D_3038770 = 0x3038770; +D_3014468 = 0x3014468; +D_302DE68 = 0x302DE68; +D_302E418 = 0x302E418; +D_302E9C8 = 0x302E9C8; +D_302EF78 = 0x302EF78; +D_302F528 = 0x302F528; +D_303E330 = 0x303E330; +D_303FC30 = 0x303FC30; +D_3040590 = 0x3040590; +D_3040270 = 0x3040270; +D_303F910 = 0x303F910; +D_303F5F0 = 0x303F5F0; +D_303FF50 = 0x303FF50; +D_3040BD0 = 0x3040BD0; +D_303E650 = 0x303E650; +D_303E970 = 0x303E970; +D_303EFB0 = 0x303EFB0; +D_303F2D0 = 0x303F2D0; +D_30408B0 = 0x30408B0; +D_303EC90 = 0x303EC90; +D_3040EF0 = 0x3040EF0; +D_302FAB0 = 0x302FAB0; +D_302FDB0 = 0x302FDB0; +D_30300B0 = 0x30300B0; +D_30303B0 = 0x30303B0; +D_302BE68 = 0x302BE68; +D_30306B0 = 0x30306B0; +D_30326B0 = 0x30326B0; +D_30346B0 = 0x30346B0; +D_30366B0 = 0x30366B0; +D_302AC68 = 0x302AC68; +D_302B568 = 0x302B568; +D_3026168 = 0x3026168; +D_3026368 = 0x3026368; +D_3026568 = 0x3026568; +D_3026768 = 0x3026768; +D_3026968 = 0x3026968; +D_3026B68 = 0x3026B68; +D_3026D68 = 0x3026D68; +D_3026F68 = 0x3026F68; +D_300D868 = 0x300D868; +D_300EA68 = 0x300EA68; +D_300FC68 = 0x300FC68; +D_3010E68 = 0x3010E68; +D_3012068 = 0x3012068; +D_3013268 = 0x3013268; +D_3005D28 = 0x3005D28; +D_300D108 = 0x300D108; +D_300D278 = 0x300D278; +D_3006000 = 0x3006000; +D_3009DC8 = 0x3009DC8; +D_300B768 = 0x300B768; +D_30079A0 = 0x30079A0; +D_3009BC0 = 0x3009BC0; +D_30081A8 = 0x30081A8; +D_3038A70 = 0x3038A70; +D_3038AF0 = 0x3038AF0; +D_3038B70 = 0x3038B70; +D_3038BF0 = 0x3038BF0; \ No newline at end of file diff --git a/src/1AB70.c b/src/1AB70.c index 477c139..876e5d9 100644 --- a/src/1AB70.c +++ b/src/1AB70.c @@ -259,7 +259,7 @@ void func_8001B058(void) { D_800ABE10.unk_A04.unk_10 = func_800044F4(0x820000, NULL, 1, 1); } -void func_8001B088(unk_func_88201DA0_034_008* arg0, s32 arg1) { +void func_8001B088(u16* arg0, s32 arg1) { BinArchive* temp_v1; u8* temp_a1; @@ -270,7 +270,7 @@ void func_8001B088(unk_func_88201DA0_034_008* arg0, s32 arg1) { } } -void func_8001B0DC(unk_func_88201DA0_034_008* arg0, s32 arg1, unk_func_80026268_arg0* arg2) { +void func_8001B0DC(u16* arg0, s32 arg1, unk_func_80026268_arg0* arg2) { arg1_func_80010CA8 sp1C; if (arg2 == 0) { diff --git a/src/1AB70.h b/src/1AB70.h index 289c8cf..c0b4ebe 100644 --- a/src/1AB70.h +++ b/src/1AB70.h @@ -6,10 +6,6 @@ #include "F420.h" #include "29BA0.h" -typedef struct unk_func_88201DA0_034_008 { - /* 0x00 */ char unk00[0x4]; -} unk_func_88201DA0_034_008; // size >= 0x4 - typedef struct unk_func_8001B1FC { /* 0x00 */ u16 unk_00; /* 0x02 */ u16 unk_02; @@ -66,7 +62,7 @@ void func_8001A324(unk_func_8001A024*, s32, s32, u16); s32 func_8001ABAC(unk_func_8001A024*, s32); void* func_8001AFD8(unk_func_8001A024*, s32); void func_8001B058(void); -void func_8001B0DC(unk_func_88201DA0_034_008*, s32, unk_func_80026268_arg0*); +void func_8001B0DC(u16*, s32, unk_func_80026268_arg0*); unk_func_8001B1FC* func_8001B1FC(unk_D_86002F58_004_000_010*, s16, s16, s16, s16, s16, s16, u8*); void func_8001B2D8(unk_func_8001B1FC* arg0, unk_func_80026268_arg0* arg1, u16 arg2); void func_8001B480(unk_func_8001B1FC*, s32, u16); diff --git a/src/22630.c b/src/22630.c index c3bfd9a..2fea46a 100644 --- a/src/22630.c +++ b/src/22630.c @@ -7,8 +7,6 @@ #include "src/hal_libc.h" #include "src/util.h" -extern unk_D_80070F84 D_80070F84[]; - u16 func_80021A30(u8* arg0) { return (arg0[0] << 8) | arg0[1]; } diff --git a/src/22630.h b/src/22630.h index 0d4ce57..c349bd7 100644 --- a/src/22630.h +++ b/src/22630.h @@ -25,6 +25,12 @@ typedef struct unk_D_80070F84 { extern unk_D_80070F84 D_80070F84[]; extern unk_D_80070F84 D_80070FA0[]; +typedef struct unk_D_80071D88 { + /* 0x00 */ char* type_name; + /* 0x04 */ Color_RGB8 color; +} unk_D_80071D88; // size = 0x8 +extern unk_D_80071D88 D_80071D88[]; + typedef struct unk_D_800AE4E8_004_1_000_010_000 { /* 0x00 */ u8 unk_00; /* 0x01 */ u8 unk_01[2]; diff --git a/src/2D340.h b/src/2D340.h index 350afd0..7a53ec4 100644 --- a/src/2D340.h +++ b/src/2D340.h @@ -22,8 +22,7 @@ typedef struct unk_func_88200FA0_030_038 { typedef struct unk_func_88201DA0_034 { /* 0x0000 */ s32 unk_000; /* 0x0004 */ char unk004[0x4]; - /* 0x0008 */ unk_func_88201DA0_034_008 unk_008; - /* 0x000C */ char unk00C[0xC7C]; + /* 0x0008 */ u16 unk_008[0x640]; } unk_func_88201DA0_034; // size = 0xC88 typedef struct unk_func_88201DA0_038 { diff --git a/src/2E110.c b/src/2E110.c index 7de14c3..3652b20 100644 --- a/src/2E110.c +++ b/src/2E110.c @@ -22,9 +22,9 @@ char** func_8002D5AC(s32 file_number) { return (char**)func_8000484C(D_800AF740, file_number); } -void func_8002D5D4(u32 arg0, char* arg1) { +void func_8002D5D4(u32 arg0, u32 arg1) { if ((arg0 >= 0x14) && (arg0 < 0x2A)) { - D_800AF744[arg0] = arg1; + D_800AF744[arg0] = (char*)arg1; } } @@ -53,18 +53,18 @@ void func_8002D628(char* arg0, u32 arg1, s8* arg2) { switch (var_s2) { case 0: temp_v0 = *arg2++; - if (temp_v0 == 0) { + if (temp_v0 == '\x00') { goto end; } - if (temp_v0 == 0x23) { + if (temp_v0 == '#') { temp_v0 = *arg2++; temp_v0 -= '0'; temp_v0 = (*arg2++ + (temp_v0 * 10)) - '0'; if ((temp_v0 > 0) && (temp_v0 < 10)) { - sprintf(&sp58, "%d", D_800AF744[temp_v0]); - var_s4 = &sp58; + sprintf(sp58, "%d", D_800AF744[temp_v0]); + var_s4 = sp58; var_s2 = 1; continue; } @@ -85,7 +85,7 @@ void func_8002D628(char* arg0, u32 arg1, s8* arg2) { case 1: temp_v0 = *var_s4++; - if (temp_v0 == 0) { + if (temp_v0 == '\x00') { var_s2 = 0; } else { *arg0++ = temp_v0; @@ -96,9 +96,8 @@ void func_8002D628(char* arg0, u32 arg1, s8* arg2) { } } - sp54 = var_s4; end: - *arg0++ = 0; + *arg0++ = '\x00'; } char* func_8002D7C0(char* arg0, s32 arg1, char** arg2, u32 file_number) { diff --git a/src/2E110.h b/src/2E110.h index 025db26..cd94951 100644 --- a/src/2E110.h +++ b/src/2E110.h @@ -5,7 +5,7 @@ void func_8002D510(void); char** func_8002D5AC(s32 file_number); -void func_8002D5D4(u32 arg0, char* arg1); +void func_8002D5D4(u32 arg0, u32 arg1); void func_8002D600(u32 arg0, char* arg1); void func_8002D628(char* arg0, u32 arg1, s8* arg2); char* func_8002D7C0(char* arg0, s32 arg1, char** arg2, u32 file_number); diff --git a/src/fragments/26/fragment26.c b/src/fragments/26/fragment26.c index d552672..de3f450 100644 --- a/src/fragments/26/fragment26.c +++ b/src/fragments/26/fragment26.c @@ -2293,24 +2293,21 @@ s32 func_8850897C(unk_func_885088F4* arg0) { return 0; } -#ifdef NON_MATCHING s32 func_88508AA8(unk_func_885088F4* arg0, s32 arg1, s32 arg2) { static Color_RGBA8 D_8850CF8C = { 0x38, 0x38, 0x68, 0xFF }; - s32 color; + u32 color = RGBA5551(D_8850CF8C.r, D_8850CF8C.g, D_8850CF8C.b, 1); gDPPipeSync(gDisplayListHead++); gDPSetCycleType(gDisplayListHead++, G_CYC_FILL); gDPSetRenderMode(gDisplayListHead++, G_RM_NOOP, G_RM_NOOP2); - color = ((D_8850CF8C.r << 8) & 0xF800) | ((D_8850CF8C.g << 3) & 0x7C0) | ((D_8850CF8C.b >> 2) & 0x3E) | 1; gDPSetFillColor(gDisplayListHead++, (color << 0x10) | color); gDPFillRectangle(gDisplayListHead++, CLAMP_MAX(arg1, 0), CLAMP_MAX(arg2, 0), CLAMP_MAX(arg1 + 0x27F, 0), CLAMP_MAX((arg0->unk_00.unk_14.unk_02 + arg2) - 0x16, 0)); - gDPFillRectangle(gDisplayListHead++, CLAMP_MAX((arg0->unk_34 + arg1) - 1, 0), - CLAMP_MAX((arg0->unk_00.unk_14.unk_02 + arg2) - 6, 0), CLAMP_MAX(arg1, 0), - CLAMP_MAX((arg0->unk_00.unk_14.unk_02 + arg2) - 0x15, 0)); + gDPFillRectangle(gDisplayListHead++, CLAMP_MAX(arg1, 0), CLAMP_MAX((arg0->unk_00.unk_14.unk_02 + arg2) - 0x15, 0), + CLAMP_MAX((arg0->unk_34 + arg1) - 1, 0), CLAMP_MAX((arg0->unk_00.unk_14.unk_02 + arg2) - 6, 0)); gDPFillRectangle(gDisplayListHead++, CLAMP_MAX((arg1 - arg0->unk_38) + 0x280, 0), CLAMP_MAX((arg0->unk_00.unk_14.unk_02 + arg2) - 0x15, 0), CLAMP_MAX(arg1 + 0x27F, 0), @@ -2327,76 +2324,38 @@ s32 func_88508AA8(unk_func_885088F4* arg0, s32 arg1, s32 arg2) { gDPLoadTextureBlock(gDisplayListHead++, D_4007948, G_IM_FMT_IA, G_IM_SIZ_8b, 8, 5, 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); - gSPTextureRectangle( - gDisplayListHead++, CLAMP_MAX(arg1 << 2, 0), CLAMP_MAX((((arg0->unk_00.unk_14.unk_02 + arg2) - 5) << 2), 0), - CLAMP_MAX(((arg0->unk_34 + arg1) << 2), 0), CLAMP_MAX(((arg0->unk_00.unk_14.unk_02 + arg2) << 2), 0), - G_TX_RENDERTILE, ((arg1 << 2) < 0) ? CLAMP_MIN(((s16)arg1 << 0xA) >> 7, 0) : 0, - -((((arg0->unk_00.unk_14.unk_02 + arg2) - 5) & 0x20000000) - ? CLAMP_MIN((((s16)((arg0->unk_00.unk_14.unk_02 + arg2) - 5) << 0xA) >> 7), 0) - : 0), - 0x0400, 0x0400); + gSPScisTextureRectangle(gDisplayListHead++, arg1 << 2, ((arg0->unk_00.unk_14.unk_02 + arg2) - 5) << 2, + (arg0->unk_34 + arg1) << 2, (arg0->unk_00.unk_14.unk_02 + arg2) << 2, G_TX_RENDERTILE, 0, 0, + 0x400, 0x400); - gSPTextureRectangle(gDisplayListHead++, CLAMP_MAX(((arg1 - arg0->unk_38) + 0x280) << 2, 0), - CLAMP_MAX(((arg0->unk_00.unk_14.unk_02 + arg2) - 5) << 2, 0), CLAMP_MAX((arg1 + 0x280) << 2, 0), - CLAMP_MAX((arg0->unk_00.unk_14.unk_02 + arg2) << 2, 0), G_TX_RENDERTILE, - ((((arg1 - arg0->unk_38) + 0x280) << 2) < 0) - ? CLAMP_MIN(((s16)((arg1 - arg0->unk_38) + 0x280) << 0xA) >> 7, 0) - : 0, - -((((arg0->unk_00.unk_14.unk_02 + arg2) - 5) & 0x20000000) - ? CLAMP_MIN(((s16)((arg0->unk_00.unk_14.unk_02 + arg2) - 5) << 0xA) >> 7, 0) - : 0), - 0x0400, 0x0400); + gSPScisTextureRectangle(gDisplayListHead++, ((arg1 - arg0->unk_38) + 0x280) << 2, + ((arg0->unk_00.unk_14.unk_02 + arg2) - 5) << 2, (arg1 + 0x280) << 2, + (arg0->unk_00.unk_14.unk_02 + arg2) << 2, G_TX_RENDERTILE, 0, 0, 0x400, 0x400); - gSPTextureRectangle( - gDisplayListHead++, CLAMP_MAX((arg0->unk_34 + arg1 + 0x10) << 2, 0), - CLAMP_MAX(((arg0->unk_00.unk_14.unk_02 + arg2) - 0x15) << 2, 0), - CLAMP_MAX(((arg1 - arg0->unk_38) + 0x270) << 2, 0), - CLAMP_MAX(((arg0->unk_00.unk_14.unk_02 + arg2) - 0x10) << 2, 0), G_TX_RENDERTILE, - (((arg0->unk_34 + arg1 + 0x10) << 2) < 0) ? CLAMP_MIN(((s16)(arg0->unk_34 + arg1 + 0x10) << 0xA) >> 7, 0) : 0, - -((((arg0->unk_00.unk_14.unk_02 + arg2) - 0x15) & 0x20000000) - ? CLAMP_MIN(((s16)((arg0->unk_00.unk_14.unk_02 + arg2) - 0x15) << 0xA) >> 7, 0) - : 0), - 0x0400, 0x0400); + gSPScisTextureRectangle(gDisplayListHead++, (arg0->unk_34 + arg1 + 0x10) << 2, + ((arg0->unk_00.unk_14.unk_02 + arg2) - 0x15) << 2, ((arg1 - arg0->unk_38) + 0x270) << 2, + ((arg0->unk_00.unk_14.unk_02 + arg2) - 0x10) << 2, G_TX_RENDERTILE, 0, 0, 0x400, 0x400); gDPPipeSync(gDisplayListHead++); gDPSetRenderMode(gDisplayListHead++, G_RM_XLU_SURF, G_RM_XLU_SURF2); - gDPSetCombineLERP(gDisplayListHead++, TEXEL0, COMBINED, PRIMITIVE, 0, 0, 0, 0, 0, TEXEL0, 0, PRIMITIVE, SHADE, 0, 0, - 0, 0); + gDPSetCombineMode(gDisplayListHead++, G_CC_MODULATEIDECALA_PRIM, G_CC_MODULATEIDECALA_PRIM); gDPLoadTextureBlock(gDisplayListHead++, D_4007978, G_IM_FMT_IA, G_IM_SIZ_8b, 16, 21, 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); - gSPTextureRectangle(gDisplayListHead++, CLAMP_MAX((arg0->unk_34 + arg1) << 2, 0), - CLAMP_MAX(((arg0->unk_00.unk_14.unk_02 + arg2) - 0x15) << 2, 0), - CLAMP_MAX(((arg1 - arg0->unk_38) + 0x270) << 2, 0), - CLAMP_MAX((arg0->unk_00.unk_14.unk_02 + arg2) << 2, 0), G_TX_RENDERTILE, - (((arg0->unk_34 + arg1) << 2) < 0) ? CLAMP_MIN(((s16)(arg0->unk_34 + arg1) << 0xA) >> 7, 0) : 0, - -(((s16)((arg0->unk_00.unk_14.unk_02 + arg2) - 0x15) & 0x20000000) - ? CLAMP_MIN(((s16)((arg0->unk_00.unk_14.unk_02 + arg2) - 0x15) << 0xA) >> 7, 0) - : 0), - 0x0400, 0x0400); + gSPScisTextureRectangle(gDisplayListHead++, (arg0->unk_34 + arg1) << 2, + ((arg0->unk_00.unk_14.unk_02 + arg2) - 0x15) << 2, ((arg1 - arg0->unk_38) + 0x270) << 2, + (arg0->unk_00.unk_14.unk_02 + arg2) << 2, G_TX_RENDERTILE, 0, 0, 0x400, 0x400); gDPLoadTextureBlock(gDisplayListHead++, D_4007978, G_IM_FMT_IA, G_IM_SIZ_8b, 16, 21, 0, G_TX_MIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, 4, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD); - gSPTextureRectangle(gDisplayListHead++, CLAMP_MAX((s16)(((arg1 - arg0->unk_38) + 0x270) << 2), 0), - CLAMP_MAX((s16)(((arg0->unk_00.unk_14.unk_02 + arg2) - 0x15) << 2), 0), - CLAMP_MAX((s16)(((arg1 - arg0->unk_38) + 0x280) << 2), 0), - CLAMP_MAX((s16)((arg0->unk_00.unk_14.unk_02 + arg2) << 2), 0), G_TX_RENDERTILE, - 0x200 - ((s16)(((arg1 - arg0->unk_38) + 0x270) << 2) < 0 - ? CLAMP_MIN(((s16)(((arg1 - arg0->unk_38) + 0x270) << 2) << 0xA) >> 7, 0) - : 0), - -(((s16)((arg0->unk_00.unk_14.unk_02 + arg2) - 0x15) & 0x20000000) - ? CLAMP_MIN(((s16)((arg0->unk_00.unk_14.unk_02 + arg2) - 0x15) << 0xA) >> 7, 0) - : 0), - 0x0400, 0x0400); + gSPScisTextureRectangle(gDisplayListHead++, ((arg1 - arg0->unk_38) + 0x270) << 2, + ((arg0->unk_00.unk_14.unk_02 + arg2) - 0x15) << 2, ((arg1 - arg0->unk_38) + 0x280) << 2, + (arg0->unk_00.unk_14.unk_02 + arg2) << 2, G_TX_RENDERTILE, 0x200, 0, 0x400, 0x400); return 0; } -#else -static Color_RGBA8 D_8850CF8C = { 0x38, 0x38, 0x68, 0xFF }; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/26/fragment26/func_88508AA8.s") -#endif void func_88509A2C(unk_func_88509A2C* arg0, s32 arg1, s32 arg2, s32 arg3, char* arg4) { func_885007CC(&arg0->unk_00, sizeof(unk_func_88509A2C)); diff --git a/src/fragments/40/fragment40.c b/src/fragments/40/fragment40.c index 33f3181..6b365e4 100644 --- a/src/fragments/40/fragment40.c +++ b/src/fragments/40/fragment40.c @@ -481,22 +481,10 @@ void func_831010E0(unk_D_83101F00* arg0, s16 arg1) { } } -#ifdef NON_MATCHING void func_831011D4(s16 arg0, s16 arg1, s16 arg2, s16 arg3, s16 arg4, s16 arg5, s16 arg6, s16 arg7) { - gSPTextureRectangle(gDisplayListHead++, CLAMP_MIN(0, (s16)(arg0 << 2)), CLAMP_MIN(0, (s16)(arg1 << 2)), - CLAMP_MIN(0, (s16)(((arg0 + arg2) - 1) << 2)), CLAMP_MIN(0, (s16)(((arg1 + arg3) - 1) << 2)), - G_TX_RENDERTILE, - arg4 - ((arg0 << 2) < 0 ? arg6 < 0 ? CLAMP_MIN(0, ((arg0 << 2) * arg6) >> 7) - : CLAMP_MAX(0, ((arg0 << 2) * arg6) >> 7) - : 0), - arg5 - ((arg1 << 0x2) < 0 ? arg7 < 0 ? CLAMP_MIN(0, ((arg1 << 2) * arg7) >> 7) - : CLAMP_MAX(0, ((arg1 << 2) * arg7) >> 7) - : 0), - arg6, arg7); + gSPScisTextureRectangle(gDisplayListHead++, arg0 << 2, arg1 << 2, ((arg0 + arg2) - 1) << 2, + ((arg1 + arg3) - 1) << 2, 0, arg4, arg5, arg6, arg7); } -#else -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/40/fragment40/func_831011D4.s") -#endif void func_831013FC(void) { f32 v = 1.8f; diff --git a/src/fragments/41/fragment41.h b/src/fragments/41/fragment41.h new file mode 100644 index 0000000..acd4888 --- /dev/null +++ b/src/fragments/41/fragment41.h @@ -0,0 +1,446 @@ +#ifndef _FRAGMENT41_H_ +#define _FRAGMENT41_H_ + +#include "global.h" +#include "src/1AB70.h" +#include "src/29BA0.h" + +typedef struct unk_func_82F00838_sp30_00C { + /* 0x00 */ u8 unk_00; + /* 0x01 */ char unk01[0xD]; + /* 0x0E */ u16 unk_0E; + /* 0x10 */ char unk10[0x14]; + /* 0x24 */ u8 unk_24; + /* 0x25 */ char unk25[0xB]; + /* 0x30 */ char unk_30[11]; + /* 0x3B */ char unk_3B[11]; + /* 0x46 */ char unk46[0xA]; + /* 0x50 */ s32 force_align; +} unk_func_82F00838_sp30_00C; // size = 0x54 + +typedef struct unk_D_82F144D0_0CA8 { + /* 0x000 */ s16 unk_000; + /* 0x004 */ struct unk_D_82F144D0_0CA8* unk_004; + /* 0x008 */ struct unk_D_82F144D0_0CA8* unk_008; + /* 0x00C */ unk_func_82F00838_sp30_00C unk_00C[20]; +} unk_D_82F144D0_0CA8; // size = 0x69C + +typedef struct unk_D_82F144D0 { + /* 0x0000 */ s16 unk_0000; + /* 0x0002 */ s16 unk_0002; + /* 0x0004 */ s16 unk_0004; + /* 0x0006 */ s16 unk_0006; + /* 0x0008 */ s16 unk_0008; + /* 0x000A */ s16 unk_000A; + /* 0x000C */ s16 unk_000C; + /* 0x000E */ s16 unk_000E; + /* 0x0010 */ s16 unk_0010; + /* 0x0012 */ s16 unk_0012; + /* 0x0014 */ s16 unk_0014; + /* 0x0016 */ s16 unk_0016; + /* 0x0018 */ s16 unk_0018; + /* 0x001A */ s16 unk_001A; + /* 0x001C */ s16 unk_001C; + /* 0x001E */ s16 unk_001E; + /* 0x0020 */ s16 unk_0020; + /* 0x0022 */ char unk0022[0x6]; + /* 0x0028 */ u16 unk_0028[0x640]; + /* 0x0CA8 */ unk_D_82F144D0_0CA8 unk_0CA8[13]; + /* 0x6294 */ char unk6294[0x4]; +} unk_D_82F144D0; // size = 0x6298 + +typedef struct unk_func_82F00838_sp30 { + /* 0x00 */ s16 unk_00; + /* 0x02 */ s16 unk_02; + /* 0x04 */ s16 unk_04; + /* 0x06 */ s16 unk_06; + /* 0x08 */ s16 unk_08; + /* 0x0C */ unk_func_82F00838_sp30_00C* unk_0C; +} unk_func_82F00838_sp30; // size = 0x10 + +typedef struct unk_D_82F14450 { + /* 0x00 */ u8 unk_00; + /* 0x01 */ u8 unk_01; + /* 0x02 */ u8 unk_02; + /* 0x03 */ u8 unk_03; + /* 0x04 */ u8 unk_04; + /* 0x05 */ u8 unk_05; + /* 0x06 */ u16 unk_06; + /* 0x08 */ char unk_08[1]; + /* 0x09 */ char unk09[0xD]; +} unk_D_82F14450; // size = 0x16 + +typedef struct unk_D_82F13B78 { + /* 0x00 */ s16 unk_00; + /* 0x02 */ s16 unk_02; + /* 0x04 */ char* unk_04; +} unk_D_82F13B78; // size = 0x8 + +typedef struct unk_D_82F20A10 { + /* 0x00 */ s16 unk_00; + /* 0x02 */ s16 unk_02; + /* 0x04 */ s16 unk_04; + /* 0x06 */ s16 unk_06; + /* 0x08 */ s16 unk_08; + /* 0x0A */ s16 unk_0A; + /* 0x0C */ s16 unk_0C; + /* 0x0E */ s16 unk_0E; + /* 0x10 */ s16 unk_10; + /* 0x14 */ unk_func_80026268_arg0* unk_14; + /* 0x18 */ unk_D_82F144D0* unk_18; + /* 0x1C */ s32 unk_1C; + /* 0x20 */ unk_D_86002F58_004_000_010* unk_20; + /* 0x24 */ unk_func_8001B1FC* unk_24; +} unk_D_82F20A10; // size >= 0x28 + +typedef struct unk_D_82F20A40_00E { + /* 0x00 */ s16 unk_00; + /* 0x02 */ s16 unk_02; + /* 0x04 */ s16 unk_04; + /* 0x06 */ s16 unk_06; +} unk_D_82F20A40_00E; // size = 0x8 + +typedef struct unk_D_82F20A40 { + /* 0x00 */ s16 unk_00; + /* 0x02 */ s16 unk_02; + /* 0x04 */ s16 unk_04; + /* 0x06 */ unk_D_82F20A40_00E unk_06; + /* 0x0E */ unk_D_82F20A40_00E unk_0E[3]; + /* 0x26 */ unk_D_82F20A40_00E unk_26; + /* 0x2E */ unk_D_82F20A40_00E unk_2E; + /* 0x36 */ unk_D_82F20A40_00E unk_36; + /* 0x40 */ unk_D_82F20A40_00E* unk_40; + /* 0x44 */ unk_D_82F20A40_00E* unk_44; +} unk_D_82F20A40; // size = 0x48 + +typedef struct unk_D_82F20A88 { + /* 0x000 */ s16 unk_000; + /* 0x002 */ s16 unk_002; + /* 0x004 */ s16 unk_004; + /* 0x006 */ s16 unk_006; + /* 0x008 */ s16 unk_008; + /* 0x00A */ s16 unk_00A; + /* 0x00C */ s16 unk_00C; + /* 0x00E */ s16 unk_00E; + /* 0x010 */ s16 unk_010; + /* 0x012 */ s16 unk_012; + /* 0x014 */ s16 unk_014; + /* 0x018 */ f32 unk_018; + /* 0x01C */ f32 unk_01C; + /* 0x020 */ f32 unk_020; + /* 0x024 */ u8* unk_024; + /* 0x028 */ unk_D_86002F58_004_000 unk_028; +} unk_D_82F20A88; // size = 0x190 + +typedef struct unk_D_82F210E0 { + /* 0x00 */ s16 unk_00; + /* 0x02 */ s16 unk_02; + /* 0x04 */ u16 unk_04; + /* 0x06 */ s16 unk_06; + /* 0x08 */ s16 unk_08; + /* 0x0A */ s16 unk_0A; + /* 0x0C */ s16 unk_0C; + /* 0x0E */ s16 unk_0E; + /* 0x10 */ s16 unk_10; + /* 0x12 */ s16 unk_12; + /* 0x14 */ unk_D_82F20A40_00E unk_14[2]; + /* 0x24 */ unk_D_82F20A40_00E unk_24; + /* 0x2C */ unk_D_82F20A40_00E unk_2C; + /* 0x34 */ unk_D_82F20A40_00E unk_34; +} unk_D_82F210E0; // size = 0x3C + +typedef struct unk_D_82F21160 { + /* 0x00 */ s16 unk_00; + /* 0x02 */ s16 unk_02; + /* 0x04 */ s16 unk_04; + /* 0x06 */ s16 unk_06; + /* 0x08 */ s16 unk_08; + /* 0x0A */ s16 unk_0A; + /* 0x0C */ s16 unk_0C; + /* 0x0E */ s16 unk_0E; + /* 0x10 */ s16 unk_10; + /* 0x12 */ s16 unk_12; + /* 0x14 */ f32 unk_14; + /* 0x18 */ f32 unk_18; + /* 0x1C */ f32 unk_1C; +} unk_D_82F21160; // size = 0x20 + +typedef struct unk_D_82F21140 { + /* 0x00 */ s16 unk_00; + /* 0x02 */ s16 unk_02; + /* 0x04 */ s16 unk_04; + /* 0x06 */ s16 unk_06; + /* 0x08 */ s16 unk_08; + /* 0x0A */ s16 unk_0A; + /* 0x0C */ u16 unk_0C; + /* 0x0E */ s16 unk_0E; + /* 0x10 */ f32 unk_10; + /* 0x14 */ u16 unk_14; + /* 0x16 */ u16 unk_16; + /* 0x18 */ s16 unk_18; +} unk_D_82F21140; // size = 0x1C + +typedef struct unk_D_82F211A0_010 { + /* 0x00 */ s16 unk_00; + /* 0x02 */ s16 unk_02; + /* 0x04 */ s16 unk_04; +} unk_D_82F211A0_010; // size = 0x6 + +typedef struct unk_D_82F211A0 { + /* 0x00 */ s16 unk_00; + /* 0x02 */ s16 unk_02; + /* 0x00 */ s16 unk_04; + /* 0x06 */ s16 unk_06; + /* 0x08 */ s16 unk_08; + /* 0x0A */ s16 unk_0A; + /* 0x0C */ s16 unk_0C; + /* 0x0E */ s16 unk_0E; + /* 0x10 */ unk_D_82F211A0_010 unk_10[10]; +} unk_D_82F211A0; // size = 0x4C + +typedef struct unk_D_82F21238 { + /* 0x00 */ s16 unk_00; + /* 0x02 */ s16 unk_02; + /* 0x04 */ s16 unk_04; + /* 0x06 */ s16 unk_06; + /* 0x08 */ s16 unk_08; + /* 0x0A */ s16 unk_0A; + /* 0x0C */ s16 unk_0C; + /* 0x0E */ s16 unk_0E; + /* 0x10 */ s16 unk_10; + /* 0x12 */ s16 unk_12; + /* 0x14 */ s16 unk_14; + /* 0x16 */ s16 unk_16; + /* 0x18 */ s16 unk_18; + /* 0x1A */ s16 unk_1A; + /* 0x1C */ s16 unk_1C; + /* 0x1E */ s16 unk_1E; + /* 0x20 */ s32 unk_20; + /* 0x24 */ unk_func_80026268_arg0* unk_24; + /* 0x28 */ unk_D_86002F58_004_000_010* unk_28; + /* 0x2C */ unk_func_8001B1FC* unk_2C; + /* 0x30 */ unk_D_82F20A40_00E unk_30; +} unk_D_82F21238; // size = 0x38 + +extern s32 D_82F14424; +extern unk_D_82F14450 D_82F14450[4]; + +extern char** D_82F13B70; +extern char** D_82F13B74; + +char* func_82F00020(s32 arg0); +char* func_82F00058(s32 arg0); +char* func_82F00090(s32 arg0); +void func_82F000C8(s16 arg0); +void func_82F00138(void); +void func_82F00164(void); +void func_82F00284(void); +void func_82F002BC(s16 arg0, s16 arg1, s8* arg2, s32 arg3); +void func_82F0036C(void); +void func_82F00378(unk_D_82F13B78* arg0, s32 arg1); +s32 func_82F003F8(unk_D_82F13B78* arg0); +void func_82F00424(void); +s32 func_82F00524(void); +void func_82F00568(void); +void func_82F00704(void); +void func_82F00734(void); +void func_82F00838(void); +void func_82F00960(void); +void func_82F00968(void); +void func_82F00A58(void); +void func_82F00AC8(s32 arg0); +void func_82F00C14(s16 arg0); +void func_82F00C50(void); +void func_82F00CE0(void); +void func_82F00D3C(void); +void func_82F00E88(void); +void func_82F00F3C(void); +void func_82F00FD8(void); +s32 func_82F0109C(void); +void func_82F01180(void); +s32 func_82F01234(s32 arg0, s32 arg1); + +s16 func_82F01390(unk_D_82F144D0* arg0, s16 arg1); +u16* func_82F014E4(u8* arg0, s16 arg1, s16 arg2); +void func_82F01530(s32 arg0, s16 arg1); +s32 func_82F018F8(void); +void func_82F01920(unk_D_82F144D0* arg0); +void func_82F01A70(unk_D_82F144D0* arg0); +void func_82F01FE4(unk_D_82F144D0* arg0); +void func_82F020B4(unk_D_82F144D0* arg0); +void func_82F02180(unk_D_82F144D0* arg0); +void func_82F022DC(s16 arg0, s16 arg1, s16 arg2, s16 arg3); +void func_82F02544(s16 arg0, s16 arg1, s16 arg2); +void func_82F028AC(s16 arg0, s16 arg1, s16 arg2, s16 arg3, Color_RGB8* arg4, s16 arg5); +void func_82F029FC(s16 arg0, s16 arg1, s16 arg2); +void func_82F02B5C(s16 arg0, s16 arg1, s16 arg2); +void func_82F02CE8(s16 arg0, s16 arg1, s16 arg2, s16 arg3); +void func_82F02EAC(s16 arg0, s16 arg1, s16 arg2); +void func_82F02FEC(s16 arg0, s16 arg1, s16 arg2, s16 arg3, u8 arg4, u8 arg5, u8 arg6, u8 arg7); +void func_82F037EC(s16, s16, s16, s16, u8, u8, u8, u8); +void func_82F04010(s16 arg0, s16 arg1, u8* arg2, s16 arg3); +void func_82F040D0(unk_D_82F144D0* arg0, s16 arg1, s16 arg2, s32 arg3); +void func_82F043A4(s16 arg0, s16 arg1, s16 arg2); +void func_82F04604(unk_D_82F144D0* arg0); +void func_82F04FD4(void); +void func_82F0504C(void); +void func_82F05110(void); +u16* func_82F05198(s32); +void func_82F051B8(void); +s32 func_82F0525C(s32 arg0, unk_func_82F00838_sp30* arg1); + +void func_82F05210(s16, unk_func_80026268_arg0*); +void func_82F052F0(unk_D_82F144D0* arg0, u8* arg1, s16 arg2, s16 arg3); +void func_82F053F8(unk_D_82F20A10* arg0); +void func_82F05560(unk_D_82F20A10* arg0); +void func_82F056D0(unk_D_82F20A10* arg0); +void func_82F05828(s16 arg0, s16 arg1, s16 arg2, s16 arg3, u8 arg4, u8 arg5, u8 arg6); +void func_82F05920(s16 arg0, s16 arg1, s16 arg2, s16 arg3, u8 arg4, u8 arg5, u8 arg6); +void func_82F05C50(s16 arg0, s16 arg1, s32 arg2); +void func_82F05D74(s16 arg0, s16 arg1, s16 arg2); +s32 func_82F05F20(s32 arg0); +void func_82F05F40(unk_D_82F20A10* arg0); +void func_82F06D50(void); +void func_82F06D88(void); +void func_82F06E04(void); +s32 func_82F06E38(void); + +s32 func_82F06E50(s32 arg0, GraphNode* arg1); +s16 func_82F06F9C(unk_D_82F14450* arg0); +void func_82F07004(s16 arg0); +void func_82F07214(unk_D_82F20A88* arg0, s16 arg1); +void func_82F07440(unk_D_82F20A88* arg0); +void func_82F07498(unk_D_82F20A88* arg0); +void func_82F0761C(unk_D_82F20A88* arg0); +void func_82F0763C(unk_D_82F20A88* arg0); +void func_82F07728(unk_D_82F20A88* arg0); +void func_82F07784(unk_D_82F20A88* arg0); +void func_82F077E0(void); +void func_82F07958(void); +s32 func_82F07A54(s16 arg0); +s32 func_82F07A74(void); +void func_82F07A80(unk_D_82F20A40* arg0, s32 arg1); +void func_82F07DEC(unk_D_82F20A40* arg0); +void func_82F08084(unk_D_82F20A40* arg0); +void func_82F081FC(unk_D_82F20A40* arg0); +void func_82F0822C(unk_D_82F20A40* arg0); +void func_82F083B0(unk_D_82F20A40* arg0, s16 arg1, s16 arg2); +void func_82F084EC(unk_D_82F20A40* arg0); +void func_82F0856C(unk_D_82F20A40* arg0); +void func_82F0866C(unk_D_82F20A40* arg0); +void func_82F087F8(unk_D_82F20A40_00E* arg0, s16 arg1, s16 arg2); +void func_82F088F8(unk_D_82F20A40* arg0); +void func_82F08968(unk_D_82F20A40* arg0); +void func_82F08B7C(unk_D_82F20A40* arg0); +void func_82F08EB4(unk_D_82F20A40* arg0); +void func_82F0917C(unk_D_82F20A40* arg0); +void func_82F09284(unk_D_82F20A40* arg0); +void func_82F094B4(unk_D_82F20A40* arg0); +void func_82F097D8(s16 arg0, s16 arg1); +void func_82F09B70(s16 arg0); +void func_82F09C6C(void); +void func_82F09D2C(void); +void func_82F09E30(void); + +s32 func_82F09EB0(unk_func_82F00838_sp30* arg0); +s32 func_82F09F44(unk_D_82F210E0* arg0); +void func_82F0A0A8(s32 arg0); +void func_82F0A23C(unk_D_82F210E0* arg0); +void func_82F0A5F8(unk_D_82F210E0* arg0); +void func_82F0A804(unk_D_82F210E0* arg0); +void func_82F0A850(unk_D_82F210E0* arg0); +void func_82F0A950(unk_D_82F210E0* arg0); +void func_82F0AA50(unk_D_82F210E0* arg0); +void func_82F0AB68(unk_D_82F210E0* arg0); +void func_82F0ACC4(unk_D_82F210E0* arg0); +void func_82F0B2A4(s16 arg0, s16 arg1, s16 arg2); +void func_82F0B3E0(unk_D_82F210E0* arg0); +void func_82F0B7B4(unk_D_82F210E0* arg0); +void func_82F0BBE8(unk_D_82F210E0* arg0); +void func_82F0BD38(unk_D_82F210E0* arg0); +void func_82F0BE7C(s16 arg0, s16 arg1, s16 arg2, s16 arg3); +void func_82F0BEF8(unk_D_82F210E0* arg0); +s32 func_82F0C16C(void); +s32 func_82F0C178(void); +s32 func_82F0C184(void); +void func_82F0C190(void); +void func_82F0C254(void); +void func_82F0C320(void); + +void func_82F0C410(s16 arg0, s16 arg1, s16 arg2, s16 arg3, s16 arg4, s16 arg5, s16 arg6, s16 arg7, s32 arg8); +void func_82F0C630(void); +void func_82F0C658(s32 arg0, s16 arg1); +void func_82F0C784(unk_D_82F211A0* arg0); +void func_82F0C7FC(unk_D_82F211A0* arg0); +void func_82F0C8EC(unk_D_82F211A0* arg0); +void func_82F0C958(unk_D_82F211A0* arg0); +void func_82F0CA7C(unk_D_82F211A0* arg0); +void func_82F0CB90(void); +void func_82F0CC3C(void); +void func_82F0D084(void); +void func_82F0D090(unk_D_82F21238* arg0, s32 arg1); +void func_82F0D160(s16 arg0); +void func_82F0D27C(unk_D_82F21238* arg0); +void func_82F0D2F4(unk_D_82F21238* arg0); +s32 func_82F0D3F4(s32 arg0); +void func_82F0D428(unk_D_82F21238* arg0); +void func_82F0D51C(unk_D_82F21238* arg0); +s32 func_82F0D64C(s16 arg0, s8* arg1); +void func_82F0D6D0(s16 arg0, unk_func_80026268_arg0* arg1); +void func_82F0D76C(unk_D_82F21238* arg0); +void func_82F0D834(unk_D_82F21238* arg0); +void func_82F0DA60(unk_D_82F21238* arg0); +void func_82F0DCF4(void); +void func_82F0DD90(s16 arg0, s16 arg1, s16 arg2); +void func_82F0E5C8(s16 arg0, s16 arg1, s16 arg2, s16 arg3); +void func_82F0E97C(unk_D_82F21238* arg0); +void func_82F0ECA4(void); +void func_82F0ECAC(unk_D_82F20A40_00E* arg0, unk_func_80026268_arg0* arg1); +void func_82F0EE58(void); +void func_82F0EF68(void); +void func_82F0EFC4(s32 arg0, s16 arg1); +void func_82F0F260(unk_D_82F21160* arg0); +void func_82F0F2AC(unk_D_82F21160* arg0); +void func_82F0F374(unk_D_82F21160* arg0); +void func_82F0F578(unk_D_82F21160* arg0); +void func_82F0F600(unk_D_82F21160* arg0); +void func_82F0F654(unk_D_82F21160* arg0); +void func_82F0F714(unk_D_82F21160* arg0); +void func_82F0F79C(unk_D_82F21160* arg0); +void func_82F0F89C(void); +void func_82F0F9E0(s16 arg0, s16 arg1, f32 arg2, s16 arg3); +void func_82F0FCC0(void); +s32 func_82F0FDCC(void); +void func_82F0FDEC(s16 arg0); +void func_82F10034(unk_D_82F21140* arg0); +void func_82F10110(unk_D_82F21140* arg0); +void func_82F101C8(unk_D_82F21140* arg0); +void func_82F10348(unk_D_82F21140* arg0); +void func_82F10400(unk_D_82F21140* arg0); +void func_82F10454(unk_D_82F21140* arg0); +void func_82F1050C(unk_D_82F21140* arg0); +void func_82F10674(unk_D_82F21140* arg0); +void func_82F10710(unk_D_82F21140* arg0); +void func_82F10744(unk_D_82F21140* arg0); +void func_82F10818(unk_D_82F21140* arg0); +void func_82F1084C(unk_D_82F21140* arg0); +void func_82F1091C(unk_D_82F21140* arg0); +void func_82F10950(unk_D_82F21140* arg0); +void func_82F10A24(unk_D_82F21140* arg0); +void func_82F10BB4(s16 arg0, s16 arg1, f32 arg2); +void func_82F10ED0(s16 arg0, s16 arg1, f32 arg2, s16 arg3, s16 arg4, s16 arg5); +void func_82F11264(s16 arg0, s16 arg1, f32 arg2, s16 arg3, s16 arg4, s16 arg5); +void func_82F115F8(s16 arg0, s16 arg1, f32 arg2, s16 arg3, s16 arg4, s16 arg5); +void func_82F1198C(s16 arg0, s16 arg1, f32 arg2, s16 arg3, s16 arg4, s16 arg5); +void func_82F11D68(s16 arg0, s16 arg1, f32 arg2, s16 arg3, s16 arg4, s16 arg5, s16 arg6); +void func_82F1228C(s16 arg0, s16 arg1, f32 arg2, s16 arg3, s16 arg4, s16 arg5); +void func_82F12614(void); +void func_82F12DE4(s16 arg0, s16 arg1, f32 arg2, s16 arg3, s16 arg4, s16 arg5); +void func_82F13278(void); +void func_82F132D0(void); +void func_82F13414(void); +s32 func_82F13964(s16 arg0); +void func_82F13B4C(s16 arg0); +s16 func_82F13B64(void); + +#endif // _FRAGMENT41_H_ diff --git a/src/fragments/41/fragment41_287ED0.c b/src/fragments/41/fragment41_287ED0.c index 447a287..6fb7d0c 100644 --- a/src/fragments/41/fragment41_287ED0.c +++ b/src/fragments/41/fragment41_287ED0.c @@ -1,64 +1,646 @@ -#include "global.h" +#include "fragment41.h" +#include "src/19840.h" +#include "src/1C720.h" +#include "src/1CF30.h" +#include "src/20330.h" +#include "src/20470.h" +#include "src/225A0.h" +#include "src/22630.h" +#include "src/232C0.h" +#include "src/2E110.h" +#include "src/3FB0.h" +#include "src/49790.h" +#include "src/4BDC0.h" +#include "src/6A40.h" +#include "src/controller.h" +#include "src/memory.h" +#include "src/stage_loader.h" -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00020.s") +typedef struct unk_D_82F14438 { + /* 0x00 */ s16 unk_00; + /* 0x02 */ s16 unk_02; + /* 0x04 */ s16 unk_04; + /* 0x06 */ s16 unk_06; + /* 0x08 */ s16 unk_08; + /* 0x0A */ s16 unk_0A; + /* 0x0C */ u16 unk_0C; + /* 0x10 */ s8* unk_10; +} unk_D_82F14438; // size = 0x14 -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00058.s") +typedef struct unk_D_82F144B0 { + /* 0x00 */ s16 unk_00; + /* 0x02 */ s16 unk_02; + /* 0x04 */ s16 unk_04; + /* 0x06 */ s16 unk_06; + /* 0x08 */ s16 unk_08; +} unk_D_82F144B0; // size = 0xA -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00090.s") +static unk_D_800AC870* D_82F14420; +s32 D_82F14424; +static s32 D_82F14428; +static s16 D_82F1442C; +static unk_D_82F13B78* D_82F14430; +static s32 pad_D_82F14434; +static unk_D_82F14438 D_82F14438; +static unk_D_82F14438* D_82F1444C; +unk_D_82F14450 D_82F14450[4]; +static s16 D_82F144A8; +static s16 D_82F144AA; +static s32 pad_D_82F144AC; +static unk_D_82F144B0 D_82F144B0; +static s32 D_82F144BC; +static s32 D_82F144C0; +static char** D_82F144C4; +static char** D_82F144C8; +static char** D_82F144CC; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F000C8.s") +char** D_82F13B70 = NULL; +char** D_82F13B74 = NULL; +static unk_D_82F13B78 D_82F13B78[2] = { + { 0x0140, 0x0168, NULL }, + { 0x0000, 0x0000, NULL }, +}; +static u16 D_82F13B88 = 0; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00138.s") +char* func_82F00020(s32 arg0) { + return func_8002D7C0(NULL, 0, D_82F144C4, arg0 - 1); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00164.s") +char* func_82F00058(s32 arg0) { + return func_8002D7C0(NULL, 0, D_82F144C8, arg0 - 1); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00284.s") +char* func_82F00090(s32 arg0) { + return func_8002D7C0(NULL, 0, D_82F144CC, func_800219FC(arg0)); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F002BC.s") +void func_82F000C8(s16 arg0) { + unk_D_82F144B0* ptr = &D_82F144B0; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F0036C.s") + switch (arg0) { + case 0: + ptr->unk_02 = 0; + ptr->unk_04 = 0; + ptr->unk_06 = 0x280; + ptr->unk_08 = 0x1E0; + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00378.s") + case 1: + ptr->unk_02 = 0; + ptr->unk_04 = 0x154; + ptr->unk_06 = 0x280; + ptr->unk_08 = 0x8C; + break; + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F003F8.s") +void func_82F00138(void) { + D_82F144B0.unk_00 = -1; + func_82F000C8(0); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00424.s") +void func_82F00164(void) { + unk_D_82F144B0* ptr = &D_82F144B0; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00524.s") + if ((ptr->unk_00 != 0) && (func_82F0FDCC() != 0)) { + if (ptr->unk_00 > 0) { + ptr->unk_00--; + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00568.s") + gSPDisplayList(gDisplayListHead++, D_8006F4C0); + gDPSetFillColor(gDisplayListHead++, 0x00010001); + gDPFillRectangle(gDisplayListHead++, ptr->unk_02, ptr->unk_04, (ptr->unk_02 + ptr->unk_06) - 1, + (ptr->unk_04 + ptr->unk_08) - 1); + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00704.s") +void func_82F00284(void) { + D_82F1444C = &D_82F14438; + D_82F14438.unk_00 = 0; + D_82F14438.unk_02 = 0; + D_82F14438.unk_08 = 0; + D_82F14438.unk_0A = 2; + D_82F14438.unk_04 = 0; + D_82F14438.unk_06 = 0; + D_82F14438.unk_0C = 0; + D_82F14438.unk_10 = NULL; +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00734.s") +void func_82F002BC(s16 arg0, s16 arg1, s8* arg2, s32 arg3) { + s8* ptr; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00838.s") + D_82F1444C->unk_00 = 0; + D_82F1444C->unk_02 = 0; + + ptr = arg2; + if (ptr != NULL) { + while (*ptr != '\x00') { + D_82F1444C->unk_02++; + ptr++; + } + } + + D_82F1444C->unk_08 = 0; + D_82F1444C->unk_0A = 2; + D_82F1444C->unk_04 = arg0; + D_82F1444C->unk_06 = arg1; + D_82F1444C->unk_0C = 0; + + if (arg3 != 0) { + D_82F1444C->unk_0C |= 1; + } + + D_82F1444C->unk_10 = arg2; +} + +void func_82F0036C(void) { + D_82F14430 = NULL; +} + +void func_82F00378(unk_D_82F13B78* arg0, s32 arg1) { + if (arg0 != D_82F14430) { + D_82F1442C = 0; + } + + D_82F14430 = arg0; + + if (NULL != arg0) { + unk_D_82F13B78* ptr = &arg0[D_82F1442C]; + + func_82F002BC(ptr->unk_00, ptr->unk_02, ptr->unk_04, arg1); + D_82F1442C++; + } +} + +s32 func_82F003F8(unk_D_82F13B78* arg0) { + unk_D_82F13B78* ptr = &arg0[D_82F1442C]; + s32 var_v1 = 0; + + if (ptr->unk_04 == NULL) { + var_v1 = 1; + } + return var_v1; +} + +void func_82F00424(void) { + u8 tmp; + + if ((D_82F1444C->unk_10 != 0) && (D_82F1444C->unk_00 >= 0)) { + if (gPlayer1Controller->buttonPressed & 0x8000) { + D_82F1444C->unk_08 = 0; + D_82F1444C->unk_0A = 1; + } else { + D_82F1444C->unk_08 -= 1; + } + + if (D_82F1444C->unk_08 <= 0) { + func_80048B90(0x01200001); + D_82F1444C->unk_08 = D_82F1444C->unk_0A; + + D_82F1444C->unk_00++; + + tmp = D_82F1444C->unk_10[D_82F1444C->unk_00 - 1]; + if (tmp >= 0x80) { + D_82F1444C->unk_00++; + } + + if (D_82F1444C->unk_00 >= D_82F1444C->unk_02) { + D_82F1444C->unk_00 = -1; + } + } + } +} + +s32 func_82F00524(void) { + s32 var_v1 = 0; + + if (D_82F1444C->unk_10 != NULL) { + if (D_82F1444C->unk_00 == -1) { + var_v1 = 2; + } else if (D_82F1444C->unk_00 >= 0) { + var_v1 = 1; + } + } + + return var_v1; +} + +void func_82F00568(void) { + s32 i; + s32 temp_t0; + s8 sp38[0x100]; + + if (D_82F1444C->unk_10 != NULL) { + func_8001F3F4(); + func_8001EBE0(0x10, 0); + + if (D_82F1444C->unk_0C & 1) { + s32 a = D_82F13B88; + u8 arg = a & 0xF; + + arg = (arg * 0xFF) / 15; + if (a & 0x10) { + arg = 0xFF - arg; + } + func_8001F324(0xFF, 0xFF, 0xFF, arg); + } else { + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + } + + func_8001F3B4(0x1E); + temp_t0 = func_8001F5B0(0, 0, D_82F1444C->unk_10) / 2; + if (D_82F1444C->unk_00 == -1) { + func_8001F1E8(D_82F1444C->unk_04 - temp_t0, D_82F1444C->unk_06, D_82F1444C->unk_10); + } else { + s8* p_sp38 = sp38; + s8* other = D_82F1444C->unk_10; + + for (i = 0; i < D_82F1444C->unk_00; i++) { + *p_sp38++ = *other++; + } + + *p_sp38 = '\x00'; + func_8001F1E8(D_82F1444C->unk_04 - temp_t0, D_82F1444C->unk_06, &sp38); + } + func_8001F444(); + D_82F13B88++; + } +} + +void func_82F00704(void) { + Cont_StartReadInputs(); + Cont_ReadInputs(); + func_8001F730(); +} + +void func_82F00734(void) { + UNUSED s32 pad; + unk_D_82F14450* ptr; + unk_D_800AC910_040 sp40; + u8 temp_s2 = Cont_GetControllerBits(); + s32 i; + + main_pool_push_state('info'); + + for (i = 0, ptr = &D_82F14450[0]; i < 4; i++, ptr++) { + func_80025040(i, &sp40); + func_80023AF8(i); + func_80021B5C(ptr->unk_08, sp40.unk_02); + ptr->unk_06 = sp40.unk_00; + ptr->unk_01 = func_80024F68(i); + ptr->unk_00 = func_80024F00(i); + ptr->unk_03 = func_80025370(i); + ptr->unk_04 = func_8002539C(i); + ptr->unk_05 = (temp_s2 & (1 << i)) != 0; + ptr->unk_02 = func_80024F8C(i); + } + + main_pool_pop_state('info'); +} + +void func_82F00838(void) { + s32 i; + unk_func_82F00838_sp30_00C sp50; + unk_func_82F00838_sp30 sp30[2]; + + for (i = 0; i < 2; i++) { + func_82F0525C(i, &sp30[i]); + } + + sp50 = sp30[0].unk_0C[sp30[0].unk_06]; + sp30[0].unk_0C[sp30[0].unk_06] = sp30[1].unk_0C[sp30[1].unk_06]; + sp30[1].unk_0C[sp30[1].unk_06] = sp50; + + func_82F051B8(); +} void func_82F00960(void) { } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00968.s") +void func_82F00968(void) { + func_8001BB20(); + func_8002D510(); + D_82F13B70 = func_8002D5AC(0x21); + D_82F13B74 = func_8002D5AC(6); + D_82F144C4 = func_8002D5AC(0x24); + D_82F144C8 = func_8002D5AC(0x25); + D_82F144CC = func_8002D5AC(0x26); + D_82F13B78[0].unk_04 = func_8002D7C0(NULL, 0, D_82F13B70, 0); + D_82F14428 = 0; + func_82F0036C(); + D_82F14424 = 0; + D_82F144A8 = 0; + D_82F144BC = 0; + func_82F00138(); + func_82F00284(); + func_82F13278(); + func_82F00734(); + func_82F09C6C(); + func_82F04FD4(); + func_82F0C190(); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00A58.s") +void func_82F00A58(void) { + func_800079C4(); + func_82F00164(); + if (func_82F0FDCC() != 0) { + func_82F13414(); + } + func_82F00568(); + func_82F09E30(); + func_82F05110(); + func_82F0C320(); + func_82F00960(); + func_80007778(); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00AC8.s") +void func_82F00AC8(s32 arg0) { + D_82F14428 = arg0; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00C14.s") + switch (D_82F14428) { + case 1: + func_82F0036C(); + func_82F00378(D_82F13B78, 0); + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00C50.s") + case 2: + func_82F07958(); + func_82F002BC(0, 0, 0, 0); + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00CE0.s") + case 4: + if (D_82F144A8 == 1) { + if (D_82F144BC != 0) { + main_pool_pop_state('pmex'); + } + main_pool_push_state('pmex'); + D_82F144BC = 1; + } + func_80023D60(func_82F07A54(D_82F144A8)); + func_82F01530(D_82F144A8, func_82F07A54(D_82F144A8)); + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00D3C.s") + case 5: + func_82F0A0A8(0); + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00E88.s") + case 6: + func_82F0A0A8(1); + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00F3C.s") + case 7: + func_82F000C8(0); + func_80006CB4(0xF); + func_8004B9C4(0xF); + break; + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00FD8.s") +void func_82F00C14(s16 arg0) { + D_82F144AA = arg0; + func_82F00AC8(3); + func_82F0FDEC(D_82F144AA); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F0109C.s") +void func_82F00C50(void) { + if (BTN_IS_PRESSED(gPlayer1Controller, BTN_A)) { + if (func_82F003F8(D_82F13B78) == 0) { + func_82F00378(D_82F13B78, 0); + } else { + func_82F00AC8(2); + } + func_80048B90(2); + func_80048B90(4); + } else if (BTN_IS_PRESSED(gPlayer1Controller, BTN_B)) { + func_82F00AC8(7); + func_80048B90(3); + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F01180.s") +void func_82F00CE0(void) { + func_82F000C8(1); + if (func_82F07A74() == 0) { + if (func_82F07A54(1) == -1) { + func_82F00AC8(7); + } else { + func_82F00C14(1); + } + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F01234.s") +void func_82F00D3C(void) { + func_82F000C8(0); + + switch (D_82F144AA) { + case 1: + if (func_82F13964(1) != 0) { + func_82F00AC8(4); + } + break; + + case 19: + if (func_82F13964(2) != 0) { + func_82F00AC8(4); + } + break; + + case 4: + case 8: + case 11: + if (func_82F13964(3) != 0) { + func_82F00AC8(2); + } + break; + + case 20: + if (func_82F13964(6) != 0) { + func_82F00AC8(5); + } + break; + + case 21: + if (func_82F13964(8) != 0) { + func_82F00838(); + func_82F00C14(0xC); + } + break; + + case 12: + if (func_82F13964(0xC) != 0) { + if (D_82F144B0.unk_00 == -1) { + D_82F144B0.unk_00 = 5; + } + } else { + D_82F144B0.unk_00 = -1; + } + + if (func_82F13964(0xA) != 0) { + func_82F00AC8(6); + } + break; + } +} + +void func_82F00E88(void) { + unk_func_82F00838_sp30 sp20; + + if (func_82F018F8() == 0) { + func_82F0525C(D_82F144A8, &sp20); + + if (sp20.unk_00 != 0) { + if (D_82F144A8 == 0) { + func_82F00C14(0x13); + } else { + func_82F00C14(0x14); + } + D_82F144A8 ^= 1; + } else { + if (D_82F144A8 == 0) { + func_82F002BC(0, 0, NULL, 0); + func_82F00C14(4); + return; + } + func_82F00C14(8); + D_82F144A8 = 0; + } + } +} + +void func_82F00F3C(void) { + func_82F000C8(1); + + if (func_82F0C16C() == 2) { + if (D_82F144B0.unk_00 == -1) { + D_82F144B0.unk_00 = 3; + } + } else { + D_82F144B0.unk_00 = -1; + } + + if (func_82F0C16C() == 0) { + if (func_82F0C178() != 0) { + func_82F00C14(0x15); + } else { + func_82F00C14(0xB); + } + } +} + +void func_82F00FD8(void) { + func_82F000C8(1); + + if (func_82F0C16C() == 2) { + if (D_82F144B0.unk_00 == -1) { + D_82F144B0.unk_00 = 3; + } + } else { + D_82F144B0.unk_00 = -1; + } + + if (func_82F0C16C() == 7) { + D_82F144C0 = 0; + } else { + D_82F144C0 = 1; + } + + if (func_82F0C16C() == 0) { + if (func_82F0C184() != 0) { + func_82F00AC8(2); + } else { + func_82F00AC8(7); + } + } +} + +s32 func_82F0109C(void) { + s32 sp1C = 1; + + switch (D_82F14428) { + case 0: + if (func_80007604() == 0) { + func_82F00AC8(1); + } + break; + + case 1: + func_82F00C50(); + break; + + case 2: + func_82F00CE0(); + break; + + case 3: + func_82F00D3C(); + break; + + case 4: + func_82F00E88(); + break; + + case 5: + func_82F00F3C(); + break; + + case 6: + func_82F00FD8(); + break; + + case 7: + if (func_80007604() == 1) { + sp1C = 0; + } + break; + } + return sp1C; +} + +void func_82F01180(void) { + func_80006C6C(0x10); + func_8004B1CC(0x10); + func_8001F738(gPlayer1Controller); + + D_82F144C0 = 1; + + do { + if (D_82F144C0 != 0) { + func_82F00704(); + } + func_82F00424(); + func_82F09D2C(); + func_82F0504C(); + func_82F0C254(); + func_82F132D0(); + func_82F00A58(); + D_82F14424++; + } while (func_82F0109C() != 0); +} + +s32 func_82F01234(s32 arg0, s32 arg1) { + unk_func_80007444* sp24; + + main_pool_push_state('PMEX'); + + func_80005E40(0x14000, 0); + sp24 = func_80007444(1, 0, 2, 0, 2, 1); + D_82F14420 = func_8001E94C(0x1E, 0); + + ASSET_LOAD(D_1000000, common_menu1_ui, 0); + ASSET_LOAD(D_3000000, trade_select_ui, 0); + + FRAGMENT_LOAD(fragment31); + + func_8001987C(); + func_8001B058(); + func_82F00968(); + func_80007678(sp24); + func_82F01180(); + func_800077B4(2); + func_800076C0(); + func_8001E9CC(); + func_80005EAC(); + + main_pool_pop_state('PMEX'); + + return 0; +} diff --git a/src/fragments/41/fragment41_289240.c b/src/fragments/41/fragment41_289240.c index 2113f8e..5639105 100644 --- a/src/fragments/41/fragment41_289240.c +++ b/src/fragments/41/fragment41_289240.c @@ -1,59 +1,1015 @@ -#include "global.h" +#include "fragment41.h" +#include "src/1AB70.h" +#include "src/1CF30.h" +#include "src/20330.h" +#include "src/20470.h" +#include "src/232C0.h" +#include "src/2E110.h" +#include "src/49790.h" +#include "src/6BC0.h" +#include "src/memory.h" -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_289240/func_82F01390.s") +typedef struct unk_D_82F20A00 { + /* 0x00000 */ u16 unk_00000[3][20][0x640]; +} unk_D_82F20A00; // size = 0x2EE00 -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_289240/func_82F014E4.s") +static unk_D_82F144D0 D_82F144D0[2]; +static unk_D_82F20A00* D_82F20A00; +static s16 D_82F20A04; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_289240/func_82F01530.s") +s16 func_82F01390(unk_D_82F144D0* arg0, s16 arg1) { + UNUSED s32 pad; + unk_func_80022C28_ret* var_v0; + unk_func_82F00838_sp30_00C sp3C; + unk_D_82F144D0_0CA8* sp34 = &arg0->unk_0CA8[arg1]; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_289240/func_82F018F8.s") + sp34->unk_000 = 0; + if (arg1 == 0) { + var_v0 = func_80022C28(0x20, arg0->unk_000E, 0, 0); + } else { + var_v0 = func_80022C28(0x21, arg0->unk_000E, arg1 - 1, 0); + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_289240/func_82F01920.s") + if (var_v0 != NULL) { + while (func_80022E18(&sp3C, 1, var_v0) == 1) { + sp34->unk_00C[sp34->unk_000++] = sp3C; + } + func_80022D8C(var_v0); + } + return sp34->unk_000; +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_289240/func_82F01A70.s") +u16* func_82F014E4(u8* arg0, s16 arg1, s16 arg2) { + return arg0 + (arg1 * 0xFA00) + (arg2 * 0xC80); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_289240/func_82F01FE4.s") +void func_82F01530(s32 arg0, s16 arg1) { + MainPoolState* temp_v0_2; + s32 var_s2; + unk_D_82F144D0* temp_s1; + s32 i; + s32 j; + unk_D_82F144D0_0CA8* ptr1; + unk_D_82F144D0_0CA8* ptr2; + unk_func_82F00838_sp30_00C* temp_a3; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_289240/func_82F020B4.s") + if ((arg0 < 0) || (arg0 >= 2)) { + return; + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_289240/func_82F02180.s") + if (func_8002513C(arg1) == 0) { + func_80024208(arg1); + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_289240/func_82F022DC.s") + D_82F20A04 = arg0; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_289240/func_82F02544.s") + main_pool_push_state('PICK'); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_289240/func_82F028AC.s") + temp_s1 = &D_82F144D0[arg0]; + temp_s1->unk_0000 = 1; + temp_s1->unk_0002 = -1; + temp_s1->unk_0004 = 0x140; + temp_s1->unk_0006 = 0xA0; + temp_s1->unk_0008 = 0; + temp_s1->unk_000A = 0; + temp_s1->unk_000C = 0xA; + temp_s1->unk_0010 = 0; + temp_s1->unk_0012 = 0; + temp_s1->unk_0014 = 0; + temp_s1->unk_0016 = 0; + temp_s1->unk_0018 = 0; + temp_s1->unk_001A = 0; + temp_s1->unk_001C = 0; + temp_s1->unk_001E = 0; + temp_s1->unk_0020 = 0; + temp_s1->unk_000E = arg1; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_289240/func_82F029FC.s") + var_s2 = 0; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_289240/func_82F02B5C.s") + for (i = 12; i >= 0; i--) { + if (func_82F01390(temp_s1, i) > 0) { + temp_s1->unk_0010 = i; + var_s2++; + } + temp_s1->unk_0CA8[i].unk_008 = NULL; + temp_s1->unk_0CA8[i].unk_004 = NULL; + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_289240/func_82F02CE8.s") + for (i = temp_s1->unk_0010; i < 13; i++) { + ptr1 = &temp_s1->unk_0CA8[i]; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_289240/func_82F02EAC.s") + if (ptr1->unk_000 <= 0) { + continue; + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_289240/func_82F02FEC.s") + for (j = i + 1; j < 13; j++) { + ptr2 = &temp_s1->unk_0CA8[j]; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_289240/func_82F037EC.s") + if (ptr2->unk_000 > 0) { + ptr1->unk_008 = ptr2; + ptr2->unk_004 = ptr1; + break; + } + } + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_289240/func_82F04010.s") + if (var_s2 >= 2) { + ptr1 = &temp_s1->unk_0CA8[0]; + while (ptr1->unk_000 <= 0) { + ptr1++; + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_289240/func_82F040D0.s") + ptr2 = &temp_s1->unk_0CA8[12]; + while (ptr2->unk_000 <= 0) { + ptr2--; + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_289240/func_82F043A4.s") + ptr1->unk_004 = ptr2; + ptr2->unk_008 = ptr1; + } + temp_v0_2 = func_80002D10(main_pool_get_available(), 0); + D_82F20A00 = func_80002DCC(temp_v0_2, sizeof(unk_D_82F20A00), 8); + func_80002D60(temp_v0_2); + + for (i = 0; i < temp_s1->unk_0CA8[temp_s1->unk_0010].unk_000; i++) { + temp_a3 = &temp_s1->unk_0CA8[temp_s1->unk_0010].unk_00C[i]; + + if (((temp_a3->unk_00 <= 0) || (temp_a3->unk_00 >= 0x98) ? 1 : 0)) { + func_8001B0DC(func_82F014E4(D_82F20A00, temp_s1->unk_0016, i), 0x98, NULL); + } else { + func_8001B0DC(func_82F014E4(D_82F20A00, temp_s1->unk_0016, i), 0, temp_a3); + } + } + + func_80048B90(4); +} + +s32 func_82F018F8(void) { + unk_D_82F144D0* ptr = &D_82F144D0[D_82F20A04]; + + return ptr->unk_0000; +} + +void func_82F01920(unk_D_82F144D0* arg0) { + arg0->unk_000C--; + + arg0->unk_0004 = 0x64 - ((arg0->unk_000C * -0xDC) / 10); + arg0->unk_0006 = 0x70 - ((arg0->unk_000C * -0x30) / 10); + arg0->unk_0008 = 0x1B8 - ((arg0->unk_000C * 0x1B8) / 10); + arg0->unk_000A = 0x10C - ((arg0->unk_000C * 0x10C) / 10); + + if (arg0->unk_000C <= 0) { + arg0->unk_0000 = 2; + arg0->unk_000C = 0; + } +} + +void func_82F01A70(unk_D_82F144D0* arg0) { + s32 temp_v1_3; + s32 var_v0; + Controller* controller; + unk_D_82F144D0_0CA8* temp_a2; + s32 i; + unk_func_82F00838_sp30_00C* temp_a1; + unk_func_82F00838_sp30_00C* temp_a3; + unk_func_82F00838_sp30_00C* temp_a3_2; + s16 temp_t1; + u16 temp_v0 = func_8001F750(); + + controller = gPlayer1Controller; + + if (arg0->unk_000C > 0) { + arg0->unk_000C--; + if (arg0->unk_000C <= 0) { + arg0->unk_000C = 0; + arg0->unk_001C = arg0->unk_0018; + arg0->unk_001E = arg0->unk_001A; + } else { + return; + } + } + + temp_a2 = &arg0->unk_0CA8[arg0->unk_0010]; + + if (temp_v0 & 0x200) { + arg0->unk_0018--; + if (arg0->unk_0018 < 0) { + arg0->unk_0018 = 0; + } + } + + if (temp_v0 & 0x100) { + arg0->unk_0018++; + if (arg0->unk_0018 >= 5) { + arg0->unk_0018 = 4; + } + } + + if (temp_v0 & 0x800) { + arg0->unk_001A--; + if (arg0->unk_001A < 0) { + arg0->unk_001A = 0; + } + } + + if (temp_v0 & 0x400) { + arg0->unk_001A++; + if (arg0->unk_001A >= 4) { + arg0->unk_001A = 3; + } + } + + if ((arg0->unk_0018 != arg0->unk_001C) || (arg0->unk_001A != arg0->unk_001E)) { + arg0->unk_000C = 4; + func_80048B90(1); + return; + } + + temp_v1_3 = (arg0->unk_001A * 5) + arg0->unk_0018; + temp_a1 = &arg0->unk_0CA8[arg0->unk_0010].unk_00C[temp_v1_3]; + + if (BTN_IS_PRESSED(controller, BTN_A) && (temp_v1_3 < arg0->unk_0CA8[arg0->unk_0010].unk_000)) { + if ((temp_a1->unk_00 <= 0) || (temp_a1->unk_00 >= 0x98)) { + var_v0 = 1; + } else { + var_v0 = 0; + } + + if (var_v0 == 0) { + arg0->unk_0000 = 4; + arg0->unk_000C = 0; + arg0->unk_0002 = 0xA; + func_82F052F0(arg0, temp_a1, arg0->unk_0004 + (arg0->unk_0018 * 0x58) + 0x2C, + arg0->unk_0006 + (arg0->unk_001A * 0x3C) + 0x3A); + func_80048B90(2); + } else { + goto block_25; + } + } else { + block_25: + if (BTN_IS_PRESSED(controller, BTN_B)) { + arg0->unk_0000 = 5; + arg0->unk_000C = 0xA; + func_80048B90(3); + } else if (BTN_IS_PRESSED(controller, BTN_R) && (temp_a2->unk_008 != NULL)) { + arg0->unk_0000 = 3; + arg0->unk_000C = 0xA; + arg0->unk_0012 = temp_a2->unk_008 - &arg0->unk_0CA8[0]; + arg0->unk_0014 = 1; + + for (i = 0; i < arg0->unk_0CA8[arg0->unk_0012].unk_000; i++) { + temp_a3 = &arg0->unk_0CA8[arg0->unk_0012].unk_00C[i]; + + temp_t1 = temp_a3->unk_00; + if ((temp_t1 <= 0) || (temp_t1 >= 0x98)) { + var_v0 = 1; + } else { + var_v0 = 0; + } + + if (var_v0 != 0) { + func_8001B0DC(func_82F014E4(D_82F20A00, arg0->unk_0016 ^ 1, i), 0x98, NULL); + } else { + func_8001B0DC(func_82F014E4(D_82F20A00, arg0->unk_0016 ^ 1, i), 0, temp_a3); + } + } + } else if (BTN_IS_PRESSED(controller, BTN_L) && (temp_a2->unk_004 != NULL)) { + arg0->unk_0000 = 3; + arg0->unk_000C = 0xA; + arg0->unk_0012 = temp_a2->unk_004 - &arg0->unk_0CA8[0]; + arg0->unk_0014 = -1; + + for (i = 0; i < arg0->unk_0CA8[arg0->unk_0012].unk_000; i++) { + temp_a3_2 = &arg0->unk_0CA8[arg0->unk_0012].unk_00C[i]; + + if ((temp_a3_2->unk_00 <= 0) || (temp_a3_2->unk_00 >= 0x98)) { + var_v0 = 1; + } else { + var_v0 = 0; + } + + if (var_v0 != 0) { + func_8001B0DC(func_82F014E4(D_82F20A00, arg0->unk_0016 ^ 1, i), 0x98, NULL); + } else { + func_8001B0DC(func_82F014E4(D_82F20A00, arg0->unk_0016 ^ 1, i), 0, temp_a3_2); + } + } + } + } + + if (arg0->unk_0000 == 3) { + func_80048B90(0x27); + } +} + +void func_82F01FE4(unk_D_82F144D0* arg0) { + arg0->unk_000C--; + if (arg0->unk_0014 >= 0) { + arg0->unk_0004 = ((arg0->unk_000C * 0x1C3) / 10) - 0x15F; + } else { + arg0->unk_0004 = 0x227 - ((arg0->unk_000C * 0x1C3) / 10); + } + + if (arg0->unk_000C <= 0) { + arg0->unk_0000 = 2; + arg0->unk_0010 = arg0->unk_0012; + arg0->unk_000C = 0; + arg0->unk_0014 = 0; + arg0->unk_0016 ^= 1; + arg0->unk_0004 = 0x64; + func_82F13B4C(2); + } +} + +void func_82F020B4(unk_D_82F144D0* arg0) { + s32 temp_v0 = func_82F06E38(); + + if (temp_v0 != 0) { + if (temp_v0 == 3) { + if (arg0->unk_0002 != -1) { + arg0->unk_0002 = -1; + } + func_82F13B4C(-1); + } + } else if (arg0->unk_0020 != 0) { + arg0->unk_0000 = 5; + arg0->unk_000C = 0xA; + _bcopy(func_82F014E4(D_82F20A00, arg0->unk_0016, (arg0->unk_001A * 5) + arg0->unk_0018), arg0->unk_0028, 0xC80); + } else { + arg0->unk_0000 = 2; + arg0->unk_000C = 0; + } +} + +void func_82F02180(unk_D_82F144D0* arg0) { + arg0->unk_000C--; + arg0->unk_0004 = 0x140 - ((arg0->unk_000C * 0xDC) / 10); + arg0->unk_0006 = 0xA0 - ((arg0->unk_000C * 0x30) / 10); + arg0->unk_0008 = (arg0->unk_000C * 0x1B8) / 10; + arg0->unk_000A = (arg0->unk_000C * 0x10C) / 10; + if (arg0->unk_000C <= 0) { + arg0->unk_0000 = 0; + main_pool_pop_state('PICK'); + } +} + +void func_82F022DC(s16 arg0, s16 arg1, s16 arg2, s16 arg3) { + gSPDisplayList(gDisplayListHead++, D_8006F518); + + func_8001CADC(arg0 - 7, arg1 - 7, 8, 8, D_302F588, 8, 0); + func_8001CADC((arg0 + arg2) - 1, arg1 - 7, 8, 8, D_302F5C8, 8, 0); + func_8001C330(arg0 + 1, arg1 - 7, arg2 - 2, 8, 0, 0, 0, 0x400, 0); + func_8001CADC(arg0 - 7, (arg1 + arg3) - 1, 8, 8, D_302F608, 8, 0); + func_8001C330(arg0 - 7, arg1 + 1, 8, arg3 - 2, 0, 0, 0x400, 0, 0); + func_8001CADC((arg0 + arg2) - 1, (arg1 + arg3) - 1, 8, 8, D_302F648, 8, 0); + func_8001C330(arg0 + 1, (arg1 + arg3) - 1, arg2 - 2, 8, 0, 0, 0, 0x400, 0); + func_8001C330((arg0 + arg2) - 1, arg1 + 1, 8, arg3 - 2, 0, 0, 0x400, 0, 0); + + gSPDisplayList(gDisplayListHead++, D_8006F630); +} + +void func_82F02544(s16 arg0, s16 arg1, s16 arg2) { + static Color_RGB8 D_82F13B90 = { 0x82, 0x1E, 0x1E }; + static Color_RGB8 D_82F13B94 = { 0x96, 0x64, 0x1E }; + + Color_RGB8* var_s0; + char sp64[64]; + s16 tmp = 0x1A8; + s16 tmp2 = 0x14; + char* var_v0; + + if (arg0 == 0) { + var_s0 = &D_82F13B90; + } else { + var_s0 = &D_82F13B94; + } + + gSPDisplayList(gDisplayListHead++, D_8006F518); + gDPSetEnvColor(gDisplayListHead++, var_s0->r, var_s0->g, var_s0->b, 0xFF); + + func_8001CADC(arg1, arg2, 8, 8, D_30387B0, 8, 0); + func_8001CADC(arg1 + tmp + 8, arg2, 8, 8, D_30387F0, 8, 0); + func_8001C330(arg1 + 8, arg2, tmp, 8, 0, 0, 0, 0x400, 0); + func_8001CADC(arg1, arg2 + tmp2, 8, 8, D_3038830, 8, 0); + func_8001C330(arg1, arg2 + 8, 8, 0xC, 0, 0, 0x400, 0, 0); + func_8001CADC(arg1 + tmp + 8, arg2 + tmp2, 8, 8, D_3038870, 8, 0); + func_8001C330(arg1 + 8, arg2 + tmp2, tmp, 8, 0, 0, 0, 0x400, 0); + func_8001C330(arg1 + tmp + 8, arg2 + 8, 8, 0xC, 0, 0, 0x400, 0, 0); + + gSPDisplayList(gDisplayListHead++, D_8006F498); + + func_8001C604(arg1 + 8, arg2 + 8, tmp, 0xC, var_s0->r, var_s0->g, var_s0->b, 0xFF); + + gSPDisplayList(gDisplayListHead++, D_8006F630); + + func_8001F3F4(); + func_8001EBE0(8, 0); + + if (arg0 == 0) { + var_v0 = func_8002D7C0(NULL, 0, D_82F13B70, 0xA); + } else { + func_8002D600(1, arg0); + var_v0 = func_8002D7C0(sp64, ARRAY_COUNT(sp64), D_82F13B70, 0xB); + } + + func_8001F1E8((arg1 - (func_8001F5B0(0, 0, var_v0) / 2)) + 0xDC, arg2 + 4, var_v0); + func_8001F444(); +} + +void func_82F028AC(s16 arg0, s16 arg1, s16 arg2, s16 arg3, Color_RGB8* arg4, s16 arg5) { + if (arg5 != 0) { + func_8001C604(arg0, arg1, arg2, arg3, arg4->r, arg4->g, arg4->b, 0xFF); + } else { + s32 color = RGBA5551(arg4->r, arg4->g, arg4->b, 1); + + gDPPipeSync(gDisplayListHead++); + gDPSetFillColor(gDisplayListHead++, (color << 0x10) | color); + gDPFillRectangle(gDisplayListHead++, arg0, arg1, (arg0 + arg2) - 1, (arg1 + arg3) - 1); + } +} + +void func_82F029FC(s16 arg0, s16 arg1, s16 arg2) { + static Color_RGB8 D_82F13B98 = { 0x3C, 0x3C, 0x82 }; + static Color_RGB8 D_82F13B9C = { 0x28, 0x28, 0x64 }; + static Color_RGB8 D_82F13BA0 = { 0x78, 0x78, 0x96 }; + + func_82F028AC(arg0 + 1, arg1 + 1, 0x56, 0x29, &D_82F13B98, arg2); + func_82F028AC(arg0 + 1, arg1 + 0x2A, 0x56, 0x11, &D_82F13B9C, arg2); + func_82F028AC(arg0, arg1, 0x58, 1, &D_82F13BA0, arg2); + func_82F028AC(arg0, arg1 + 0x3B, 0x58, 1, &D_82F13BA0, arg2); + func_82F028AC(arg0, arg1 + 1, 1, 0x3A, &D_82F13BA0, arg2); + func_82F028AC(arg0 + 0x57, arg1 + 1, 1, 0x3A, &D_82F13BA0, arg2); +} + +void func_82F02B5C(s16 arg0, s16 arg1, s16 arg2) { + static u8* D_82F13BA4[] = { + D_302F6E0, D_302F740, D_302F7A0, D_302F800, D_302F860, D_302F8C0, D_302F928, D_302F988, D_302F9E8, D_302FA48, + }; + + s32 i; + s32 var_s0 = 0x05F5E100; + s32 var_s4 = 0; + + for (i = 9; i > 0; i--) { + s32 temp_lo = arg2 / var_s0; + + if ((temp_lo != 0) || (var_s4 != 0) || (i == 0)) { + func_8001CADC(arg0, arg1, 8, 0xC, D_82F13BA4[temp_lo], 8, 0); + var_s4 = 1; + arg0 += 9; + } + + arg2 %= var_s0; + var_s0 /= 10; + } +} + +void func_82F02CE8(s16 arg0, s16 arg1, s16 arg2, s16 arg3) { + static s16 D_82F13BCC = 0; + + s16 sins = SINS(D_82F13BCC) * 2; + UNUSED s32 pad[2]; + + gDPPipeSync(gDisplayListHead++); + gDPSetEnvColor(gDisplayListHead++, 240, 212, 104, 255); + + func_8001CADC(arg0 + sins, arg1 + sins, 0x10, 0x10, D_3038C70, 0x10, 0); + func_8001CADC(arg0 + sins, ((arg1 + arg3) - sins) - 0x10, 0x10, 0x10, D_3038F70, 0x10, 0); + func_8001CADC(((arg0 + arg2) - sins) - 0x10, arg1 + sins, 0x10, 0x10, D_3038D70, 0x10, 0); + func_8001CADC(((arg0 + arg2) - sins) - 0x10, ((arg1 + arg3) - sins) - 0x10, 0x10, 0x10, D_3038E70, 0x10, 0); + D_82F13BCC += 0x2000; +} + +void func_82F02EAC(s16 arg0, s16 arg1, s16 arg2) { + gSPDisplayList(gDisplayListHead++, D_8006F518); + gDPSetEnvColor(gDisplayListHead++, 0, 0, 0, 255); + + func_8001CF10(arg0, arg1, 0x10, 0x1C, D_30388B0, 0x10, 0); + func_8001CF10((arg0 + arg2) - 0x10, arg1, 0x10, 0x1C, D_3038990, 0x10, 0); + func_8001C330(arg0 + 0x10, arg1, arg2 - 0x20, 0x1C, 0, 0, 0, 0x400, 0); + + gSPDisplayList(gDisplayListHead++, D_8006F630); +} + +void func_82F02FEC(s16 arg0, s16 arg1, s16 arg2, s16 arg3, u8 arg4, u8 arg5, u8 arg6, u8 arg7) { + s16 sp4C; + s16 sp48; + s16 var_s2; + s16 var_s3; + + if (arg2 >= 0x10) { + var_s3 = 8; + } else { + var_s3 = arg2 / 2; + } + + if (arg3 >= 0x10) { + var_s2 = 8; + } else { + var_s2 = arg3 / 2; + } + + sp48 = arg2 - (var_s3 * 2); + sp4C = arg3 - (var_s2 * 2); + + gSPDisplayList(gDisplayListHead++, D_8006F518); + gDPSetEnvColor(gDisplayListHead++, arg4, arg5, arg6, arg7); + + gDPLoadTextureBlock_4b(gDisplayListHead++, D_3038730, G_IM_FMT_I, 16, 8, 0, G_TX_NOMIRROR | G_TX_WRAP, + G_TX_NOMIRROR | G_TX_WRAP, 5, 5, G_TX_NOLOD, G_TX_NOLOD); + + func_8001C330(arg0, arg1, var_s3, var_s2, 0, 0, 0x2000 / var_s3, 0x2000 / var_s2, 0); + + gDPLoadTextureBlock_4b(gDisplayListHead++, D_3038770, G_IM_FMT_I, 16, 8, 0, G_TX_NOMIRROR | G_TX_WRAP, + G_TX_NOMIRROR | G_TX_WRAP, 5, 5, G_TX_NOLOD, G_TX_NOLOD); + + func_8001C330((arg0 + arg2) - var_s3, arg1, var_s3, var_s2, 0, 0, 0x2000 / var_s3, 0x2000 / var_s2, 0); + + gDPLoadTextureBlock_4b(gDisplayListHead++, D_30386B0, G_IM_FMT_I, 16, 8, 0, G_TX_NOMIRROR | G_TX_WRAP, + G_TX_NOMIRROR | G_TX_WRAP, 5, 5, G_TX_NOLOD, G_TX_NOLOD); + + func_8001C330(arg0, (arg1 + arg3) - var_s2, var_s3, var_s2, 0, 0, 0x2000 / var_s3, 0x2000 / var_s2, 0); + + gDPLoadTextureBlock_4b(gDisplayListHead++, D_30386F0, G_IM_FMT_I, 16, 8, 0, G_TX_NOMIRROR | G_TX_WRAP, + G_TX_NOMIRROR | G_TX_WRAP, 5, 5, G_TX_NOLOD, G_TX_NOLOD); + + func_8001C330((arg0 + arg2) - var_s3, (arg1 + arg3) - var_s2, var_s3, var_s2, 0, 0, 0x2000 / var_s3, + 0x2000 / var_s2, 0); + + gSPDisplayList(gDisplayListHead++, D_8006F498); + + if ((sp48 > 0) && (sp4C > 0)) { + func_8001C604(arg0 + var_s3, arg1, sp48, var_s2, arg4, arg5, arg6, arg7); + func_8001C604(arg0, arg1 + var_s3, arg2, sp4C, arg4, arg5, arg6, arg7); + func_8001C604(arg0 + var_s3, arg1 + var_s3 + sp4C, sp48, var_s2, arg4, arg5, arg6, arg7); + } else if (sp48 > 0) { + func_8001C604(arg0 + var_s3, arg1, sp48, arg3, arg4, arg5, arg6, arg7); + } else if (sp4C > 0) { + func_8001C604(arg0, arg1 + var_s2, arg2, sp4C, arg4, arg5, arg6, arg7); + } + + gSPDisplayList(gDisplayListHead++, D_8006F630); +} + +void func_82F037EC(s16 arg0, s16 arg1, s16 arg2, s16 arg3, u8 arg4, u8 arg5, u8 arg6, u8 arg7) { + s16 temp_a2; + s16 temp_s0_32; + s16 var_s2; + s16 var_s3; + + if ((arg2 < 0x20) && (arg2 & 1)) { + arg2 += 1; + } + + if ((arg3 < 0x20) && (arg3 & 1)) { + arg3 += 1; + } + + if (arg2 >= 0x20) { + var_s3 = 0x10; + } else { + var_s3 = arg2 / 2; + } + + if (arg3 >= 0x20) { + var_s2 = 0x10; + } else { + var_s2 = arg3 / 2; + } + + temp_a2 = arg2 - (var_s3 * 2); + temp_s0_32 = arg3 - (var_s2 * 2); + + gSPDisplayList(gDisplayListHead++, D_8006F518); + gDPSetEnvColor(gDisplayListHead++, arg4, arg5, arg6, arg7); + + gDPLoadTextureBlock_4b(gDisplayListHead++, D_3038B70, G_IM_FMT_I, 16, 16, 0, G_TX_NOMIRROR | G_TX_WRAP, + G_TX_NOMIRROR | G_TX_WRAP, 5, 5, G_TX_NOLOD, G_TX_NOLOD); + + func_8001C330(arg0, arg1, var_s3, var_s2, 0, 0, 0x4000 / var_s3, 0x4000 / var_s2, 0); + + gDPLoadTextureBlock_4b(gDisplayListHead++, D_3038BF0, G_IM_FMT_I, 16, 16, 0, G_TX_NOMIRROR | G_TX_WRAP, + G_TX_NOMIRROR | G_TX_WRAP, 5, 5, G_TX_NOLOD, G_TX_NOLOD); + + func_8001C330((arg0 + arg2) - var_s3, arg1, var_s3, var_s2, 0, 0, 0x4000 / var_s3, 0x4000 / var_s2, 0); + + gDPLoadTextureBlock_4b(gDisplayListHead++, D_3038A70, G_IM_FMT_I, 16, 16, 0, G_TX_NOMIRROR | G_TX_WRAP, + G_TX_NOMIRROR | G_TX_WRAP, 5, 5, G_TX_NOLOD, G_TX_NOLOD); + + func_8001C330(arg0, (arg1 + arg3) - var_s2, var_s3, var_s2, 0, 0, 0x4000 / var_s3, 0x4000 / var_s2, 0); + + gDPLoadTextureBlock_4b(gDisplayListHead++, D_3038AF0, G_IM_FMT_I, 16, 16, 0, G_TX_NOMIRROR | G_TX_WRAP, + G_TX_NOMIRROR | G_TX_WRAP, 5, 5, G_TX_NOLOD, G_TX_NOLOD); + + func_8001C330((arg0 + arg2) - var_s3, (arg1 + arg3) - var_s2, var_s3, var_s2, 0, 0, 0x4000 / var_s3, + 0x4000 / var_s2, 0); + + gSPDisplayList(gDisplayListHead++, D_8006F498); + + if ((temp_a2 > 0) && (temp_s0_32 > 0)) { + func_8001C604(arg0 + var_s3, arg1, temp_a2, var_s2, arg4, arg5, arg6, arg7); + func_8001C604(arg0, arg1 + var_s3, arg2, temp_s0_32, arg4, arg5, arg6, arg7); + func_8001C604(arg0 + var_s3, arg1 + var_s3 + temp_s0_32, temp_a2, var_s2, arg4, arg5, arg6, arg7); + } else if (temp_a2 > 0) { + func_8001C604(arg0 + var_s3, arg1, temp_a2, arg3, arg4, arg5, arg6, arg7); + } else if (temp_s0_32 > 0) { + func_8001C604(arg0, arg1 + var_s2, arg2, temp_s0_32, arg4, arg5, arg6, arg7); + } + + gSPDisplayList(gDisplayListHead++, D_8006F630); +} + +void func_82F04010(s16 arg0, s16 arg1, u8* arg2, s16 arg3) { + gDPPipeSync(gDisplayListHead++); + + if (arg3 == 0) { + gDPSetEnvColor(gDisplayListHead++, 255, 255, 255, 150); + } else { + gDPSetEnvColor(gDisplayListHead++, 255, 255, 255, 255); + } + + func_8001C6AC(arg0, arg1, 0x24, 0x14, arg2, 0x24, 0); +} + +void func_82F040D0(unk_D_82F144D0* arg0, s16 arg1, s16 arg2, s32 arg3) { + static u8* D_82F13BD0[] = { + D_3039A10, D_3039FB0, D_303A550, D_303AAF0, D_303B090, D_303B630, D_303BBD0, + D_303C170, D_303C710, D_303CCB0, D_303D250, D_303D7F0, D_303DD90, + }; + + s32 i; + + func_82F02EAC(arg1 - 0x10, arg2 - 4, 0x1F4); + + gSPDisplayList(gDisplayListHead++, D_8006F518); + + for (i = 0; i < 13; i++) { + func_82F04010(arg1 + i * 0x24, arg2, D_82F13BD0[i], arg0->unk_0CA8[i].unk_000); + } + + gDPPipeSync(gDisplayListHead++); + gDPSetEnvColor(gDisplayListHead++, 255, 255, 255, 255); + + if (arg0->unk_0000 != 3) { + func_8001C6AC((arg1 + (arg0->unk_0010 * 0x24)) - 4, arg2 - 4, 0x2C, 0xE, D_3039070, 0x2C, 0); + func_8001C6AC((arg1 + (arg0->unk_0010 * 0x24)) - 4, arg2 + 0xA, 0x2C, 0xE, D_3039540, 0x2C, 0); + } + + gDPPipeSync(gDisplayListHead++); + + if (arg3 != 0) { + gDPSetEnvColor(gDisplayListHead++, 255, 255, 255, 255); + } else { + gDPSetEnvColor(gDisplayListHead++, 64, 64, 64, 255); + } + + func_8001C6AC(arg1 - 0x38, arg2 - 8, 0x30, 0x24, D_3027168, 0x30, 0); + func_8001C6AC(arg1 + 0x1DC, arg2 - 8, 0x30, 0x24, D_3027EE8, 0x30, 0); + + gSPDisplayList(gDisplayListHead++, D_8006F630); +} + +void func_82F043A4(s16 arg0, s16 arg1, s16 arg2) { + static s16 D_82F13C04[] = { 0xDC, 8 }; + static s16 D_82F13C08[] = { 8, 0x2C }; + + UNUSED s32 pad; + unk_D_82F14450* sp40 = &D_82F14450[D_82F144D0[arg0].unk_000E]; + u8* sp3C; + + func_82F02FEC(arg1, arg2, 0x104, 0x28, 0x1E, 0x1E, 0x82, 0xFF); + + switch (sp40->unk_01) { + case 1: + sp3C = D_3029C68; + break; + + case 2: + sp3C = D_302A468; + break; + + case 3: + sp3C = D_3028C68; + break; + + case 7: + sp3C = D_3029468; + break; + } + + if (sp3C != NULL) { + gSPDisplayList(gDisplayListHead++, D_8006F518); + + func_8001C6AC(D_82F13C04[arg0] + arg1, arg2 + 4, 0x20, 0x20, sp3C, 0x20, 0); + + gSPDisplayList(gDisplayListHead++, D_8006F630); + } + + func_8001F3F4(); + func_8001EBE0(0x10, 0); + func_8001F1E8(D_82F13C08[arg0] + arg1, arg2 + 0xC, sp40->unk_08); + func_8001EBE0(4, 0); + func_8001F1E8(D_82F13C08[arg0] + arg1 + 0x8E, arg2 + 0x14, "%05d", sp40->unk_06); + func_8001EBE0(4, 0); + func_8001F1E8(D_82F13C08[arg0] + arg1 + 0x72, arg2 + 0x14, "ID"); + func_8001F444(); +} + +#ifdef NON_MATCHING +void func_82F04604(unk_D_82F144D0* arg0) { + static s16 D_82F13C0C[] = { 0x34, 0x148 }; + + s32 i; + s32 spF8; + s32 spF4; + s16 var_v0; + s16 temp_t0; + s16 spEE; + s16 var_s2; + s16 var_a3; + s16 spE8; + s32 spE4; + s32 pad2[3]; + s32 pad[14]; + s16 idx1; + s16 idx2; + s16 temp_t1; + s16 temp_lo; + s16 temp_s3; + + spE4 = 0; + if (arg0->unk_0002 > 0) { + arg0->unk_0002--; + } + + if (arg0->unk_0000 == 3) { + spF4 = 2; + if (arg0->unk_0014 < 0) { + spEE = -0x1C3; + } else { + spEE = 0x1C3; + } + func_800060E0(&gDisplayListHead, 0x60, 0x6C, 0x1C3, 0x117); + spE4 = 1; + } else { + spF4 = 1; + spEE = 0; + } + + spF8 = 0; + while (spF8 < spF4) { + s32 sp68 = spEE * spF8; + unk_D_82F144D0_0CA8* sp64; + + if (spF8 == 0) { + var_s2 = arg0->unk_0010; + spE8 = arg0->unk_0016; + } else { + var_s2 = arg0->unk_0012; + spE8 = arg0->unk_0016 ^ 1; + } + + sp64 = &arg0->unk_0CA8[var_s2]; + func_82F022DC((s16)sp68 + arg0->unk_0004, arg0->unk_0006, arg0->unk_0008, arg0->unk_000A); + + if ((arg0->unk_0008 == 0x1B8) && (arg0->unk_000A == 0x10C)) { + unk_func_82F00838_sp30_00C* ptr; + + func_82F02544(var_s2, (s16)sp68 + arg0->unk_0004, arg0->unk_0006); + + if (spF4 == 2) { + gSPDisplayList(gDisplayListHead++, D_8006F498); + } else { + gSPDisplayList(gDisplayListHead++, D_8006F4C0); + } + + for (i = 0; i < 20; i++) { + idx1 = i / 5; + idx2 = i % 5; + + func_82F029FC((s16)sp68 + arg0->unk_0004 + (idx2 * 0x58), arg0->unk_0006 + (idx1 * 0x3C) + 0x1C, + spF4 - 1); + } + + gSPDisplayList(gDisplayListHead++, D_8006F518); + gDPSetCombineMode(gDisplayListHead++, G_CC_DECALRGBA, G_CC_DECALRGBA); + + for (i = 0; i < sp64->unk_000; i++) { + ptr = &sp64->unk_00C[i]; + idx1 = i / 5; + idx2 = i % 5; + + func_8001CADC((s16)sp68 + arg0->unk_0004 + (idx2 * 0x58) + 4, arg0->unk_0006 + (idx1 * 0x3C) + 0x3B, 8, + 0xA, D_302F690, 8, 0); + + if ((ptr->unk_00 <= 0) || (ptr->unk_00 >= 0x98)) { + var_v0 = 1; + } else { + var_v0 = 0; + } + + if (var_v0 == 0) { + func_82F02B5C((s16)sp68 + arg0->unk_0004 + (idx2 * 0x58) + 0xE, + arg0->unk_0006 + (idx1 * 0x3C) + 0x39, ptr->unk_24); + } + } + + func_8001F3F4(); + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + func_8001EBE0(2, 0); + + for (i = 0; i < sp64->unk_000; i++) { + ptr = &sp64->unk_00C[i]; + idx1 = i / 5; + idx2 = i % 5; + + if ((ptr->unk_00 <= 0) || (ptr->unk_00 >= 0x98)) { + var_v0 = 1; + } else { + var_v0 = 0; + } + + if (var_v0 == 0) { + continue; + } + + func_8001F1E8((s16)sp68 + arg0->unk_0004 + (idx2 * 0x58) + 0xE, arg0->unk_0006 + (idx1 * 0x3C) + 0x3A, + "??"); + } + + func_8001F444(); + func_8001F3F4(); + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + func_8001EBE0(4, 0); + + for (i = 0; i < sp64->unk_000; i++) { + ptr = &sp64->unk_00C[i]; + idx1 = i / 5; + idx2 = i % 5; + + func_8001F1E8((s16)sp68 + arg0->unk_0004 + (idx2 * 0x58) + 5, arg0->unk_0006 + (idx1 * 0x3C) + 0x46, + ptr->unk_30); + } + + func_8001F444(); + + gSPDisplayList(gDisplayListHead++, D_8006F518); + + for (i = 0; i < sp64->unk_000; i++) { + idx1 = i / 5; + idx2 = i % 5; + + func_8001C6AC((s16)sp68 + arg0->unk_0004 + (idx2 * 0x58) + 0x2C, arg0->unk_0006 + (idx1 * 0x3C) + 0x1F, + 0x28, 0x28, func_82F014E4(D_82F20A00, spE8, i), 0x28, 0); + } + + if (arg0->unk_0000 == 2) { + temp_s3 = (arg0->unk_0004 + (arg0->unk_001C * 0x58)); + temp_lo = (arg0->unk_0006 + (arg0->unk_001E * 0x3C) + 0x1C); + + temp_t0 = arg0->unk_0004 + (arg0->unk_0018 * 0x58); + temp_t1 = arg0->unk_0006 + (arg0->unk_001A * 0x3C) + 0x1C; + + func_82F02CE8(temp_t0 - (((temp_t0 - temp_s3) * arg0->unk_000C) / 4), + temp_t1 - (((temp_t1 - temp_lo) * arg0->unk_000C) / 4), 0x58, 0x3C); + } + + gSPDisplayList(gDisplayListHead++, D_8006F630); + } + spF8++; + sp68 += spEE; + } + + if ((arg0->unk_0008 == 0x1B8) && (arg0->unk_000A == 0x10C)) { + if (spE4 != 0) { + func_800060E0(&gDisplayListHead, 0, 0, 0x280, 0x1E0); + } + + if ((arg0->unk_0000 == 2) || (arg0->unk_0000 == 3)) { + var_a3 = 1; + } else { + var_a3 = 0; + } + + func_82F040D0(arg0, 0x56, 0x50, var_a3); + func_82F043A4(D_82F20A04, D_82F13C0C[D_82F20A04], 0x20); + } +} +#else +static s16 D_82F13C0C[] = { 0x34, 0x148 }; #pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_289240/func_82F04604.s") +#endif -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_289240/func_82F04FD4.s") +void func_82F04FD4(void) { + unk_D_82F144D0* ptr; + s32 i; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_289240/func_82F0504C.s") + D_82F20A04 = 0; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_289240/func_82F05110.s") + ptr = &D_82F144D0[0]; + for (i = 0; i < 2; i++, ptr++) { + ptr->unk_0018 = ptr->unk_001A = 0; + ptr->unk_001C = ptr->unk_001E = 0; + ptr->unk_0000 = 0; + ptr->unk_0004 = 0; + ptr->unk_0006 = 0; + ptr->unk_0008 = 0; + ptr->unk_000A = 0; + ptr->unk_000C = 0; + ptr->unk_000E = 0; + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_289240/func_82F05198.s") + func_82F06D50(); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_289240/func_82F051B8.s") +void func_82F0504C(void) { + s16 temp_v0; + s32 i; + unk_D_82F144D0* var_s0; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_289240/func_82F05210.s") + var_s0 = D_82F144D0; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_289240/func_82F0525C.s") + for (i = 0; i < 2; i++, var_s0++) { + if (var_s0->unk_0000 == 0) { + continue; + } + + switch (var_s0->unk_0000) { + case 1: + func_82F01920(var_s0); + break; + + case 2: + func_82F01A70(var_s0); + break; + + case 3: + func_82F01FE4(var_s0); + break; + + case 4: + func_82F06D88(); + func_82F020B4(var_s0); + break; + + case 5: + func_82F02180(var_s0); + break; + } + } +} + +void func_82F05110(void) { + s32 i; + s32 var_s3 = 0; + unk_D_82F144D0* ptr = &D_82F144D0[0]; + + for (i = 0; i < 2; i++, ptr++) { + if (ptr->unk_0000 != 0) { + var_s3 = 1; + if (ptr->unk_0002 != 0) { + func_82F04604(ptr); + } + } + } + + if (var_s3 != 0) { + func_82F06E04(); + } +} + +u16* func_82F05198(s32 arg0) { + return D_82F144D0[arg0].unk_0028; +} + +void func_82F051B8(void) { + UNUSED s32 pad[2]; + u16 sp18[0x640]; + + _bcopy(D_82F144D0[0].unk_0028, sp18, sizeof(D_82F144D0[0].unk_0028)); + _bcopy(D_82F144D0[1].unk_0028, D_82F144D0[0].unk_0028, sizeof(D_82F144D0[0].unk_0028)); + _bcopy(sp18, D_82F144D0[1].unk_0028, sizeof(D_82F144D0[0].unk_0028)); +} + +void func_82F05210(s16 arg0, unk_func_80026268_arg0* arg1) { + func_8001B0DC(D_82F144D0[arg0].unk_0028, 0, arg1); +} + +s32 func_82F0525C(s32 arg0, unk_func_82F00838_sp30* arg1) { + s32 ret = 0; + unk_D_82F144D0* ptr; + + if (arg1 != NULL) { + ptr = &D_82F144D0[arg0]; + arg1->unk_00 = ptr->unk_0020; + arg1->unk_02 = ptr->unk_000E; + arg1->unk_04 = ptr->unk_0010; + arg1->unk_06 = (ptr->unk_001A * 5) + ptr->unk_0018; + arg1->unk_08 = ptr->unk_0CA8[ptr->unk_0010].unk_000; + arg1->unk_0C = &ptr->unk_0CA8[ptr->unk_0010].unk_00C; + ret = 1; + } + + return ret; +} diff --git a/src/fragments/41/fragment41_28D1A0.c b/src/fragments/41/fragment41_28D1A0.c index fcf7ca0..af241d1 100644 --- a/src/fragments/41/fragment41_28D1A0.c +++ b/src/fragments/41/fragment41_28D1A0.c @@ -1,29 +1,461 @@ -#include "global.h" +#include "fragment41.h" +#include "src/19840.h" +#include "src/1CF30.h" +#include "src/20470.h" +#include "src/225A0.h" +#include "src/22630.h" +#include "src/2E110.h" +#include "src/49790.h" +#include "src/memory.h" -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28D1A0/func_82F052F0.s") +static unk_D_82F20A10 D_82F20A10; +static s16 D_82F20A38; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28D1A0/func_82F053F8.s") +void func_82F052F0(unk_D_82F144D0* arg0, u8* arg1, s16 arg2, s16 arg3) { + unk_D_82F20A10* ptr = &D_82F20A10; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28D1A0/func_82F05560.s") + main_pool_push_state('BBRD'); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28D1A0/func_82F056D0.s") + ptr->unk_00 = 1; + ptr->unk_02 = -1; + ptr->unk_04 = arg2; + ptr->unk_06 = arg3; + ptr->unk_0C = 0; + ptr->unk_0E = 0; + ptr->unk_08 = arg2; + ptr->unk_0A = arg3; + ptr->unk_10 = 6; + ptr->unk_14 = arg1; + ptr->unk_18 = arg0; + ptr->unk_1C = NULL; + ptr->unk_20 = func_80019760(1); + ptr->unk_24 = func_8001B1FC(ptr->unk_20, 0xE4, 0xA0, 0, 0, 0xE0, 0xA0, D_3014468); + ptr->unk_24->unk_00 &= ~2; + func_8001B2D8(ptr->unk_24, ptr->unk_14, 0x108D); + func_80048B90(4); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28D1A0/func_82F05828.s") +void func_82F053F8(unk_D_82F20A10* arg0) { + arg0->unk_10--; + arg0->unk_04 = 0x38 - (((0x38 - arg0->unk_08) * arg0->unk_10) / 6); + arg0->unk_06 = 0x70 - (((0x70 - arg0->unk_0A) * arg0->unk_10) / 6); + arg0->unk_0C = 0x210 - ((arg0->unk_10 * 0x210) / 6); + arg0->unk_0E = 0x148 - ((arg0->unk_10 * 0x148) / 6); + if (arg0->unk_10 <= 0) { + arg0->unk_00 = 2; + arg0->unk_02 = 4; + D_82F20A38 = 0; + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28D1A0/func_82F05920.s") +void func_82F05560(unk_D_82F20A10* arg0) { + static Controller** D_82F13C10[] = { + &gPlayer1Controller, + &gPlayer1Controller, + &gPlayer1Controller, + &gPlayer1Controller, + }; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28D1A0/func_82F05C50.s") + s16 tmp; + s32 var_t0; + Controller* temp_a3; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28D1A0/func_82F05D74.s") + arg0->unk_1C = func_8001B9D4(arg0->unk_24); + temp_a3 = *D_82F13C10[arg0->unk_18->unk_000E]; + var_t0 = 0; + tmp = D_82F20A38; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28D1A0/func_82F05F20.s") + if (temp_a3->buttonPressed & 0x200) { + D_82F20A38--; + if (D_82F20A38 < 0) { + D_82F20A38 = 0; + } + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28D1A0/func_82F05F40.s") + if (temp_a3->buttonPressed & 0x100) { + D_82F20A38++; + if (D_82F20A38 >= 2) { + D_82F20A38 = 1; + } + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28D1A0/func_82F06D50.s") + if (D_82F20A38 != tmp) { + func_80048B90(1); + var_t0 = 0; + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28D1A0/func_82F06D88.s") + if (temp_a3->buttonPressed & 0x8000) { + var_t0 = 1; + } else if (temp_a3->buttonPressed & 0x4000) { + var_t0 = 1; + D_82F20A38 = 1; + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28D1A0/func_82F06E04.s") + if (var_t0 != 0) { + arg0->unk_00 = 3; + arg0->unk_02 = -1; + arg0->unk_10 = 6; + arg0->unk_1C = 0; + if (D_82F20A38 == 0) { + arg0->unk_18->unk_0020 = 1; + func_80048B90(2); + } else { + arg0->unk_18->unk_0020 = 0; + func_80048B90(3); + } + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28D1A0/func_82F06E38.s") +void func_82F056D0(unk_D_82F20A10* arg0) { + arg0->unk_10--; + arg0->unk_04 = arg0->unk_08 - (((arg0->unk_08 - 0x38) * arg0->unk_10) / 6); + arg0->unk_06 = arg0->unk_0A - (((arg0->unk_0A - 0x70) * arg0->unk_10) / 6); + arg0->unk_0C = (arg0->unk_10 * 0x210) / 6; + arg0->unk_0E = (arg0->unk_10 * 0x148) / 6; + + if (arg0->unk_10 <= 0) { + arg0->unk_00 = 0; + main_pool_pop_state('BBRD'); + } +} + +void func_82F05828(s16 arg0, s16 arg1, s16 arg2, s16 arg3, u8 arg4, u8 arg5, u8 arg6) { + s32 color = RGBA5551(arg4, arg5, arg6, 1); + + gDPPipeSync(gDisplayListHead++); + gDPSetFillColor(gDisplayListHead++, (color << 0x10) | color); + gDPFillRectangle(gDisplayListHead++, arg0, arg1, (arg0 + arg2) - 1, (arg1 + arg3) - 1); +} + +void func_82F05920(s16 arg0, s16 arg1, s16 arg2, s16 arg3, u8 arg4, u8 arg5, u8 arg6) { + gSPDisplayList(gDisplayListHead++, D_8006F518); + gDPSetRenderMode(gDisplayListHead++, G_RM_AA_OPA_SURF, G_RM_AA_OPA_SURF2); + gDPSetEnvColor(gDisplayListHead++, arg4, arg5, arg6, 255); + + func_8001CADC(arg0, arg1, 8, 8, D_30387B0, 8, 0); + func_8001CADC((arg0 + arg2) - 8, arg1, 8, 8, D_30387F0, 8, 0); + func_8001C330(arg0 + 8, arg1, arg2 - 0x10, 8, 0, 0, 0, 0x400, 0); + func_8001CADC(arg0, (arg1 + arg3) - 8, 8, 8, D_3038830, 8, 0); + func_8001C330(arg0, arg1 + 8, 8, arg3 - 0x10, 0, 0, 0x400, 0, 0); + func_8001CADC((arg0 + arg2) - 8, (arg1 + arg3) - 8, 8, 8, D_3038870, 8, 0); + func_8001C330(arg0 + 8, (arg1 + arg3) - 8, arg2 - 0x10, 8, 0, 0, 0, 0x400, 0); + func_8001C330((arg0 + arg2) - 8, arg1 + 8, 8, arg3 - 0x10, 0, 0, 0x400, 0, 0); + + gSPDisplayList(gDisplayListHead++, D_8006F4C0); + + func_82F05828(arg0 + 8, arg1 + 8, arg2 - 0x10, arg3 - 0x10, arg4, arg5, arg6); + + gSPDisplayList(gDisplayListHead++, D_8006F630); +} + +void func_82F05C50(s16 arg0, s16 arg1, s32 arg2) { + s32 temp_v0_3; + s16 var_a3; + s16 i; + + if (arg2 != 0) { + gDPPipeSync(gDisplayListHead++); + gDPSetBlendColor(gDisplayListHead++, 0, 0, 0, 128); + + for (i = 0; i < 0xA0; i += 8) { + temp_v0_3 = 0xA0 - i; + if (temp_v0_3 < 8) { + var_a3 = temp_v0_3; + } else { + var_a3 = 8; + } + func_8001C6AC(arg0, arg1 + i, 0xE0, var_a3, (i * 0x1C8) + arg2, 0xE4, 0x200000); + } + } +} + +void func_82F05D74(s16 arg0, s16 arg1, s16 arg2) { + static u8* D_82F13C20[] = { + D_302F6E0, D_302F740, D_302F7A0, D_302F800, D_302F860, D_302F8C0, D_302F928, D_302F988, D_302F9E8, D_302FA48, + }; + + s32 i; + s32 var_s0; + s16 var_s4; + + arg2 %= 100; + var_s0 = 0xA; + var_s4 = 0; + + for (i = 0; i < 2; i++) { + s32 temp_lo = arg2 / var_s0; + + if ((temp_lo != 0) || (var_s4 != 0) || (i == 1)) { + func_8001CADC(arg0, arg1, 8, 0xC, D_82F13C20[temp_lo], 8, 0); + var_s4 = 1; + } + + arg0 += 9; + arg2 %= var_s0; + var_s0 /= 10; + } +} + +s32 func_82F05F20(s32 arg0) { + s32 var_v1 = 0; + + if ((arg0 <= 0) || (arg0 >= 0xA6)) { + var_v1 = 1; + } + return var_v1; +} + +void func_82F05F40(unk_D_82F20A10* arg0) { + static Color_RGBA8 D_82F13C48 = { 0xFF, 0xFF, 0xFF, 0xFF }; + static Color_RGB8 D_82F13C4C = { 0x82, 0x1E, 0x1E }; + static Color_RGB8 D_82F13C50 = { 0x96, 0x64, 0x1E }; + static s16 D_82F13C54[] = { 0x122, 0x136, 0x1C, 8 }; + static s16 D_82F13C5C[] = { 0xD3, 0xED, 0x107, 0xED }; + static s16 D_82F13C64[] = { 0x15E, 0x1BA }; + static u8* D_82F13C68[] = { + D_303E330, D_303FC30, D_3040590, D_3040270, D_303F910, D_303F5F0, D_3040590, D_303FF50, + D_3040BD0, D_303E650, D_303E970, D_303EFB0, D_303F2D0, D_30408B0, D_303EC90, D_3040EF0, + }; + + s32 i; + Color_RGB8* var_v0; + s16 temp_s0; + s16 temp_s1_2; + s32 temp_s1_3; + unk_func_80026268_arg0* sp11C; + unk_D_80072B00* ptr; + UNUSED s32 pad; + char sp94[128]; + char* sp8C[2]; + s32 temp_v0_5; + s32 var_t0; + s32 sp80; + + sp8C[0] = func_8002D7C0(NULL, 0, D_82F13B70, 0x12); + sp8C[1] = func_8002D7C0(NULL, 0, D_82F13B70, 0x13); + sp11C = arg0->unk_14; + func_82F022DC(arg0->unk_04, arg0->unk_06, arg0->unk_0C, arg0->unk_0E); + + if ((arg0->unk_0C == 0x210) && (arg0->unk_0E == 0x148)) { + if (arg0->unk_18->unk_0010 == 0) { + var_v0 = &D_82F13C4C; + } else { + var_v0 = &D_82F13C50; + } + + if (arg0->unk_02 != 0) { + func_82F05920(arg0->unk_04, arg0->unk_06, 0x210, 0x24, var_v0->r, var_v0->g, var_v0->b); + func_82F05920(arg0->unk_04 + 0xE0, arg0->unk_06 + 0x24, 0x130, 0x1C, 0x3C, 0x3C, 0x82); + func_82F05920(arg0->unk_04 + 0xE0, arg0->unk_06 + 0x40, 0x130, 0x84, 0x3C, 0x3C, 0x82); + func_82F05920(arg0->unk_04, arg0->unk_06 + 0xC4, 0x210, 0x60, 0x3C, 0x3C, 0x82); + } + + func_82F05920(arg0->unk_04, arg0->unk_06 + 0x124, 0x210, 0x24, 0x28, 0x28, 0x64); + func_80020B88(arg0->unk_04 + 0x140, arg0->unk_06 + 0x5A, 0x94, sp11C->unk_02, sp11C->unk_26); + + gSPDisplayList(gDisplayListHead++, D_8006F4E0); + + func_8001C6AC(arg0->unk_04 + 0xF8, arg0->unk_06 + 0xD0, 0x1C, 0x1A, D_302DE68, 0x1C, 0x200000); + func_8001C6AC(arg0->unk_04 + 0xE2, arg0->unk_06 + 0xEA, 0x1C, 0x1A, D_302E9C8, 0x1C, 0x200000); + func_8001C6AC(arg0->unk_04 + 0x110, arg0->unk_06 + 0xEA, 0x1C, 0x1A, D_302EF78, 0x1C, 0x200000); + func_8001C6AC(arg0->unk_04 + 0xF8, arg0->unk_06 + 0x104, 0x1C, 0x1A, D_302E418, 0x1C, 0x200000); + + for (i = 0; i < 4; i++) { + if (sp11C->unk_09[i] == 0) { + break; + } + + if (func_82F05F20(sp11C->unk_09[i]) == 0) { + func_8001C6AC(D_82F13C54[i] + arg0->unk_04, D_82F13C5C[i] + arg0->unk_06, 0x14, 0x14, + D_82F13C68[D_80072338[sp11C->unk_09[i] - 1].unk_01], 0x14, 0x200000); + } + } + + func_82F05C50(arg0->unk_04, arg0->unk_06 + 0x24, arg0->unk_1C); + + gSPDisplayList(gDisplayListHead++, D_8006F518); + + for (i = 0; i < 4; i++) { + if (sp11C->unk_09[i] == 0) { + break; + } + + if (func_82F05F20(sp11C->unk_09[i]) == 0) { + ptr = &D_80072B00[sp11C->unk_09[i] - 1]; + + var_t0 = ptr->unk_05 / 5; + if (var_t0 >= 7) { + var_t0 = 7; + } + + sp80 = ((sp11C->unk_20[i] >> 6) * var_t0) + ptr->unk_05; + func_8001CADC(D_82F13C54[i] + arg0->unk_04 + 0xB6, D_82F13C5C[i] + arg0->unk_06 + 6, 8, 0xC, D_302F528, + 8, 0); + func_82F05D74(D_82F13C54[i] + arg0->unk_04 + 0xA4, D_82F13C5C[i] + arg0->unk_06 + 6, + sp11C->unk_20[i] & 0x3F); + func_82F05D74(D_82F13C54[i] + arg0->unk_04 + 0xC0, D_82F13C5C[i] + arg0->unk_06 + 6, sp80); + } + } + + func_8001F3F4(); + func_8001EBE0(0x10, 0); + func_8001F1E8(arg0->unk_04 + 0x10, arg0->unk_06 + 6, sp11C->unk_30); + func_8001EBE0(0x10, 0); + func_8001F1E8(arg0->unk_04 + 0xA0, arg0->unk_06 + 6, "%s%d", func_8002D7C0(NULL, 0, D_82F13B74, 0x15), + sp11C->unk_24); + func_8001EBE0(8, 0); + func_8001F1E8(arg0->unk_04 + 0x12E, arg0->unk_06 + 8, "%s%03d", func_8002D7C0(NULL, 0, D_82F13B74, 0x16), + sp11C->unk_00.unk_00); + func_8001EBE0(8, 0); + func_8001F1E8(arg0->unk_04 + 0x19C, arg0->unk_06 + 8, func_82F00020(sp11C->unk_00.unk_00)); + + temp_s0 = func_800219FC(sp11C->unk_06); + temp_s1_2 = func_800219FC(sp11C->unk_07); + + func_8001EBE0(8, 0); + func_8001F1E8(arg0->unk_04 + 0xE4, arg0->unk_06 + 0x28, func_8002D7C0(NULL, 0, D_82F13B70, 0xC)); + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + func_8001F1E8(arg0->unk_04 + 0x120, arg0->unk_06 + 0x28, "1/"); + func_8001F324(D_80071D88[temp_s0].color.r, D_80071D88[temp_s0].color.g, D_80071D88[temp_s0].color.b, 0xFF); + func_8001F1E8(arg0->unk_04 + 0x13E, arg0->unk_06 + 0x28, "%s", func_82F00090(sp11C->unk_06)); + + if (sp11C->unk_06 != sp11C->unk_07) { + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + func_8001F1E8(arg0->unk_04 + 0x19E, arg0->unk_06 + 0x28, "2/"); + func_8001F324(D_80071D88[temp_s1_2].color.r, D_80071D88[temp_s1_2].color.g, D_80071D88[temp_s1_2].color.b, + 0xFF); + func_8001F1E8(arg0->unk_04 + 0x1BC, arg0->unk_06 + 0x28, "%s", func_82F00090(sp11C->unk_07)); + } + + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + func_8001EBE0(8, 0); + func_8001F1E8(arg0->unk_04 + 0x144, arg0->unk_06 + 0x44, func_8002D7C0(NULL, 0, D_82F13B74, 8)); + func_8001EBE0(8, 0); + sprintf(sp94, "%d", sp11C->unk_26); + func_8001F1E8((arg0->unk_04 - func_8001F5B0(0, 0, sp94)) + 0x1D0, arg0->unk_06 + 0x44, sp94); + temp_s1_3 = 0x1D0 - func_8001F5B0(0, 0, "999"); + sprintf(sp94, "/"); + temp_v0_5 = func_8001F5B0(0, 0, sp94); + func_8001F1E8((arg0->unk_04 + temp_s1_3) - temp_v0_5, arg0->unk_06 + 0x44, sp94); + temp_s1_3 -= temp_v0_5; + sprintf(sp94, "%d", sp11C->unk_02); + func_8001F1E8((arg0->unk_04 + temp_s1_3) - func_8001F5B0(0, 0, sp94), arg0->unk_06 + 0x44, sp94); + func_8001EBE0(8, 0); + func_8001F1E8(arg0->unk_04 + 0x144, arg0->unk_06 + 0x6A, func_8002D7C0(NULL, 0, D_82F13B70, 0xD)); + func_8001F1E8(arg0->unk_04 + 0x144, arg0->unk_06 + 0x80, func_8002D7C0(NULL, 0, D_82F13B70, 0xE)); + func_8001F1E8(arg0->unk_04 + 0x144, arg0->unk_06 + 0x96, func_8002D7C0(NULL, 0, D_82F13B70, 0xF)); + func_8001F1E8(arg0->unk_04 + 0x144, arg0->unk_06 + 0xAC, func_8002D7C0(NULL, 0, D_82F13B70, 0x10)); + func_8001EBE0(8, 0); + + sprintf(sp94, "%d", sp11C->unk_28); + func_8001F1E8((arg0->unk_04 - func_8001F5B0(0, 0, sp94)) + 0x1D0, arg0->unk_06 + 0x6A, sp94); + sprintf(sp94, "%d", sp11C->unk_2A); + func_8001F1E8((arg0->unk_04 - func_8001F5B0(0, 0, sp94)) + 0x1D0, arg0->unk_06 + 0x80, sp94); + sprintf(sp94, "%d", sp11C->unk_2C); + func_8001F1E8((arg0->unk_04 - func_8001F5B0(0, 0, sp94)) + 0x1D0, arg0->unk_06 + 0x96, sp94); + sprintf(sp94, "%d", sp11C->unk_2E); + func_8001F1E8((arg0->unk_04 - func_8001F5B0(0, 0, sp94)) + 0x1D0, arg0->unk_06 + 0xAC, sp94); + func_8001EBE0(8, 0); + + { + char* sp74; + Color_RGB8* sp70; + Color_RGBA8 sp6C; + s32 j; + + for (i = 0; i < 4; i++) { + sp6C = D_82F13C48; + + if (sp11C->unk_09[i] == 0) { + break; + } + + if (func_82F05F20(sp11C->unk_09[i]) == 0) { + sp70 = &D_80071D88[D_80072338[sp11C->unk_09[i] - 1].unk_01].color; + sp74 = func_82F00058(sp11C->unk_09[i]); + } else { + // "？？？？？？？" + static const char D_29C080[] = { 0xA1, 0xA9, 0xA1, 0xA9, 0xA1, 0xA9, 0xA1, + 0xA9, 0xA1, 0xA9, 0xA1, 0xA9, 0xA1, 0xA9 }; + sp70 = &sp6C; + sp74 = D_29C080; + } + func_8001F324(sp70->r, sp70->g, sp70->b, 0xFF); + func_8001F1E8(D_82F13C54[i] + arg0->unk_04 + 0x18, D_82F13C5C[i] + arg0->unk_06, sp74); + } + + func_8001EBE0(0x10, 0); + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + func_8001F1E8(arg0->unk_04 + 0x10, arg0->unk_06 + 0x12A, func_8002D7C0(NULL, 0, D_82F13B70, 0x11)); + + for (i = 0; i < 2; i++) { + func_8001F1E8(arg0->unk_04 + D_82F13C64[i], arg0->unk_06 + 0x12A, sp8C[i]); + } + + func_8001F444(); + + gSPDisplayList(gDisplayListHead++, D_8006F518); + + { + s16 sp60[2]; + + for (j = 0; j < 2; j++) { + sp60[j] = func_8001F5B0(0, 0, sp8C[j]); + } + + func_82F02CE8((D_82F13C64[D_82F20A38] + arg0->unk_04) - 8, arg0->unk_06 + 0x128, + sp60[D_82F20A38] + 0x10, 0x1E); + } + } + + gSPDisplayList(gDisplayListHead++, D_8006F630); + + if (arg0->unk_02 > 0) { + arg0->unk_02--; + } + } +} + +void func_82F06D50(void) { + D_82F20A10.unk_00 = 0; + D_82F20A10.unk_04 = 0; + D_82F20A10.unk_06 = 0; + D_82F20A10.unk_0C = 0; + D_82F20A10.unk_0E = 0; + D_82F20A10.unk_10 = 0; + D_82F20A10.unk_14 = NULL; + D_82F20A10.unk_18 = NULL; + D_82F20A10.unk_1C = 0; + D_82F20A10.unk_20 = NULL; + D_82F20A10.unk_24 = NULL; +} + +void func_82F06D88(void) { + unk_D_82F20A10* ptr = &D_82F20A10; + + if (ptr->unk_00) { + switch (ptr->unk_00) { + case 1: + func_82F053F8(&D_82F20A10); + break; + + case 2: + func_82F05560(&D_82F20A10); + break; + + case 3: + func_82F056D0(&D_82F20A10); + break; + } + } +} + +void func_82F06E04(void) { + if (D_82F20A10.unk_00 != 0) { + func_82F05F40(&D_82F20A10); + } +} + +s32 func_82F06E38(void) { + return D_82F20A10.unk_00; +} diff --git a/src/fragments/41/fragment41_28ED00.c b/src/fragments/41/fragment41_28ED00.c index 3ae3fd1..7061e4f 100644 --- a/src/fragments/41/fragment41_28ED00.c +++ b/src/fragments/41/fragment41_28ED00.c @@ -1,73 +1,1180 @@ -#include "global.h" +#include "fragment41.h" +#include "src/12D80.h" +#include "src/1C720.h" +#include "src/1CF30.h" +#include "src/20470.h" +#include "src/29BA0.h" +#include "src/2E110.h" +#include "src/49790.h" +#include "src/F420.h" +#include "src/geo_layout.h" +#include "src/math_util.h" +#include "src/memmap.h" +#include "src/memory.h" -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28ED00/func_82F06E50.s") +s32 func_82F06E50(s32 arg0, GraphNode* arg1); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28ED00/func_82F06F9C.s") +static unk_D_82F20A40 D_82F20A40; +static unk_D_82F20A88 D_82F20A88[4]; +static GraphNode* D_82F210C8; +static GraphNode* D_82F210CC; +static s16 D_82F210D0; +static s16 D_82F210D2; +static s16 D_82F210D4; +static s16 D_82F210D8[2]; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28ED00/func_82F07004.s") +static Vtx D_82F13CB0[] = { + VTX(-32, 64, 0, 0, 0, 0xFF, 0xFF, 0xFF, 0xFF), VTX(-32, 32, 0, 0, 1024, 0xFF, 0xFF, 0xFF, 0xFF), + VTX(32, 32, 0, 2048, 1024, 0xFF, 0xFF, 0xFF, 0xFF), VTX(32, 64, 0, 2048, 0, 0xFF, 0xFF, 0xFF, 0xFF), + VTX(-32, 32, 0, 0, 0, 0xFF, 0xFF, 0xFF, 0xFF), VTX(-32, 0, 0, 0, 1024, 0xFF, 0xFF, 0xFF, 0xFF), + VTX(32, 0, 0, 2048, 1024, 0xFF, 0xFF, 0xFF, 0xFF), VTX(32, 32, 0, 2048, 0, 0xFF, 0xFF, 0xFF, 0xFF), + VTX(-16, 39, 0, 0, 0, 0xFF, 0xFF, 0xFF, 0xFF), VTX(-16, 15, 0, 0, 768, 0xFF, 0xFF, 0xFF, 0xFF), + VTX(16, 15, 0, 1024, 768, 0xFF, 0xFF, 0xFF, 0xFF), VTX(16, 39, 0, 1024, 0, 0xFF, 0xFF, 0xFF, 0xFF), +}; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28ED00/func_82F07214.s") +static Gfx D_82F13D70[] = { + gsSPSetGeometryMode(G_CULL_BACK), + gsDPSetCombineLERP(0, 0, 0, TEXEL0, TEXEL0, 0, ENVIRONMENT, 0, 0, 0, 0, COMBINED, 0, 0, 0, COMBINED), + gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON), + gsSPVertex(D_82F13CB0, 12, 0), + gsDPLoadTextureBlock(0x0F000000, G_IM_FMT_RGBA, G_IM_SIZ_16b, 64, 32, 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), + gsSP2Triangles(0, 1, 2, 0, 0, 2, 3, 0), + gsDPLoadTextureBlock(0x0F001000, G_IM_FMT_RGBA, G_IM_SIZ_16b, 64, 32, 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), + gsSP2Triangles(4, 5, 6, 0, 4, 6, 7, 0), + gsDPLoadTextureBlock(0x0E000000, G_IM_FMT_IA, G_IM_SIZ_8b, 32, 24, 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), + gsSP2Triangles(8, 9, 10, 0, 8, 10, 11, 0), + gsSPEndDisplayList(), +}; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28ED00/func_82F07440.s") +static u32 D_82F13E58[] = { + 0x17000000, 0x00000000, 0x00000000, 0x00000000, D_82F13CB0, 0x05000000, 0x22050000, + 0x00000000, 0x08000000, func_82F06E50, D_82F13D70, 0x06000000, 0x01000000, +}; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28ED00/func_82F07498.s") +static u32 D_82F13E8C[] = { + 0x0C000000, 0x05000000, 0x0B00002D, 0x00000000, 0x028001E0, 0x00000000, 0xFDBD0000, 0x00000243, + 0x05000000, 0x0D000000, 0x05000000, 0x14000000, 0x002D013B, 0xFFFFFF32, 0x16FFFFFF, 0x0F000002, + 0x05000000, 0x0A000000, &D_800AC840, 0x06000000, 0x06000000, 0x06000000, 0x06000000, 0x01000000, +}; +static s16 D_82F13EEC[] = { + 0x007E, + 0x013C, + 0x0184, + 0x0000, +}; +static s16 D_82F13EF4[] = { + 0x007E, + 0x0120, + 0x0184, + 0x0038, +}; +static s16 D_82F13EFC[] = { + 0x00A1, + 0x013C, + 0x013E, + 0x0000, +}; +static s16 D_82F13F04[] = { + 0x00A1, + 0x0120, + 0x013E, + 0x0038, +}; +static s16 D_82F13F0C[] = { + 0x007D, + 0x0149, + 0x0186, + 0x0000, +}; +static s16 D_82F13F14[] = { + 0x007D, + 0x0120, + 0x0186, + 0x0052, +}; +static s16 D_82F13F1C[] = { + 0x00CC, + 0x013C, + 0x00E8, + 0x0000, +}; +static s16 D_82F13F24[] = { + 0x00CC, + 0x0120, + 0x00E8, + 0x0038, +}; +static u8* D_82F13F2C[] = { + D_302FAB0, + D_302FDB0, + D_30300B0, + D_30303B0, +}; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28ED00/func_82F0761C.s") +s32 func_82F06E50(s32 arg0, GraphNode* arg1) { + if (arg0 == 5) { + s32 idx = D_8006F09C->unk_000.unk_14; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28ED00/func_82F0763C.s") + gDPPipeSync(gDisplayListHead++); + gDPSetEnvColor(gDisplayListHead++, 0, 0, 0, D_8006F09C->unk_01D); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28ED00/func_82F07728.s") + if (D_82F20A88[idx].unk_024 != NULL) { + gSPSegment(gDisplayListHead++, 0x0F, Memmap_GetSegmentVaddr(D_82F20A88[idx].unk_024)); + gSPSegment(gDisplayListHead++, 0x0E, Memmap_GetSegmentVaddr(D_82F13F2C[D_82F20A88[idx].unk_002])); + gSPDisplayList(gDisplayListHead++, arg1->unk_14); + } + func_80015684(); + } + return 0; +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28ED00/func_82F07784.s") +s16 func_82F06F9C(unk_D_82F14450* arg0) { + s16 ret; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28ED00/func_82F077E0.s") + switch (arg0->unk_00) { + case 0: + if (arg0->unk_04 == 0) { + ret = 4; + } else if (arg0->unk_03 == 0) { + ret = 3; + } else { + ret = 0; + } + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28ED00/func_82F07958.s") + case 2: + ret = 1; + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28ED00/func_82F07A54.s") + case 3: + ret = 2; + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28ED00/func_82F07A74.s") + default: + ret = -1; + break; + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28ED00/func_82F07A80.s") + return ret; +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28ED00/func_82F07DEC.s") +void func_82F07004(s16 arg0) { + s16 temp_v0; + unk_D_82F20A88* var_s0; + s32 i; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28ED00/func_82F08084.s") + var_s0 = &D_82F20A88[0]; + for (i = 0; i < 4; i++, var_s0++) { + var_s0->unk_000 = 0; + var_s0->unk_002 = -1; + var_s0->unk_004 = 0; + var_s0->unk_024 = NULL; + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28ED00/func_82F081FC.s") + D_82F210D0 = 1; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28ED00/func_82F0822C.s") + for (i = 0; i < 4; i++) { + temp_v0 = func_82F06F9C(&D_82F14450[i]); + if (temp_v0 == -1) { + continue; + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28ED00/func_82F083B0.s") + if (i != D_82F210D8[0]) { + var_s0 = &D_82F20A88[D_82F210D0++]; + } else { + var_s0 = &D_82F20A88[0]; + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28ED00/func_82F084EC.s") + var_s0->unk_002 = i; + var_s0->unk_004 = temp_v0; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28ED00/func_82F0856C.s") + switch (var_s0->unk_004) { + case 0: + case 2: + case 3: + case 4: + switch (D_82F14450[i].unk_01) { + case 1: + var_s0->unk_024 = D_30306B0; + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28ED00/func_82F0866C.s") + case 2: + var_s0->unk_024 = D_30326B0; + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28ED00/func_82F087F8.s") + case 3: + var_s0->unk_024 = D_30346B0; + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28ED00/func_82F088F8.s") + case 7: + var_s0->unk_024 = D_30366B0; + break; + } + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28ED00/func_82F08968.s") + case 1: + var_s0->unk_024 = D_302BE68; + break; + } + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28ED00/func_82F08B7C.s") + var_s0 = &D_82F20A88[0]; + for (i = 0; i < D_82F210D0; i++, var_s0++) { + unk_D_86002F58_004_000* ptr = &var_s0->unk_028; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28ED00/func_82F08EB4.s") + func_8001BB58(ptr); + func_8001BC34(ptr, 0, 0, D_82F210CC); + ptr->unk_000.unk_14 = i; + ptr->unk_000.unk_01 &= ~1; + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28ED00/func_82F0917C.s") +void func_82F07214(unk_D_82F20A88* arg0, s16 arg1) { + unk_D_86002F58_004_000* temp_v0 = &arg0->unk_028; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28ED00/func_82F09284.s") + arg0->unk_000 = arg1; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28ED00/func_82F094B4.s") + switch (arg0->unk_000) { + case 0: + temp_v0->unk_000.unk_01 &= ~1; + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28ED00/func_82F097D8.s") + case 1: + if ((((s32)arg0 - (s32)D_82F20A88) / 400) == 0) { + arg0->unk_006 = 0xF8; + arg0->unk_008 = 0xB8; + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28ED00/func_82F09B70.s") + arg0->unk_010 = 0; + arg0->unk_00C = 0; + arg0->unk_00E = 0; + arg0->unk_012 = 0; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28ED00/func_82F09C6C.s") + if (arg0->unk_004 != 0) { + arg0->unk_014 = 0x80; + } else { + arg0->unk_014 = 0xFF; + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28ED00/func_82F09D2C.s") + arg0->unk_018 = 1.0f; + arg0->unk_01C = 1.0f; + arg0->unk_020 = 1.0f; + temp_v0->unk_000.unk_01 |= 1; + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28ED00/func_82F09E30.s") + case 2: + arg0->unk_006 = ((((s32)arg0 - (s32)D_82F20A88) / 400) * 0x88) + 0x30; + arg0->unk_008 = 0x17C; + arg0->unk_00A = arg0->unk_006; + arg0->unk_010 = 0xA; + arg0->unk_00C = 0; + arg0->unk_00E = 0; + arg0->unk_012 = 0; + + if (arg0->unk_004 != 0) { + arg0->unk_014 = 0x80; + } else { + arg0->unk_014 = 0xFF; + } + + arg0->unk_01C = 1.0f; + arg0->unk_020 = 1.0f; + arg0->unk_018 = 0.0f; + temp_v0->unk_000.unk_01 |= 1; + break; + + case 4: + arg0->unk_010 = 0; + arg0->unk_00A = arg0->unk_006; + + if ((((s32)arg0 - (s32)D_82F20A88) / 400) & 1) { + arg0->unk_00C = -0x8000; + } else { + arg0->unk_00C = 0; + } + + arg0->unk_00E = arg0->unk_00C; + arg0->unk_018 = 1.0f; + break; + + case 3: + arg0->unk_006 = ((((s32)arg0 - (s32)D_82F20A88) / 400) * 0x88) + 0x30; + arg0->unk_008 = 0x17C; + arg0->unk_010 = 0xA; + arg0->unk_00C = 0; + arg0->unk_00E = 0; + arg0->unk_012 = 0; + arg0->unk_01C = 1.0f; + arg0->unk_020 = 1.0f; + break; + + case 5: + arg0->unk_010 = 0xA; + break; + + case 6: + arg0->unk_010 = 0xA; + break; + } +} + +void func_82F07440(unk_D_82F20A88* arg0) { + arg0->unk_010--; + arg0->unk_018 = (0xA - arg0->unk_010) / 10.0f; + if (arg0->unk_010 <= 0) { + func_82F07214(arg0, 4); + } +} + +void func_82F07498(unk_D_82F20A88* arg0) { + static s16 D_82F13F38[] = { 0x5C0, 0x680, 0x580 }; + + s32 temp_lo = arg0 - &D_82F20A88[0]; + s16 var_a2; + s16 var_a3; + f32 var_fv0; + f32 var_fv1; + + if (temp_lo - 1 == D_82F210D2) { + var_fv0 = 1.5f; + var_a2 = D_82F13F38[temp_lo - 1] * 2; + var_fv1 = 0.06f; + var_a3 = 0x3000; + } else { + var_a2 = D_82F13F38[temp_lo - 1]; + var_fv1 = 0.02f; + var_a3 = 0x2000; + var_fv0 = 1.0f; + } + + arg0->unk_006 = arg0->unk_00A - (SINS(arg0->unk_00C) * (6.0f * var_fv0)); + + arg0->unk_012 = SINS(arg0->unk_00C) * (1536.0f * var_fv0); + arg0->unk_01C = (SINS(arg0->unk_00E) * var_fv1) + 1.0f; + arg0->unk_020 = (COSS(arg0->unk_00E) * var_fv1) + 1.0f; + + arg0->unk_00C += var_a2; + arg0->unk_00E += var_a3 + ((MathUtil_Random16() & 0xF) * 0x10); +} + +void func_82F0761C(unk_D_82F20A88* arg0) { + func_82F07498(arg0); +} + +void func_82F0763C(unk_D_82F20A88* arg0) { + arg0->unk_010 -= 1; + arg0->unk_006 = 0x208 - (((0x208 - arg0->unk_00A) * arg0->unk_010) / 10); + arg0->unk_008 = 0xB8 - ((arg0->unk_010 * -0xC4) / 10); + if (arg0->unk_010 <= 0) { + func_82F07214(arg0, 1); + D_82F210D8[1] = arg0->unk_002; + } +} + +void func_82F07728(unk_D_82F20A88* arg0) { + arg0->unk_010--; + arg0->unk_014 = (arg0->unk_010 * 0xFF) / 10; + if (arg0->unk_010 <= 0) { + func_82F07214(arg0, 0); + D_82F210D8[1] = -1; + } +} + +void func_82F07784(unk_D_82F20A88* arg0) { + func_82F07498(arg0); + arg0->unk_010--; + arg0->unk_018 = arg0->unk_010 / 10.0f; + if (arg0->unk_010 <= 0) { + func_82F07214(arg0, 0); + } +} + +void func_82F077E0(void) { + s32 i; + unk_D_82F20A88* var_s0 = &D_82F20A88[0]; + + for (i = 0; i < D_82F210D0; i++, var_s0++) { + switch (var_s0->unk_000) { + case 0: + case 1: + break; + + case 2: + func_82F07440(var_s0); + break; + + case 4: + func_82F0761C(var_s0); + break; + + case 3: + func_82F0763C(var_s0); + break; + + case 6: + func_82F07784(var_s0); + break; + + case 5: + func_82F07728(var_s0); + break; + } + + if (var_s0->unk_000 != 0) { + unk_D_86002F58_004_000* ptr = &var_s0->unk_028; + + func_8000E88C(&ptr->unk_024, var_s0->unk_006 - 320.0f, 240.0f - var_s0->unk_008, -579.0f); + ptr->unk_01E.z = var_s0->unk_012; + ptr->unk_01D = var_s0->unk_014; + ptr->unk_030.x = var_s0->unk_01C * var_s0->unk_018; + ptr->unk_030.y = var_s0->unk_020 * var_s0->unk_018; + } + } +} + +void func_82F07958(void) { + unk_D_82F20A40* ptr = &D_82F20A40; + s32 i; + + ptr->unk_00 = 1; + ptr->unk_02 = 0xA; + ptr->unk_04 = 0; + ptr->unk_06.unk_00 = 0x40; + ptr->unk_06.unk_02 = 0x8C; + ptr->unk_06.unk_04 = 0x200; + ptr->unk_06.unk_06 = 0; + + for (i = 0; i < 3; i++) { + ptr->unk_0E[i].unk_00 = 0x7C + i * 0x88; + ptr->unk_0E[i].unk_02 = 0x10C; + ptr->unk_0E[i].unk_04 = 0x78; + ptr->unk_0E[i].unk_06 = 0; + } + + ptr->unk_26.unk_00 = 0x38; + ptr->unk_26.unk_02 = 0x1A4; + ptr->unk_26.unk_04 = 0x210; + ptr->unk_26.unk_06 = 0; + ptr->unk_2E.unk_00 = 0xCC; + ptr->unk_2E.unk_02 = 0x130; + ptr->unk_2E.unk_04 = 0xE8; + ptr->unk_2E.unk_06 = 0; + ptr->unk_36.unk_00 = 0; + ptr->unk_36.unk_02 = 0; + ptr->unk_36.unk_04 = 0; + ptr->unk_36.unk_06 = 0; + + D_82F210D8[1] = -1; + D_82F210D2 = -1; + + if (D_82F20A88[0].unk_004 == 0) { + D_82F210D2 = 0; + } +} + +s32 func_82F07A54(s16 arg0) { + return D_82F210D8[arg0]; +} + +s32 func_82F07A74(void) { + return D_82F20A40.unk_00; +} + +void func_82F07A80(unk_D_82F20A40* arg0, s32 arg1) { + s32 i; + + arg0->unk_02--; + if (arg1 != 0) { + arg0->unk_06.unk_00 = 0x40 - ((arg0->unk_02 * 0) / 10); + arg0->unk_06.unk_02 = 0x48 - ((arg0->unk_02 * -0x44) / 10); + arg0->unk_06.unk_04 = 0x200 - ((arg0->unk_02 * 0) / 10); + arg0->unk_06.unk_06 = 0x88 - ((arg0->unk_02 * 0x88) / 10); + } + + for (i = 0; i < 3; i++) { + arg0->unk_0E[i].unk_00 = ((i * 0x88) - ((arg0->unk_02 * 0) / 10)) + 0x7C; + arg0->unk_0E[i].unk_02 = 0xF0 - ((arg0->unk_02 * -0x1C) / 10); + arg0->unk_0E[i].unk_04 = 0x78 - ((arg0->unk_02 * 0) / 10); + arg0->unk_0E[i].unk_06 = 0x38 - ((arg0->unk_02 * 0x38) / 10); + } + + if (arg1 != 0) { + arg0->unk_26.unk_00 = 0x38 - ((arg0->unk_02 * 0) / 10); + arg0->unk_26.unk_02 = 0x190 - ((arg0->unk_02 * -0x14) / 10); + arg0->unk_26.unk_04 = 0x210 - ((arg0->unk_02 * 0) / 10); + arg0->unk_26.unk_06 = 0x28 - ((arg0->unk_02 * 0x28) / 10); + } + + if (arg0->unk_02 <= 0) { + arg0->unk_00 = 2; + arg0->unk_02 = 0; + func_82F07214(D_82F20A88, 1); + + for (i = 0; i < 3; i++) { + if (D_82F20A88[i + 1].unk_002 != -1) { + func_82F07214(&D_82F20A88[i + 1], 2); + } + } + } +} + +void func_82F07DEC(unk_D_82F20A40* arg0) { + s32 i; + s16 tmp; + + MathUtil_Random16(); + + tmp = D_82F210D2; + + if (BTN_IS_PRESSED(gPlayer1Controller, BTN_DLEFT) && (D_82F210D2 != -1) && (D_82F210D2 > 0)) { + D_82F210D2 -= 1; + } + + if (BTN_IS_PRESSED(gPlayer1Controller, BTN_DRIGHT) && (D_82F210D2 != -1) && (D_82F210D2 < (D_82F210D0 - 2))) { + D_82F210D2 += 1; + } + + if (D_82F210D2 != tmp) { + func_80048B90(0x25); + } + + if (BTN_IS_PRESSED(gPlayer1Controller, BTN_A) && (D_82F210D2 != -1)) { + if (D_82F20A88[D_82F210D2 + 1].unk_004 == 0) { + arg0->unk_00 = 6; + arg0->unk_02 = 0xA; + + for (i = 0; i < 3; i++) { + if (D_82F20A88[i + 1].unk_002 != -1) { + if (i != D_82F210D2) { + func_82F07214(&D_82F20A88[i + 1], 6); + } else { + func_82F07214(&D_82F20A88[i + 1], 3); + } + } + } + func_80048B90(2); + } else { + arg0->unk_00 = 3; + arg0->unk_02 = 0xA; + arg0->unk_04 = D_82F20A88[D_82F210D2 + 1].unk_004; + + switch (arg0->unk_04) { + case 1: + arg0->unk_40 = &D_82F13EEC; + arg0->unk_44 = &D_82F13EF4; + break; + + case 2: + arg0->unk_40 = &D_82F13EFC; + arg0->unk_44 = &D_82F13F04; + break; + + case 3: + arg0->unk_40 = &D_82F13F0C; + arg0->unk_44 = &D_82F13F14; + break; + + case 4: + arg0->unk_40 = &D_82F13F1C; + arg0->unk_44 = &D_82F13F24; + break; + + default: + arg0->unk_44 = NULL; + arg0->unk_40 = NULL; + break; + } + } + } else if (BTN_IS_PRESSED(gPlayer1Controller, BTN_B)) { + arg0->unk_00 = 0xB; + arg0->unk_02 = 0xA; + + for (i = 0; i < 4; i++) { + func_82F07214(&D_82F20A88[i], 0); + } + + func_80048B90(3); + } +} + +void func_82F08084(unk_D_82F20A40* arg0) { + arg0->unk_02--; + arg0->unk_36.unk_00 = arg0->unk_44->unk_00 - (((arg0->unk_44->unk_00 - arg0->unk_40->unk_00) * arg0->unk_02) / 10); + arg0->unk_36.unk_02 = arg0->unk_44->unk_02 - (((arg0->unk_44->unk_02 - arg0->unk_40->unk_02) * arg0->unk_02) / 10); + arg0->unk_36.unk_04 = arg0->unk_44->unk_04 - (((arg0->unk_44->unk_04 - arg0->unk_40->unk_04) * arg0->unk_02) / 10); + arg0->unk_36.unk_06 = arg0->unk_44->unk_06 - (((arg0->unk_44->unk_06 - arg0->unk_40->unk_06) * arg0->unk_02) / 10); + if (arg0->unk_02 <= 0) { + arg0->unk_00 = 4; + arg0->unk_02 = 0; + } +} + +void func_82F081FC(unk_D_82F20A40* arg0) { + if (BTN_IS_PRESSED(gPlayer1Controller, BTN_A | BTN_B)) { + arg0->unk_00 = 5; + arg0->unk_02 = 0xA; + } +} + +void func_82F0822C(unk_D_82F20A40* arg0) { + arg0->unk_02--; + arg0->unk_36.unk_00 = arg0->unk_40->unk_00 - (((arg0->unk_40->unk_00 - arg0->unk_44->unk_00) * arg0->unk_02) / 10); + arg0->unk_36.unk_02 = arg0->unk_40->unk_02 - (((arg0->unk_40->unk_02 - arg0->unk_44->unk_02) * arg0->unk_02) / 10); + arg0->unk_36.unk_04 = arg0->unk_40->unk_04 - (((arg0->unk_40->unk_04 - arg0->unk_44->unk_04) * arg0->unk_02) / 10); + arg0->unk_36.unk_06 = arg0->unk_40->unk_06 - (((arg0->unk_40->unk_06 - arg0->unk_44->unk_06) * arg0->unk_02) / 10); + if (arg0->unk_02 <= 0) { + arg0->unk_00 = 2; + arg0->unk_02 = 0; + arg0->unk_04 = 0; + arg0->unk_44 = NULL; + arg0->unk_40 = NULL; + } +} + +void func_82F083B0(unk_D_82F20A40* arg0, s16 arg1, s16 arg2) { + unk_D_82F20A40_00E* ptr; + s32 i; + s32 tmp; + + for (i = 0; i < 3; i++) { + ptr = &arg0->unk_0E[i]; + + if ((ptr->unk_04 == 0x78) && (ptr->unk_06 == 0)) { + continue; + } + + tmp = (ptr->unk_00 * 0) / arg2; + + ptr->unk_00 = (0x7C + (i * 0x88)) - (tmp); + ptr->unk_02 = 0x10C - ((arg1 * 0x1C) / arg2); + ptr->unk_04 = 0x78 - (tmp); + ptr->unk_06 = -((arg1 * -0x38) / arg2); + } +} + +void func_82F084EC(unk_D_82F20A40* arg0) { + s32 i; + + arg0->unk_02--; + func_82F083B0(arg0, arg0->unk_02, 0xA); + if (arg0->unk_02 <= 0) { + arg0->unk_00 = 7; + arg0->unk_02 = 0xA; + + for (i = 0; i < 3; i++) { + arg0->unk_0E[i].unk_00 = 0x7C + i * 0x88; + arg0->unk_0E[i].unk_02 = 0x10C; + arg0->unk_0E[i].unk_04 = 0x78; + arg0->unk_0E[i].unk_06 = 0; + } + } +} + +void func_82F0856C(unk_D_82F20A40* arg0) { + arg0->unk_02--; + arg0->unk_2E.unk_00 = 0xCC - (arg0->unk_02 * 0) / 10; + arg0->unk_2E.unk_02 = 0xF8 - ((arg0->unk_02 * -0x38) / 10); + arg0->unk_2E.unk_04 = 0xE8 - (arg0->unk_02 * 0) / 10; + arg0->unk_2E.unk_06 = 0x70 - ((arg0->unk_02 * 0x70) / 10); + if (arg0->unk_02 <= 0) { + arg0->unk_00 = 8; + arg0->unk_02 = 0; + D_82F210D4 = 0; + } +} + +void func_82F0866C(unk_D_82F20A40* arg0) { + s16 tmp; + s32 var_a2; + + var_a2 = 0; + tmp = D_82F210D4; + + if (BTN_IS_PRESSED(gPlayer1Controller, BTN_DUP) && (D_82F210D4 > 0)) { + D_82F210D4 -= 1; + } + + if (BTN_IS_PRESSED(gPlayer1Controller, BTN_DDOWN) && (D_82F210D4 <= 0)) { + D_82F210D4 += 1; + } + + if (D_82F210D4 != tmp) { + func_80048B90(1); + } + + if (BTN_IS_PRESSED(gPlayer1Controller, BTN_A)) { + var_a2 = 1; + } else if (BTN_IS_PRESSED(gPlayer1Controller, BTN_B)) { + var_a2 = 1; + D_82F210D4 = 1; + } + + if (var_a2 != 0) { + if (D_82F210D4 == 0) { + arg0->unk_00 = 0xB; + arg0->unk_02 = 0xA; + func_82F07214(D_82F20A88, 0); + func_82F07214(&D_82F20A88[D_82F210D2 + 1], 0); + func_80048B90(0x1B); + } else { + arg0->unk_00 = 9; + arg0->unk_02 = 0xA; + func_82F07214(&D_82F20A88[D_82F210D2 + 1], 5); + func_80048B90(3); + } + } +} + +void func_82F087F8(unk_D_82F20A40_00E* arg0, s16 arg1, s16 arg2) { + if ((arg0->unk_04 != 0xE8) || (arg0->unk_06 != 0)) { + s32 tmp = (arg0->unk_00 * 0) / arg2; + + arg0->unk_00 = 0xCC - tmp; + arg0->unk_02 = 0x130 - ((arg1 * 0x38) / arg2); + arg0->unk_04 = 0xE8 - tmp; + arg0->unk_06 = -((arg1 * -0x70) / arg2); + } +} + +void func_82F088F8(unk_D_82F20A40* arg0) { + if (arg0->unk_02 > 0) { + arg0->unk_02--; + } + + func_82F087F8(&arg0->unk_2E, arg0->unk_02, 0xA); + + if ((arg0->unk_02 <= 0) && (D_82F210D8[1] == -1)) { + arg0->unk_00 = 0xA; + arg0->unk_02 = 0xA; + } +} + +void func_82F08968(unk_D_82F20A40* arg0) { + arg0->unk_02--; + arg0->unk_06.unk_00 = 0x40 - (arg0->unk_02 * 0) / 10; + arg0->unk_06.unk_02 = 0x8C - ((arg0->unk_02 * 0x44) / 10); + arg0->unk_06.unk_04 = 0x200 - (arg0->unk_02 * 0) / 10; + arg0->unk_06.unk_06 = -((arg0->unk_02 * -0x88) / 10); + + func_82F083B0(arg0, arg0->unk_02, 0xA); + func_82F087F8(&arg0->unk_2E, arg0->unk_02, 0xA); + + arg0->unk_26.unk_00 = 0x38 - (arg0->unk_02 * 0) / 10; + arg0->unk_26.unk_02 = 0x1A4 - ((arg0->unk_02 * 0x14) / 10); + arg0->unk_26.unk_04 = 0x210 - (arg0->unk_02 * 0) / 10; + arg0->unk_26.unk_06 = -((arg0->unk_02 * -0x28) / 10); + + if (arg0->unk_02 <= 0) { + arg0->unk_00 = 0; + arg0->unk_02 = 0; + } +} + +void func_82F08B7C(unk_D_82F20A40* arg0) { + Color_RGB8* var_v0; + unk_D_82F20A40_00E* temp_s4 = &arg0->unk_06; + s32 i; + unk_D_82F14450* ptr; + + func_82F022DC(temp_s4->unk_00, temp_s4->unk_02, temp_s4->unk_04, temp_s4->unk_06); + + if ((temp_s4->unk_04 == 0x200) && (temp_s4->unk_06 == 0x88)) { + gSPDisplayList(gDisplayListHead++, D_8006F498); + + func_8001C604(temp_s4->unk_00, temp_s4->unk_02, temp_s4->unk_04, temp_s4->unk_06, 0x32, 0x32, 0x96, 0xFF); + + gSPDisplayList(gDisplayListHead++, D_8006F630); + + for (i = 0; i < 2; i++) { + Color_RGB8 sp5C = { 0x1E, 0x1E, 0x64 }; + Color_RGB8 sp58 = { 0x64, 0x64, 0xC8 }; + + if (D_82F210D8[i] == -1) { + var_v0 = &sp58; + } else { + var_v0 = &sp5C; + } + + func_82F02FEC(temp_s4->unk_00 + (i * 0x110) + 0x10, temp_s4->unk_02 + 0x28, 0xD0, 0x50, var_v0->r, + var_v0->g, var_v0->b, 0xFF); + } + + func_82F097D8(temp_s4->unk_00 + 0xE0, temp_s4->unk_02 + 0x28); + func_8001F3F4(); + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + func_8001EBE0(0x10, 0); + func_8001F1E8(temp_s4->unk_00 + 0x5A, temp_s4->unk_02 + 8, func_8002D7C0(NULL, 0, D_82F13B70, 1)); + + for (i = 0; i < 2; i++) { + if (D_82F210D8[i] != -1) { + if (i == 0) { + if (D_82F20A88[0].unk_004 == 0) { + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + } else { + func_8001F324(0xFF, 0xFF, 0xFF, 0x80); + } + } else { + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + } + + ptr = &D_82F14450[D_82F210D8[i]]; + if (ptr) {} + + func_8001EBE0(0x10, 0); + func_8001F1E8(temp_s4->unk_00 + (i * 0x110) + 0x24, temp_s4->unk_02 + 0x3C, ptr->unk_08); + func_8001EBE0(8, 0); + func_8001F1E8(temp_s4->unk_00 + (i * 0x110) + 0x24, temp_s4->unk_02 + 0x54, "ID%05d", ptr->unk_06); + } + } + + func_8001F444(); + } +} + +void func_82F08EB4(unk_D_82F20A40* arg0) { + s32 i; + Color_RGB8* var_v0; + s32 var_v1; + char* var_s0_2; + unk_D_82F14450* var_s2; + Color_RGB8 sp88 = { 0x1E, 0x1E, 0x82 }; + Color_RGB8 sp84 = { 0x64, 0x1E, 0x1E }; + char sp68[28]; + unk_D_82F20A40_00E* ptr; + + for (i = 0; i < 3; i++) { + ptr = &arg0->unk_0E[i]; + + if ((arg0->unk_0E[i].unk_04 == 0x78) && (ptr->unk_06 == 0)) { + continue; + } + + if (D_82F20A88[i + 1].unk_002 == -1) { + var_v1 = 0x80; + } else { + var_v1 = 0xFF; + } + + if (D_82F20A88[i + 1].unk_004 == 0) { + var_v0 = &sp88; + } else { + var_v0 = &sp84; + } + + func_82F037EC(ptr->unk_00, ptr->unk_02, ptr->unk_04, ptr->unk_06, var_v0->r, var_v0->g, var_v0->b, var_v1); + } + + func_8001F3F4(); + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + + for (i = 0; i < 3; i++) { + var_s2 = NULL; + if (D_82F20A88[i + 1].unk_002 == -1) { + continue; + } + + ptr = &arg0->unk_0E[i]; + + switch (D_82F20A88[i + 1].unk_004) { + case 0: + case 3: + case 4: + var_s2 = &D_82F14450[D_82F20A88[i + 1].unk_002]; + break; + } + + if ((arg0->unk_0E[i].unk_04 == 0x78) && (ptr->unk_06 == 0x38)) { + func_8001EBE0(8, 0); + if (var_s2 != NULL) { + var_s0_2 = var_s2->unk_08; + } else { + var_s0_2 = "?????"; + } + + func_8001F1E8(((ptr->unk_04 - func_8001F5B0(0, 0, var_s0_2)) / 2) + ptr->unk_00, ptr->unk_02 + 8, var_s0_2); + func_8001EBE0(4, 0); + + if (var_s2 != NULL) { + sprintf(sp68, "ID%05d", var_s2->unk_06); + var_s0_2 = sp68; + } else { + var_s0_2 = "ID*****"; + } + + func_8001F1E8(((ptr->unk_04 - func_8001F5B0(0, 0, var_s0_2)) / 2) + ptr->unk_00, ptr->unk_02 + 0x20, + var_s0_2); + } + } + + func_8001F444(); +} + +void func_82F0917C(unk_D_82F20A40* arg0) { + unk_D_82F20A40_00E* temp_s1 = &arg0->unk_26; + char* temp_v0; + + func_82F037EC(arg0->unk_26.unk_00, arg0->unk_26.unk_02, arg0->unk_26.unk_04, arg0->unk_26.unk_06, 0x1E, 0x1E, 0x82, + 0xFF); + if ((temp_s1->unk_04 == 0x210) && (temp_s1->unk_06 == 0x28)) { + func_8001F3F4(); + func_8001EBE0(0x10, 0); + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + temp_v0 = func_8002D7C0(NULL, 0, D_82F13B70, 2); + func_8001F1E8((temp_s1->unk_00 - (func_8001F5B0(0, 0, temp_v0) / 2)) + 0x108, temp_s1->unk_02 + 8, temp_v0); + func_8001F444(); + } +} + +void func_82F09284(unk_D_82F20A40* arg0) { + char* temp_v0; + unk_D_82F20A40_00E* temp_s3 = &arg0->unk_2E; + s32 i; + s32 tmp; + Color_RGB8 sp54 = { 0x1E, 0x1E, 0x82 }; + char* sp4C[2]; + + if ((temp_s3->unk_04 == 0xE8) && (temp_s3->unk_06 == 0)) { + return; + } + + if ((temp_s3->unk_04 >= 0xE) && (temp_s3->unk_06 >= 0xE)) { + func_8002053C(temp_s3->unk_00, temp_s3->unk_02, temp_s3->unk_04, temp_s3->unk_06, &sp54, &sp54); + } + + if ((temp_s3->unk_04 != 0xE8) || (temp_s3->unk_06 != 0x70)) { + return; + } + + func_8001F3F4(); + func_8001EBE0(0x10, 0); + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + temp_v0 = func_8002D7C0(NULL, 0, D_82F13B70, 3); + tmp = (temp_s3->unk_00 - (func_8001F5B0(0, 0, temp_v0) / 2)) + 0x74; + func_8001F1E8(tmp, temp_s3->unk_02 + 0x10, temp_v0); + + for (i = 0; i < 2; i++) { + sp4C[0] = func_8002D7C0(NULL, 0, D_82F13B70, 4); + sp4C[1] = func_8002D7C0(NULL, 0, D_82F13B70, 5); + if (i != D_82F210D4) { + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + } else { + func_8001F324(0xFF, 0xFF, 0, 0xFF); + } + // clang-format off + tmp = (temp_s3->unk_00 - (func_8001F5B0(0, 0, sp4C[i]) / 2)) + 0x74; func_8001F1E8(tmp, temp_s3->unk_02 + (i * 0x1C) + 0x2C, sp4C[i]); + // clang-format on + } + + func_8001F444(); +} + +void func_82F094B4(unk_D_82F20A40* arg0) { + UNUSED s32 pad; + char* sp48; + unk_D_82F20A40_00E* temp_s0 = &arg0->unk_36; + Color_RGB8 sp40 = { 0x64, 0x1E, 0x1E }; + + if (arg0->unk_04 == 0) { + return; + } + + if ((arg0->unk_40 == NULL) || (arg0->unk_44 == NULL)) { + return; + } + + if ((arg0->unk_36.unk_04 != arg0->unk_40->unk_04) || (arg0->unk_36.unk_06 != arg0->unk_40->unk_06)) { + + if ((temp_s0->unk_04 >= 0xE) && (temp_s0->unk_06 >= 0xE)) { + func_8002053C(temp_s0->unk_00, temp_s0->unk_02, temp_s0->unk_04, temp_s0->unk_06, &sp40, &sp40); + } + + if ((temp_s0->unk_04 >= arg0->unk_44->unk_04) && (temp_s0->unk_06 >= arg0->unk_44->unk_06)) { + func_8001F3F4(); + func_8001EBE0(0x10, 0); + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + func_8001F3B4(0x1A); + + switch (arg0->unk_04) { + case 1: + sp48 = func_8002D7C0(NULL, 0, D_82F13B70, 6); + func_8001F1E8((temp_s0->unk_00 + (temp_s0->unk_04 / 2)) - (func_8001F5B0(0, 0, sp48) / 2), + temp_s0->unk_02 + 0x10, sp48); + break; + + case 2: + sp48 = func_8002D7C0(NULL, 0, D_82F13B70, 7); + func_8001F1E8((temp_s0->unk_00 + (temp_s0->unk_04 / 2)) - (func_8001F5B0(0, 0, sp48) / 2), + temp_s0->unk_02 + 0x10, sp48); + break; + + case 3: + sp48 = func_8002D7C0(NULL, 0, D_82F13B70, 8); + func_8001F1E8((temp_s0->unk_00 + (temp_s0->unk_04 / 2)) - (func_8001F5B0(0, 0, sp48) / 2), + temp_s0->unk_02 + 0x10, sp48); + break; + + case 4: + sp48 = func_8002D7C0(NULL, 0, D_82F13B70, 9); + func_8001F1E8((temp_s0->unk_00 + (temp_s0->unk_04 / 2)) - (func_8001F5B0(0, 0, sp48) / 2), + temp_s0->unk_02 + 0x10, sp48); + break; + } + + func_8001F444(); + } + } +} + +void func_82F097D8(s16 arg0, s16 arg1) { + static s16 D_82F13F5C = 0; + + s16 sp86 = ROUND_MAX(2.0f * SINS(D_82F13F5C)); + + gSPDisplayList(gDisplayListHead++, D_8006F518); + gDPLoadTextureBlock(gDisplayListHead++, D_302AC68, G_IM_FMT_RGBA, G_IM_SIZ_16b, 48, 24, 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_8001C330(arg0 + sp86, arg1, 0x30, 0x18, 0, 0, 0x400, 0x400, 0); + func_8001C330((arg0 - sp86) + 0x10, arg1 + 0x28, 0x30, 0x18, 0x600, 0, -0x400, 0x400, 0); + + gDPLoadTextureBlock(gDisplayListHead++, D_302B568, G_IM_FMT_RGBA, G_IM_SIZ_16b, 48, 24, 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_8001C330(arg0 + sp86, arg1 + 0x18, 0x30, 0x18, 0, 0, 0x400, 0x400, 0); + func_8001C330((arg0 - sp86) + 0x10, arg1 + 0x40, 0x30, 0x18, 0x600, 0, -0x400, 0x400, 0); + + gSPDisplayList(gDisplayListHead++, D_8006F630); + + D_82F13F5C += 0x1000; +} + +void func_82F09B70(s16 arg0) { + static s16 D_82F13F60 = 0; + + s16 sp1E; + UNUSED s16 sp1C; + s16 sp1A; + s32 var_v1 = 0; + + switch (arg0) { + case 2: + if (D_82F210D2 != -1) { + var_v1 = 1; + sp1E = (D_82F210D2 * 0x88) + 0x78; + sp1A = 0x154; + } + break; + + case 8: + var_v1 = 1; + sp1E = 0xE4; + sp1A = (D_82F210D4 * 0x1C) + 0x12A; + break; + } + + if (var_v1 != 0) { + s16 sins = SINS(D_82F13F60) * 3.0f; + + func_800207FC(sp1E + sins, sp1A); + } + + D_82F13F60 += 0x1000; +} + +void func_82F09C6C(void) { + UNUSED s32 pad; + s32 i; + MemoryBlock* sp1C = func_80002D10(main_pool_get_available(), 0); + + D_82F210C8 = process_geo_layout(sp1C, D_82F13E8C); + D_82F210CC = process_geo_layout(sp1C, D_82F13E58); + func_80002D60(sp1C); + + D_82F20A40.unk_00 = 0; + D_82F20A40.unk_02 = 0; + D_82F20A40.unk_04 = 0; + + for (i = 0; i < 2; i++) { + D_82F210D8[i] = -1; + } + + D_82F210D8[0] = func_80029080(); + D_82F210D2 = 0; + func_82F07004(D_82F210D8[0]); +} + +void func_82F09D2C(void) { + unk_D_82F20A40* ptr = &D_82F20A40; + + if (ptr->unk_00 == 0) { + return; + } + + switch (ptr->unk_00) { + case 1: + func_82F07A80(ptr, 1); + break; + + case 10: + func_82F07A80(ptr, 0); + break; + + case 2: + func_82F07DEC(ptr); + break; + + case 3: + func_82F08084(ptr); + break; + + case 4: + func_82F081FC(ptr); + break; + + case 5: + func_82F0822C(ptr); + break; + + case 6: + func_82F084EC(ptr); + break; + + case 7: + func_82F0856C(ptr); + break; + + case 8: + func_82F0866C(ptr); + break; + + case 9: + func_82F088F8(ptr); + break; + + case 11: + func_82F08968(ptr); + break; + } + + func_82F077E0(); +} + +void func_82F09E30(void) { + unk_D_82F20A40* ptr = &D_82F20A40; + + if (ptr->unk_00 != 0) { + func_80015348(); + func_82F08B7C(&D_82F20A40); + func_82F08EB4(&D_82F20A40); + func_82F0917C(&D_82F20A40); + func_82F09284(&D_82F20A40); + func_80015094(D_82F210C8); + func_82F09B70(ptr->unk_00); + func_82F094B4(&D_82F20A40); + } +} diff --git a/src/fragments/41/fragment41_291D60.c b/src/fragments/41/fragment41_291D60.c index 2dc559e..773c088 100644 --- a/src/fragments/41/fragment41_291D60.c +++ b/src/fragments/41/fragment41_291D60.c @@ -1,49 +1,813 @@ -#include "global.h" +#include "fragment41.h" +#include "src/1CF30.h" +#include "src/20470.h" +#include "src/232C0.h" +#include "src/2E110.h" +#include "src/49790.h" -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F09EB0.s") +static unk_D_82F210E0 D_82F210E0; +static unk_func_82F00838_sp30_00C* D_82F21120[2]; +static s16 D_82F21128; +static s32 D_82F2112C; +static s32 D_82F21130; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F09F44.s") +s32 func_82F09EB0(unk_func_82F00838_sp30* arg0) { + unk_func_80022C28_ret* sp24; + s32 var_v1; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0A0A8.s") + if (arg0->unk_04 == 0) { + sp24 = func_80022C28(0x20, arg0->unk_02, 0, 1); + } else { + sp24 = func_80022C28(0x21, arg0->unk_02, arg0->unk_04 - 1, 1); + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0A23C.s") + func_80022F24(&arg0->unk_0C->unk_00, arg0->unk_08, sp24); + func_80022D8C(sp24); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0A5F8.s") + var_v1 = func_80024270(arg0->unk_02); + if (var_v1 != 0) { + var_v1 = func_8002431C(arg0->unk_02); + } + return var_v1; +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0A804.s") +s32 func_82F09F44(unk_D_82F210E0* arg0) { + s32 i; + unk_func_82F00838_sp30* ptr; + unk_func_82F00838_sp30 sp30[2]; + s32 sp2C = 0; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0A850.s") + for (i = 0; i < 2; i++) { + func_82F0525C(i, &sp30[i]); + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0A950.s") + if (arg0->unk_06 < 0) { + arg0->unk_06 = 0; + for (i = 0, ptr = &sp30[0]; i < 2; i++, ptr++) { + func_8002447C(ptr->unk_02); + } + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0AA50.s") + if (arg0->unk_08 < 2) { + for (i = 0, ptr = &sp30[0]; i < 2; i++, ptr++) { + if (i < arg0->unk_08) { + continue; + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0AB68.s") + if (func_80023658(ptr->unk_02) != 0) { + arg0->unk_08++; + } else { + break; + } + } + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0ACC4.s") + if (arg0->unk_08 < 2) { + return 0; + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0B2A4.s") + for (i = 0, ptr = &sp30[0]; i < 2; i++, ptr++) { + if (i < arg0->unk_0A) { + continue; + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0B3E0.s") + if (func_82F09EB0(ptr) != 0) { + arg0->unk_0A += 1; + func_800244F4(ptr->unk_02); + } else { + break; + } + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0B7B4.s") + if (arg0->unk_0A == 2) { + sp2C = 1; + } + return sp2C; +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0BBE8.s") +void func_82F0A0A8(s32 arg0) { + UNUSED s32 pad; + unk_D_82F210E0* ptr = &D_82F210E0; + s32 i; + unk_func_82F00838_sp30 sp2C; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0BD38.s") + ptr->unk_00 = 1; + ptr->unk_02 = 0xA; + ptr->unk_04 = 0; + ptr->unk_06 = -1; + ptr->unk_08 = 0; + ptr->unk_0A = 0; + ptr->unk_0C = 0; + ptr->unk_0E = 0; + ptr->unk_10 = -1; + ptr->unk_12 = -1; + if (arg0 != 0) { + ptr->unk_04 |= 1; + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0BE7C.s") + for (i = 0; i < 2; i++) { + func_82F0525C(i, &sp2C); + D_82F21120[i] = &sp2C.unk_0C[sp2C.unk_06]; + } + D_82F21128 = 0; + D_82F2112C = 0; + D_82F21130 = 0; + + for (i = 0; i < 2; i++) { + ptr->unk_14[i].unk_00 = ptr->unk_14[i].unk_02 = 0; + ptr->unk_14[i].unk_04 = 0xC8; + ptr->unk_14[i].unk_06 = 0; + } + + ptr->unk_24.unk_00 = 0; + ptr->unk_24.unk_04 = 0xE8; + ptr->unk_24.unk_06 = 0; + ptr->unk_2C.unk_00 = 0; + ptr->unk_2C.unk_04 = 0x210; + ptr->unk_2C.unk_06 = 0; + ptr->unk_34.unk_00 = 0; + ptr->unk_34.unk_04 = 0xE8; + ptr->unk_34.unk_06 = 0; + ptr->unk_24.unk_02 = 0; + ptr->unk_2C.unk_02 = 0; + ptr->unk_34.unk_02 = 0; + + if (arg0 != 0) { + func_80048B90(0x1E); + } else { + func_80048B90(4); + } +} + +void func_82F0A23C(unk_D_82F210E0* arg0) { + s32 i; + unk_D_82F20A40_00E* ptr; + + arg0->unk_02--; + + for (i = 0; i < 2; i++) { + arg0->unk_14[i].unk_00 = ((i * 0x118) - ((arg0->unk_02 * 0) / 10)) + 0x50; + arg0->unk_14[i].unk_02 = 0x60 - ((arg0->unk_02 * -0x54) / 10); + arg0->unk_14[i].unk_04 = 0xC8 - ((arg0->unk_02 * 0) / 10); + arg0->unk_14[i].unk_06 = 0xA8 - ((arg0->unk_02 * 0xA8) / 10); + } + + ptr = &arg0->unk_24; + if (!(arg0->unk_04 & 1)) { + ptr->unk_00 = 0xCC - ((arg0->unk_02 * 0) / 10); + ptr->unk_02 = 0x11C - ((arg0->unk_02 * -0x38) / 10); + ptr->unk_04 = 0xE8 - ((arg0->unk_02 * 0) / 10); + ptr->unk_06 = 0x70 - ((arg0->unk_02 * 0x70) / 10); + } + + ptr = &arg0->unk_2C; + if (arg0->unk_04 & 1) { + ptr->unk_00 = 0x38 - ((arg0->unk_02 * 0) / 10); + ptr->unk_02 = 0x190 - ((arg0->unk_02 * -0x14) / 10); + ptr->unk_04 = 0x210 - ((arg0->unk_02 * 0) / 10); + ptr->unk_06 = 0x28 - ((arg0->unk_02 * 0x28) / 10); + } + + if (arg0->unk_02 <= 0) { + if (arg0->unk_04 & 1) { + arg0->unk_00 = 3; + arg0->unk_02 = 0x14; + arg0->unk_04 |= 4; + } else { + arg0->unk_00 = 2; + arg0->unk_02 = 0; + arg0->unk_04 |= 6; + } + } +} + +void func_82F0A5F8(unk_D_82F210E0* arg0) { + s32 var_t0 = 0; + s32 var_a2; + s16 tmp; + + if (arg0->unk_04 & 1) { + var_a2 = 3; + } else { + var_a2 = 2; + } + + tmp = D_82F21128; + if (BTN_IS_PRESSED(gPlayer1Controller, BTN_DUP) && (D_82F21128 > 0)) { + D_82F21128--; + } + + if (BTN_IS_PRESSED(gPlayer1Controller, BTN_DDOWN) && (D_82F21128 < (var_a2 - 1))) { + D_82F21128++; + } + + if (D_82F21128 != tmp) { + var_t0 = 0; + func_80048B90(1); + } + + if (BTN_IS_PRESSED(gPlayer1Controller, BTN_A)) { + var_t0 = 1; + } else if (BTN_IS_PRESSED(gPlayer1Controller, BTN_B) && !(arg0->unk_04 & 1)) { + var_t0 = 1; + D_82F21128 = 1; + } + + if (var_t0 != 0) { + if (arg0->unk_04 & 1) { + switch (D_82F21128) { + case 0: + arg0->unk_00 = 5; + arg0->unk_02 = 0xA; + D_82F21130 = 0; + func_80048B90(0x1D); + break; + + case 1: + arg0->unk_00 = 5; + arg0->unk_02 = 0xA; + D_82F21130 = 1; + func_80048B90(0x22); + break; + + default: + arg0->unk_00 = 8; + arg0->unk_02 = 0xA; + arg0->unk_04 &= ~4; + D_82F21130 = 0; + func_80048B90(3); + break; + } + } else { + arg0->unk_00 = 8; + arg0->unk_02 = 0xA; + arg0->unk_04 &= ~6; + if (D_82F21128 == 0) { + D_82F2112C = 1; + func_80048B90(2); + } else { + D_82F2112C = 0; + func_80048B90(3); + } + } + arg0->unk_12 = -1; + } +} + +void func_82F0A804(unk_D_82F210E0* arg0) { + arg0->unk_02--; + if (BTN_IS_PRESSED(gPlayer1Controller, BTN_A)) { + arg0->unk_02 = 0; + } + + if (arg0->unk_02 <= 0) { + arg0->unk_00 = 4; + arg0->unk_02 = 0xA; + } +} + +void func_82F0A850(unk_D_82F210E0* arg0) { + arg0->unk_02--; + arg0->unk_24.unk_00 = 0xA2 - (arg0->unk_02 * 0) / 10; + arg0->unk_24.unk_02 = 0x116 - ((arg0->unk_02 * -0x2E) / 10); + arg0->unk_24.unk_04 = 0x13C - (arg0->unk_02 * 0) / 10; + arg0->unk_24.unk_06 = 0x70 - ((arg0->unk_02 * 0x70) / 10); + if (arg0->unk_02 <= 0) { + arg0->unk_00 = 2; + arg0->unk_02 = 0; + } +} + +void func_82F0A950(unk_D_82F210E0* arg0) { + arg0->unk_02--; + arg0->unk_24.unk_00 = 0xA2 - (arg0->unk_02 * 0) / 10; + arg0->unk_24.unk_02 = 0x144 - ((arg0->unk_02 * 0x2E) / 10); + arg0->unk_24.unk_04 = 0x13C - (arg0->unk_02 * 0) / 10; + arg0->unk_24.unk_06 = -((arg0->unk_02 * -0x70) / 10); + if (arg0->unk_02 <= 0) { + arg0->unk_00 = 6; + arg0->unk_02 = 0xA; + } +} + +void func_82F0AA50(unk_D_82F210E0* arg0) { + arg0->unk_02--; + arg0->unk_34.unk_00 = 0xCC - (arg0->unk_02 * 0) / 10; + arg0->unk_34.unk_02 = 0x134 - ((arg0->unk_02 * -0x1C) / 10); + arg0->unk_34.unk_04 = 0xE8 - (arg0->unk_02 * 0) / 10; + arg0->unk_34.unk_06 = 0x38 - ((arg0->unk_02 * 0x38) / 10); + if (arg0->unk_02 <= 0) { + arg0->unk_00 = 7; + arg0->unk_02 = 5; + arg0->unk_06 = -1; + arg0->unk_08 = 0; + arg0->unk_0A = 0; + arg0->unk_0C = 0; + arg0->unk_0E = 0; + arg0->unk_10 = -1; + } +} + +void func_82F0AB68(unk_D_82F210E0* arg0) { + s32 temp_v0; + unk_func_82F00838_sp30 sp24; + + arg0->unk_02--; + if (arg0->unk_02 <= 0) { + arg0->unk_02 = 0; + if (arg0->unk_0C == 1) { + func_82F0525C(arg0->unk_0A, &sp24); + temp_v0 = func_80023E34(sp24.unk_02); + if (temp_v0 == 1) { + arg0->unk_10 = 1; + } + + if (temp_v0 == 3) { + arg0->unk_10 = 3; + } + + if (temp_v0 == 2) { + arg0->unk_0C = 2; + arg0->unk_0E = 3; + arg0->unk_10 = 0; + } + } + + if (arg0->unk_0C == 2) { + arg0->unk_0E -= 1; + if (arg0->unk_0E <= 0) { + arg0->unk_0C = 0; + arg0->unk_0E = 0; + } + } + + if (arg0->unk_0C == 0) { + if (func_82F09F44(arg0) != 0) { + arg0->unk_00 = 8; + arg0->unk_02 = 0xA; + arg0->unk_04 &= ~4; + arg0->unk_10 = -1; + func_80048B90(9); + } else { + arg0->unk_06 += 1; + arg0->unk_0C = 1; + arg0->unk_10 = 2; + func_82F0525C(arg0->unk_0A, &sp24); + temp_v0 = func_80023E34(sp24.unk_02); + if (temp_v0 == 1) { + arg0->unk_10 = 1; + } + + if (temp_v0 == 3) { + arg0->unk_10 = 3; + } + } + } + } +} + +void func_82F0ACC4(unk_D_82F210E0* arg0) { + unk_D_82F20A40_00E* temp_v1; + s32 i; + + arg0->unk_02--; + + for (i = 0; i < 2; i++) { + arg0->unk_14[i].unk_00 = ((i * 0x118) - ((arg0->unk_02 * 0) / 10)) + 0x50; + arg0->unk_14[i].unk_02 = 0xB4 - ((arg0->unk_02 * 0x54) / 10); + arg0->unk_14[i].unk_04 = 0xC8 - ((arg0->unk_02 * 0) / 10); + arg0->unk_14[i].unk_06 = -((arg0->unk_02 * -0xA8) / 10); + } + + temp_v1 = &arg0->unk_24; + if (arg0->unk_04 & 1) { + if ((temp_v1->unk_04 != 0x13C) || (temp_v1->unk_06 != 0)) { + temp_v1->unk_00 = 0xA2 - ((arg0->unk_02 * 0) / 10); + temp_v1->unk_02 = 0x144 - ((arg0->unk_02 * 0x2E) / 10); + temp_v1->unk_04 = 0x13C - ((arg0->unk_02 * 0) / 10); + temp_v1->unk_06 = -((arg0->unk_02 * -0x70) / 10); + } + } else if ((temp_v1->unk_04 != 0xE8) || (temp_v1->unk_06 != 0)) { + temp_v1->unk_00 = 0xCC - ((arg0->unk_02 * 0) / 10); + temp_v1->unk_02 = 0x154 - ((arg0->unk_02 * 0x38) / 10); + temp_v1->unk_04 = 0xE8 - ((arg0->unk_02 * 0) / 10); + temp_v1->unk_06 = -((arg0->unk_02 * -0x70) / 10); + } + + temp_v1 = &arg0->unk_2C; + if ((arg0->unk_2C.unk_04 != 0x210) || (arg0->unk_2C.unk_06 != 0)) { + temp_v1->unk_00 = 0x38 - ((arg0->unk_02 * 0) / 10); + temp_v1->unk_02 = 0x1A4 - ((arg0->unk_02 * 0x14) / 10); + temp_v1->unk_04 = 0x210 - ((arg0->unk_02 * 0) / 10); + temp_v1->unk_06 = -((arg0->unk_02 * -0x28) / 10); + } + + temp_v1 = &arg0->unk_34; + if ((arg0->unk_34.unk_04 != 0xE8) || (arg0->unk_34.unk_06 != 0)) { + temp_v1->unk_00 = 0xCC - ((arg0->unk_02 * 0) / 10); + temp_v1->unk_02 = 0x150 - ((arg0->unk_02 * 0x1C) / 10); + temp_v1->unk_04 = 0xE8 - ((arg0->unk_02 * 0) / 10); + temp_v1->unk_06 = -((arg0->unk_02 * -0x38) / 10); + } + + if (arg0->unk_02 <= 0) { + arg0->unk_00 = 0; + arg0->unk_02 = 0; + arg0->unk_04 = 0; + } +} + +void func_82F0B2A4(s16 arg0, s16 arg1, s16 arg2) { + UNUSED s32 pad; + u16* img = func_82F05198(arg0); + + gDPLoadTextureBlock(gDisplayListHead++, img, G_IM_FMT_RGBA, G_IM_SIZ_16b, 40, 40, 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_8001C330(arg1, arg2, 0x3C, 0x3C, 0, 0, 0x2AB, 0x2AB, 0); +} + +void func_82F0B3E0(unk_D_82F210E0* arg0) { + unk_D_82F20A40_00E* var_s0; + s32 sp74[2]; + unk_func_82F00838_sp30_00C* temp_s3; + s32 i; + + if (arg0->unk_12 > 0) { + arg0->unk_12--; + } + + for (i = 0; i < 2; i++) { + var_s0 = &arg0->unk_14[i]; + if ((var_s0->unk_04 != 0xC8) || (var_s0->unk_06 != 0)) { + func_82F022DC(var_s0->unk_00, var_s0->unk_02, var_s0->unk_04, var_s0->unk_06); + } + } + + for (i = 0; i < 2; i++) { + if ((arg0->unk_14[i].unk_04 == 0xC8) && (arg0->unk_14[i].unk_06 == 0xA8)) { + sp74[i] = 1; + } else { + sp74[i] = 0; + } + } + + gSPDisplayList(gDisplayListHead++, D_8006F498); + + for (i = 0; i < 2; i++) { + var_s0 = &arg0->unk_14[i]; + if (sp74[i] != 0) { + func_8001C604(var_s0->unk_00, var_s0->unk_02, var_s0->unk_04, var_s0->unk_06, 0x32, 0x32, 0x96, 0xFF); + } + } + + gSPDisplayList(gDisplayListHead++, D_8006F630); + gSPDisplayList(gDisplayListHead++, D_8006F518); + + for (i = 0; i < 2; i++) { + if (sp74[i] != 0) { + func_82F0B2A4(i, arg0->unk_14[i].unk_00 + 0x46, arg0->unk_14[i].unk_02 + 0xA); + } + } + + gSPDisplayList(gDisplayListHead++, D_8006F630); + + func_8001F3F4(); + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + + for (i = 0; i < 2; i++) { + if (sp74[i] != 0) { + temp_s3 = D_82F21120[i]; + var_s0 = &arg0->unk_14[i]; + func_8001EBE0(4, 0); + func_8001F1E8(var_s0->unk_00 + 0xA, var_s0->unk_02 + 0x4A, "No."); + func_8001EBE0(4, 0); + func_8001F1E8(var_s0->unk_00 + 0x26, var_s0->unk_02 + 0x4A, "%03d", temp_s3->unk_00); + func_8001EBE0(8, 0); + func_8001F1E8(var_s0->unk_00 + 0x62, var_s0->unk_02 + 0x46, func_82F00020(temp_s3->unk_00)); + func_8001EBE0(8, 0); + func_8001F1E8(var_s0->unk_00 + 0x10, var_s0->unk_02 + 0x5E, func_8002D7C0(NULL, 0, D_82F13B70, 0x14)); + func_8001F1E8(var_s0->unk_00 + 0x46, var_s0->unk_02 + 0x5E, "/%s", temp_s3->unk_30); + func_8001F1E8(var_s0->unk_00 + 0x10, var_s0->unk_02 + 0x74, func_8002D7C0(NULL, 0, D_82F13B70, 0x15)); + func_8001F1E8(var_s0->unk_00 + 0x46, var_s0->unk_02 + 0x74, "/%s", temp_s3->unk_3B); + func_8001F1E8(var_s0->unk_00 + 0x10, var_s0->unk_02 + 0x8A, "ID%05d", temp_s3->unk_0E); + } + } + + func_8001F444(); +} + +void func_82F0B7B4(unk_D_82F210E0* arg0) { + s32 i; + unk_D_82F20A40_00E* var_s4 = &arg0->unk_24; + Color_RGB8* var_v0; + s16 temp_ft3; + s16 arg2; + Color_RGB8 sp64 = { 0x1E, 0x1E, 0x82 }; + Color_RGB8 sp60 = { 0x64, 0x1E, 0x1E }; + + if (arg0->unk_04 & 1) { + if ((var_s4->unk_04 == 0x13C) && (var_s4->unk_06 == 0)) { + return; + } + } else if ((var_s4->unk_04 == 0xE8) && (var_s4->unk_06 == 0)) { + return; + } + + if (arg0->unk_04 & 1) { + var_v0 = &sp60; + } else { + var_v0 = &sp64; + } + + if ((var_s4->unk_04 >= 0xE) && (var_s4->unk_06 >= 0xE)) { + func_8002053C(var_s4->unk_00, var_s4->unk_02, var_s4->unk_04, var_s4->unk_06, var_v0, var_v0); + } + + if (arg0->unk_04 & 1) { + if ((var_s4->unk_04 != 0x13C) || (var_s4->unk_06 != 0x70)) { + return; + } + } else if ((var_s4->unk_04 != 0xE8) || (var_s4->unk_06 != 0x70)) { + return; + } + + { + static s16 D_82F13F78 = 0; + + temp_ft3 = SINS(D_82F13F78) * 3.0f; + + if (arg0->unk_04 & 1) { + func_800207FC(var_s4->unk_00 + temp_ft3 + 0x10, var_s4->unk_02 + (D_82F21128 * 0x1C) + 0x14); + } else { + func_800207FC(var_s4->unk_00 + temp_ft3 + 0x18, var_s4->unk_02 + (D_82F21128 * 0x1C) + 0x32); + } + + func_8001F3F4(); + func_8001EBE0(0x10, 0); + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + + if (arg0->unk_04 & 1) { + char* sp54[3]; + for (i = 0; i < 3; i++) { + sp54[0] = func_8002D7C0(NULL, 0, D_82F13B70, 0x1A); + sp54[1] = func_8002D7C0(NULL, 0, D_82F13B70, 0x1B); + sp54[2] = func_8002D7C0(NULL, 0, D_82F13B70, 0x1C); + func_8001F1E8(var_s4->unk_00 + 0x38, var_s4->unk_02 + i * 0x1C + 0x10, sp54[i]); + } + } else { + char* temp_v0 = func_8002D7C0(NULL, 0, D_82F13B70, 0x16); + char* sp48[2]; + + arg2 = func_8001F5B0(0, 0, temp_v0); + func_8001F1E8((var_s4->unk_00 + (var_s4->unk_04 / 2)) - (arg2 / 2), var_s4->unk_02 + 0x10, temp_v0); + + for (i = 0; i < 2; i++) { + sp48[0] = func_8002D7C0(NULL, 0, D_82F13B70, 0x17); + sp48[1] = func_8002D7C0(NULL, 0, D_82F13B70, 0x18); + if (i != D_82F21128) { + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + } else { + func_8001F324(0xFF, 0xFF, 0, 0xFF); + } + arg2 = func_8001F5B0(0, 0, sp48[i]); + func_8001F1E8((var_s4->unk_00 + (var_s4->unk_04 / 2)) - (arg2 / 2), var_s4->unk_02 + i * 0x1C + 0x2C, + sp48[i]); + } + } + + func_8001F444(); + D_82F13F78 += 0x1000; + } +} + +void func_82F0BBE8(unk_D_82F210E0* arg0) { + s32 sp34; + unk_D_82F20A40_00E* temp_s0 = &arg0->unk_2C; + + if ((arg0->unk_2C.unk_04 != 0x210) || (arg0->unk_2C.unk_06 != 0)) { + func_82F037EC(temp_s0->unk_00, temp_s0->unk_02, temp_s0->unk_04, temp_s0->unk_06, 0x1E, 0x1E, 0x82, 0xFF); + if ((temp_s0->unk_04 == 0x210) && (temp_s0->unk_06 == 0x28)) { + func_8001F3F4(); + func_8001EBE0(0x10, 0); + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + sp34 = func_8001F5B0(0, 0, func_8002D7C0(NULL, 0, D_82F13B70, 0x1D)) / 2; + func_8001F1E8((temp_s0->unk_00 + (temp_s0->unk_04 / 2)) - sp34, temp_s0->unk_02 + 8, + func_8002D7C0(NULL, 0, D_82F13B70, 0x1D)); + func_8001F444(); + } + } +} + +void func_82F0BD38(unk_D_82F210E0* arg0) { + unk_D_82F20A40_00E* temp_s0 = &arg0->unk_34; + char* sp40; + UNUSED s32 pad; + Color_RGB8 sp38 = { 0x64, 0x1E, 0x1E }; + + if ((arg0->unk_34.unk_04 != 0xE8) || (arg0->unk_34.unk_06 != 0)) { + if ((temp_s0->unk_04 >= 0xE) && (temp_s0->unk_06 >= 0xE)) { + func_8002053C(temp_s0->unk_00, temp_s0->unk_02, temp_s0->unk_04, temp_s0->unk_06, &sp38, &sp38); + } + + if ((temp_s0->unk_04 == 0xE8) && (temp_s0->unk_06 == 0x38)) { + func_8001F3F4(); + func_8001EBE0(0x10, 0); + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + sp40 = func_8002D7C0(NULL, 0, D_82F13B70, 0x1E); + func_8001F1E8((temp_s0->unk_00 + (temp_s0->unk_04 / 2)) - (func_8001F5B0(0, 0, sp40) / 2), + temp_s0->unk_02 + 0x10, sp40); + func_8001F444(); + } + } +} + +void func_82F0BE7C(s16 arg0, s16 arg1, s16 arg2, s16 arg3) { + Color_RGB8 sp24 = { 0x58, 0x08, 0x00 }; + Color_RGB8 sp20 = { 0x58, 0x08, 0x00 }; + + func_8002053C(arg0, arg1, arg2, arg3, &sp24, &sp20); +} + +#ifdef NON_MATCHING +void func_82F0BEF8(unk_D_82F210E0* arg0) { + static s16 D_82F13F88 = 0; + + s32 pad[2]; + char sp38[64]; + s32 pad2[2]; + unk_func_82F00838_sp30 sp20; + + if (arg0->unk_08 < 2) { + func_82F0525C(arg0->unk_08, &sp20); + } else { + func_82F0525C(arg0->unk_0A, &sp20); + } + + if (arg0->unk_10 == -1) { + return; + } + + func_82F0BE7C(0x6E, 0x72, 0x1A4, 0x114); + func_8001F3F4(); + func_8001EBE0(0x10, 0); + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + + switch (arg0->unk_10) { + case 0: + func_8001F470(); + func_8001F36C(0xFF, 0xF1, 0x78, 0xFF); + func_8001F1E8(0xEC, 0xA8, func_8002D7C0(NULL, 0, D_82F13B70, 0x1F)); + func_8001F4C4(); + break; + + case 2: + func_8001F470(); + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + func_8001F36C(0xFF, 0xF1, 0x78, 0xFF); + // func_8002D600(1, (((((((((tmp) & 0xFFFFFFFFFFFFFFFF) & 0xFFFFFFFFFFFFFFFF) & 0xFFFFFFFFFFFFFFFF) & + // 0xFFFFFFFFFFFFFFFF) & 0xFFFFFFFFFFFFFFFF) & 0xFFFFFFFFFFFFFFFF) & 0xFFFFFFFFFFFFFFFF) & + // 0xFFFFFFFFFFFFFFFF) & 0xFFFFFFFFFFFFFFFF); + func_8002D600(1, sp20.unk_02 + 1); + func_8001F1E8(0xB0, 0x90, func_8002D7C0(sp38, sizeof(sp38), D_82F13B70, 0x20)); + func_8001F4C4(); + break; + + case 3: + func_8001F470(); + func_8001F36C(0xFF, 0xF1, 0x78, 0xFF); + func_8001F1E8(0x80, 0x90, func_8002D7C0(NULL, 0, D_82F13B70, 0x21)); + func_8001F4C4(); + break; + } + + if (arg0->unk_10 != 0) { + func_8001F470(); + func_8001F36C(0xFF, 0xF1, 0x78, 0xFF); + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + func_8001F3B4(0x24); + func_8001F1E8(0x80, 0xF0, func_8002D7C0(NULL, 0, D_82F13B70, 0x22)); + } + + func_8001F444(); + D_82F13F88 += 0x800; +} +#else +static s16 D_82F13F88 = 0; #pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0BEF8.s") +#endif -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0C16C.s") +s32 func_82F0C16C(void) { + return D_82F210E0.unk_00; +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0C178.s") +s32 func_82F0C178(void) { + return D_82F2112C; +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0C184.s") +s32 func_82F0C184(void) { + return D_82F21130; +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0C190.s") +void func_82F0C190(void) { + unk_D_82F210E0* ptr = &D_82F210E0; + s32 i; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0C254.s") + ptr->unk_00 = 0; + ptr->unk_02 = 0; + ptr->unk_04 = 0; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0C320.s") + for (i = 0; i < 2; i++) { + D_82F210E0.unk_14[i].unk_00 = D_82F210E0.unk_14[i].unk_02 = 0; + D_82F210E0.unk_14[i].unk_04 = 0xC8; + D_82F210E0.unk_14[i].unk_06 = 0; + } + + ptr->unk_24.unk_00 = 0; + ptr->unk_24.unk_04 = 0xE8; + ptr->unk_24.unk_06 = 0; + ptr->unk_2C.unk_00 = 0; + ptr->unk_2C.unk_04 = 0x210; + ptr->unk_2C.unk_06 = 0; + ptr->unk_34.unk_00 = 0; + ptr->unk_34.unk_04 = 0xE8; + ptr->unk_34.unk_06 = 0; + + ptr->unk_24.unk_02 = 0; + ptr->unk_2C.unk_02 = ptr->unk_34.unk_02 = 0; + + for (i = 0; i < 2; i++) { + D_82F21120[i] = NULL; + } +} + +void func_82F0C254(void) { + unk_D_82F210E0* ptr = &D_82F210E0; + + if (ptr->unk_00 == 0) { + return; + } + + switch (ptr->unk_00) { + case 1: + func_82F0A23C(&D_82F210E0); + break; + + case 2: + func_82F0A5F8(&D_82F210E0); + break; + + case 3: + func_82F0A804(&D_82F210E0); + break; + + case 4: + func_82F0A850(&D_82F210E0); + break; + + case 5: + func_82F0A950(&D_82F210E0); + break; + + case 6: + func_82F0AA50(&D_82F210E0); + break; + + case 7: + func_82F0AB68(&D_82F210E0); + break; + + case 8: + func_82F0ACC4(&D_82F210E0); + break; + } +} + +void func_82F0C320(void) { + static s16 D_82F13F8C[] = { 0x32, 0x14A }; + + unk_D_82F210E0* ptr = &D_82F210E0; + s32 i; + + if (ptr->unk_00 != 0) { + if (ptr->unk_12 != 0) { + func_82F0B3E0(&D_82F210E0); + } + + func_82F0B7B4(&D_82F210E0); + func_82F0BBE8(&D_82F210E0); + func_82F0BD38(&D_82F210E0); + + if (ptr->unk_04 & 2) { + func_82F097D8(0x120, 0x8C); + } + + if (ptr->unk_04 & 4) { + for (i = 0; i < 2; i++) { + func_82F043A4(i, D_82F13F8C[i], 0x2A); + } + } + func_82F0BEF8(&D_82F210E0); + } +} diff --git a/src/fragments/41/fragment41_2942C0.c b/src/fragments/41/fragment41_2942C0.c index 493e7aa..e004805 100644 --- a/src/fragments/41/fragment41_2942C0.c +++ b/src/fragments/41/fragment41_2942C0.c @@ -1,152 +1,2107 @@ -#include "global.h" +#include "fragment41.h" +#include "src/17300.h" +#include "src/19840.h" +#include "src/1AB70.h" +#include "src/1C720.h" +#include "src/1CF30.h" +#include "src/22630.h" +#include "src/232C0.h" +#include "src/2E110.h" +#include "src/49790.h" +#include "src/6BC0.h" +#include "src/math_util.h" +#include "src/memory.h" +#include "src/stage_loader.h" -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0C410.s") +static unk_D_82F21140 D_82F21140; +static unk_D_80068BB0* D_82F2115C; +static unk_D_82F21160 D_82F21160[2]; +static unk_D_82F211A0 D_82F211A0[2]; +static unk_D_82F21238 D_82F21238; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0C630.s") +void func_82F0C410(s16 arg0, s16 arg1, s16 arg2, s16 arg3, s16 arg4, s16 arg5, s16 arg6, s16 arg7, s32 arg8) { + gSPScisTextureRectangle(gDisplayListHead++, arg0 << 2, arg1 << 2, (arg0 + arg2) << 2, (arg1 + arg3) << 2, 0, arg4, + arg5, arg6, arg7); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0C658.s") +void func_82F0C630(void) { + unk_D_82F211A0* var_v1; + s32 i; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0C784.s") + for (i = 0, var_v1 = &D_82F211A0[0]; i < 2; i++, var_v1++) { + var_v1->unk_00 = 0; + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0C7FC.s") +void func_82F0C658(s32 arg0, s16 arg1) { + s32 i; + unk_D_82F211A0* temp_v0 = &D_82F211A0[arg0]; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0C8EC.s") + temp_v0->unk_00 = arg1; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0C958.s") + switch (arg1) { + case 1: + temp_v0->unk_02 = (arg0 * 0x5A) + 0xFA; + temp_v0->unk_04 = 0x5A; + temp_v0->unk_06 = 0x28; + temp_v0->unk_0C = 0; + temp_v0->unk_0E = 0; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0CA7C.s") + for (i = 0; i < 10; i++) { + temp_v0->unk_10[i].unk_00 = temp_v0->unk_10[i].unk_02 = 0; + temp_v0->unk_10[i].unk_04 = 0; + } + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0CB90.s") + case 2: + temp_v0->unk_06 = 0x1E; + temp_v0->unk_0A = 0; + temp_v0->unk_0C = 0xFF; + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0CC3C.s") + case 3: + temp_v0->unk_06 = 0; + temp_v0->unk_0A = 0; + temp_v0->unk_08 = 0; + temp_v0->unk_0C = 0xFF; + break; + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0D084.s") +void func_82F0C784(unk_D_82F211A0* arg0) { + arg0->unk_06--; + arg0->unk_0C = 0xFF - ((arg0->unk_06 * 0xFF) / 40); + if (arg0->unk_06 <= 0) { + func_82F0C658(arg0 - D_82F211A0, 2); + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0D090.s") +void func_82F0C7FC(unk_D_82F211A0* arg0) { + s32 sp1C; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0D160.s") + if (arg0->unk_06 > 0) { + arg0->unk_06--; + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0D27C.s") + arg0->unk_0A += 0x200; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0D2F4.s") + arg0->unk_0C = ROUND_MAX(((COSS(arg0->unk_0A) * 0.5f) + 0.5f) * 255.0f); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0D3F4.s") + if ((arg0->unk_06 <= 0) && (arg0->unk_0C >= 0xFF)) { + sp1C = arg0 - D_82F211A0; + func_82F0C658(sp1C, 3); + if (sp1C == 0) { + func_80048B90(0x01200006); + } + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0D428.s") +void func_82F0C8EC(unk_D_82F211A0* arg0) { + s32 i; + unk_D_82F211A0_010* var_v0 = NULL; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0D51C.s") + for (i = 0; i < 10; i++) { + if (arg0->unk_10[i].unk_04 == 0) { + break; + } + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0D64C.s") + if (i < 10) { + var_v0 = &arg0->unk_10[i]; + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0D6D0.s") + if (var_v0 != NULL) { + var_v0->unk_00 = arg0->unk_02; + var_v0->unk_02 = arg0->unk_04; + var_v0->unk_04 = 0x14; + arg0->unk_0E++; + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0D76C.s") +void func_82F0C958(unk_D_82F211A0* arg0) { + s32 i; + unk_D_82F211A0_010* ptr; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0D834.s") + for (i = 0, ptr = &arg0->unk_10[0]; i < 10; i++, ptr++) { + if (ptr->unk_04 != 0) { + ptr->unk_04--; + if (ptr->unk_04 <= 0) { + arg0->unk_0E--; + } + } + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0DA60.s") +void func_82F0CA7C(unk_D_82F211A0* arg0) { + s32 idx = arg0 - D_82F211A0; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0DCF4.s") + if (arg0->unk_0E > 0) { + func_82F0C958(arg0); + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0DD90.s") + if ((arg0->unk_02 < 0xA0) || (arg0->unk_02 >= 0x1C3)) { + if (arg0->unk_0E == 0) { + arg0->unk_00 = 0; + func_82F0EFC4(idx ^ 1, 6); + } + } else { + if (arg0->unk_06 > 0) { + arg0->unk_06--; + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0E5C8.s") + if ((arg0->unk_06 == 0) && (arg0->unk_0E < 0xA)) { + func_82F0C8EC(arg0); + arg0->unk_06 = 2; + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0E97C.s") + if (idx != 0) { + arg0->unk_08--; + } else { + arg0->unk_08++; + } + + arg0->unk_02 += arg0->unk_08; + } +} + +void func_82F0CB90(void) { + s32 i; + unk_D_82F211A0* var_s0 = &D_82F211A0[0]; + + for (i = 0; i < 2; i++, var_s0++) { + switch (var_s0->unk_00) { + case 1: + func_82F0C784(var_s0); + break; + + case 2: + func_82F0C7FC(var_s0); + break; + + case 3: + func_82F0CA7C(var_s0); + break; + } + } +} + +void func_82F0CC3C(void) { + s32 i; + s32 j; + s32 sp84 = 0; + s16 var_s0; + u16* temp_s0; + unk_D_82F211A0* var_s4; + s16 v; + s16 tmp; + + for (i = 0, var_s4 = &D_82F211A0[0]; i < 2; i++, var_s4++) { + if (var_s4->unk_00 != 0) { + temp_s0 = func_82F05198(i); + + if (sp84 == 0) { + sp84 = 1; + func_800060E0(&gDisplayListHead, 0xEC, 0x50, 0xAA, 0x50); + } + + gDPPipeSync(gDisplayListHead++); + + gDPSetEnvColor(gDisplayListHead++, 255, 255, 255, var_s4->unk_0C); + gDPLoadTextureBlock(gDisplayListHead++, temp_s0, G_IM_FMT_RGBA, G_IM_SIZ_16b, 40, 40, 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); + + v = 60; + + if (var_s4->unk_00 == 1) { + for (j = 0; j < v; j++) { + var_s0 = ((MathUtil_Random16() % 33) * var_s4->unk_06) / 40; + if (MathUtil_Random16() & 0x8000) { + var_s0 = -var_s0; + } + func_8001C330(var_s4->unk_02 + var_s0, var_s4->unk_04 + j, 0x3C, 1, 0, + ROUND_MAX((j * 32.0f) / 1.5f), 0x2AB, 0x2AB, 0); + } + } else { + func_8001C330(var_s4->unk_02, var_s4->unk_04, 0x3C, 0x3C, 0, 0, 0x2AB, 0x2AB, 0); + } + + if (var_s4->unk_0E == 0) { + } else { + for (j = 0; j < 10; j++) { + if (var_s4->unk_10[j].unk_04 == 0) { + continue; + } + + tmp = (var_s4->unk_10[j].unk_04 * 0xFF) / 20; + + gDPPipeSync(gDisplayListHead++); + gDPSetEnvColor(gDisplayListHead++, 255, 255, 255, tmp); + + func_8001C330(var_s4->unk_10[j].unk_00, var_s4->unk_10[j].unk_02, 0x3C, 0x3C, 0, 0, 0x2AB, 0x2AB, + 0); + } + } + } + } + + if (sp84 != 0) { + func_800060E0(&gDisplayListHead, 0, 0, 0x280, 0x1E0); + } +} + +void func_82F0D084(void) { + D_82F21238.unk_02 = 0; +} + +void func_82F0D090(unk_D_82F21238* arg0, s32 arg1) { + arg0->unk_28 = func_80019760(1); + arg0->unk_2C = func_8001B1FC(arg0->unk_28, 0xC0, 0xC0, 0, 0, 0xC0, 0xC0, NULL); + arg0->unk_2C->unk_00 &= ~2; + func_8001B2D8(arg0->unk_2C, arg0->unk_24, 1); + + if (arg1 != 0) { + arg0->unk_06 = 2; + arg0->unk_2C->unk_00 &= ~4; + } else { + arg0->unk_06 = 1; + arg0->unk_2C->unk_00 |= 4; + } + func_8001BD04(arg0->unk_2C->unk_24, arg0->unk_06); +} + +void func_82F0D160(s16 arg0) { + unk_func_82F00838_sp30 sp20; + unk_D_82F21238* ptr = &D_82F21238; + + main_pool_push_state('intr'); + func_82F0525C(arg0, &sp20); + D_82F21238.unk_00 = arg0; + D_82F21238.unk_02 = 1; + D_82F21238.unk_04 = sp20.unk_02; + D_82F21238.unk_06 = 1; + D_82F21238.unk_08 = 0; + ptr->unk_0A = MathUtil_Random16() % 2; + ptr->unk_0C = 0; + ptr->unk_0E = 0x140; + ptr->unk_10 = 0xC4; + ptr->unk_12 = 0; + ptr->unk_14 = 0; + ptr->unk_16 = 0xFF; + ptr->unk_20 = 0; + ptr->unk_24 = &sp20.unk_0C[sp20.unk_06]; + func_82F0D090(&D_82F21238, 0); + ptr->unk_30.unk_00 = ptr->unk_30.unk_02 = 0; + ptr->unk_30.unk_04 = ptr->unk_30.unk_06 = -1; + + func_80048B90(4); + func_800256F4(ptr->unk_04, ptr->unk_24->unk_00.unk_00, 3); +} + +void func_82F0D27C(unk_D_82F21238* arg0) { + unk_D_86002F58_004_000* sp24 = arg0->unk_2C->unk_24; + + if ((func_80017514(sp24) != 0) && (arg0->unk_06 == 2)) { + arg0->unk_06 = 1; + arg0->unk_2C->unk_00 |= 4; + func_8001BD04(sp24, arg0->unk_06); + } + arg0->unk_20 = func_8001B9D4(arg0->unk_2C); +} + +void func_82F0D2F4(unk_D_82F21238* arg0) { + if (arg0->unk_12 < 0xC0) { + arg0->unk_12 += 0x20; + if (arg0->unk_12 >= 0xC1) { + arg0->unk_12 = 0xC0; + } + } else { + arg0->unk_14 += 0x20; + if (arg0->unk_14 >= 0xC1) { + arg0->unk_14 = 0xC0; + } + } + + arg0->unk_0E = ((arg0->unk_12 * -0x60) / 192) + 0x140; + arg0->unk_10 = ((arg0->unk_14 * -0x60) / 192) + 0xC4; + + func_82F0D27C(arg0); + + if ((arg0->unk_12 == 0xC0) && (arg0->unk_14 == 0xC0)) { + arg0->unk_02 = 2; + arg0->unk_0C = 0; + arg0->unk_0E = 0xE0; + arg0->unk_10 = 0x64; + } +} + +s32 func_82F0D3F4(s32 arg0) { + s32 var_v1 = 0; + + if ((arg0 == 0x40) || (arg0 == 0x43) || (arg0 == 0x4B) || (arg0 == 0x5D)) { + var_v1 = 1; + } + return var_v1; +} + +void func_82F0D428(unk_D_82F21238* arg0) { + func_82F0D27C(arg0); + + if (arg0->unk_08 != 0) { + arg0->unk_0C -= 1; + if (arg0->unk_0C <= 0) { + arg0->unk_0C = 0; + } else { + return; + } + } + + if (BTN_IS_PRESSED(gPlayer1Controller, BTN_A)) { + if (func_82F0D3F4(arg0->unk_24->unk_00.unk_00) != 0) { + arg0->unk_02 = 3; + arg0->unk_08 = 1; + arg0->unk_0C = 0x3C; + arg0->unk_18 = 0; + arg0->unk_1A = 0x800; + arg0->unk_1C = 0; + func_80048B90(2); + func_80048B90(0x01200007); + } else { + arg0->unk_02 = 6; + arg0->unk_0C = 0xA; + if (arg0->unk_08 != 0) { + func_80048B90(0x01200009); + } else { + func_80048B90(2); + } + } + } +} + +void func_82F0D51C(unk_D_82F21238* arg0) { + arg0->unk_0C--; + func_82F0D27C(arg0); + arg0->unk_16 = (arg0->unk_0C * 0xFF) / 60; + + switch (arg0->unk_0A) { + case 1: + break; + + case 0: + arg0->unk_1C = ((0x3C - arg0->unk_0C) * 0xF0) / 60; + arg0->unk_1A = 0x1000 - ((arg0->unk_0C << 0xB) / 60); + arg0->unk_18 += 0x1000; + break; + } + + if (arg0->unk_0C <= 0) { + arg0->unk_02 = 4; + arg0->unk_0C = 1; + arg0->unk_16 = 0; + arg0->unk_20 = 0; + } +} + +s32 func_82F0D64C(s16 arg0, s8* arg1) { + s32 sp64; + s8* var_v1; + char sp20[64]; + + sp64 = 1; + func_80021C80(sp20, func_82F00020(arg0)); + + var_v1 = sp20; + while (*var_v1 != '\x00') { + if (*var_v1 != *arg1) { + sp64 = 0; + break; + } + var_v1++; + arg1++; + } + + return sp64; +} + +void func_82F0D6D0(s16 arg0, unk_func_80026268_arg0* arg1) { + s16 sp2E = 0; + + if (func_82F0D3F4(arg1->unk_00.unk_00) != 0) { + sp2E = arg1->unk_00.unk_00; + arg1->unk_00.unk_00++; + } + + if (sp2E != 0) { + if (func_82F0D64C(sp2E, arg1->unk_30) != 0) { + func_80021C80(arg1->unk_30, func_82F00020(arg1->unk_00.unk_00)); + } + func_80022338(arg1); + func_800256F4(arg0, arg1->unk_00.unk_00, 3); + } +} + +void func_82F0D76C(unk_D_82F21238* arg0) { + arg0->unk_0C--; + if (arg0->unk_0C <= 0) { + main_pool_pop_state('intr'); + main_pool_push_state('intr'); + + arg0->unk_02 = 5; + arg0->unk_0C = 0x3C; + arg0->unk_16 = 0; + if (arg0->unk_0A == 0) { + arg0->unk_1C = 0xF0; + } + arg0->unk_20 = 0; + func_82F0D6D0(arg0->unk_04, arg0->unk_24); + func_82F05210(arg0->unk_00, arg0->unk_24); + func_82F0D090(arg0, 1); + arg0->unk_30.unk_00 = 0x38; + arg0->unk_30.unk_02 = 0x168; + arg0->unk_30.unk_04 = 0x210; + arg0->unk_30.unk_06 = 0; + func_80048B90(0x01200008); + } +} + +void func_82F0D834(unk_D_82F21238* arg0) { + s16 var_v1; + unk_D_82F20A40_00E* ptr = &arg0->unk_30; + + func_82F0D27C(arg0); + arg0->unk_0C--; + arg0->unk_16 = ((0x3C - arg0->unk_0C) * 0xFF) / 60; + + switch (arg0->unk_0A) { + case 1: + break; + + case 0: + arg0->unk_1C = (arg0->unk_0C * 0xF0) / 60; + arg0->unk_1A = 0x800 - ((arg0->unk_0C * -0x800) / 60); + arg0->unk_18 += 0x1000; + break; + } + + var_v1 = arg0->unk_0C; + if (var_v1 >= 0xB) { + var_v1 = 0xA; + } + + ptr->unk_00 = 0x38 - (var_v1 * 0) / 10; + ptr->unk_02 = 0x154 - ((var_v1 * -0x14) / 10); + ptr->unk_04 = 0x210 - (var_v1 * 0) / 10; + ptr->unk_06 = 0x28 - ((var_v1 * 0x28) / 10); + + if (arg0->unk_0C <= 0) { + arg0->unk_02 = 2; + arg0->unk_0C = 0x5A; + arg0->unk_16 = 0xFF; + } +} + +void func_82F0DA60(unk_D_82F21238* arg0) { + unk_D_82F20A40_00E* temp_v0_2 = &arg0->unk_30; + + if (arg0->unk_0C > 0) { + arg0->unk_0C--; + } + + if (arg0->unk_30.unk_04 != -1) { + temp_v0_2->unk_00 = 0x38 - ((arg0->unk_0C * 0) / 10); + temp_v0_2->unk_02 = 0x168 - ((arg0->unk_0C * 0x14) / 10); + temp_v0_2->unk_04 = 0x210 - ((arg0->unk_0C * 0) / 10); + temp_v0_2->unk_06 = -((arg0->unk_0C * -0x28) / 10); + } + + if (arg0->unk_14 > 0) { + arg0->unk_14 -= 0x20; + if (arg0->unk_14 < 0) { + arg0->unk_14 = 0; + } + } else { + arg0->unk_12 -= 0x20; + if (arg0->unk_12 < 0) { + arg0->unk_12 = 0; + } + } + + arg0->unk_0E = ((arg0->unk_12 * -0x60) / 192) + 0x140; + arg0->unk_10 = ((arg0->unk_14 * -0x60) / 192) + 0xC4; + func_82F0D27C(arg0); + + if ((arg0->unk_12 == 0) && (arg0->unk_14 == 0)) { + if (arg0->unk_0C <= 0) { + arg0->unk_02 = 0; + arg0->unk_0C = 0; + arg0->unk_20 = 0; + + temp_v0_2->unk_00 = temp_v0_2->unk_02 = 0; + temp_v0_2->unk_04 = temp_v0_2->unk_06 = -1; + + main_pool_pop_state('intr'); + } + } +} + +void func_82F0DCF4(void) { + switch (D_82F21238.unk_02) { + case 0: + break; + + case 1: + func_82F0D2F4(&D_82F21238); + break; + + case 2: + func_82F0D428(&D_82F21238); + break; + + case 3: + func_82F0D51C(&D_82F21238); + break; + + case 4: + func_82F0D76C(&D_82F21238); + break; + + case 5: + func_82F0D834(&D_82F21238); + break; + + case 6: + func_82F0DA60(&D_82F21238); + break; + } +} + +void func_82F0DD90(s16 arg0, s16 arg1, s16 arg2) { + static Gfx D_82F13F90[] = { + gsDPPipeSync(), + gsDPSetCycleType(G_CYC_2CYCLE), + gsDPSetRenderMode(G_RM_PASS, G_RM_XLU_SURF2), + gsDPSetCombineLERP(TEXEL0, TEXEL1, PRIM_LOD_FRAC, TEXEL1, TEXEL0, TEXEL1, PRIM_LOD_FRAC, TEXEL1, PRIMITIVE, + ENVIRONMENT, COMBINED, ENVIRONMENT, COMBINED, 0, PRIMITIVE, ENVIRONMENT), + gsDPSetPrimColor(0, 0x80, 0, 0, 255, 0), + gsSPEndDisplayList(), + }; + static f32 D_82F13FC0 = 0.0f; + static f32 D_82F13FC4 = 0.0f; + static f32 D_82F13FC8 = 0.0f; + static f32 D_82F13FCC = 0.0f; + + UNUSED s32 pad[2]; + f32 temp_fa0; + f32 temp_fa4; + f32 temp_fa8; + f32 temp_faC; + + gSPDisplayList(gDisplayListHead++, D_82F13F90); + gDPSetEnvColor(gDisplayListHead++, 0, 0, 50, (arg2 << 7) / 255); + + gDPLoadMultiBlock_4b(gDisplayListHead++, D_3026368, 0x0100, 1, G_IM_FMT_I, 32, 32, 0, G_TX_NOMIRROR | G_TX_WRAP, + G_TX_NOMIRROR | G_TX_WRAP, 5, 5, 1, G_TX_NOLOD); + temp_fa0 = D_82F13FC0 + 31.0f; + temp_fa4 = D_82F13FC4 + 31.0f; + gDPSetTileSize(gDisplayListHead++, 1, D_82F13FC0 * 4.0f, D_82F13FC4 * 4.0f, temp_fa0 * 4.0f, temp_fa4 * 4.0f); + + gDPLoadTextureBlock_4b(gDisplayListHead++, D_3026168, G_IM_FMT_I, 32, 32, 0, G_TX_NOMIRROR | G_TX_WRAP, + G_TX_NOMIRROR | G_TX_WRAP, 5, 5, G_TX_NOLOD, 1); + temp_fa8 = D_82F13FC8 + 31.0f; + temp_faC = D_82F13FCC + 31.0f; + gDPSetTileSize(gDisplayListHead++, G_TX_RENDERTILE, D_82F13FC8 * 4.0f, D_82F13FCC * 4.0f, temp_fa8 * 4.0f, + temp_faC * 4.0f); + + func_82F0C410(arg0, arg1, 0xC0, 0xC0, 0, 0, 0xAB, 0xAB, 0x100000); + + D_82F13FC0 -= 0.25f; + if (D_82F13FC0 < 0.0f) { + D_82F13FC0 += 32.0f; + } + + D_82F13FC4 -= 0.25f; + if (D_82F13FC4 < 0.0f) { + D_82F13FC4 += 32.0f; + } + + D_82F13FC8 += 0.25f; + if (D_82F13FC8 >= 32.0f) { + D_82F13FC8 -= 32.0f; + } + + D_82F13FCC -= 0.5f; + if (D_82F13FCC < 0.0f) { + D_82F13FCC += 32.0f; + } +} + +void func_82F0E5C8(s16 arg0, s16 arg1, s16 arg2, s16 arg3) { + s16 tmp = (arg1 + (arg3 / 2)) - 8; + + gSPDisplayList(gDisplayListHead++, D_8006F518); + + func_8001C6AC(arg0 - 0xD, arg1 - 0xD, 0x10, 0x10, D_3026568, 0x10, 0); + func_8001C330(arg0 - 0xD, arg1 + 3, 0x10, (arg3 / 2) - 3, 0, 0x1E0, 0x400, 0, 0); + func_8001C6AC((arg0 + arg2) - 3, arg1 - 0xD, 0x10, 0x10, D_3026768, 0x10, 0); + func_8001C330(arg0 + 3, arg1 - 0xD, arg2 - 6, 0x10, 0, 0, 0, 0x400, 0); + func_8001C330((arg0 + arg2) - 3, arg1 + 3, 0x10, (arg3 / 2) - 3, 0, 0x1E0, 0x400, 0, 0); + func_8001C6AC(arg0 - 0xD, (arg1 + arg3) - 3, 0x10, 0x10, D_3026D68, 0x10, 0); + + func_8001C330(arg0 - 0xD, tmp + 8, 0x10, (arg3 / 2) - 3, 0, 0, 0x400, 0, 0); + func_8001C6AC((arg0 + arg2) - 3, (arg1 + arg3) - 3, 0x10, 0x10, D_3026F68, 0x10, 0); + func_8001C330(arg0 + 3, (arg1 + arg3) - 3, arg2 - 6, 0x10, 0, 0, 0, 0x400, 0); + func_8001C330((arg0 + arg2) - 3, tmp + 8, 0x10, (arg3 / 2) - 3, 0, 0, 0x400, 0, 0); + + if (arg3 >= 0x10) { + func_8001C6AC(arg0 - 0xD, tmp, 0x10, 0x10, D_3026968, 0x10, 0); + func_8001C6AC((arg0 + arg2) - 3, tmp, 0x10, 0x10, D_3026B68, 0x10, 0); + } + + gSPDisplayList(gDisplayListHead++, D_8006F630); +} + +void func_82F0E97C(unk_D_82F21238* arg0) { + UNUSED s32 pad; + s16 i; + s32 sp5C; + s16 var_a0; + s16 var_s2; + s16 var_s3; + + sp5C = 0; + if (arg0->unk_0A == 1) { + sp5C = 1; + } + + gSPDisplayList(gDisplayListHead++, D_8006F518); + gDPSetEnvColor(gDisplayListHead++, 255, 255, 255, arg0->unk_16); + + if (sp5C != 0) { + gDPSetAlphaCompare(gDisplayListHead++, G_AC_DITHER); + } + + var_s3 = 8; + if ((arg0->unk_02 == 3) || (arg0->unk_02 == 5)) { + var_s3 = 1; + } + + for (i = 0; i < 0xC0; i += var_s3) { + var_s2 = CLAMP_MIN(0xC0 - i, var_s3); + + gDPLoadTextureTile(gDisplayListHead++, arg0->unk_20 + (i * 0x180), G_IM_FMT_RGBA, G_IM_SIZ_16b, 192, 0, 0, 0, + 191, var_s2 - 1, 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); + + if (var_s3 != 1) { + var_a0 = 0xE0; + } else { + var_a0 = (s16)(SINS(arg0->unk_18 + (arg0->unk_1A * i)) * arg0->unk_1C) + 0xE0; + } + func_8001C330(var_a0, i + 0x64, 0xC0, var_s2, 0, 0, 0x400, 0x400, 0); + } + + if (sp5C != 0) { + gDPPipeSync(gDisplayListHead++); + gDPSetAlphaCompare(gDisplayListHead++, G_AC_NONE); + } +} void func_82F0ECA4(void) { } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0ECAC.s") +void func_82F0ECAC(unk_D_82F20A40_00E* arg0, unk_func_80026268_arg0* arg1) { + s16 spC6; + s8 sp44[0x80]; + char* sp40; + char* sp3C; + char* sp38; + s16 tmp1; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0EE58.s") + sp44[0] = '\x00'; + sp3C = NULL; + sp40 = NULL; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0EF68.s") + if (func_82F0D3F4(arg1->unk_00.unk_00 - 1) != 0) { + sp40 = func_82F00020(arg1->unk_00.unk_00 - 1); + sp3C = func_82F00020(arg1->unk_00.unk_00); + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0EFC4.s") + if (sp40 != NULL) { + func_8002D5D4(0x21, sp40); + func_8002D5D4(0x22, sp3C); + sp38 = func_8002D7C0(sp44, 0x80, D_82F13B70, 0x19); + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0F260.s") + if ((sp44[0] != '\x00') && ((arg0->unk_04 != 0x210) || (arg0->unk_06 != 0))) { + func_82F037EC(arg0->unk_00, arg0->unk_02, arg0->unk_04, arg0->unk_06, 0x1E, 0x1E, 0x82, 0xFF); + if ((arg0->unk_04 == 0x210) && (arg0->unk_06 == 0x28)) { + func_8001F3F4(); + func_8001EBE0(0x10, 0); + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + spC6 = arg0->unk_00 + (arg0->unk_04 / 2); + tmp1 = func_8001F5B0(0, 0, sp38) / 2; + func_8001F1E8(spC6 - tmp1, arg0->unk_02 + 8, sp38); + func_8001F444(); + } + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0F2AC.s") +void func_82F0EE58(void) { + unk_D_82F21238* ptr = &D_82F21238; + UNUSED s32 pad; + s32 sp24; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0F374.s") + if (ptr->unk_02 != 0) { + sp24 = 0; + if (ptr->unk_12 > 0) { + if (ptr->unk_14 > 0) { + sp24 = 1; + func_800060E0(&gDisplayListHead, ptr->unk_0E, ptr->unk_10, ptr->unk_12, ptr->unk_14); + if (ptr->unk_20 != 0) { + func_82F0E97C(&D_82F21238); + } + func_82F0DD90(0xE0, 0x64, ptr->unk_16); + } + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0F578.s") + if (sp24 != 0) { + func_800060E0(&gDisplayListHead, 0, 0, 0x280, 0x1E0); + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0F600.s") + func_82F0E5C8(ptr->unk_0E, ptr->unk_10, ptr->unk_12, ptr->unk_14); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0F654.s") + if (ptr->unk_30.unk_04 != -1) { + func_82F0ECAC(&ptr->unk_30, ptr->unk_24); + } + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0F714.s") +void func_82F0EF68(void) { + s32 i; + unk_D_82F21160* var_v1; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0F79C.s") + for (i = 0, var_v1 = &D_82F21160[0]; i < 2; i++, var_v1++) { + var_v1->unk_00 = 0; + var_v1->unk_02 = 0; + var_v1->unk_04 = 0; + var_v1->unk_06 = 0; + var_v1->unk_08 = 0; + var_v1->unk_0A = 0; + var_v1->unk_0C = 0; + var_v1->unk_0E = 0; + var_v1->unk_10 = 0; + var_v1->unk_12 = 0; + var_v1->unk_14 = 0.0f; + var_v1->unk_18 = 0.0f; + var_v1->unk_1C = 0.0f; + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0F89C.s") +void func_82F0EFC4(s32 arg0, s16 arg1) { + static s16 D_82F13FD0[] = { 0x64, 0x2C8 }; + static s16 D_82F13FD4[] = { 0x50, 0x236, 0, 0, 0x3F80, 0 }; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0F9E0.s") + unk_D_82F21160* temp_v0 = &D_82F21160[arg0]; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0FCC0.s") + temp_v0->unk_00 = arg1; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0FDCC.s") + switch (arg1) { + case 1: + temp_v0->unk_02 = D_82F13FD0[arg0]; + temp_v0->unk_04 = D_82F21140.unk_02 + temp_v0->unk_02; + temp_v0->unk_06 = 0xFA; + temp_v0->unk_08 = temp_v0->unk_04 - 0x40; + temp_v0->unk_0A = 0xAE; + temp_v0->unk_0C = 0x80; + temp_v0->unk_0E = 0x48; + temp_v0->unk_10 = 0; + temp_v0->unk_12 = 0; + temp_v0->unk_14 = 1.0f; + temp_v0->unk_18 = 0.0f; + temp_v0->unk_1C = 9.0f; + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F0FDEC.s") + case 2: + temp_v0->unk_08 = 0; + temp_v0->unk_0A = 0; + temp_v0->unk_0C = 0; + temp_v0->unk_0E = 0; + temp_v0->unk_06 = 0xBE; + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F10034.s") + case 3: + temp_v0->unk_08 = 0; + temp_v0->unk_0A = 0; + temp_v0->unk_0C = 0; + temp_v0->unk_0E = 0; + temp_v0->unk_10 = D_82F21140.unk_18; + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F10110.s") + case 4: + if (arg0 == 0) { + temp_v0->unk_02 = 0x50; + } else { + temp_v0->unk_02 = 0x236; + } + temp_v0->unk_04 = D_82F21140.unk_02 + temp_v0->unk_02; + temp_v0->unk_14 = 0.75f; + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F101C8.s") + case 5: + temp_v0->unk_12 = 0; + temp_v0->unk_08 = temp_v0->unk_04 - 0x40; + if (temp_v0->unk_08 < 0) { + temp_v0->unk_08 = 0; + } + temp_v0->unk_0A = 0xC2; + temp_v0->unk_0C = 0x80; + temp_v0->unk_0E = 0x3C; + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F10348.s") + case 6: + temp_v0->unk_02 = D_82F13FD4[arg0]; + temp_v0->unk_04 = D_82F21140.unk_02 + temp_v0->unk_02; + temp_v0->unk_06 = 0xA0; + temp_v0->unk_08 = temp_v0->unk_04 - 0x40; + if (temp_v0->unk_08 < 0) { + temp_v0->unk_08 = 0; + } + temp_v0->unk_0A = 0xC2; + temp_v0->unk_0C = 0x80; + temp_v0->unk_0E = 0x3C; + temp_v0->unk_10 = 0; + temp_v0->unk_12 = 0; + temp_v0->unk_14 = 0.75f; + temp_v0->unk_18 = 0.0f; + temp_v0->unk_1C = 1.0f; + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F10400.s") + case 8: + temp_v0->unk_02 = D_82F13FD4[arg0]; + temp_v0->unk_04 = D_82F21140.unk_02 + temp_v0->unk_02; + temp_v0->unk_06 = 0xA0; + temp_v0->unk_08 = temp_v0->unk_04 - 0x40; + if (temp_v0->unk_08 < 0) { + temp_v0->unk_08 = 0; + } + temp_v0->unk_0A = 0xC2; + temp_v0->unk_0C = 0x80; + temp_v0->unk_0E = 0x3C; + temp_v0->unk_10 = 0; + temp_v0->unk_12 = 0; + temp_v0->unk_14 = 0.75f; + temp_v0->unk_18 = 0.0f; + temp_v0->unk_1C = 1.0f; + break; + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F10454.s") +void func_82F0F260(unk_D_82F21160* arg0) { + arg0->unk_06 -= 2; + if (arg0->unk_06 < 0xBF) { + func_82F0EFC4(arg0 - D_82F21160, 2); + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F1050C.s") +void func_82F0F2AC(unk_D_82F21160* arg0) { + arg0->unk_04 = D_82F21140.unk_02 + arg0->unk_02; + arg0->unk_06 = (s16)ROUND_MAX(SINS(arg0->unk_12) * 3.0f) + 0xBE; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F10674.s") + arg0->unk_12 += 0x800; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F10710.s") + arg0->unk_1C -= 0.2f; + if (arg0->unk_1C < 1.0f) { + arg0->unk_1C = 1.0f; + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F10744.s") +void func_82F0F374(unk_D_82F21160* arg0) { + f32 one = 1.0f; + s16 var_v0; + s16 tmp1; + s32 temp_a1; + s32 temp_a3; + f32 tmpf1; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F10818.s") + var_v0 = D_82F21140.unk_18; + if (arg0->unk_10 < var_v0) { + var_v0 = 0; + } + temp_a1 = (var_v0 * -0x14); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F1084C.s") + temp_a3 = arg0 - D_82F21160; + if (temp_a3 == 0) { + arg0->unk_02 = ((var_v0 * 0x14) / arg0->unk_10) + 0x50; + } else { + arg0->unk_02 = ((var_v0 * 0x92) / arg0->unk_10) + 0x236; + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F1091C.s") + arg0->unk_04 = D_82F21140.unk_02 + arg0->unk_02; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F10950.s") + tmp1 = (temp_a1 / arg0->unk_10) + 0xD2; + tmpf1 = (((var_v0 * one) / arg0->unk_10) + 2.0f); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F10A24.s") + arg0->unk_06 = (s16)ROUND_MAX(SINS(arg0->unk_12) * tmpf1) + tmp1; + arg0->unk_12 += 0x800; + arg0->unk_14 = ((var_v0 * 0.25f) / arg0->unk_10) + 0.75f; + + if (temp_a1 >= -0x13) { + func_82F0EFC4(temp_a3, 4); + } +} + +void func_82F0F578(unk_D_82F21160* arg0) { + arg0->unk_04 = D_82F21140.unk_02 + arg0->unk_02; + arg0->unk_06 = (s16)ROUND_MAX(2.0f * SINS(arg0->unk_12)) + 0xD2; + arg0->unk_12 += 0x800; +} + +void func_82F0F600(unk_D_82F21160* arg0) { + arg0->unk_04 = D_82F21140.unk_02 + arg0->unk_02; + arg0->unk_12--; + arg0->unk_06 += arg0->unk_12; + if (arg0->unk_06 < 0x79) { + arg0->unk_00 = 0; + arg0->unk_06 = 0x78; + } +} + +void func_82F0F654(unk_D_82F21160* arg0) { + s16 idx; + + arg0->unk_12++; + arg0->unk_06 += arg0->unk_12; + if (arg0->unk_06 >= 0xD2) { + arg0->unk_00 = 7; + arg0->unk_06 = 0xD2; + arg0->unk_18 = MathUtil_Random16() % 16; + arg0->unk_12 = MathUtil_Random16(); + idx = arg0 - D_82F21160; + if (idx == 0) { + D_82F21140.unk_0C &= ~0x40; + } + } +} + +void func_82F0F714(unk_D_82F21160* arg0) { + arg0->unk_04 = D_82F21140.unk_02 + arg0->unk_02; + arg0->unk_06 = (s16)ROUND_MAX(2.0f * SINS(arg0->unk_12)) + 0xD2; + arg0->unk_12 += 0x800; +} + +void func_82F0F79C(unk_D_82F21160* arg0) { + if (arg0->unk_1C < 9.0f) { + arg0->unk_04 = D_82F21140.unk_02 + arg0->unk_02; + arg0->unk_06 = (s16)ROUND_MAX(2.0f * SINS(arg0->unk_12)) + 0xD2; + arg0->unk_12 += 0x800; + + arg0->unk_1C += 0.2f; + if (arg0->unk_1C >= 9.0f) { + arg0->unk_1C = 9.0f; + } + } else { + arg0->unk_1C = 9.0f; + arg0->unk_06 += 2; + if (arg0->unk_06 >= 0x104) { + arg0->unk_00 = 0; + arg0->unk_06 = 0; + } + } +} + +void func_82F0F89C(void) { + s32 var_s1; + unk_D_82F21160* var_s0; + s32 i; + + var_s0 = D_82F21160; + + for (i = 0; i < 2; i++, var_s0++) { + var_s1 = 1; + + switch (var_s0->unk_00) { + case 0: + var_s1 = 0; + break; + + case 1: + func_82F0F260(var_s0); + break; + + case 2: + func_82F0F2AC(var_s0); + break; + + case 3: + func_82F0F374(var_s0); + break; + + case 4: + func_82F0F578(var_s0); + break; + + case 5: + func_82F0F600(var_s0); + break; + + case 6: + func_82F0F654(var_s0); + break; + + case 7: + func_82F0F714(var_s0); + break; + + case 8: + func_82F0F79C(var_s0); + break; + } + + if (var_s1 != 0) { + s32 tmp; + + var_s0->unk_18 += var_s0->unk_1C; + + tmp = var_s0->unk_18; + tmp /= 16; + + var_s0->unk_18 -= (tmp * 0x10); + } + } +} + +void func_82F0F9E0(s16 arg0, s16 arg1, f32 arg2, s16 arg3) { + static u8* D_82F13FE0[] = { + D_300D868, D_300EA68, D_300FC68, D_3010E68, D_3012068, D_3013268, D_3013268, D_3013268, + D_3013268, D_3013268, D_3013268, D_3013268, D_3012068, D_3010E68, D_300FC68, D_300EA68, + }; + + s32 i; + s16 var_fv0_4; + s16 sp60; + s16 sp5E; + s16 sp5C; + f32 var_fv0; + u8* var_s2; + + if ((arg0 < 0x281) && (arg0 >= -0x30) && (arg1 < 0x1E1)) { + sp60 = 0; + if (arg1 >= -0x30) { + var_fv0 = arg2; + if ((arg3 >= 0xC) && (arg3 < 0x10)) { + sp60 = 0x600; + var_fv0 = 0.0f - arg2; + } + + sp5E = ROUND_MAX(1024.0f / var_fv0); + sp5C = ROUND_MAX(1024.0f / arg2); + var_fv0_4 = ROUND_MAX(24.0f * arg2); + + var_s2 = D_82F13FE0[arg3]; + for (i = 0; i < 2; i++) { + gDPLoadTextureBlock(gDisplayListHead++, var_s2, G_IM_FMT_RGBA, G_IM_SIZ_16b, 48, 24, 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_82F0C410(arg0, arg1 + (var_fv0_4 * i), 0x30, 0x18, sp60, 0, sp5E, sp5C, 0); + var_s2 += 0x900; + } + } + } +} + +void func_82F0FCC0(void) { + s32 i; + s32 var_s3 = 0; + unk_D_82F21160* var_s0; + + for (i = 0, var_s0 = D_82F21160; i < 2; i++, var_s0++) { + if (var_s0->unk_00 == 0) { + continue; + } + + if ((var_s0->unk_0C != 0) && (var_s0->unk_0E != 0)) { + var_s3 = 1; + var_s0->unk_08 = var_s0->unk_04 - 0x40; + if (var_s0->unk_08 < 0) { + var_s0->unk_08 = 0; + } + func_800060E0(&gDisplayListHead, var_s0->unk_08, var_s0->unk_0A, var_s0->unk_0C, var_s0->unk_0E); + } + + func_82F0F9E0(var_s0->unk_04, var_s0->unk_06, var_s0->unk_14, var_s0->unk_18); + } + + if (var_s3 != 0) { + func_800060E0(&gDisplayListHead, 0, 0, 0x280, 0x1E0); + } +} + +s32 func_82F0FDCC(void) { + s32 var_v1 = 0; + + if (D_82F21140.unk_0E != 0) { + var_v1 = 1; + } + return var_v1; +} + +void func_82F0FDEC(s16 arg0) { + UNUSED s32 pad; + unk_D_82F21140* ptr = &D_82F21140; + unk_D_82F21160* ptr2; + s32 i; + u16 tmp = 0; + + if (arg0 < 0x12) { + ptr->unk_00 = arg0; + } + + switch (arg0) { + case 0: + ptr->unk_02 = -0x14; + ptr->unk_04 = 0x18; + ptr->unk_10 = 1.5f; + ptr->unk_06 = 0xB4; + ptr->unk_08 = 0xE4; + ptr->unk_0A = 0xAA; + ptr->unk_0E = -1; + ptr->unk_14 = 0x80; + ptr->unk_16 = 0x40; + ptr->unk_0C = tmp; + ptr->unk_0C |= 0x1F; + break; + + case 1: + ptr->unk_18 = 0x1E; + ptr->unk_0C |= 0x20; + func_80048B90(0x01200002); + break; + + case 2: + case 4: + ptr->unk_18 = 0xA; + break; + + case 3: + ptr->unk_18 = 2; + break; + + case 6: + ptr->unk_18 = 0xA; + break; + + case 7: + ptr->unk_18 = 2; + break; + + case 8: + case 9: + ptr->unk_18 = 0xA; + + ptr2 = &D_82F21160[0]; + for (i = 0; i < 2; i++, ptr2++) { + if (ptr2->unk_00 != 0) { + func_82F0EFC4(i, 3); + } + } + break; + + case 11: + func_82F0EFC4(0, 8); + func_82F0EFC4(1, 8); + break; + + case 12: + ptr->unk_18 = 0xA; + break; + + case 14: + ptr->unk_18 = 0xA; + break; + + case 16: + ptr->unk_18 = 0xA; + break; + + case 5: + case 17: + ptr->unk_18 = 0x1E; + break; + + case 19: + func_82F0EFC4(0, 1); + func_80048B90(0x01200004); + break; + + case 20: + func_82F0EFC4(1, 1); + func_80048B90(0x01200004); + break; + + case 21: + if (1) {} + if (1) {} + func_82F0EFC4(0, 5); + func_82F0EFC4(1, 5); + break; + } +} + +void func_82F10034(unk_D_82F21140* arg0) { + if (func_82F07A74() != 0) { + switch (func_82F07A74()) { + case 1: + case 11: + arg0->unk_0E = -1; + arg0->unk_0C |= 0x1E; + break; + + default: + arg0->unk_0C &= ~0x1E; + break; + } + } else if (func_82F0C16C() != 0) { + switch (func_82F0C16C()) { + case 1: + case 8: + arg0->unk_0E = -1; + arg0->unk_0C |= 0x1E; + break; + + default: + arg0->unk_0C &= ~0x1E; + break; + } + } else { + arg0->unk_0E = -1; + arg0->unk_0C |= 0x1E; + } +} + +void func_82F10110(unk_D_82F21140* arg0) { + arg0->unk_18--; + arg0->unk_14 = ((arg0->unk_18 * 0x60) / 30) + 0x20; + arg0->unk_16 = ((arg0->unk_18 * -0x40) / 30) + 0x80; + if (arg0->unk_18 <= 0) { + func_82F0FDEC(2); + } +} + +void func_82F101C8(unk_D_82F21140* arg0) { + s16 var_v0; + + arg0->unk_18--; + var_v0 = arg0->unk_18; + if (arg0->unk_00 == 4) { + var_v0 = 0xA - var_v0; + } + + arg0->unk_02 = ((var_v0 * -0xAE) / 10) + 0x9A; + arg0->unk_04 = ((var_v0 * 0x43) / 10) - 0x2B; + arg0->unk_10 = ((var_v0 * -0.39999998f) / 10) + 1.9f; + arg0->unk_0A = ((var_v0 * 3) / 10) + 0xA7; + + if (arg0->unk_18 <= 0) { + if (arg0->unk_00 == 4) { + func_82F0FDEC(5); + } else { + func_82F0FDEC(3); + } + } +} + +void func_82F10348(unk_D_82F21140* arg0) { + if (arg0->unk_18 > 0) { + arg0->unk_18--; + } + + switch (func_82F018F8()) { + case 3: + break; + + case 2: + case 4: + if (arg0->unk_0E == -1) { + arg0->unk_0E = 2; + } + arg0->unk_0C &= ~1; + break; + + case 1: + arg0->unk_0C &= ~0x1E; + break; + + default: + arg0->unk_0E = -1; + arg0->unk_0C |= 0x1F; + break; + } + + if (func_82F13964(4) != 0) { + func_82F0FDEC(6); + } +} + +void func_82F10400(unk_D_82F21140* arg0) { + arg0->unk_18--; + arg0->unk_02 = ((arg0->unk_18 * 0x1F8) / 10) - 0x15E; + if (arg0->unk_18 <= 0) { + func_82F0FDEC(7); + } +} + +void func_82F10454(unk_D_82F21140* arg0) { + if (arg0->unk_18 > 0) { + arg0->unk_18--; + } + + switch (func_82F018F8()) { + case 3: + break; + + case 2: + case 4: + if (arg0->unk_0E == -1) { + arg0->unk_0E = 2; + } + arg0->unk_0C &= ~1; + break; + + case 1: + arg0->unk_0C &= ~0x1E; + break; + + default: + arg0->unk_0E = -1; + arg0->unk_0C |= 0x1F; + break; + } + + if (func_82F13964(5) != 0) { + func_82F0FDEC(9); + } +} + +void func_82F1050C(unk_D_82F21140* arg0) { + arg0->unk_18--; + arg0->unk_02 = ((arg0->unk_18 * -0x14A) / 10) - 0x14; + arg0->unk_04 = ((arg0->unk_18 * -0x43) / 10) + 0x18; + arg0->unk_10 = ((arg0->unk_18 * 0.39999998f) / 10.0f) + 1.5f; + arg0->unk_0A = ((arg0->unk_18 * -3) / 10) + 0xAA; + + if (arg0->unk_18 <= 0) { + if (arg0->unk_00 == 8) { + func_82F0FDEC(5); + } else { + func_82F0FDEC(0xA); + } + } +} + +void func_82F10674(unk_D_82F21140* arg0) { + if (func_82F0C16C() == 2) { + arg0->unk_0C &= ~0x10; + arg0->unk_0C &= ~2; + } else { + arg0->unk_0C |= 0x12; + } + + if (func_82F13964(7) != 0) { + if (!(arg0->unk_0C & 0x40)) { + arg0->unk_0C |= 0x40; + func_82F0C658(0, 1); + func_82F0C658(1, 1); + func_80048B90(0x01200005); + } + } +} + +void func_82F10710(unk_D_82F21140* arg0) { + if (func_82F13964(7) != 0) { + func_82F0FDEC(5); + } +} + +void func_82F10744(unk_D_82F21140* arg0) { + s16 var_v1 = arg0->unk_18; + + arg0->unk_18--; + if (var_v1 < 0) { + var_v1 = 0; + } + + arg0->unk_02 = ((var_v1 * -0x1E4) / 10) + 0x1D0; + arg0->unk_04 = ((var_v1 * 0) / 10) + 0x18; + if (arg0->unk_18 < -5) { + func_82F0FDEC(0xD); + func_82F0D160(0); + } +} + +void func_82F10818(unk_D_82F21140* arg0) { + if (func_82F13964(0xB) != 0) { + func_82F0FDEC(0xE); + } +} + +void func_82F1084C(unk_D_82F21140* arg0) { + s16 var_v1 = arg0->unk_18; + + arg0->unk_18--; + if (var_v1 < 0) { + var_v1 = 0; + } + + arg0->unk_02 = ((var_v1 * 0x3A0) / 10) - 0x1D0; + arg0->unk_04 = ((var_v1 * 0) / 10) + 0x18; + if (arg0->unk_18 < -5) { + func_82F0FDEC(0xF); + func_82F0D160(1); + } +} + +void func_82F1091C(unk_D_82F21140* arg0) { + if (func_82F13964(0xB) != 0) { + func_82F0FDEC(0x10); + } +} + +void func_82F10950(unk_D_82F21140* arg0) { + arg0->unk_18--; + arg0->unk_02 = ((arg0->unk_18 * -0x1BC) / 10) - 0x14; + arg0->unk_04 = ((arg0->unk_18 * 0) / 10) + 0x18; + if (arg0->unk_18 <= 0) { + func_82F0FDEC(0x11); + func_82F0EFC4(0, 8); + func_82F0EFC4(1, 8); + } +} + +void func_82F10A24(unk_D_82F21140* arg0) { + s32 i; + + if (arg0->unk_00 == 5) { + for (i = 0; i < 2; i++) { + if (D_82F21160[i].unk_00 == 4) { + func_82F0EFC4(i, 8); + } + } + + if ((D_82F21160->unk_00 != 0) || (D_82F21160[1].unk_00 != 0)) { + return; + } + } else if ((arg0->unk_00 == 0x11) && (func_82F13964(9) == 0)) { + return; + } + + if (arg0->unk_0C & 0x20) { + arg0->unk_0C &= ~0x20; + func_80048B90(0x01200003); + } + + arg0->unk_18--; + arg0->unk_14 = ((arg0->unk_18 * -0x60) / 30) + 0x80; + arg0->unk_16 = ((arg0->unk_18 << 6) / 30) + 0x40; + if (arg0->unk_18 <= 0) { + func_82F0FDEC(0); + } +} + +#ifdef NON_MATCHING +void func_82F10BB4(s16 arg0, s16 arg1, f32 arg2) { + s16 sp58; + s16 temp_ft1; + s16 temp_ft2; + s32 temp_ft0; + s32 i; + s32 var_s2; + u8* var_s6 = D_3000008; + + temp_ft2 = ROUND_MAX(228.0f * arg2); + temp_ft1 = ROUND_MAX(19.0f * arg2); + temp_ft0 = ROUND_MAX(1024.0f / arg2); + sp58 = ROUND_MAX(-1024.0f / arg2); + + for (i = 0, var_s2 = arg1; i < 11; i++, var_s2 += temp_ft1, var_s6 += 0x876) { + gDPLoadTextureTile_4b(gDisplayListHead++, var_s6, G_IM_FMT_I, 228, 0, 0, 0, 227, 18, 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_82F0C410(arg0, var_s2, temp_ft2, temp_ft1, 0, 0, temp_ft0, temp_ft0, 0); + func_82F0C410(arg0 + temp_ft2, var_s2, temp_ft2, temp_ft1, 0x1C60, 0, sp58, temp_ft0, 0); + } +} +#else #pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F10BB4.s") +#endif -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F10ED0.s") +void func_82F10ED0(s16 arg0, s16 arg1, f32 arg2, s16 arg3, s16 arg4, s16 arg5) { + s16 sp6E; + s16 sp6C; + s16 sp6A; + s16 sp68; + s16 sp66; + s32 temp_fv1_4; + s32 sp5C; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F11264.s") + sp6E = ROUND_MAX(48.0f * arg2); + sp6C = ROUND_MAX(30.0f * arg2); + sp6A = ROUND_MAX(arg3 * arg2); + sp68 = ROUND_MAX(arg4 * arg2); + sp66 = ROUND_MAX(arg5 * arg2); + sp5C = ROUND_MAX(1024.0f / arg2); + temp_fv1_4 = ROUND_MAX(-1024.0f / arg2); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F115F8.s") + gDPLoadTextureTile_4b(gDisplayListHead++, D_3005D28, G_IM_FMT_I, 48, 0, 0, 0, 47, 29, 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); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F1198C.s") + func_82F0C410(arg0 + sp6A, arg1 + sp66, sp6E, sp6C, 0, 0, sp5C, sp5C, 0); + func_82F0C410(arg0 + sp68, arg1 + sp66, sp6E, sp6C, 0x5E0, 0, temp_fv1_4, sp5C, 0); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F11D68.s") +void func_82F11264(s16 arg0, s16 arg1, f32 arg2, s16 arg3, s16 arg4, s16 arg5) { + s16 sp6E; + s16 sp6C; + s16 sp6A; + s16 sp68; + s16 sp66; + s32 temp_fv1_4; + s32 sp5C; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F1228C.s") + sp6E = ROUND_MAX(24.0f * arg2); + sp6C = ROUND_MAX(30.0f * arg2); + sp6A = ROUND_MAX(arg3 * arg2); + sp68 = ROUND_MAX(arg4 * arg2); + sp66 = ROUND_MAX(arg5 * arg2); + sp5C = ROUND_MAX(1024.0f / arg2); + temp_fv1_4 = ROUND_MAX(-1024.0f / arg2); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F12614.s") + gDPLoadTextureTile_4b(gDisplayListHead++, D_300D108, G_IM_FMT_I, 24, 0, 0, 0, 23, 29, 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); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F12DE4.s") + func_82F0C410(arg0 + sp6A, arg1 + sp66, sp6E, sp6C, 0, 0, sp5C, sp5C, 0); + func_82F0C410(arg0 + sp68, arg1 + sp66, sp6E, sp6C, 0x2E0, 0, temp_fv1_4, sp5C, 0); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F13278.s") +void func_82F115F8(s16 arg0, s16 arg1, f32 arg2, s16 arg3, s16 arg4, s16 arg5) { + s16 sp6E; + s16 sp6C; + s16 sp6A; + s16 sp68; + s16 sp66; + s32 temp_fv1_4; + s32 sp5C; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F132D0.s") + sp6E = ROUND_MAX(16.0f * arg2); + sp6C = ROUND_MAX(14.0f * arg2); + sp6A = ROUND_MAX(arg3 * arg2); + sp68 = ROUND_MAX(arg4 * arg2); + sp66 = ROUND_MAX(arg5 * arg2); + sp5C = ROUND_MAX(1024.0f / arg2); + temp_fv1_4 = ROUND_MAX(-1024.0f / arg2); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F13414.s") + gDPLoadTextureTile_4b(gDisplayListHead++, D_300D278, G_IM_FMT_I, 16, 0, 0, 0, 15, 13, 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); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F13964.s") + func_82F0C410(arg0 + sp6A, arg1 + sp66, sp6E, sp6C, 0, 0, sp5C, sp5C, 0); + func_82F0C410(arg0 + sp68, arg1 + sp66, sp6E, sp6C, 0x1E0, 0, temp_fv1_4, sp5C, 0); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F13B4C.s") +void func_82F1198C(s16 arg0, s16 arg1, f32 arg2, s16 arg3, s16 arg4, s16 arg5) { + s16 spB6; + s16 i; + s32 sp60; + u8* var_s5; + s16 temp_fa0; + s16 temp_fa0_2; + s16 temp_fv1_2; + s16 var_s4; + s16 var_t3; + s16 temp_ft0; + s32 temp_ft1; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_2942C0/func_82F13B64.s") + spB6 = ROUND_MAX(100.0f * arg2); + temp_fa0 = ROUND_MAX(arg3 * arg2); + temp_fv1_2 = ROUND_MAX(arg4 * arg2); + temp_fa0_2 = ROUND_MAX(arg5 * arg2); + temp_ft1 = ROUND_MAX(1024.0f / arg2); + sp60 = ROUND_MAX(-1024.0f / arg2); + + var_s4 = 0; + var_s5 = D_3006000; + var_t3 = 0; + for (i = 0x83; i > 0;) { + if ((i - 0x48) >= 0) { + var_t3 = 0x48; + } else { + var_t3 = i; + } + + gDPLoadTextureTile_4b(gDisplayListHead++, var_s5, G_IM_FMT_I, 100, 0, 0, 0, 99, var_t3, 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); + + i -= var_t3; + temp_ft0 = var_t3 * arg2; + func_82F0C410(arg0 + temp_fa0, arg1 + temp_fa0_2 + var_s4, spB6, temp_ft0, 0, 0, temp_ft1, temp_ft1, 0); + func_82F0C410(arg0 + temp_fv1_2, arg1 + temp_fa0_2 + var_s4, spB6, temp_ft0, 0xC60, 0, sp60, temp_ft1, 0); + var_s5 += 0xE10; + var_s4 += temp_ft0; + } +} + +void func_82F11D68(s16 arg0, s16 arg1, f32 arg2, s16 arg3, s16 arg4, s16 arg5, s16 arg6) { + static Gfx D_82F14020[] = { + gsDPPipeSync(), + gsDPSetCycleType(G_CYC_2CYCLE), + gsDPSetRenderMode(G_RM_PASS, G_RM_XLU_SURF2), + gsDPSetCombineLERP(NOISE, 0, TEXEL1, 0, TEXEL0, 0, PRIMITIVE, 0, PRIMITIVE, ENVIRONMENT, COMBINED, ENVIRONMENT, + 0, 0, 0, COMBINED), + gsDPSetEnvColor(200, 255, 255, 255), + gsSPEndDisplayList(), + }; + + s16 spE6; + s16 i; + s32 sp6C; + s32 sp60; + u8* var_fp; + u8* var_s7; + s16 temp_fa0; + s16 temp_fv1_2; + s16 temp_fv1_3; + s16 var_ra; + s16 var_s6; + s16 temp_ft0; + + spE6 = ROUND_MAX(100.0f * arg2); + if (1) {} + temp_fv1_2 = ROUND_MAX(arg3 * arg2); + temp_fa0 = ROUND_MAX(arg4 * arg2); + temp_fv1_3 = ROUND_MAX(arg5 * arg2); + sp6C = ROUND_MAX(1024.0f / arg2); + sp60 = ROUND_MAX(-1024.0f / arg2); + + var_s6 = 0; + var_s7 = D_3009DC8; + var_fp = D_300B768; + i = 0x83; + + gSPDisplayList(gDisplayListHead++, D_82F14020); + gDPSetPrimColor(gDisplayListHead++, 0, 0, 100, 100, 255, arg6); + + for (; i > 0;) { + if ((i - 0x20) >= 0) { + var_ra = 0x20; + } else { + var_ra = i; + } + + gDPLoadMultiTile_4b(gDisplayListHead++, var_fp, 0x0100, 1, G_IM_FMT_I, 100, 0, 0, 0, 99, var_ra, 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); + + i -= var_ra; + temp_ft0 = var_ra * arg2; + + gDPLoadMultiTile_4b(gDisplayListHead++, var_s7, 0x0000, G_TX_RENDERTILE, G_IM_FMT_I, 100, 0, 0, 0, 99, var_ra, + 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_82F0C410(arg0 + temp_fv1_2, arg1 + temp_fv1_3 + var_s6, spE6, temp_ft0, 0, 0, sp6C, sp6C, 0x100000); + func_82F0C410(arg0 + temp_fa0, arg1 + temp_fv1_3 + var_s6, spE6, temp_ft0, 0xC60, 0, sp60, sp6C, 0x100000); + var_s7 += 0x640; + var_fp += 0x640; + var_s6 += temp_ft0; + } +} + +void func_82F1228C(s16 arg0, s16 arg1, f32 arg2, s16 arg3, s16 arg4, s16 arg5) { + s16 sp76; + s16 sp74; + s16 sp72; + s16 sp70; + s16 sp6E; + UNUSED s32 pad; + s16 sp5C; + s32 sp60; + + sp76 = ROUND_MAX(64.0f * arg2); + sp74 = ROUND_MAX(64.0f * arg2); + sp72 = ROUND_MAX(arg3 * arg2); + sp70 = ROUND_MAX(arg4 * arg2); + sp6E = ROUND_MAX(arg5 * arg2); + sp60 = ROUND_MAX(1024.0f / arg2); + sp5C = ROUND_MAX(-1024.0f / arg2); + + gDPLoadTextureTile_4b(gDisplayListHead++, D_30079A0, G_IM_FMT_I, 64, 0, 0, 0, 63, 63, 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_82F0C410(arg0 + sp72, arg1 + sp6E, sp76, sp74, 0, 0, sp60, sp60, 0); + func_82F0C410(arg0 + sp70, arg1 + sp6E, sp76, sp74, 0x7E0, 0, sp5C, sp60, 0); +} + +void func_82F12614(void) { + static f32 D_82F14050 = 0.0f; + static f32 D_82F14054 = 0.0f; + static f32 D_82F14058 = 0.0f; + static f32 D_82F1405C = 0.0f; + static Gfx D_82F14060[] = { + gsDPPipeSync(), + gsDPSetCycleType(G_CYC_2CYCLE), + gsDPSetRenderMode(G_RM_OPA_SURF, G_RM_OPA_SURF2), + gsDPSetCombineLERP(TEXEL0, TEXEL1, PRIM_LOD_FRAC, TEXEL1, 0, 0, 0, PRIMITIVE, PRIMITIVE, ENVIRONMENT, COMBINED, + ENVIRONMENT, 0, 0, 0, COMBINED), + gsDPSetPrimColor(0, 0x80, 55, 255, 255, 255), + gsDPSetEnvColor(0, 0, 255, 255), + gsSPEndDisplayList(), + }; + + f32 temp_fa0; + f32 temp_fa4; + f32 temp_fa8; + f32 temp_faC; + + func_80006498(&gDisplayListHead, D_82F2115C); + + gSPDisplayList(gDisplayListHead++, D_82F14060); + + gDPLoadMultiBlock_4b(gDisplayListHead++, D_3009BC0, 0x0100, 1, G_IM_FMT_I, 32, 32, 0, G_TX_NOMIRROR | G_TX_WRAP, + G_TX_NOMIRROR | G_TX_WRAP, 5, 5, G_TX_NOLOD, 1); + + temp_fa8 = D_82F14058 + 31.0f; + temp_faC = D_82F1405C + 31.0f; + if (1) {} + gDPSetTileSize(gDisplayListHead++, 1, D_82F14058 * 4.0f, D_82F1405C * 4.0f, temp_fa8 * 4.0f, temp_faC * 4.0f); + + gDPLoadTextureBlock_4b(gDisplayListHead++, D_30099B8, G_IM_FMT_I, 32, 32, 0, G_TX_NOMIRROR | G_TX_WRAP, + G_TX_NOMIRROR | G_TX_WRAP, 5, 5, G_TX_NOLOD, 2); + + temp_fa0 = D_82F14050 + 31.0f; + temp_fa4 = D_82F14054 + 31.0f; + gDPSetTileSize(gDisplayListHead++, G_TX_RENDERTILE, D_82F14050 * 4.0f, D_82F14054 * 4.0f, temp_fa0 * 4.0f, + temp_fa4 * 4.0f); + + func_8001C330(0, 0, 0x20, 0x20, 0, 0, 0x400, 0x400, 0x100000); + + D_82F14050 += 0.75f; + if (D_82F14050 >= 32.0f) { + D_82F14050 -= 32.0f; + } + + D_82F14054 += 5.75f; + if (D_82F14054 >= 32.0f) { + D_82F14054 -= 32.0f; + } + + D_82F1405C -= 2.5f; + if (D_82F1405C < 0.0f) { + D_82F1405C += 32.0f; + } + + gDPPipeSync(gDisplayListHead++); + + func_800079C4(); +} + +void func_82F12DE4(s16 arg0, s16 arg1, f32 arg2, s16 arg3, s16 arg4, s16 arg5) { + static Gfx D_82F14098[] = { + gsDPPipeSync(), + gsDPSetCycleType(G_CYC_2CYCLE), + gsDPSetRenderMode(G_RM_PASS, G_RM_XLU_SURF2), + gsDPSetCombineLERP(0, 0, 0, TEXEL1, TEXEL0, 0, ENVIRONMENT, 0, 0, 0, 0, COMBINED, 0, 0, 0, COMBINED), + gsDPSetEnvColor(0, 0, 0, 60), + gsSPEndDisplayList(), + }; + + s16 sp96; + s16 sp94; + s16 sp92; + s16 sp90; + s16 sp8E; + UNUSED s32 pad; + s32 temp_fa0_3; + s32 sp80; + + func_82F12614(); + + sp96 = ROUND_MAX(64.0f * arg2); + sp94 = ROUND_MAX(64.0f * arg2); + sp92 = ROUND_MAX(arg3 * arg2); + sp90 = ROUND_MAX(arg4 * arg2); + sp8E = ROUND_MAX(arg5 * arg2); + sp80 = ROUND_MAX(1024.0f / arg2); + temp_fa0_3 = ROUND_MAX(-1024.0f / arg2); + + gSPDisplayList(gDisplayListHead++, D_82F14098); + gDPLoadMultiBlock(gDisplayListHead++, D_82F2115C->img_p, 0x0100, 1, G_IM_FMT_RGBA, G_IM_SIZ_16b, 32, 32, 0, + G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, 5, 5, 1, 1); + gDPLoadTextureBlock_4b(gDisplayListHead++, D_30081A8, G_IM_FMT_I, 64, 64, 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_82F0C410(arg0 + sp92, arg1 + sp8E, sp96, sp94, 0, 0, sp80, sp80, 0x100000); + func_82F0C410(arg0 + sp90, arg1 + sp8E, sp96, sp94, 0x7E0, 0, temp_fa0_3, sp80, 0x100000); +} + +void func_82F13278(void) { + func_82F0FDEC(0); + func_82F0EF68(); + func_82F0C630(); + func_82F0D084(); + D_82F2115C = func_80006314(0, 2, 0x20, 0x20, 1); +} + +void func_82F132D0(void) { + switch (D_82F21140.unk_00) { + case 0: + func_82F10034(&D_82F21140); + break; + + case 1: + func_82F10110(&D_82F21140); + break; + + case 2: + case 4: + func_82F101C8(&D_82F21140); + break; + + case 3: + func_82F10348(&D_82F21140); + break; + + case 6: + func_82F10400(&D_82F21140); + break; + + case 7: + func_82F10454(&D_82F21140); + break; + + case 8: + case 9: + func_82F1050C(&D_82F21140); + break; + + case 10: + func_82F10674(&D_82F21140); + break; + + case 11: + func_82F10710(&D_82F21140); + break; + + case 12: + func_82F10744(&D_82F21140); + break; + + case 13: + func_82F10818(&D_82F21140); + break; + + case 14: + func_82F1084C(&D_82F21140); + break; + + case 15: + func_82F1091C(&D_82F21140); + break; + + case 16: + func_82F10950(&D_82F21140); + break; + + case 5: + case 17: + func_82F10A24(&D_82F21140); + break; + } + func_82F0F89C(); + func_82F0CB90(); + func_82F0DCF4(); +} + +void func_82F13414(void) { + unk_D_82F21140* ptr = &D_82F21140; + u8 sp83; + s32 var_v0_2; + s32 tmp1; + + if (ptr->unk_0E > 0) { + ptr->unk_0E--; + } + + gSPDisplayList(gDisplayListHead++, D_8006F518); + gDPSetRenderMode(gDisplayListHead++, G_RM_OPA_SURF, G_RM_OPA_SURF2); + gDPSetEnvColor(gDisplayListHead++, ptr->unk_14, ptr->unk_14, ptr->unk_14, 255); + + func_82F10BB4(ptr->unk_02, ptr->unk_04, ptr->unk_10); + tmp1 = D_82F14424 & 0x3F; + sp83 = (ptr->unk_16 * tmp1) / 63u; + if (D_82F14424 & 0x40) { + sp83 = ptr->unk_16 - sp83; + } + + if (ptr->unk_0C & 1) { + if (func_82F00524() == 1) { + tmp1 = D_82F14424 & 3; + sp83 = (tmp1 * 0xFF) / 3u; + if (D_82F14424 & 4) { + sp83 = 0xFF - sp83; + } + } + } + + gDPPipeSync(gDisplayListHead++); + gDPSetRenderMode(gDisplayListHead++, G_RM_XLU_SURF, G_RM_XLU_SURF2); + + if (ptr->unk_0C & 0x10) { + gDPSetEnvColor(gDisplayListHead++, 255, 255, 255, sp83); + func_82F10ED0(ptr->unk_02, ptr->unk_04, ptr->unk_10, ptr->unk_06, ptr->unk_08, ptr->unk_0A); + } + + gDPPipeSync(gDisplayListHead++); + gDPSetEnvColor(gDisplayListHead++, 255, 255, 255, 255); + + func_82F0FCC0(); + func_82F0CC3C(); + + tmp1 = D_82F14424 & 0x3F; + sp83 = (tmp1 * 0xFF) / 63u; + if (D_82F14424 & 0x40) { + sp83 = 0xFF - sp83; + } + + gDPPipeSync(gDisplayListHead++); + gDPSetEnvColor(gDisplayListHead++, 255, 255, 255, sp83); + + tmp1 = D_82F14424 & 0x3F; + sp83 = ((tmp1) << 7) / 63u; + if (D_82F14424 & 0x40) { + sp83 = 0x80 - sp83; + } + + gDPPipeSync(gDisplayListHead++); + gDPSetEnvColor(gDisplayListHead++, 255, 255, 255, sp83); + + if (ptr->unk_0C & 2) { + func_82F11264(ptr->unk_02, ptr->unk_04, ptr->unk_10, 0xB4, 0xFA, 0x73); + } + + if (ptr->unk_0C & 4) { + func_82F115F8(ptr->unk_02, ptr->unk_04, ptr->unk_10, 0xD4, 0xE4, 2); + } + + if (ptr->unk_0C & 4) { + if (ptr->unk_0C & 0x40) { + var_v0_2 = 0x64; + } else { + var_v0_2 = 0x32; + } + func_82F11D68(ptr->unk_02, ptr->unk_04, ptr->unk_10, 0x81, 0xE5, 0, var_v0_2); + + gSPDisplayList(gDisplayListHead++, D_8006F518); + gDPSetEnvColor(gDisplayListHead++, 255, 255, 255, sp83); + + if (!(ptr->unk_0C & 0x40)) { + func_82F1198C(ptr->unk_02, ptr->unk_04, ptr->unk_10, 0x81, 0xE5, 0); + } + } + + if (ptr->unk_0C & 8) { + if (ptr->unk_0C & 0x20) { + func_82F12DE4(ptr->unk_02, ptr->unk_04, ptr->unk_10, 0x23, 0x164, 0x68); + } else { + func_82F1228C(ptr->unk_02, ptr->unk_04, ptr->unk_10, 0x23, 0x164, 0x68); + } + } + + func_82F0EE58(); + gSPDisplayList(gDisplayListHead++, D_8006F630); +} + +s32 func_82F13964(s16 arg0) { + unk_D_82F21160* ptr = &D_82F21160[0]; + s32 var_v1 = 0; + + switch (arg0) { + case 1: + if ((D_82F21140.unk_00 == 3) && (D_82F21140.unk_18 == 0)) { + var_v1 = 1; + } + break; + + case 2: + if ((D_82F21140.unk_00 == 7) && (D_82F21140.unk_18 == 0)) { + var_v1 = 1; + } + break; + + case 3: + if (D_82F21140.unk_00 == 0) { + var_v1 = 1; + } + break; + + case 4: + if ((D_82F21160[0].unk_00 == 2) && (ptr[0].unk_1C <= 1.0f)) { + var_v1 = 1; + } + break; + + case 5: + if ((D_82F21160[1].unk_00 == 2) && (ptr[1].unk_1C <= 1.0f)) { + var_v1 = 1; + } + break; + + case 6: + if (D_82F21140.unk_00 == 0xA) { + var_v1 = 1; + } + break; + + case 8: + if ((D_82F21160[0].unk_00 == 7) && (D_82F21160[1].unk_00 == 7)) { + var_v1 = 1; + } + break; + + case 7: + case 9: + if ((D_82F21160[0].unk_00 == 0) && (D_82F21160[1].unk_00 == 0)) { + var_v1 = 1; + } + break; + + case 10: + if (D_82F21140.unk_00 == 0) { + var_v1 = 1; + } + break; + + case 11: + if (D_82F21238.unk_02 == 0) { + var_v1 = 1; + } + break; + + case 12: + if (D_82F21238.unk_02 == 2) { + var_v1 = 1; + } + break; + } + + return var_v1; +} + +void func_82F13B4C(s16 arg0) { + D_82F21140.unk_0E = arg0; +} + +s16 func_82F13B64(void) { + return D_82F21140.unk_00; +} diff --git a/src/fragments/43/fragment43_2A1B50.c b/src/fragments/43/fragment43_2A1B50.c index ef4048d..780a612 100644 --- a/src/fragments/43/fragment43_2A1B50.c +++ b/src/fragments/43/fragment43_2A1B50.c @@ -389,7 +389,7 @@ void func_8340144C(u16* arg0, s32 arg1, s32 arg2, s32 arg3, s32 arg4, s32 arg5) s32 i; for (i = 0; i < arg4; i += tmp) { - temp_v0 = CLAMP_MAX(tmp, arg4 - i); + temp_v0 = CLAMP_MIN(arg4 - i, tmp); gDPLoadTextureTile(gDisplayListHead++, &arg0[i * arg3], G_IM_FMT_RGBA, G_IM_SIZ_16b, arg3, 0, 0, 0, arg3, temp_v0 - 1, 0, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK, @@ -438,7 +438,7 @@ void func_834018C0(u16* arg0, s32 arg1, s32 arg2, s32 arg3, s32 arg4, s32 arg5, gDPSetRenderMode(gDisplayListHead++, G_RM_OPA_SURF, G_RM_OPA_SURF2); for (i = 0; i < arg4; i += arg5) { - temp_v0 = CLAMP_MAX(arg5, arg4 - i); + temp_v0 = CLAMP_MIN(arg4 - i, arg5); gDPLoadTextureTile(gDisplayListHead++, &arg0[i * arg3], G_IM_FMT_RGBA, G_IM_SIZ_16b, arg3, 0, 0, 0, arg3 - 1, temp_v0 - 1, 0, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK, diff --git a/src/fragments/44/fragment44.c b/src/fragments/44/fragment44.c index 16ae6fc..d38ef00 100644 --- a/src/fragments/44/fragment44.c +++ b/src/fragments/44/fragment44.c @@ -255,7 +255,7 @@ void func_83500758(s32 arg0, s32 arg1) { s32 tmp3 = 64; for (i = 0; i < new_var; i += tmp) { - temp_v0 = CLAMP_MAX(tmp, new_var - i); + temp_v0 = CLAMP_MIN(new_var - i, tmp); gDPLoadTextureTile(gDisplayListHead++, D_04001000 + ((i << 6) << 1), G_IM_FMT_RGBA, G_IM_SIZ_16b, 64, 64, tmp2, tmp2, 64, temp_v0 - 1, 0, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_CLAMP, @@ -687,7 +687,7 @@ void func_835024FC(void) { idx = 0; for (i = 0; i < end; i += 0x40, idx++) { - temp_v0_11 = CLAMP_MAX(0x40, end - i); + temp_v0_11 = CLAMP_MIN(end - i, 0x40); if (D_83504088 & (1 << idx)) { r = (((D_83503EA0.r - D_83503E98.r) * idx) / 8) + D_83503E98.r; @@ -839,7 +839,7 @@ void func_835028D0(s32 arg0, s32 arg1, s32 arg2) { gSPDisplayList(gDisplayListHead++, D_8006F518); for (i = 0; i < end; i += var_s2) { - s32 temp_v0_11 = CLAMP_MAX(var_s2, end - i); + s32 temp_v0_11 = CLAMP_MIN(end - i, var_s2); gDPLoadTextureTile(gDisplayListHead++, &spF0[i * var_ra], G_IM_FMT_IA, G_IM_SIZ_8b, var_ra, 0, 0, 0, var_ra, temp_v0_11 - 1, 0, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK, @@ -856,7 +856,7 @@ void func_835028D0(s32 arg0, s32 arg1, s32 arg2) { var_ra = 0x64; end = 0x37; for (i = 0; i < end; i += var_s2) { - s32 temp_v0_11 = CLAMP_MAX(var_s2, end - i); + s32 temp_v0_11 = CLAMP_MIN(end - i, var_s2); gDPLoadTextureTile(gDisplayListHead++, &spEC[i * var_ra], G_IM_FMT_IA, G_IM_SIZ_8b, var_ra, 0, 0, 0, var_ra, temp_v0_11 - 1, 0, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK, @@ -875,7 +875,7 @@ void func_835028D0(s32 arg0, s32 arg1, s32 arg2) { var_s2 = 0x14; end = 0x3C; for (i = 0; i < end; i += var_s2) { - s32 temp_v0_11 = CLAMP_MAX(var_s2, end - i); + s32 temp_v0_11 = CLAMP_MIN(end - i, var_s2); gDPLoadTextureTile(gDisplayListHead++, &spE8[i * var_ra], G_IM_FMT_RGBA, G_IM_SIZ_16b, var_ra, 0, 0, 0, var_ra, temp_v0_11 - 1, 0, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_CLAMP, @@ -912,7 +912,7 @@ void func_83502F78(int arg0, int arg1, s32 arg2, f32 arg3) { gSPDisplayList(gDisplayListHead++, D_8006F518); for (i = 0; i < spF8; i += iter) { - s32 temp_v0_2 = CLAMP_MAX(iter, spF8 - i); + s32 temp_v0_2 = CLAMP_MIN(spF8 - i, iter); s32 temp_fv1_2 = ROUND_MAX((temp_v0_2 * arg3) + 0.4f); s32 temp_fa0 = ROUND_MAX((i * arg3) + 0.4f); diff --git a/src/fragments/45/fragment45.c b/src/fragments/45/fragment45.c index e2282c4..b0a9480 100644 --- a/src/fragments/45/fragment45.c +++ b/src/fragments/45/fragment45.c @@ -350,7 +350,7 @@ void func_83600E20(s32 arg0, s32 arg1, s16 arg2) { gSPDisplayList(gDisplayListHead++, D_8006F518); for (i = 0; i < spC0; i += end) { - temp_v0_2 = CLAMP_MAX(end, spC0 - i); + temp_v0_2 = CLAMP_MIN(spC0 - i, end); gDPLoadTextureBlock(gDisplayListHead++, &D_4004D48[i * spC0], G_IM_FMT_RGBA, G_IM_SIZ_16b, spC0, temp_v0_2, 0, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK, G_TX_NOMASK, @@ -388,7 +388,7 @@ void func_83601314(s32 arg0, s32 arg1, s16 arg2) { gSPDisplayList(gDisplayListHead++, D_8006F518); for (i = 0; i < spC0; i += end) { - temp_v0_2 = CLAMP_MAX(end, spC0 - i); + temp_v0_2 = CLAMP_MIN(spC0 - i, end); gDPLoadTextureBlock(gDisplayListHead++, &D_4005F48[i * spC0], G_IM_FMT_RGBA, G_IM_SIZ_16b, spC0, temp_v0_2, 0, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK, G_TX_NOMASK, @@ -566,7 +566,7 @@ void func_83601F28(int arg0, int arg1, s32 arg2, f32 arg3) { gSPDisplayList(gDisplayListHead++, D_8006F518); for (i = 0; i < spF8; i += iter) { - s32 temp_v0_2 = CLAMP_MAX(iter, spF8 - i); + s32 temp_v0_2 = CLAMP_MIN(spF8 - i, iter); s32 temp_fv1_2 = ROUND_MAX((temp_v0_2 * arg3) + 0.4f); s32 temp_fa0 = ROUND_MAX((i * arg3) + 0.4f); @@ -615,7 +615,7 @@ void func_83602458(void) { idx = 0; for (i = 0; i < end; i += 0x40, idx++) { - s32 temp_v0_2 = CLAMP_MAX(0x40, end - i); + s32 temp_v0_2 = CLAMP_MIN(end - i, 0x40); if (D_836033C0 & (1 << idx)) { r = (((D_836032AC.r - D_836032A4.r) * idx) / 8) + D_836032A4.r; diff --git a/yamls/us/rom.yaml b/yamls/us/rom.yaml index 1de7989..9cb5a49 100644 --- a/yamls/us/rom.yaml +++ b/yamls/us/rom.yaml @@ -1634,14 +1634,26 @@ - [0x28ED00, c, fragments/41/fragment41_28ED00] - [0x291D60, c, fragments/41/fragment41_291D60] - [0x2942C0, c, fragments/41/fragment41_2942C0] - - [0x29BA20, data, fragments/41/fragment41_data] - - [0x29BF80, rodata, fragments/41/fragment41_rodata_29BF80] - - [0x29C010, rodata, fragments/41/fragment41_rodata_29C010] - - [0x29C040, rodata, fragments/41/fragment41_rodata_29C040] - - [0x29C140, rodata, fragments/41/fragment41_rodata_29C140] - - [0x29C180, rodata, fragments/41/fragment41_rodata_29C180] + - [0x29BA20, .data, fragments/41/fragment41_287ED0] + - [0x29BA40, .data, fragments/41/fragment41_289240] + - [0x29BAC0, .data, fragments/41/fragment41_28D1A0] + - [0x29BB60, .data, fragments/41/fragment41_28ED00] + - [0x29BE20, .data, fragments/41/fragment41_291D60] + - [0x29BE40, .data, fragments/41/fragment41_2942C0] + + - [0x29BF80, .rodata, fragments/41/fragment41_287ED0] + - [0x29C010, .rodata, fragments/41/fragment41_289240] + - [0x29C040, .rodata, fragments/41/fragment41_28D1A0] + - [0x29C090, .rodata, fragments/41/fragment41_28ED00] + - [0x29C140, .rodata, fragments/41/fragment41_291D60] + - [0x29C180, .rodata, fragments/41/fragment41_2942C0] - - {vram: 0x82F14420, type: bss, name: fragments/41/fragment41_bss} + - {vram: 0x82F14420, type: .bss, name: fragments/41/fragment41_287ED0} + - {vram: 0x82F144D0, type: .bss, name: fragments/41/fragment41_289240} + - {vram: 0x82F20A10, type: .bss, name: fragments/41/fragment41_28D1A0} + - {vram: 0x82F20A40, type: .bss, name: fragments/41/fragment41_28ED00} + - {vram: 0x82F210E0, type: .bss, name: fragments/41/fragment41_291D60} + - {vram: 0x82F21140, type: .bss, name: fragments/41/fragment41_2942C0} - name: fragment41_relocs type: code