From f4a30b39d41d1f366d99fe25837c5dd74a54bbf0 Mon Sep 17 00:00:00 2001 From: Kelebek1 Date: Sat, 26 Apr 2025 22:34:56 +0100 Subject: [PATCH] fragment61 --- include/variables.h | 42 + linker_scripts/us/symbol_addrs.txt | 49 +- linker_scripts/us/undefined_syms.ld | 42 +- src/22630.c | 2 +- src/29BA0.h | 4 +- src/fragments/47/fragment47.h | 28 +- src/fragments/47/fragment47_2AE1F0.c | 11 - src/fragments/47/fragment47_2AFDB0.c | 34 +- src/fragments/61/fragment61.h | 359 +++++++- src/fragments/61/fragment61_2D78B0.c | 1128 +++++++++++++++++++++++- src/fragments/61/fragment61_2DB900.c | 816 +++++++++++++++++- src/fragments/61/fragment61_2DD710.c | 943 +++++++++++++++++++- src/fragments/61/fragment61_2DFB60.c | 1017 +++++++++++++++++++++- src/fragments/61/fragment61_2E2C20.c | 671 +++++++++++---- src/fragments/61/fragment61_2E4040.c | 646 ++++++++++++++ src/fragments/61/fragment61_2E5430.c | 1196 ++++++++++++++++++++++++++ src/fragments/62/fragment62_2F1D60.c | 2 + tools/data2c.py | 13 +- yamls/us/rom.yaml | 31 +- 19 files changed, 6664 insertions(+), 370 deletions(-) create mode 100644 src/fragments/61/fragment61_2E4040.c create mode 100644 src/fragments/61/fragment61_2E5430.c diff --git a/include/variables.h b/include/variables.h index 641802c..0e6ca60 100644 --- a/include/variables.h +++ b/include/variables.h @@ -56,6 +56,7 @@ extern f32 gSineTable[]; extern f32 gCosineTable[0x1000]; extern s16 gArctanTable[0x401]; extern s32 D_B0000504; +extern s32 D_B0000800; extern u8 D_1000000[]; extern u8 D_8000000[]; @@ -574,6 +575,47 @@ extern u8 D_3024000[]; extern u8 D_3009000[]; extern u8 D_3012000[]; extern u8 D_301B000[]; +extern u8 D_2028AE0[]; +extern u8 D_20293E0[]; +extern u8 D_200DFA0[]; +extern u8 D_200F3E0[]; +extern u8 D_2010820[]; +extern u8 D_2011C60[]; +extern u8 D_20130A0[]; +extern u8 D_2029CE0[]; +extern u8 D_20068E0[]; +extern u8 D_200AC00[]; +extern u8 D_202C080[]; +extern u8 D_202C500[]; +extern u8 D_202C980[]; +extern u8 D_202CE00[]; +extern u8 D_202D280[]; +extern u8 D_202D700[]; +extern u8 D_202DB80[]; +extern u8 D_202E000[]; +extern u8 D_202A8C0[]; +extern u8 D_202B4A0[]; +extern u8 D_2014F00[]; +extern u8 D_20154B0[]; +extern u8 D_2015A60[]; +extern u8 D_2016D40[]; +extern u8 D_2017740[]; +extern u8 D_2019040[]; +extern u8 D_2019680[]; +extern u8 D_2018D20[]; +extern u8 D_2018A00[]; +extern u8 D_20199A0[]; +extern u8 D_2019360[]; +extern u8 D_2019FE0[]; +extern u8 D_2017A60[]; +extern u8 D_2017D80[]; +extern u8 D_20183C0[]; +extern u8 D_20186E0[]; +extern u8 D_2019CC0[]; +extern u8 D_20180A0[]; +extern u8 D_201A300[]; +extern u8 D_20165C0[]; +extern u8 D_2016980[]; extern LEODiskID D_800818E0; diff --git a/linker_scripts/us/symbol_addrs.txt b/linker_scripts/us/symbol_addrs.txt index 8158c89..f5c14bf 100644 --- a/linker_scripts/us/symbol_addrs.txt +++ b/linker_scripts/us/symbol_addrs.txt @@ -829,4 +829,51 @@ D_82E01F68 = 0x82E01F68; // size:0x438 D_3024000 = 0x3024000; D_3009000 = 0x3009000; D_3012000 = 0x3012000; -D_301B000 = 0x301B000; \ No newline at end of file +D_301B000 = 0x301B000; +D_8423D3D8 = 0x8423D3D8; // size:0x20 +D_8423D3A8 = 0x8423D3A8; // size:0x2C +D_2028AE0 = 0x2028AE0; +D_20293E0 = 0x20293E0; +D_200DFA0 = 0x200DFA0; +D_200F3E0 = 0x200F3E0; +D_2010820 = 0x2010820; +D_2011C60 = 0x2011C60; +D_20130A0 = 0x20130A0; +D_84211B50 = 0x84211B50; // size:0x4D10 +D_B0000800 = 0xB0000800; +D_842168A0 = 0x842168A0; // size:0x13610 +D_2029CE0 = 0x2029CE0; +D_84210DA0 = 0x84210DA0; // size:0x38 +D_20068E0 = 0x20068E0; +D_200AC00 = 0x200AC00; +D_202C080 = 0x202C080; +D_202C500 = 0x202C500; +D_202C980 = 0x202C980; +D_202CE00 = 0x202CE00; +D_202D280 = 0x202D280; +D_202D700 = 0x202D700; +D_202DB80 = 0x202DB80; +D_202E000 = 0x202E000; +D_202A8C0 = 0x202A8C0; +D_202B4A0 = 0x202B4A0; +D_2014F00 = 0x2014F00; +D_20154B0 = 0x20154B0; +D_2015A60 = 0x2015A60; +D_2016D40 = 0x2016D40; +D_2017740 = 0x2017740; +D_2019040 = 0x2019040; +D_2019680 = 0x2019680; +D_2018D20 = 0x2018D20; +D_2018A00 = 0x2018A00; +D_20199A0 = 0x20199A0; +D_2019360 = 0x2019360; +D_2019FE0 = 0x2019FE0; +D_2017A60 = 0x2017A60; +D_2017D80 = 0x2017D80; +D_20183C0 = 0x20183C0; +D_20186E0 = 0x20186E0; +D_2019CC0 = 0x2019CC0; +D_20180A0 = 0x20180A0; +D_201A300 = 0x201A300; +D_20165C0 = 0x20165C0; +D_2016980 = 0x2016980; \ No newline at end of file diff --git a/linker_scripts/us/undefined_syms.ld b/linker_scripts/us/undefined_syms.ld index cda4fce..b2bbaeb 100644 --- a/linker_scripts/us/undefined_syms.ld +++ b/linker_scripts/us/undefined_syms.ld @@ -344,4 +344,44 @@ D_0302A9C0 = 0x0302A9C0; D_0302B740 = 0x0302B740; D_0302C4C0 = 0x0302C4C0; D_0302D480 = 0x0302D480; -D_301B000 = 0x301B000; \ No newline at end of file +D_301B000 = 0x301B000; +D_B0000800 = 0xB0000800; +D_200F3E0 = 0x200F3E0; +D_2010820 = 0x2010820; +D_2011C60 = 0x2011C60; +D_20130A0 = 0x20130A0; +D_2029CE0 = 0x2029CE0; +D_20068E0 = 0x20068E0; +D_200AC00 = 0x200AC00; +D_202C080 = 0x202C080; +D_202C500 = 0x202C500; +D_202C980 = 0x202C980; +D_202CE00 = 0x202CE00; +D_202D280 = 0x202D280; +D_202D700 = 0x202D700; +D_202DB80 = 0x202DB80; +D_202E000 = 0x202E000; +D_202A8C0 = 0x202A8C0; +D_202B4A0 = 0x202B4A0; +D_2014F00 = 0x2014F00; +D_20154B0 = 0x20154B0; +D_2015A60 = 0x2015A60; +D_2016D40 = 0x2016D40; +D_2017740 = 0x2017740; +D_2019040 = 0x2019040; +D_2019680 = 0x2019680; +D_2018D20 = 0x2018D20; +D_2018A00 = 0x2018A00; +D_20199A0 = 0x20199A0; +D_2019360 = 0x2019360; +D_2019FE0 = 0x2019FE0; +D_2017A60 = 0x2017A60; +D_2017D80 = 0x2017D80; +D_20183C0 = 0x20183C0; +D_20186E0 = 0x20186E0; +D_2019CC0 = 0x2019CC0; +D_20180A0 = 0x20180A0; +D_201A300 = 0x201A300; +D_20165C0 = 0x20165C0; +D_2016980 = 0x2016980; +D_200DFA0 = 0x200DFA0; \ No newline at end of file diff --git a/src/22630.c b/src/22630.c index 392e1b1..eba39fc 100644 --- a/src/22630.c +++ b/src/22630.c @@ -158,7 +158,7 @@ void func_80021F04(unk_func_80026268_arg0* arg0, unk_D_800AE4E8_004_1_000_010_00 arg1->unk_00 = arg0->unk_00.unk_01; } - func_80021A68(arg1->unk_01, arg0->unk_02); + func_80021A68(arg1->unk_01, (u16)arg0->unk_02); arg1->unk_03 = arg0->unk_04; arg1->unk_04 = arg0->unk_05; diff --git a/src/29BA0.h b/src/29BA0.h index 8fbf78d..6bc50e3 100644 --- a/src/29BA0.h +++ b/src/29BA0.h @@ -58,7 +58,7 @@ typedef struct unk_D_800AE540_0874 { /* 0x002 */ u8 unk_002; /* 0x003 */ u8 unk_003; /* 0x004 */ char unk004[0x10]; - /* 0x014 */ char unk_014[0x4]; + /* 0x014 */ char unk_014[4]; /* 0x018 */ char unk018[0x10]; /* 0x028 */ unk_func_80026268_arg0 unk_028[1]; /* 0x07C */ char unk07C[0x1A4]; @@ -71,7 +71,7 @@ typedef struct unk_D_800AE540_0004 { /* 0x001 */ u8 unk_001; /* 0x002 */ u8 unk_002; /* 0x004 */ Controller* controller; - /* 0x008 */ char unk_008[0x4]; + /* 0x008 */ char unk_008[4]; /* 0x00C */ char unk00C[0xC]; /* 0x018 */ s32 unk_018; /* 0x01C */ unk_func_80026268_arg0 unk_01C[1]; diff --git a/src/fragments/47/fragment47.h b/src/fragments/47/fragment47.h index f4be802..1e05602 100644 --- a/src/fragments/47/fragment47.h +++ b/src/fragments/47/fragment47.h @@ -14,12 +14,17 @@ typedef struct unk_D_8380565C { } unk_D_8380565C; // size >= 0x838 typedef struct unk_D_838067F0_0168_0000 { - /* 0x000 */ u8 unk_000; - /* 0x001 */ u8 unk_001; - /* 0x002 */ u8 unk_002; - /* 0x003 */ u8 unk_003; - /* 0x004 */ unk_func_80026268_arg0 unk_004[3]; - /* 0x100 */ char unk100[0xBD8]; + union { + struct { + /* 0x000 */ u8 unk_000; + /* 0x001 */ u8 unk_001; + /* 0x002 */ u8 unk_002; + /* 0x003 */ u8 unk_003; + }; + s32 raw; + }; + /* 0x004 */ unk_func_80026268_arg0 unk_004; + /* 0x058 */ u16 unk_058[0x640]; } unk_D_838067F0_0168_0000; // size = 0xCD8 typedef struct unk_D_838067F0_0168 { @@ -60,6 +65,17 @@ typedef struct unk_D_838067F0 { /* 0x0168 */ unk_D_838067F0_0168 unk_0168[12]; } unk_D_838067F0; // size = 0x1D088 +typedef struct unk_D_8380548C { + /* 0x00 */ u8 unk_00; + /* 0x01 */ u8 unk_01; + /* 0x02 */ s16 unk_02; + /* 0x04 */ s16 unk_04; + /* 0x06 */ s16 unk_06; + /* 0x08 */ s16 unk_08; + /* 0x0A */ s16 unk_0A; + /* 0x0C */ s16 unk_0C; +} unk_D_8380548C; // size = 0xE + void func_83800020(s32 arg0); void func_8380008C(s32 arg0); void func_83800098(s32 arg0, s32 arg1); diff --git a/src/fragments/47/fragment47_2AE1F0.c b/src/fragments/47/fragment47_2AE1F0.c index 40287e7..6299d69 100644 --- a/src/fragments/47/fragment47_2AE1F0.c +++ b/src/fragments/47/fragment47_2AE1F0.c @@ -13,17 +13,6 @@ #include "src/memmap.h" #include "src/memory.h" -typedef struct unk_D_8380548C { - /* 0x00 */ u8 unk_00; - /* 0x01 */ u8 unk_01; - /* 0x02 */ s16 unk_02; - /* 0x04 */ s16 unk_04; - /* 0x06 */ s16 unk_06; - /* 0x08 */ s16 unk_08; - /* 0x0A */ s16 unk_0A; - /* 0x0C */ s16 unk_0C; -} unk_D_8380548C; // size = 0xE - typedef struct unk_D_83806778 { /* 0x00 */ u8 unk_00; /* 0x01 */ u8 unk_01; diff --git a/src/fragments/47/fragment47_2AFDB0.c b/src/fragments/47/fragment47_2AFDB0.c index c7c57ac..bda8c98 100644 --- a/src/fragments/47/fragment47_2AFDB0.c +++ b/src/fragments/47/fragment47_2AFDB0.c @@ -99,7 +99,7 @@ s32 func_83802700(unk_D_838067F0* arg0, unk_D_838067F0_0168* arg1, s32 arg2, unk arg1->unk_2692 = arg0->unk_001C; for (i = 0; i < 3; i++) { - arg1->unk_0000[i].unk_004[0].unk_00.unk_00 = 0; + arg1->unk_0000[i].unk_004.unk_00.unk_00 = 0; *(s32*)&arg1->unk_0000[i].unk_000 = 0; } @@ -118,7 +118,7 @@ s32 func_83802700(unk_D_838067F0* arg0, unk_D_838067F0_0168* arg1, s32 arg2, unk for (j = 0; j < 3; j++) { if (i < temp_s3->unk_00) { if (func_80022DF4(var_v0, temp_s3->unk_02[i++]) != 0) { - var_s4 += func_80022E18(arg1->unk_0000[j].unk_004, 1, var_v0); + var_s4 += func_80022E18(&arg1->unk_0000[j].unk_004, 1, var_v0); } } } @@ -130,24 +130,25 @@ s32 func_83802700(unk_D_838067F0* arg0, unk_D_838067F0_0168* arg1, s32 arg2, unk s32 var_s1_3 = arg2 * 3; for (j = 0; j < 3; j++) { if (var_s1_3 < arg3->unk_000) { - _bcopy(&arg3->unk_004[var_s1_3++], &arg1->unk_0000[var_s4].unk_004[0], 0x54); - func_800228B0(arg1->unk_0000[var_s4++].unk_004); + _bcopy(&arg3->unk_004[var_s1_3++], &arg1->unk_0000[var_s4].unk_004, + sizeof(arg1->unk_0000[var_s4].unk_004)); + func_800228B0(&arg1->unk_0000[var_s4++].unk_004); } } } for (i = 0; i < var_s4; i++) { - func_8001B0DC(&arg1->unk_0000[i].unk_004[1], 0, &arg1->unk_0000[i].unk_004[0]); + func_8001B0DC(arg1->unk_0000[i].unk_058, 0, &arg1->unk_0000[i].unk_004); arg1->unk_0000[i].unk_000 = arg0->unk_0018; arg1->unk_0000[i].unk_001 = arg0->unk_001C; arg1->unk_0000[i].unk_002 = arg2 * 3 + i; - arg1->unk_0000[i].unk_003 = arg1->unk_0000[i].unk_004[0].unk_00.unk_00; + arg1->unk_0000[i].unk_003 = arg1->unk_0000[i].unk_004.unk_00.unk_00; - arg1->unk_0000[i].unk_004[0].unk_53 = arg2 * 3 + i; - arg1->unk_0000[i].unk_004[0].unk_52 = (arg0->unk_0018 * 0x10) | arg0->unk_001C; + arg1->unk_0000[i].unk_004.unk_53 = arg2 * 3 + i; + arg1->unk_0000[i].unk_004.unk_52 = (arg0->unk_0018 * 0x10) | arg0->unk_001C; - func_83802660(arg0, &arg1->unk_0000[i].unk_004[0]); + func_83802660(arg0, &arg1->unk_0000[i].unk_004); } return var_s4; @@ -238,7 +239,7 @@ unk_D_838067F0_0168* func_83802C74(unk_D_838067F0_0168* arg0, s32 arg1) { void func_83802C98(unk_D_838067F0* arg0) { unk_D_838067F0_0168* ptr = func_83802C74(arg0->unk_0160, arg0->unk_0028); - unk_func_80026268_arg0* temp_a1 = &ptr->unk_0000[arg0->unk_0024].unk_004[0]; + unk_func_80026268_arg0* temp_a1 = &ptr->unk_0000[arg0->unk_0024].unk_004; if (temp_a1->unk_00.unk_00 != 0) { arg0->unk_0000 = 7; @@ -667,7 +668,7 @@ void func_8380419C(s32 arg0, s32 arg1, unk_D_838067F0_0168* arg2) { s32 i; for (i = 0; i < 3; i++) { - if (arg2->unk_0000[i].unk_004[0].unk_00.unk_00 != 0) { + if (arg2->unk_0000[i].unk_004.unk_00.unk_00 != 0) { func_84200420(arg0 + i * 0x84, arg1, 0x84, 0x2C, 0x64, 0x64, 0xC8, 0xFF); } else { func_84200420(arg0 + i * 0x84, arg1, 0x84, 0x2C, 0x3C, 0x3C, 0xA0, 0xFF); @@ -677,21 +678,20 @@ void func_8380419C(s32 arg0, s32 arg1, unk_D_838067F0_0168* arg2) { gSPDisplayList(gDisplayListHead++, D_8006F518); for (i = 0; i < 3; i++) { - if (arg2->unk_0000[i].unk_004[0].unk_00.unk_00 != 0) { - func_8001C6AC(arg0 + (i * 0x84) + 2, arg1 + 2, 0x28, 0x28, &arg2->unk_0000[i].unk_004[1].unk_00.unk_00, - 0x28, 0); + if (arg2->unk_0000[i].unk_004.unk_00.unk_00 != 0) { + func_8001C6AC(arg0 + (i * 0x84) + 2, arg1 + 2, 0x28, 0x28, &arg2->unk_0000[i].unk_058, 0x28, 0); } } func_8001F3F4(); for (i = 0; i < 3; i++) { - if (arg2->unk_0000[i].unk_004[0].unk_00.unk_00 != 0) { + if (arg2->unk_0000[i].unk_004.unk_00.unk_00 != 0) { func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); func_8001EBE0(4, 0); - func_8001F1E8(arg0 + (i * 0x84) + 0x2C, arg1 + 5, arg2->unk_0000[i].unk_004[0].unk_30); + func_8001F1E8(arg0 + (i * 0x84) + 0x2C, arg1 + 5, arg2->unk_0000[i].unk_004.unk_30); func_8001EBE0(4, 0); - func_8001F1E8(arg0 + (i * 0x84) + 0x2C, arg1 + 0x17, "L%d", arg2->unk_0000[i].unk_004[0].unk_24); + func_8001F1E8(arg0 + (i * 0x84) + 0x2C, arg1 + 0x17, "L%d", arg2->unk_0000[i].unk_004.unk_24); } } diff --git a/src/fragments/61/fragment61.h b/src/fragments/61/fragment61.h index 85ef9c8..9ada734 100644 --- a/src/fragments/61/fragment61.h +++ b/src/fragments/61/fragment61.h @@ -2,11 +2,360 @@ #define _FRAGMENT61_H_ #include "global.h" +#include "src/11BA0.h" +#include "src/1AB70.h" +#include "src/fragments/47/fragment47.h" -void func_842001B8(s16, s16, s16, s16); -void func_84200420(s16, s16, s16, s16, u8, u8, u8, u8); -void func_84200738(s16, s16, s16, s16); -void func_8420092C(s16, s16, s16, s16, u8, u8, u8, u8); -void func_8420112C(s16, s16, s16, s16, u8, u8, u8, u8); +struct unk_D_842168A0; +struct unk_D_84229EB0; + +typedef struct unk_D_8423D3A8 { + /* 0x00 */ u8 unk_00; + /* 0x01 */ u8 unk_01; + /* 0x02 */ u8 unk_02; + /* 0x03 */ u8 unk_03; + /* 0x04 */ s16 unk_04; + /* 0x06 */ s16 unk_06; + /* 0x08 */ s16 unk_08; + /* 0x0A */ s16 unk_0A; + /* 0x0C */ s16 unk_0C; + /* 0x0E */ unk_D_800A7440 unk_0E; + /* 0x16 */ unk_D_800A7440 unk_16; + /* 0x20 */ s32 unk_20; + /* 0x24 */ unk_D_86002F58_004_000_010* unk_24; + /* 0x28 */ unk_func_8001B1FC* unk_28; + /* 0x2C */ unk_D_838067F0_0168_0000* unk_2C; +} unk_D_8423D3A8; // size >= 0x30 + +typedef struct unk_D_842168A0_13608 { + /* 0x00 */ char unk04[0x4]; +} unk_D_842168A0_13608; // size >= 0x4 + +typedef struct unk_D_84229EB0_00024 { + /* 0x0000 */ unk_D_838067F0_0168_0000 unk_0000[6]; + /* 0x4D10 */ u16 unk_4D10; + /* 0x4D12 */ char unk_4D12[2]; + /* 0x4D14 */ char unk4D14[0xA]; + /* 0x4D1E */ s16 unk_4D1E; + /* 0x4D20 */ s16 unk_4D20; + /* 0x4D24 */ struct unk_D_84229EB0_00024* unk_4D24; + /* 0x4D28 */ struct unk_D_84229EB0_00024* unk_4D28; + /* 0x4D2C */ char unk4D2C[0x4]; +} unk_D_84229EB0_00024; // size = 0x4D30 + +typedef struct unk_D_84211B50 { + /* 0x0000 */ u8 unk_0000; + /* 0x0001 */ u8 unk_0001; + /* 0x0002 */ u8 unk_0002; + /* 0x0003 */ u8 unk_0003; + /* 0x0004 */ u8 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 */ u16 unk_001C; + /* 0x001E */ char unk_001E[2]; + /* 0x0020 */ char unk0020[0x10]; + /* 0x0030 */ unk_D_838067F0_0168_0000 unk_0030[6]; + /* 0x4D40 */ struct unk_D_842168A0* unk_4D40; + /* 0x4D44 */ unk_D_8423D3A8* unk_4D44; + /* 0x4D48 */ struct unk_D_84229EB0* unk_4D48; +} unk_D_84211B50; // size = 0x4D4C + +typedef struct unk_D_842168A0_0013C { + /* 0x00 */ u32 unk_00; + /* 0x04 */ unk_func_80026268_arg0 unk_04[1]; +} unk_D_842168A0_0013C; // size >= 0x58 + +typedef struct unk_D_842168A0 { + /* 0x00000 */ u8 unk_00000; + /* 0x00001 */ u8 unk_00001; + /* 0x00002 */ u8 unk_00002; + /* 0x00003 */ u8 unk_00003; + /* 0x00004 */ u8 unk_00004; + /* 0x00005 */ u8 unk_00005; + /* 0x00006 */ u8 unk_00006; + /* 0x00007 */ u8 unk_00007; + /* 0x00008 */ u8 unk_00008; + /* 0x00009 */ u8 unk_00009; + /* 0x0000A */ s16 unk_0000A; + /* 0x0000C */ s16 unk_0000C; + /* 0x0000E */ s16 unk_0000E; + /* 0x00010 */ s16 unk_00010; + /* 0x00012 */ s16 unk_00012; + /* 0x00014 */ s16 unk_00014; + /* 0x00016 */ s16 unk_00016; + /* 0x00018 */ s16 unk_00018; + /* 0x0001A */ s16 unk_0001A; + /* 0x0001C */ unk_D_838067F0_003C unk_0001C[13]; + /* 0x0013A */ char unk0013A[0x2]; + /* 0x0013C */ unk_D_842168A0_0013C* unk_0013C; + /* 0x00140 */ unk_D_838067F0_0168* unk_00140; + /* 0x00144 */ char unk00144[0x4]; + /* 0x00148 */ unk_D_838067F0_0168 unk_00148[8]; + /* 0x13608 */ unk_D_84211B50* unk_13608; + /* 0x1360C */ unk_D_8423D3A8* unk_1360C; +} unk_D_842168A0; // size = 0x13610 + +typedef struct unk_D_84229EB0 { + /* 0x00000 */ u8 unk_00000; + /* 0x00001 */ u8 unk_00001; + /* 0x00002 */ u8 unk_00002; + /* 0x00003 */ u8 unk_00003; + /* 0x00004 */ u8 unk_00004; + /* 0x00005 */ s8 unk_00005; + /* 0x00006 */ s16 unk_00006; + /* 0x00008 */ s16 unk_00008; + /* 0x0000A */ s16 unk_0000A; + /* 0x0000C */ u8 unk_0000C; + /* 0x0000D */ u8 unk_0000D; + /* 0x0000E */ s16 unk_0000E; + /* 0x00010 */ s16 unk_00010; + /* 0x00012 */ s16 unk_00012; + /* 0x00014 */ s16 unk_00014; + /* 0x00016 */ s16 unk_00016; + /* 0x00018 */ s16 unk_00018; + /* 0x0001A */ s16 unk_0001A; + /* 0x0001C */ s16 unk_0001C; + /* 0x0001E */ u8 unk_0001E; + /* 0x0001F */ u8 unk_0001F; + /* 0x00020 */ u8 unk_00020; + /* 0x00024 */ unk_D_84229EB0_00024* unk_00024; + /* 0x00028 */ unk_D_84229EB0_00024 unk_00028[3]; + /* 0x0E7B8 */ char unk0E7B8[0x4D30]; + /* 0x134E8 */ unk_D_84211B50* unk_134E8; + /* 0x134EC */ unk_D_842168A0* unk_134EC; + /* 0x134F0 */ unk_D_8423D3A8* unk_134F0; + /* 0x134F4 */ char unk134F4[0x4]; +} unk_D_84229EB0; // size = 0x134F8 + +typedef struct unk_D_8423D3D8 { + /* 0x00 */ u8 unk_00; + /* 0x01 */ u8 unk_01; + /* 0x02 */ s16 unk_02; + /* 0x04 */ unk_D_800AE540_0004* unk_04; +} unk_D_8423D3D8; // size = 0x8 + +typedef struct unk_D_84211704 { + /* 0x00 */ s16 unk_00; + /* 0x02 */ s16 unk_02; + /* 0x04 */ s16 unk_04; + /* 0x06 */ s16 unk_06; + /* 0x08 */ s16 unk_08; + /* 0x0A */ s8 unk_0A; + /* 0x0B */ s8 unk_0B; + /* 0x0C */ s16 unk_0C; + /* 0x0E */ u16 unk_0E; +} unk_D_84211704; // size = 0x10 + +s32 func_84200020(s32 arg0); +char* func_84200088(s32 arg0); +char* func_842000C0(s32 arg0); +char* func_842000F8(s32 arg0); +char* func_84200130(s32 arg0); +char* func_84200160(s32 arg0); +char* func_84200190(char* arg0, s32 arg1, s32 arg2); +void func_842001B8(s16 arg0, s16 arg1, s16 arg2, s16 arg3); +void func_84200420(s16 arg0, s16 arg1, s16 arg2, s16 arg3, u8 arg4, u8 arg5, u8 arg6, u8 arg7); +void func_84200738(s16 arg0, s16 arg1, s16 arg2, s16 arg3); +void func_8420092C(s16 arg0, s16 arg1, s16 arg2, s16 arg3, u8 arg4, u8 arg5, u8 arg6, u8 arg7); +void func_8420112C(s16 arg0, s16 arg1, s16 arg2, s16 arg3, u8 arg4, u8 arg5, u8 arg6, u8 arg7); +void func_8420192C(s16 arg0, s16 arg1); +void func_84201A00(s16 arg0, s16 arg1); +void func_84201AD4(s16 arg0, s16 arg1, s16 arg2); +void func_84201BC4(s16 arg0, s16 arg1, s16 arg2, Color_RGBA8* arg3, Color_RGBA8* arg4); +void func_84201D6C(void); +void func_84201E70(s16 arg0, s16 arg1, s16 arg2, s32 arg3); +void func_84201F04(s16 arg0, s16 arg1, s16 arg2); +void func_84202208(void); +s32 func_84202284(void); +s16 func_842023E4(void); +void func_842024DC(s16 arg0, s16 arg1); +void func_84202718(UNUSED s16 arg0, s16 arg1, s16 arg2); +s16 func_84202844(s16 arg0, s16 arg1, s16 arg2, s32 arg3); +void func_84202974(UNUSED s16 arg0, UNUSED s32 arg1); +void func_84202A64(s16 arg0, s32 arg1, s16 arg2); +void func_84202AF4(s16 arg0, s16 arg1, s16 arg2); +void func_84202C20(void); +void func_84202D18(unk_D_8423D3D8* arg0, s16 arg1); +s32 func_84202EB0(unk_D_8423D3D8* arg0, s16 arg1); +void func_8420305C(s32 arg0); +void func_84203100(void); +void func_8420318C(s16 arg0, s16 arg1); +s32 func_84203210(void); +s32 func_842034E4(void); +void func_842037AC(void); +void func_842039B4(void); +void func_84203AB8(void); +s32 func_84203BBC(void); +void func_84203C90(void); +void func_84203D74(void); +s32 func_84203E6C(s32 arg0, UNUSED s32 arg1); + +s32 func_84204070(s32 arg0, unk_func_80011B94* arg1); +void func_84204210(void); +void func_84204294(s32 arg0); +void func_8420448C(void); +void func_84204660(s32 arg0, s16 arg1, s16 arg2); +void func_84204760(s32 arg0); +void func_84204934(s16 arg0, f32 arg1); +void func_84204A3C(s16 arg0, f32 arg1); +void func_84204B50(void); +void func_84204BF8(void); +void func_84204C9C(void); +void func_84204D5C(void); +void func_84204E0C(void); +void func_84204F78(void); +void func_842050CC(void); +void func_84205200(void); +void func_8420545C(void); +void func_8420563C(void); +s32 func_8420570C(void); +void func_842057AC(void); +void func_8420594C(void); +void func_84205B3C(void); +s32 func_84205C18(s16 arg0); +s32 func_84205D48(s16 arg0, s32 arg1); +s16 func_84205E54(void); + +void func_84205E80(s16 arg0, s16 arg1, s32 arg2); +void func_84205F18(unk_D_84211B50* arg0, s16 arg1, s16 arg2); +void func_84206144(unk_D_84211B50* arg0); +void func_842062D4(unk_D_84211B50* arg0, s32 arg1); +void func_842068DC(unk_D_84211B50* arg0); +s32 func_84206990(unk_D_84211B50* arg0); +s32 func_84206A68(unk_D_84211B50* arg0); +void func_84206BC4(unk_D_84211B50* arg0); +void func_84206BDC(unk_D_84211B50* arg0); +void func_84206BF0(unk_D_84211B50* a0); +void func_84206D10(unk_D_84211B50* arg0); +void func_84206DE8(unk_D_84211B50* arg0); +void func_84206E88(unk_D_84211B50* arg0); +void func_84206EE0(unk_D_84211B50* arg0); +void func_84206F1C(unk_D_84211B50* arg0); +void func_84206F64(unk_D_84211B50* arg0); +void func_84206FB0(unk_D_84211B50* arg0); +void func_84206FF8(unk_D_84211B50* arg0); +void func_84207040(unk_D_84211B50* arg0); +void func_84207190(unk_D_84211B50* arg0); +void func_8420720C(unk_D_84211B50* arg0); +void func_842073A4(unk_D_84211B50* arg0); +void func_84207530(unk_D_84211B50* arg0); +void func_84207634(unk_D_84211B50* arg0); +void func_842076A0(unk_D_84211B50* arg0); +void func_842076F8(unk_D_84211B50* arg0); +s32 func_8420776C(unk_D_84211B50* arg0); +s32 func_842078C0(unk_D_84211B50* arg0, unk_D_842168A0* arg1, unk_D_8423D3A8* arg2, unk_D_84229EB0* arg3, s16 arg4, u16 arg5, + char* arg6, s16 arg7, s16 arg8, s16 arg9); +s32 func_842079B4(unk_D_84211B50* arg0, s16 arg1); +s32 func_842079F0(unk_D_84211B50*); +s32 func_84207A1C(unk_D_84211B50*); +s32 func_84207AAC(unk_D_84211B50*); +s32 func_84207BD4(unk_D_84211B50*, unk_D_838067F0_0168_0000*); +s32 func_84207D5C(unk_D_84211B50*); +s32 func_84207E3C(unk_D_84211B50*, unk_D_838067F0_0168_0000*); +s32 func_8420804C(unk_D_84211B50*, unk_D_838067F0_0168_0000*); +s32 func_842081A8(unk_D_84211B50* arg0); +void func_842081B4(unk_D_84211B50* arg0, unk_func_80026268_arg0* arg1, s16 arg2); + +void func_84209340(unk_D_842168A0*, s32); +s32 func_8420AF1C(unk_D_842168A0*, unk_D_84211B50*, unk_D_8423D3A8*, s16, s16, s16, s16, s16, unk_D_842168A0_0013C*); +s32 func_8420B0C8(unk_D_842168A0*); +s32 func_8420B1D0(unk_D_842168A0*, s16); +s32 func_8420B20C(unk_D_842168A0*); +s32 func_8420B238(unk_D_842168A0*); +void func_8420B264(unk_D_842168A0*); +s32 func_8420B334(unk_D_842168A0*); +s32 func_8420B37C(unk_D_842168A0*); + +void func_8420B390(s16 arg0, s16 arg1, s16 arg2, s16 arg3, s8* arg4); +void func_8420B40C(s16 arg0, s16 arg1, s16 arg2, s16 arg3); +void func_8420B5A4(s16 arg0, s16 arg1, s16 arg2); +void func_8420B71C(s16 arg0, s16 arg1, s32 arg2); +s16 func_8420B870(s16 arg0, s16 arg1, char* arg2); +void func_8420B8CC(unk_D_8423D3A8* arg0, s32 arg1); +void func_8420C360(unk_D_8423D3A8* arg0); +void func_8420C368(unk_D_8423D3A8* arg0); +void func_8420C484(unk_D_8423D3A8* arg0); +void func_8420C4DC(unk_D_8423D3A8* arg0); +s32 func_8420C504(unk_D_8423D3A8* arg0); +s32 func_8420C580(unk_D_8423D3A8* arg0); +s32 func_8420C60C(unk_D_8423D3A8* arg0, s16 arg1, s16 arg2, s16 arg3, s16 arg4, s16 arg5, + unk_D_838067F0_0168_0000* arg6, s16 arg7); +s32 func_8420C6D8(unk_D_8423D3A8* arg0, s16 arg1, s16 arg2, unk_D_838067F0_0168_0000* arg3); +s32 func_8420C788(unk_D_8423D3A8* arg0); +void func_8420C7B0(s16 arg0, s16 arg1, s16 arg2, char* arg3); +void func_8420C844(unk_D_84211704* arg0); +void func_8420C930(unk_D_84211704* arg0); +void func_8420CA00(unk_D_84211704* arg0); +void func_8420CAD0(unk_D_84211704* arg0); +void func_8420CBA0(unk_D_84211704* arg0); +void func_8420CC54(unk_D_84211704* arg0); +void func_8420CCAC(unk_D_84211704* arg0); +void func_8420CE24(unk_D_84211704* arg0); +void func_8420CFC4(unk_D_84211704* arg0); +void func_8420D144(unk_D_84211704* arg0); +void func_8420D2BC(unk_D_84211704* arg0); +void func_8420D370(unk_D_84211704* arg0, s16 arg1); +void func_8420D464(unk_D_84211704* arg0, s16 arg1); +void func_8420D4F8(s32 arg0); +void func_8420D75C(void); +void func_8420D938(void); +void func_8420D978(void); +s32 func_8420D9B0(void); +s32 func_8420DA28(s16 arg0, Controller* arg1); +s32 func_8420DAF4(s16 arg0); +s16 func_8420DB48(s16 arg0); +s32 func_8420DBA0(unk_D_84229EB0_00024* arg0); +void func_8420DC78(unk_D_84229EB0_00024* arg0); +void func_8420DD14(unk_D_84229EB0* arg0, s16 arg1, s16 arg2, unk_D_84229EB0_00024* arg3); +void func_8420E46C(s16 arg0, s16 arg1); +void func_8420E63C(unk_D_84229EB0* arg0); +void func_8420EA88(unk_D_84229EB0* arg0); +void func_8420EB7C(unk_D_84229EB0* arg0); +void func_8420ED0C(unk_D_84229EB0* arg0); +void func_8420EE54(unk_D_84229EB0* arg0, s32 arg1); +unk_D_84229EB0_00024* func_8420F1BC(unk_D_84229EB0_00024* arg0, s32 arg1); +unk_D_84229EB0_00024* func_8420F1E0(unk_D_84229EB0_00024* arg0, s32 arg1); +s32 func_8420F204(unk_D_84229EB0_00024* arg0, s16 arg1); +void func_8420F37C(unk_D_84229EB0* arg0); +void func_8420F4FC(unk_D_84229EB0* arg0); +void func_8420F524(unk_D_84229EB0* arg0); +void func_8420F53C(unk_D_84229EB0* arg0); +void func_8420F598(unk_D_84229EB0* arg0); +void func_8420F5F0(unk_D_84229EB0* arg0); +void func_8420F654(unk_D_84229EB0* arg0); +void func_8420F754(unk_D_84229EB0* arg0); +void func_8420F86C(unk_D_84229EB0* arg0); +void func_8420F9C8(unk_D_84229EB0* arg0); +void func_8420FA88(unk_D_84229EB0* arg0); +void func_8420FB4C(unk_D_84229EB0* arg0); +void func_8420FC0C(unk_D_84229EB0* arg0); +void func_8420FCCC(unk_D_84229EB0* arg0); +void func_8420FDDC(unk_D_84229EB0* arg0); +void func_8420FE50(unk_D_84229EB0* arg0); +void func_8420FE90(unk_D_84229EB0* arg0); +void func_8420FEC0(unk_D_84229EB0* arg0); +void func_8420FFB0(unk_D_84229EB0* arg0); +void func_8421009C(unk_D_84229EB0* arg0); +void func_8421015C(unk_D_84229EB0* arg0); +void func_84210328(unk_D_84229EB0* arg0); +void func_8421059C(unk_D_84229EB0* arg0); +void func_84210668(unk_D_84229EB0* arg0); +s32 func_842106FC(unk_D_84229EB0* arg0); +s32 func_8421089C(unk_D_84229EB0* arg0, unk_D_84211B50* arg1, unk_D_842168A0* arg2, unk_D_8423D3A8* arg3, + s16 arg4, s16 arg5, s16 arg6, s16 arg7); +s32 func_84210A18(unk_D_84229EB0* arg0); +s32 func_84210A48(unk_D_84229EB0* arg0, u16 arg1, char* arg2, unk_D_838067F0_0168_0000* arg3); +s32 func_84210B54(unk_D_84229EB0* arg0); +s32 func_84210B60(unk_D_84229EB0* arg0, unk_D_84229EB0_00024** arg1); +void func_84210C80(unk_D_84229EB0* arg0, s16 arg1); #endif // _FRAGMENT61_H_ diff --git a/src/fragments/61/fragment61_2D78B0.c b/src/fragments/61/fragment61_2D78B0.c index c0ca652..0b0d4df 100644 --- a/src/fragments/61/fragment61_2D78B0.c +++ b/src/fragments/61/fragment61_2D78B0.c @@ -1,87 +1,1127 @@ -#include "global.h" +#include "fragment61.h" +#include "src/19840.h" +#include "src/1AB70.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/26820.h" +#include "src/29BA0.h" +#include "src/2C1C0.h" +#include "src/2E110.h" +#include "src/3FB0.h" +#include "src/49790.h" +#include "src/DDC0.h" +#include "src/F420.h" +#include "src/fragments/61/fragment61.h" +#include "src/hal_libc.h" +#include "src/memory.h" +#include "src/stage_loader.h" -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_84200020.s") +BinArchive* D_84211B30; +void* D_84211B34; +unk_D_842168A0_0013C* D_84211B38; +char** D_84211B3C; +char** D_84211B40; +char** D_84211B44; +char** D_84211B48; +char** D_84211B4C; +unk_D_84211B50 D_84211B50; +unk_D_842168A0 D_842168A0; +unk_D_84229EB0 D_84229EB0; +unk_D_8423D3A8 D_8423D3A8; +unk_D_8423D3D8 D_8423D3D8[4]; +s16 D_8423D3F8; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_84200088.s") +s16 D_84210D40 = 2; +s16 D_84210D44 = 0x20; +s16 D_84210D48 = 0; +u8 D_84210D4C[] = { + 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0F, +}; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_842000C0.s") +s32 func_84200020(s32 arg0) { + u32 temp_a0 = osSetIntMask(1); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_842000F8.s") + if (!(IO_READ(PI_STATUS_REG) & (PI_STATUS_DMA_BUSY | PI_STATUS_IO_BUSY)) && + (((D_B0000800 & 0xFFFF) & 0xFFFF) != 1)) { + arg0 = -0x80; + } + osSetIntMask(temp_a0); + return arg0; +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_84200130.s") +char* func_84200088(s32 arg0) { + return func_8002D7C0(NULL, 0, D_84211B3C, arg0 - 1); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_84200160.s") +char* func_842000C0(s32 arg0) { + return func_8002D7C0(NULL, 0, D_84211B40, arg0 - 1); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_84200190.s") +char* func_842000F8(s32 arg0) { + return func_8002D7C0(NULL, 0, D_84211B44, func_800219FC(arg0)); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_842001B8.s") +char* func_84200130(s32 arg0) { + return func_8002D7C0(NULL, 0, D_84211B48, arg0); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_84200420.s") +char* func_84200160(s32 arg0) { + return func_8002D7C0(NULL, 0, D_84211B4C, arg0); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_84200738.s") +char* func_84200190(char* arg0, s32 arg1, s32 arg2) { + return func_8002D7C0(arg0, arg1, D_84211B48, arg2); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_8420092C.s") +void func_842001B8(s16 arg0, s16 arg1, s16 arg2, s16 arg3) { + gSPDisplayList(gDisplayListHead++, D_8006F518); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_8420112C.s") + func_8001CADC(arg0 - 3, arg1 - 3, 8, 8, D_2000340, 8, 0); + func_8001CADC((arg0 + arg2) - 5, arg1 - 3, 8, 8, D_2000380, 8, 0); + func_8001C330(arg0 + 4, arg1 - 3, arg2 - 8, 8, 0, 0, 0, 0x400, 0); + func_8001CADC(arg0 - 3, (arg1 + arg3) - 5, 8, 8, D_20002C0, 8, 0); + func_8001C330(arg0 - 3, arg1 + 4, 8, arg3 - 8, 0, 0, 0x400, 0, 0); + func_8001CADC((arg0 + arg2) - 5, (arg1 + arg3) - 5, 8, 8, D_2000300, 8, 0); + func_8001C330(arg0 + 4, (arg1 + arg3) - 5, arg2 - 8, 8, 0, 0, 0, 0x400, 0); + func_8001C330((arg0 + arg2) - 5, arg1 + 4, 8, arg3 - 8, 0, 0, 0x400, 0, 0); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_8420192C.s") + gSPDisplayList(gDisplayListHead++, D_8006F630); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_84201A00.s") +void func_84200420(s16 arg0, s16 arg1, s16 arg2, s16 arg3, u8 arg4, u8 arg5, u8 arg6, u8 arg7) { + gSPDisplayList(gDisplayListHead++, D_8006F518); + gDPSetEnvColor(gDisplayListHead++, arg4, arg5, arg6, arg7); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_84201AD4.s") + func_8001CADC(arg0, arg1, 8, 8, D_2000B40, 8, 0); + func_8001CADC((arg0 + arg2) - 8, arg1, 8, 8, D_2000B80, 8, 0); + func_8001C330(arg0 + 8, arg1, arg2 - 0x10, 8, 0, 0, 0, 0x400, 0); + func_8001CADC(arg0, (arg1 + arg3) - 8, 8, 8, D_2000BC0, 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_2000C00, 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); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_84201BC4.s") + gSPDisplayList(gDisplayListHead++, D_8006F498); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_84201D6C.s") + func_8001C604(arg0 + 8, arg1 + 8, arg2 - 0x10, arg3 - 0x10, arg4, arg5, arg6, arg7); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_84201E70.s") + gSPDisplayList(gDisplayListHead++, D_8006F630); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_84201F04.s") +void func_84200738(s16 arg0, s16 arg1, s16 arg2, s16 arg3) { + static s16 D_84210D58 = 0; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_84202208.s") + s16 sp56 = SINS(D_84210D58) * 2; + UNUSED s32 pad[2]; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_84202284.s") + gSPDisplayList(gDisplayListHead++, D_8006F518); + gDPSetEnvColor(gDisplayListHead++, 240, 212, 104, 255); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_842023E4.s") + func_8001CADC(arg0 + sp56, arg1 + sp56, 0x10, 0x10, D_2000C80, 0x10, 0); + func_8001CADC(arg0 + sp56, ((arg1 + arg3) - sp56) - 0x10, 0x10, 0x10, D_2000F80, 0x10, 0); + func_8001CADC(((arg0 + arg2) - sp56) - 0x10, arg1 + sp56, 0x10, 0x10, D_2000D80, 0x10, 0); + func_8001CADC(((arg0 + arg2) - sp56) - 0x10, ((arg1 + arg3) - sp56) - 0x10, 0x10, 0x10, D_2000E80, 0x10, 0); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_842024DC.s") + gSPDisplayList(gDisplayListHead++, D_8006F630); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_84202718.s") + D_84210D58 += 0x2000; +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_84202844.s") +void func_8420092C(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; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_84202974.s") + 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); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_84202A64.s") + gSPDisplayList(gDisplayListHead++, D_8006F518); + gDPSetEnvColor(gDisplayListHead++, arg4, arg5, arg6, arg7); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_84202AF4.s") + gDPLoadTextureBlock_4b(gDisplayListHead++, D_20288E0, 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); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_84202C20.s") + func_8001C330(arg0, arg1, var_s3, var_s2, 0, 0, 0x4000 / var_s3, 0x4000 / var_s2, 0); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_84202D18.s") + gDPLoadTextureBlock_4b(gDisplayListHead++, D_2028960, 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); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_84202EB0.s") + func_8001C330((arg0 + arg2) - var_s3, arg1, var_s3, var_s2, 0, 0, 0x4000 / var_s3, 0x4000 / var_s2, 0); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_8420305C.s") + gDPLoadTextureBlock_4b(gDisplayListHead++, D_20287E0, 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); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_84203100.s") + func_8001C330(arg0, (arg1 + arg3) - var_s2, var_s3, var_s2, 0, 0, 0x4000 / var_s3, 0x4000 / var_s2, 0); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_8420318C.s") + gDPLoadTextureBlock_4b(gDisplayListHead++, D_2028860, 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); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_84203210.s") + func_8001C330((arg0 + arg2) - var_s3, (arg1 + arg3) - var_s2, var_s3, var_s2, 0, 0, 0x4000 / var_s3, + 0x4000 / var_s2, 0); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_842034E4.s") + gSPDisplayList(gDisplayListHead++, D_8006F498); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_842037AC.s") + 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); + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_842039B4.s") + gSPDisplayList(gDisplayListHead++, D_8006F630); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_84203AB8.s") +void func_8420112C(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; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_84203BBC.s") + if (arg2 >= 0x10) { + var_s3 = 8; + } else { + var_s3 = arg2 / 2; + } + if (arg3 >= 0x10) { + var_s2 = 8; + } else { + var_s2 = arg3 / 2; + } + temp_a2 = arg2 - (var_s3 * 2); + temp_s0_32 = arg3 - (var_s2 * 2); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_84203C90.s") + gSPDisplayList(gDisplayListHead++, D_8006F518); + gDPSetEnvColor(gDisplayListHead++, arg4, arg5, arg6, arg7); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_84203D74.s") + gDPLoadTextureBlock_4b(gDisplayListHead++, D_2028A60, 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); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2D78B0/func_84203E6C.s") + func_8001C330(arg0, arg1, var_s3, var_s2, 0, 0, 0x2000 / var_s3, 0x2000 / var_s2, 0); + + gDPLoadTextureBlock_4b(gDisplayListHead++, D_2028AA0, 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_20289E0, 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_2028A20, 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 ((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_8420192C(s16 arg0, s16 arg1) { + gSPDisplayList(gDisplayListHead++, D_8006F518); + + func_8001C6AC(arg0, arg1, 0x30, 0x18, D_2006C00, 0x30, 0); + func_8001C6AC(arg0, arg1 + 0x18, 0x30, 0x18, D_2007500, 0x30, 0); + + gSPDisplayList(gDisplayListHead++, D_8006F630); +} + +void func_84201A00(s16 arg0, s16 arg1) { + gSPDisplayList(gDisplayListHead++, D_8006F518); + + func_8001C6AC(arg0, arg1, 0x30, 0x18, &D_2028AE0, 0x30, 0); + func_8001C6AC(arg0, arg1 + 0x18, 0x30, 0x18, &D_20293E0, 0x30, 0); + + gSPDisplayList(gDisplayListHead++, D_8006F630); +} + +void func_84201AD4(s16 arg0, s16 arg1, s16 arg2) { + static u8* D_84210D5C[] = { D_200DFA0, D_200F3E0, D_2010820, D_2011C60, D_20130A0 }; + + gSPDisplayList(gDisplayListHead++, D_8006F518); + + func_8001C6AC(arg0, arg1, 0x48, 0x12, D_84210D5C[arg2], 0x48, 0); + func_8001C6AC(arg0, arg1 + 0x12, 0x48, 0x12, D_84210D5C[arg2] + 0xA20, 0x48, 0); + + gSPDisplayList(gDisplayListHead++, D_8006F630); +} + +void func_84201BC4(s16 arg0, s16 arg1, s16 arg2, Color_RGBA8* arg3, Color_RGBA8* arg4) { + gSPDisplayList(gDisplayListHead++, D_8006F558); + gDPSetEnvColor(gDisplayListHead++, arg3->r, arg3->g, arg3->b, 255); + gDPSetPrimColor(gDisplayListHead++, 0, 0, arg4->r, arg4->g, arg4->b, 255); + + func_8001CADC(arg0, arg1, 0x10, 0x20, D_20003C0, 0x10, 0); + func_8001CADC((arg0 + arg2) - 0x10, arg1, 0x10, 0x20, D_20005C0, 0x10, 0); + func_8001C330(arg0 + 0x10, arg1, arg2 - 0x20, 0x20, 0, 0, 0, 0x400, 0); + + gSPDisplayList(gDisplayListHead++, D_8006F630); +} + +void func_84201D6C(void) { + static s32 D_84210D70[] = { + 0x3B, 0x3C, 0x3C, 0x3C, 0x3C, 0x3C, 0x3C, 0x3D, 0x3E, + }; + + Color_RGBA8 sp2C; + Color_RGBA8 sp28; + + func_8000E820(&sp2C, 0x64, 0x64, 0xC8); + func_8000E820(&sp28, 0x28, 0x28, 0x8C); + func_84201BC4(0x48, 0x28, 0x208, &sp2C, &sp28); + func_8420192C(0x30, 0x20); + func_8001F3F4(); + func_8001EBE0(0x10, 0); + func_8001F324(0, 0, 0, 0xFF); + func_8001F1E8(0x6A, 0x2C, func_84200130(D_84210D70[D_800AE540.unk_0000])); + func_8001F324(0xFF, 0xFF, 0x77, 0xFF); + func_8001F1E8(0x68, 0x2A, func_84200130(D_84210D70[D_800AE540.unk_0000])); + func_8001F444(); +} + +void func_84201E70(s16 arg0, s16 arg1, s16 arg2, s32 arg3) { + if (arg2 == D_8423D3F8) { + func_8001F324(0xFF, 0xFF, 0, 0xFF); + } else { + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + } + func_8001F1E8(arg0 + 0x36, arg1 + (arg2 * 0x1E) + 0x2C, arg3); +} + +void func_84201F04(s16 arg0, s16 arg1, s16 arg2) { + UNUSED s32 pad[2]; + char* sp30; + s16 temp_a3; + s16 temp_v0; + + func_800079C4(); + func_8001D924(D_84211B34); + func_84201D6C(); + if (arg2 > 0) { + temp_a3 = (((arg2 * 0x9A) - 0x9A) / 8) + 0x10; + func_80020754(0x6D, (s16)(((0xAA - temp_a3) / 2) + 0x81), 0x1A6, temp_a3); + temp_v0 = (((arg2 * 0x5C) - 0x5C) / 8) + 0x10; + if (1) {} + func_8420112C(0x38, ((0x6C - temp_v0) / 2) + 0x14C, 0x210, (((arg2 * 0x5C) - 0x5C) / 8) + 0x10, 0x1E, 0x1E, + 0x82, 0x96); + if (arg2 == 9) { + func_84200420(0x74, 0x88, 0x198, 0x20, 0x8C, 0x28, 0x8C, 0xFF); + func_84200420(0x74, 0xA8, 0x198, 0x7C, 0x64, 0x1E, 0x64, 0xFF); + func_80020928(0x79, (D_8423D3F8 * 0x1E) + 0xAD); + func_8001F3F4(); + func_8001EBE0(0x10, 0); + func_8001F1E8(0x7D, 0x8B, "%s %s", func_84200130(D_800AE540.unk_0001 + 0x3F), func_84200130(0x48)); + func_84201E70(0x6D, 0x81, 0, func_84200130(0x49)); + func_84201E70(0x6D, 0x81, 1, func_84200130(0x4A)); + func_84201E70(0x6D, 0x81, 2, func_84200130(0x4B)); + func_84201E70(0x6D, 0x81, 3, func_84200130(0x4C)); + func_8001EBE0(8, 0); + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + func_8001F3B4(0x18); + func_8001F1E8(0x58, 0x154, func_8002D7C0(NULL, 0, D_84211B48, 0x4D)); + func_8001F444(); + } + } + func_8420D4F8(0); + func_80007778(); +} + +void func_84202208(void) { + func_80048B90(8); + func_8420DA28(0x10, gPlayer1Controller); + + while (func_8420DB48(0x10) == -1) { + func_8420D9B0(); + func_84201F04(0x8C, 0xBC, 9); + func_800290B4(); + } +} + +s32 func_84202284(void) { + s32 sp1C = 'exec'; + + if (BTN_IS_PRESSED(gPlayer1Controller, BTN_A)) { + if ((D_8423D3F8 == 0) && (func_80028E68() == 0xA)) { + func_84202208(); + } else { + if (D_8423D3F8 < 3) { + func_80048B90(0x1C); + } else { + func_80048B90(3); + } + sp1C = 'btnA'; + } + } else if (BTN_IS_PRESSED(gPlayer1Controller, BTN_B)) { + func_80048B90(3); + D_8423D3F8 = 3; + sp1C = 'btnB'; + } else if (BTN_IS_PRESSED(gPlayer1Controller, BTN_DUP)) { + func_80048B90(1); + D_8423D3F8--; + if (D_8423D3F8 < 0) { + D_8423D3F8 = 3; + } + } else if (BTN_IS_PRESSED(gPlayer1Controller, BTN_DDOWN)) { + func_80048B90(1); + D_8423D3F8++; + if (D_8423D3F8 >= 4) { + D_8423D3F8 = 0; + } + } + return sp1C; +} + +s16 func_842023E4(void) { + s16 i; + s32 temp_s0; + + D_8423D3F8 = 0; + func_80048B90(4); + + for (i = 0; i < 9; i++) { + func_800290B4(); + func_84201F04(0x8C, 0xBC, i); + } + + do { + func_800290B4(); + temp_s0 = func_84202284(); + func_84201F04(0x8C, 0xBC, 9); + } while (temp_s0 == 'exec'); + + for (i = 8; i >= 0; i--) { + func_800290B4(); + func_84201F04(0x8C, 0xBC, i); + } + + func_84201F04(0x8C, 0xBC, 0); + return func_84200020(D_8423D3F8); +} + +void func_842024DC(s16 arg0, s16 arg1) { + Color_RGBA8 sp34; + Color_RGBA8 sp30; + s32 var_t0 = 0; + + if ((D_800AE540.unk_0000 == 0) && (arg1 >= 0)) { + if (D_84210D48 == 0) { + var_t0 = 1; + } else { + if ((D_84210D48 % 12) >= 5) { + var_t0 = 1; + } + D_84210D48--; + } + } + + if (arg0 == 0) { + func_8000E820(&sp34, 0x64, 0x64, 0xC8); + func_8000E820(&sp30, 0x28, 0x28, 0x8C); + func_84201BC4(0x48, 0x28, 0x208, &sp34, &sp30); + func_8420192C(0x30, 0x20); + if (var_t0 != 0) { + func_84201AD4(0x1AE, 0x26, arg1); + } + } else { + func_8000E820(&sp34, 0xB4, 0x5A, 0xA0); + func_8000E820(&sp30, 0x78, 0x28, 0x64); + func_84201BC4(0x48, 0x28, 0x208, &sp34, &sp30); + func_84201A00(0x30, 0x20); + } + + func_8001F3F4(); + func_8001EBE0(0x10, 0); + func_8001F324(0, 0, 0, 0xFF); + + func_8001F1E8(0x6A, 0x2C, func_8002D7C0(NULL, 0, D_84211B48, arg0 + 0x37)); + func_8001F324(0xFF, 0xFF, 0x77, 0xFF); + func_8001F1E8(0x68, 0x2A, func_8002D7C0(NULL, 0, D_84211B48, arg0 + 0x37)); + + if ((arg0 == 0) && (var_t0 != 0)) { + func_8001EBE0(4, 0); + func_8001F1E8(0x1F9, 0x2F, func_8002D7C0(NULL, 0, D_84211B48, 0x4E)); + } + func_8001F444(); +} + +void func_84202718(UNUSED s16 arg0, s16 arg1, s16 arg2) { + s32 temp_s0 = D_84210D40 > 0; + + func_800079C4(); + + if (temp_s0 != 0) { + D_84210D40--; + func_8001D924(D_84211B34); + func_842024DC(arg1, arg2); + } + + if (D_84210D44 & 8) { + func_84204760(temp_s0); + } + + if (D_84210D44 & 1) { + func_842062D4(&D_84211B50, temp_s0); + } + + if (D_84210D44 & 2) { + func_84209340(&D_842168A0, temp_s0); + } + + if (D_84210D44 & 4) { + func_8420EE54(&D_84229EB0, temp_s0); + } + + if (D_84210D44 & 0x10) { + func_8420B8CC(&D_8423D3A8, temp_s0); + } + + if (D_84210D44 & 0x20) { + func_8420D4F8(temp_s0); + } + + func_80007778(); +} + +s16 func_84202844(s16 arg0, s16 arg1, s16 arg2, s32 arg3) { + s32 temp_s1 = -1; + s16 i; + + D_84210D48 = 0x27; + + for (i = 0; i < 4; i++) { + D_84210D40 = 2; + func_84202718(-1, arg1, arg2); + } + + func_84205D48(arg0, arg3); + + while (temp_s1 == -1) { + func_800290B4(); + func_8420570C(); + func_8420D9B0(); + temp_s1 = func_84205E54(); + D_84210D40 = 2; + func_84202718(-1, arg1, arg2); + } + + func_84202718(-1, arg1, arg2); + return temp_s1; +} + +void func_84202974(UNUSED s16 arg0, UNUSED s32 arg1) { + s32 var_a1 = 0; + + if (D_84210D44 & 1) { + var_a1 = func_8420776C(&D_84211B50); + } + + if (D_84210D44 & 2) { + var_a1 |= func_8420B0C8(&D_842168A0); + } + + if (D_84210D44 & 4) { + var_a1 |= func_842106FC(&D_84229EB0); + } + + if (D_84210D44 & 0x10) { + var_a1 |= func_8420C580(&D_8423D3A8); + } + + if (D_84210D44 & 0x20) { + var_a1 |= func_8420D9B0(); + } + + if (var_a1 != 0) { + D_84210D40 = 2; + } +} + +void func_84202A64(s16 arg0, s32 arg1, s16 arg2) { + func_80048B90(4); + if (arg0 == 4) { + func_84210A18(&D_84229EB0); + } else { + func_842079B4(&D_84211B50, 0); + func_8420B1D0(&D_842168A0, 0); + } + func_800290B4(); + func_84202974(arg0, 0); + func_84202718(arg0, arg1, arg2); +} + +void func_84202AF4(s16 arg0, s16 arg1, s16 arg2) { + s32 var_s0 = 1; + + func_8001F738(&gControllers[D_842168A0.unk_00003]); + + while (var_s0 != 0) { + func_800290B4(); + func_84202974(arg0, func_8001F750() & 0xFFFF); + func_84202718(arg0, arg1, arg2); + + if (arg0 == 4) { + var_s0 = func_84210B54(&D_84229EB0) == 0; + } else { + var_s0 = !func_842081A8(&D_84211B50); + var_s0 |= !func_8420B37C(&D_842168A0); + } + } +} + +void func_84202C20(void) { + s16 i; + unk_D_800AE540_0004* var_v0 = D_800AE540.unk_0004; + + for (i = 0; i < 4; i++) { + D_8423D3D8[i].unk_00 = 0; + D_8423D3D8[i].unk_01 = i; + D_8423D3D8[i].unk_02 = i; + } + + for (i = 0; i < 4; i++, var_v0++) { + if (var_v0->unk_000 & 1) { + if (!(var_v0->unk_000 & 2)) { + D_8423D3D8[var_v0->unk_001].unk_00 = 1; + D_8423D3D8[var_v0->unk_001].unk_04 = var_v0; + } else if (D_800AE540.unk_0000 == 0) { + D_8423D3D8[var_v0->unk_001].unk_00 = 1; + D_8423D3D8[var_v0->unk_001].unk_04 = var_v0; + D_8423D3D8[var_v0->unk_001].unk_01 = 4; + D_8423D3D8[var_v0->unk_001].unk_02 = 0; + } + } + } +} + +void func_84202D18(unk_D_8423D3D8* arg0, s16 arg1) { + char sp50[16]; + UNUSED s32 pad; + u16 var_v1; + unk_D_800AC910_040 sp38; + + if (arg1 == 4) { + D_84210D44 |= func_8421089C(&D_84229EB0, &D_84211B50, &D_842168A0, &D_8423D3A8, 0, 0x2C, 0x54, arg0->unk_02); + return; + } + + if (arg1 < 4) { + func_80025040(arg1, &sp38); + func_80021A90(sp50, sp38.unk_02); + var_v1 = sp38.unk_00; + } else { + HAL_Strcpy(sp50, func_8002311C(1)); + var_v1 = 0; + } + + D_84210D44 |= func_842078C0(&D_84211B50, &D_842168A0, &D_8423D3A8, NULL, 0, var_v1, sp50, 0x40, 0x54, arg0->unk_02); + D_84210D44 |= func_8420AF1C(&D_842168A0, &D_84211B50, &D_8423D3A8, 0, 0x68, 0xE4, arg0->unk_02, arg1, D_84211B38); +} + +s32 func_84202EB0(unk_D_8423D3D8* arg0, s16 arg1) { + s32 temp_s3; + s32 var_s0 = 0; + unk_D_84229EB0_00024* sp34; + s32 i; + + arg0->unk_04->unk_002 = 0; + if (arg1 == 4) { + temp_s3 = func_84210B60(&D_84229EB0, &sp34); + if (sp34 != NULL) { + arg0->unk_04->unk_018 = sp34->unk_4D10; + if (D_800AE540.unk_0000 != 0) { + HAL_Strcpy(arg0->unk_04->unk_008, sp34->unk_4D12); + } + HAL_Strcpy(arg0->unk_04->unk_214->unk_014, sp34->unk_4D12); + + for (i = 0; i < temp_s3; i++) { + func_8002B888(arg0->unk_04, &sp34->unk_0000[i].unk_004); + } + var_s0 = 1; + } + } else { + arg0->unk_04->unk_018 = D_84211B50.unk_001C; + if (D_800AE540.unk_0000 != 0) { + HAL_Strcpy(arg0->unk_04->unk_008, D_84211B50.unk_001E); + } + HAL_Strcpy(arg0->unk_04->unk_214->unk_014, D_84211B50.unk_001E); + + if (D_84211B50.unk_0006 > 0) { + for (i = 0; i < D_84211B50.unk_0006; i++) { + func_8002B888(arg0->unk_04, &D_84211B50.unk_0030[i].unk_004); + } + var_s0 = 1; + } + } + return var_s0; +} + +void func_8420305C(s32 arg0) { + s32 i; + + func_80007990(1); + func_8000D278(0x10); + func_80006CB4(8); + + for (i = 0; i < 8; i++) { + func_800290B4(); + func_800079C4(); + func_8001D924(D_84211B34); + if (arg0 != 0) { + func_842024DC(0, -1); + } + func_80007778(); + } + + func_800077B4(2); +} + +void func_84203100(void) { + s32 i; + + if (func_80007604() == 1) { + func_80006C6C(8); + for (i = 0; i < 10; i++) { + func_800290B4(); + func_800079C4(); + func_8001D924(D_84211B34); + func_842024DC(0, -1); + func_80007778(); + } + } +} + +void func_8420318C(s16 arg0, s16 arg1) { + unk_D_800AE540_0004* temp_v1 = D_8423D3D8[arg0].unk_04; + + if (temp_v1->unk_002 != 0) { + if (arg1 == 4) { + func_84210C80(&D_84229EB0, temp_v1->unk_214->unk_028[0].unk_53); + } else { + func_842081B4(&D_84211B50, &temp_v1->unk_214->unk_028, temp_v1->unk_214->unk_002); + } + } +} + +s32 func_84203210(void) { + s16 var_s1 = 0; + s16 var_s2; + + if ((D_800AE540.unk_0000 == 7) && (D_800AE540.unk_0002 == 9)) { + func_8420305C(0); + func_8002B6BC(); + return 1; + } + + switch (D_800AE540.unk_0000) { + case 0: + func_8000D1F0(0x2D); + break; + + case 7: + func_8000D1F0(0x2B); + break; + + case 8: + func_8000D1F0(0x30); + break; + + default: + func_8000D1F0(0x15); + break; + } + + func_84202C20(); + func_84203100(); + + D_84210D44 |= func_84205C18(0); + D_84210D44 |= func_8420C504(&D_8423D3A8); + + while (var_s1 >= 0 && var_s1 < 4) { + if (D_8423D3D8[var_s1].unk_00 != 0) { + var_s2 = func_84202844(D_8423D3D8[var_s1].unk_02, 0, D_8423D3D8[var_s1].unk_01, 1); + D_8423D3D8[var_s1].unk_04->unk_002 = 0; + + if (var_s2 < 0) { + var_s1 -= 1; + while (var_s1 >= 0) { + if (D_8423D3D8[var_s1].unk_00 != 0) { + var_s2 = (D_8423D3D8[var_s1].unk_04->unk_01C[0].unk_52 & 0x70) >> 4; + break; + } + var_s1--; + } + } + + if (var_s1 >= 0) { + s32 idx = var_s1; + + main_pool_push_state('pkgb'); + + if (var_s2 < 4) { + func_80023D60(var_s2); + func_80024208(var_s2); + D_800AE540.unk_11F0 = func_80025328(var_s2); + } else { + D_800AE540.unk_11F0 = 0; + } + + func_84202D18(&D_8423D3D8[(unsigned long)idx], var_s2); + func_8420318C(var_s1, var_s2); + func_84202A64(var_s2, 0, D_8423D3D8[var_s1].unk_01); + func_84202AF4(var_s2, 0, D_8423D3D8[var_s1].unk_01); + + if (func_84202EB0(&D_8423D3D8[(unsigned long)idx], var_s2) != 0) { + var_s1++; + } + + main_pool_pop_state('pkgb'); + } + } else { + var_s1++; + } + } + + if (var_s1 == -1) { + return 0; + } + + func_8420305C(1); + func_8002B6BC(); + return 1; +} + +s32 func_842034E4(void) { + s16 var_s1 = 0; + s16 var_s2; + + switch (D_800AE540.unk_0000) { + case 0: + func_8000D1F0(0x2D); + break; + + case 7: + func_8000D1F0(0x2B); + break; + + case 8: + func_8000D1F0(0x30); + break; + + default: + func_8000D1F0(0x15); + break; + } + + func_84202C20(); + func_84203100(); + + D_84210D44 |= func_84205C18(0); + D_84210D44 |= func_8420C504(&D_8423D3A8); + + while ((var_s1 >= 0) && (var_s1 < 4)) { + if (D_8423D3D8[var_s1].unk_00 != 0) { + if (D_8423D3D8[var_s1].unk_04->unk_002 == 0) { + var_s2 = func_84202844(D_8423D3D8[var_s1].unk_02, 0, D_8423D3D8[var_s1].unk_01, 1); + } else { + var_s2 = ((D_8423D3D8[var_s1].unk_04->unk_01C[0].unk_52 & 0x70) >> 4); + } + + if (var_s2 < 0) { + var_s1--; + + while (var_s1 >= 0) { + if (D_8423D3D8[var_s1].unk_00 != 0) { + var_s2 = (D_8423D3D8[var_s1].unk_04->unk_01C[0].unk_52 & 0x70) >> 4; + break; + } + var_s1--; + } + } + + if (var_s1 >= 0) { + s32 idx = var_s1; + + main_pool_push_state('pkgb'); + + if (var_s2 < 4) { + func_80023D60(var_s2); + func_80024208(var_s2); + D_800AE540.unk_11F0 = func_80025328(var_s2); + } else { + D_800AE540.unk_11F0 = 0; + } + func_84202D18(&D_8423D3D8[(unsigned long)idx], var_s2); + func_8420318C(var_s1, var_s2); + func_84202A64(var_s2, 0, D_8423D3D8[var_s1].unk_01); + func_84202AF4(var_s2, 0, D_8423D3D8[var_s1].unk_01); + if (func_84202EB0(&D_8423D3D8[(unsigned long)idx], var_s2) != 0) { + var_s1++; + } + + main_pool_pop_state('pkgb'); + } + } else { + var_s1++; + } + } + + if (var_s1 == -1) { + return 0; + } + + func_8420305C(1); + func_8002B6BC(); + return 1; +} + +void func_842037AC(void) { + unk_D_84229EB0* ptr; + char sp74[16]; + s16 temp_v0; + u16 var_s1; + unk_D_800AC910_040 sp60; + + while (true) { + temp_v0 = func_84202844(0, 1, 0, 1); + if (temp_v0 < 0) { + return; + } + + main_pool_push_state('regi'); + + if (temp_v0 < 4) { + func_80023D60(temp_v0); + func_80024208(temp_v0); + func_80025040(temp_v0, &sp60); + func_80021A90(sp74, sp60.unk_02); + var_s1 = sp60.unk_00; + } else { + HAL_Strcpy(sp74, func_8002311C(1)); + var_s1 = 0; + } + + ptr = &D_84229EB0; + D_84210D44 |= func_8421089C(ptr, &D_84211B50, &D_842168A0, &D_8423D3A8, 3, 0x2C, 0xBC, 0); + D_84210D44 |= func_842078C0(&D_84211B50, &D_842168A0, &D_8423D3A8, ptr, 1, var_s1, sp74, 0x40, 0x54, 0); + D_84210D44 |= func_8420AF1C(&D_842168A0, &D_84211B50, &D_8423D3A8, 1, 0x68, 0xE4, 0, temp_v0, D_84211B38); + + func_84202A64(temp_v0, 1, 0); + func_84202AF4(temp_v0, 1, 0); + + main_pool_pop_state('regi'); + + if (D_84211B50.unk_0006 != 0) { + break; + } + } +} + +void func_842039B4(void) { + D_84210D44 |= func_8421089C(&D_84229EB0, &D_84211B50, &D_842168A0, &D_8423D3A8, 1, 0x2C, 0x54, 0); + + func_84210A18(&D_84229EB0); + func_800290B4(); + func_84202974(4, 0); + func_84202718(4, 2, 0); + func_8001F738(&gControllers[D_842168A0.unk_00003]); + + do { + func_800290B4(); + func_84202974(4, func_8001F750() & 0xFFFF); + func_84202718(4, 2, 0); + } while (func_84210B54(&D_84229EB0) == 0); +} + +void func_84203AB8(void) { + D_84210D44 |= func_8421089C(&D_84229EB0, &D_84211B50, &D_842168A0, &D_8423D3A8, 2, 0x2C, 0x54, 0); + + func_84210A18(&D_84229EB0); + func_800290B4(); + func_84202974(4, 0); + func_84202718(4, 3, 0); + func_8001F738(&gControllers[D_842168A0.unk_00003]); + + do { + func_800290B4(); + func_84202974(4, func_8001F750() & 0xFFFF); + func_84202718(4, 3, 0); + } while (func_84210B54(&D_84229EB0) == 0); +} + +s32 func_84203BBC(void) { + s16 temp_v0; + + D_84210D44 |= func_84205C18(1); + D_84210D44 |= func_8420C504(&D_8423D3A8); + + do { + temp_v0 = func_842023E4(); + switch (temp_v0) { + case 0: + func_842037AC(); + break; + + case 1: + func_842039B4(); + break; + + case 2: + func_84203AB8(); + break; + } + } while (temp_v0 != 3); + + return 1; +} + +void func_84203C90(void) { + BinArchive* temp_a0; + s16 var_a1; + + temp_a0 = func_800044F4(0x898000, NULL, 1, 0); + + switch (D_800AE540.unk_0001) { + case 0: + var_a1 = 0x1A; + break; + + case 1: + var_a1 = 0x1A; + break; + + case 2: + var_a1 = 0x1B; + break; + + case 3: + var_a1 = 0x1C; + break; + + case 4: + var_a1 = 0x17; + break; + + case 5: + var_a1 = 0x18; + break; + + case 6: + var_a1 = 0x19; + break; + + case 7: + var_a1 = 0x1E; + break; + + case 8: + var_a1 = 0x19; + break; + + default: + var_a1 = 0; + break; + } + + if (var_a1 == 0) { + D_84211B38 = NULL; + } else { + if (D_800AE540.unk_11F2 != 0) { + var_a1 += 0x1F; + } + D_84211B38 = func_8000484C(temp_a0, var_a1); + } +} + +void func_84203D74(void) { + unk_func_80027FA0 sp20; + + D_84211B30 = ASSET_LOAD2(backgrounds, 1, 1); + if (D_800AE540.unk_0000 == 7) { + if (D_800AE540.unk_0002 >= 8) { + D_84211B34 = func_8000484C(D_84211B30, 0xE); + } else { + func_80028AFC(2); + func_80027FA0(&sp20, D_800AE540.unk_11F2); + if (sp20.unk_04 < 8) { + D_84211B34 = func_8000484C(D_84211B30, 0xD); + } else { + D_84211B34 = func_8000484C(D_84211B30, 0x10); + } + } + } else { + D_84211B34 = func_8000484C(D_84211B30, D_84210D4C[D_800AE540.unk_0000]); + } +} + +s32 func_84203E6C(s32 arg0, UNUSED s32 arg1) { + s32 var_v1; + + main_pool_push_state('PICK'); + + func_8001E94C(0x1C, 0); + ASSET_LOAD(D_1000000, common_menu1_ui, 0); + ASSET_LOAD(D_2000000, common_menu2_ui, 0); + FRAGMENT_LOAD(fragment31); + func_8001987C(); + func_8002D510(); + + D_84211B3C = func_8002D5AC(0x24); + D_84211B40 = func_8002D5AC(0x25); + D_84211B44 = func_8002D5AC(0x26); + D_84211B48 = func_8002D5AC(0x1A); + D_84211B4C = func_8002D5AC(6); + + func_80028AFC(D_800AE540.unk_0001 / 4); + func_80028C48(D_800AE540.unk_0001); + func_80028EB8(); + func_84203D74(); + func_8001B058(); + func_84203C90(); + func_80007754(); + + if (arg0 == 1) { + var_v1 = func_84203BBC(); + } else if (D_800AE540.unk_11F6 & 0x20) { + var_v1 = func_842034E4(); + D_800AE540.unk_11F6 = D_800AE540.unk_11F6 & 0xFFDF; + } else { + D_800AE540.unk_11F5 &= 0xFFFD; + var_v1 = func_84203210(); + } + + func_8000771C(); + + main_pool_pop_state('PICK'); + + return var_v1; +} diff --git a/src/fragments/61/fragment61_2DB900.c b/src/fragments/61/fragment61_2DB900.c index 99c0af1..cc7a2be 100644 --- a/src/fragments/61/fragment61_2DB900.c +++ b/src/fragments/61/fragment61_2DB900.c @@ -1,51 +1,815 @@ -#include "global.h" +#include "fragment61.h" +#include "src/12D80.h" +#include "src/1C720.h" +#include "src/1CF30.h" +#include "src/20470.h" +#include "src/22630.h" +#include "src/232C0.h" +#include "src/26820.h" +#include "src/2E110.h" +#include "src/49790.h" +#include "src/F420.h" +#include "src/controller.h" +#include "src/geo_layout.h" +#include "src/math_util.h" +#include "src/memmap.h" +#include "src/fragments/47/fragment47.h" +#include "src/memory.h" -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DB900/func_84204070.s") +typedef struct unk_D_8423E518 { + /* 0x00 */ u8 unk_00; + /* 0x01 */ u8 unk_01; + /* 0x02 */ u8 unk_02; + /* 0x03 */ u8 unk_03; + /* 0x04 */ u16 unk_04; + /* 0x06 */ char unk_06[1]; + /* 0x07 */ char unk_07[0xD]; +} unk_D_8423E518; // size = 0x14 -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DB900/func_84204210.s") +GraphNode* D_8423D400; +unk_D_86002F58_004_000 D_8423D408[2][6]; +unk_D_86002F58_004_000_004* D_8423E4E8[6]; +unk_D_86002F58_004_000_004* D_8423E500; +u8* D_8423E508[4]; +unk_D_8423E518 D_8423E518[4]; +s16 D_8423E568; +s16 D_8423E56A; +s16 D_8423E56C; +s16 D_8423E56E; +Controller* D_8423E570; +s16 D_8423E574; +s16 D_8423E576; +s16 D_8423E578; +s32 D_8423E57C; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DB900/func_84204294.s") +unk_D_8380548C D_84210DA0[] = { + { + 0x01, + 0x00, + 134, + 210, + 64, + 0, + 0, + 1472, + }, + { + 0x01, + 0x00, + 258, + 210, + 64, + -32768, + -32768, + 1664, + }, + { + 0x01, + 0x00, + 382, + 210, + 64, + 0, + 0, + 1408, + }, + { + 0x01, + 0x00, + 506, + 210, + 64, + -32768, + -32768, + 1600, + }, +}; +u8 D_84210DD8[] = { + 1, 0, 0, 0xBE, 1, 0x70, 0, 0x4C, 0, 0, 0, 0, 6, 0x20, 1, 0, 1, 0xC2, 1, 0x70, 0, 0x64, 0x80, 0, 0x80, 0, 5, 0xE0, +}; +u32 D_84210DF4[] = { + 0x0C000000, 0x05000000, 0x0B00002D, 0x00000000, 0x028001E0, 0x00000000, 0xFDBD0000, + 0x00000243, 0x05000000, 0x0D000000, 0x05000000, 0x0F000002, 0x05000000, 0x0A000000, + &D_800AC840, 0x06000000, 0x06000000, 0x06000000, 0x06000000, 0x01000000, 0x00000000, +}; +Vtx D_84210E48[] = { + 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), +}; +static Gfx D_84210F08[] = { + gsSPSetGeometryMode(G_CULL_BACK), + gsDPSetCombineMode(G_CC_DECALRGBA, G_CC_PASS2), + gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON), + gsSPVertex(D_84210E48, 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(), +}; +static u32 D_84210FF0[] = { + 0x17000000, 0x00000000, 0x00000000, 0x00000000, D_84210E48, 0x05000000, 0x22040000, + 0x00000000, 0x08000000, func_84204070, D_84210F08, 0x06000000, 0x01000000, 0x00000000, +}; +static Vtx D_84211028[] = { + VTX(-38, 60, 0, 0, 0, 0xFF, 0xFF, 0xFF, 0xFF), VTX(-38, 40, 0, 0, 640, 0xFF, 0xFF, 0xFF, 0xFF), + VTX(38, 40, 0, 2432, 640, 0xFF, 0xFF, 0xFF, 0xFF), VTX(38, 60, 0, 2432, 0, 0xFF, 0xFF, 0xFF, 0xFF), + VTX(-38, 40, 0, 0, 0, 0xFF, 0xFF, 0xFF, 0xFF), VTX(-38, 20, 0, 0, 640, 0xFF, 0xFF, 0xFF, 0xFF), + VTX(38, 20, 0, 2432, 640, 0xFF, 0xFF, 0xFF, 0xFF), VTX(38, 40, 0, 2432, 0, 0xFF, 0xFF, 0xFF, 0xFF), + VTX(-38, 20, 0, 0, 0, 0xFF, 0xFF, 0xFF, 0xFF), VTX(-38, 0, 0, 0, 640, 0xFF, 0xFF, 0xFF, 0xFF), + VTX(38, 0, 0, 2432, 640, 0xFF, 0xFF, 0xFF, 0xFF), VTX(38, 20, 0, 2432, 0, 0xFF, 0xFF, 0xFF, 0xFF), +}; +static Gfx D_842110E8[] = { + 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_84211028, 12, 0), + gsDPLoadTextureBlock(0x0F000000, G_IM_FMT_RGBA, G_IM_SIZ_16b, 76, 20, 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(0x0F000BE0, G_IM_FMT_RGBA, G_IM_SIZ_16b, 76, 20, 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(0x0F0017C0, G_IM_FMT_RGBA, G_IM_SIZ_16b, 76, 20, 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(), +}; +static u32 D_842111D0[] = { + 0x17000000, 0x00000000, 0x00000000, 0x00000000, D_84211028, 0x05000000, 0x22050000, + 0x00000000, 0x08000000, func_84204070, D_842110E8, 0x06000000, 0x01000000, 0x00000000, +}; +static Vtx D_84211208[] = { + VTX(-50, 64, 0, 0, 0, 0xFF, 0xFF, 0xFF, 0xFF), VTX(-50, 48, 0, 0, 512, 0xFF, 0xFF, 0xFF, 0xFF), + VTX(50, 48, 0, 3200, 512, 0xFF, 0xFF, 0xFF, 0xFF), VTX(50, 64, 0, 3200, 0, 0xFF, 0xFF, 0xFF, 0xFF), + VTX(-50, 48, 0, 0, 0, 0xFF, 0xFF, 0xFF, 0xFF), VTX(-50, 32, 0, 0, 512, 0xFF, 0xFF, 0xFF, 0xFF), + VTX(50, 32, 0, 3200, 512, 0xFF, 0xFF, 0xFF, 0xFF), VTX(50, 48, 0, 3200, 0, 0xFF, 0xFF, 0xFF, 0xFF), + VTX(-50, 32, 0, 0, 0, 0xFF, 0xFF, 0xFF, 0xFF), VTX(-50, 16, 0, 0, 512, 0xFF, 0xFF, 0xFF, 0xFF), + VTX(50, 16, 0, 3200, 512, 0xFF, 0xFF, 0xFF, 0xFF), VTX(50, 32, 0, 3200, 0, 0xFF, 0xFF, 0xFF, 0xFF), + VTX(-50, 16, 0, 0, 0, 0xFF, 0xFF, 0xFF, 0xFF), VTX(-50, 0, 0, 0, 512, 0xFF, 0xFF, 0xFF, 0xFF), + VTX(50, 0, 0, 3200, 512, 0xFF, 0xFF, 0xFF, 0xFF), VTX(50, 16, 0, 3200, 0, 0xFF, 0xFF, 0xFF, 0xFF), +}; +static Gfx D_84211308[] = { + gsSPSetGeometryMode(G_CULL_BACK), + gsDPSetCombineMode(G_CC_DECALRGBA, G_CC_PASS2), + gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON), + gsSPVertex(D_84211208, 16, 0), + gsDPLoadTextureBlock(0x0F000000, G_IM_FMT_RGBA, G_IM_SIZ_16b, 100, 16, 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(0x0F000C80, G_IM_FMT_RGBA, G_IM_SIZ_16b, 100, 16, 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(0x0F001900, G_IM_FMT_RGBA, G_IM_SIZ_16b, 100, 16, 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), + gsDPLoadTextureBlock(0x0F002580, G_IM_FMT_RGBA, G_IM_SIZ_16b, 100, 16, 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(12, 13, 14, 0, 12, 14, 15, 0), + gsSPEndDisplayList(), +}; +static u32 D_84211430[] = { + 0x17000000, 0x00000000, 0x00000000, 0x00000000, D_84211208, 0x05000000, 0x22040000, + 0x00000000, 0x08000000, func_84204070, D_84211308, 0x06000000, 0x01000000, 0x00000000, +}; +static Vtx D_84211468[] = { + VTX(-36, 12, 0, 0, 0, 0xFF, 0xFF, 0xFF, 0xFF), + VTX(-36, -12, 0, 0, 768, 0xFF, 0xFF, 0xFF, 0xFF), + VTX(36, -12, 0, 2304, 768, 0xFF, 0xFF, 0xFF, 0xFF), + VTX(36, 12, 0, 2304, 0, 0xFF, 0xFF, 0xFF, 0xFF), +}; +static Gfx D_842114A8[] = { + gsSPSetGeometryMode(G_CULL_BACK), + gsDPSetCombineLERP(0, 0, 0, 0, TEXEL0, 0, ENVIRONMENT, 0, 0, 0, 0, COMBINED, 0, 0, 0, COMBINED), + gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON), + gsSPVertex(D_84211468, 4, 0), + gsDPLoadTextureBlock_4b(0x0F000000, G_IM_FMT_I, 80, 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(0, 1, 2, 0, 0, 2, 3, 0), + gsSPEndDisplayList(), +}; +static u32 D_84211510[] = { + 0x17000000, 0x00000000, 0x00000000, 0x00000000, D_84211468, 0x05000000, 0x22050000, + 0x00000000, 0x08000000, func_84204070, D_842114A8, 0x06000000, 0x01000000, +}; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DB900/func_8420448C.s") +s16 D_84211544[] = { 0x46, 0x28, 0x1E, 0x1E, 0x1E, 0x1E, 0x28, 0x3C, 0x5A, 0x78, 0x6E, 0x64 }; +s16 D_8421155C[] = { 0x14, 0x3C, 0x5F, 0x78, 0x82, 0x87, 0x82, 0x78, 0x6E, 0x69, 0x66, 0x64 }; +s16 D_84211574[] = { 0x46, 0x32, 0x28, 0x1E, 0x19, 0x14, 0x14, 0x14, 0x19, 0x1E, 0x28, 0x32 }; +s16 D_8421158C[] = { + 0x64, 0x6E, 0x82, 0x96, 0xA0, 0xA0, 0x78, 0x50, 0x32, 0x1E, 0xA, 5, +}; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DB900/func_84204660.s") +s32 func_84204070(s32 arg0, unk_func_80011B94* arg1) { + u32 var_a0; + u8* var_a3; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DB900/func_84204760.s") + if (arg0 == 5) { + // clang-format off + switch (D_8006F09C->unk_000.unk_14) { + case 0: + var_a0 = D_8423E508[0]; var_a3 = D_201D820; + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DB900/func_84204934.s") + case 1: + var_a0 = D_8423E508[1]; var_a3 = D_201DB20; + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DB900/func_84204A3C.s") + case 2: + var_a0 = D_8423E508[2]; var_a3 = D_201DE20; + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DB900/func_84204B50.s") + case 3: + var_a0 = D_8423E508[3]; var_a3 = D_201E120; + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DB900/func_84204BF8.s") + case 4: + var_a0 = D_2029CE0; + var_a3 = NULL; + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DB900/func_84204C9C.s") + case 5: + var_a0 = D_201A620; + var_a3 = NULL; + break; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DB900/func_84204D5C.s") + default: + var_a0 = D_2028420; + var_a3 = NULL; + break; + } + // clang-format on -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DB900/func_84204E0C.s") + gDPPipeSync(gDisplayListHead++); + gDPSetEnvColor(gDisplayListHead++, 0, 0, 0, D_8006F09C->unk_01D); + gSPSegment(gDisplayListHead++, 0x0F, Memmap_GetSegmentVaddr(var_a0)); + gSPSegment(gDisplayListHead++, 0x0E, Memmap_GetSegmentVaddr(var_a3)); + gSPDisplayList(gDisplayListHead++, arg1->unk_00.unk_14); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DB900/func_84204F78.s") + func_80015684(); + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DB900/func_842050CC.s") + return 0; +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DB900/func_84205200.s") +void func_84204210(void) { + if (D_8423E56C == 3) { + s16 tmp = (D_84210DA0[D_8423E568].unk_02 - (D_84210DA0[D_8423E568].unk_06 / 2)) - 0x1E; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DB900/func_8420545C.s") + func_80020928(tmp, D_84210DA0[D_8423E568].unk_04 - 0x20); + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DB900/func_8420563C.s") +void func_84204294(s32 arg0) { + UNUSED s32 pad; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DB900/func_8420570C.s") + if (D_84210DA0[arg0].unk_00 != 0) { + if (D_84210DA0[arg0].unk_01 == 0) { + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + func_8001EBE0(8, 0); + func_8001F1E8(((arg0 * 128) - (func_8001F5B0(8, 0, D_8423E518[arg0].unk_06) / 2)) + 0x80, 0x5C, + D_8423E518[arg0].unk_06); + func_8001F324(0xFF, 0xBE, 0xFF, 0xFF); + func_8001EBE0(4, 0); + func_8001F1E8(((arg0 * 128) - (func_8001F5B0(4, 0, "ID 00000") / 2)) + 0x80, 0x73, "ID %05d", + D_8423E518[arg0].unk_04); + } else { + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + func_8001EBE0(8, 0); + func_8001F1E8(((arg0 * 128) - (func_8001F5B0(8, 0, "???????") / 2)) + 0x80, 0x5C, "???????"); + func_8001F324(0xFF, 0xBE, 0xFF, 0xFF); + func_8001EBE0(4, 0); + func_8001F1E8(((arg0 * 128) - (func_8001F5B0(4, 0, "ID *****") / 2)) + 0x80, 0x73, "ID *****"); + } + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DB900/func_842057AC.s") +void func_8420448C(void) { + s32 tmp; + char* temp_v0; + char sp20[0x100]; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DB900/func_8420594C.s") + func_8001F3F4(); + func_84204294(0); + func_84204294(1); + func_84204294(2); + func_84204294(3); + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + func_8001EBE0(0x10, 0); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DB900/func_84205B3C.s") + temp_v0 = func_84200130(0xB); + tmp = func_8001F5B0(0x10, 0, temp_v0) / 2; + func_8001F1E8(0x140 - tmp, 0x198, temp_v0); + func_8001EBE0(8, 0); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DB900/func_84205C18.s") + if (D_8423E56A == 0) { + temp_v0 = func_84200130(0xC); + } else { + temp_v0 = func_84200130(0xD); + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DB900/func_84205D48.s") + tmp = func_8001F5B0(8, 0, temp_v0) / 2; + func_8001F1E8(0x1C0 - tmp, 0x102, temp_v0); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DB900/func_84205E54.s") + if (D_8423E56A == 0) { + temp_v0 = func_84200130(0xE); + tmp = func_8001F5B0(8, 0, temp_v0) / 2; + func_8001F1E8(0xC0 - tmp, 0xF6, temp_v0); + func_8001F324(0xFF, 0xBA, 0xCC, 0xFF); + func_8002D600(2, D_8423E578); + temp_v0 = func_84200190(sp20, sizeof(sp20), 0xF); + tmp = func_8001F5B0(8, 0, temp_v0) / 2; + func_8001F1E8(0xC0 - tmp, 0x10E, temp_v0); + } + func_8001F444(); +} + +void func_84204660(s32 arg0, s16 arg1, s16 arg2) { + Color_RGBA8 sp2C; + + if (D_84210DA0[arg0].unk_00 != 0) { + if (D_84210DA0[arg0].unk_01 == 0) { + func_8000E840(&sp2C, 0x1E, 0x1E, 0x82, 0xFF); + } else { + func_8000E840(&sp2C, 0x64, 0x1E, 0x1E, 0xFF); + } + } else { + func_8000E840(&sp2C, 0x1E, 0x1E, 0x82, 0x80); + } + func_8420092C((arg0 * 128) + 0x44, arg1 + 0x54, 0x78, arg2, sp2C.r, sp2C.g, sp2C.b, sp2C.a); +} + +void func_84204210(void); + +void func_84204760(s32 arg0) { + UNUSED s32 pad; + s16 sp32; + s16 temp_s0; + + if (D_8423E56C != 0) { + temp_s0 = (0x38 - D_8423E574) / 2; + sp32 = (0x28 - D_8423E576) / 2; + func_80015094(D_8423D400); + func_84204210(); + + if (D_8423E574 > 0) { + func_84204660(0, temp_s0, D_8423E574); + func_84204660(1, temp_s0, D_8423E574); + func_84204660(2, temp_s0, D_8423E574); + func_84204660(3, temp_s0, D_8423E574); + if (D_8423E56A == 0) { + func_8420092C(0x44, temp_s0 + 0xF0, 0xF8, D_8423E574, 0x78, 0x1E, 0x64, 0xFF); + } + func_8420092C(0x144, temp_s0 + 0xF0, 0xF8, D_8423E574, 0x78, 0x1E, 0x64, 0xFF); + } + + if (D_8423E576 > 0) { + func_8420112C(0x38, sp32 + 0x190, 0x210, D_8423E576, 0x1E, 0x1E, 0x82, 0x96); + } + + if (D_8423E574 == 0x38) { + func_8420448C(); + } + } +} + +void func_84204934(s16 arg0, f32 arg1) { + s16 var_a2; + f32 var_fa0; + + if (arg0 == D_8423E568) { + var_fa0 = 0.06f; + var_a2 = 0x3000; + } else { + var_fa0 = 0.02f; + var_a2 = 0x2000; + } + + D_8423D408[0][arg0].unk_030.x = ((SINS(D_84210DA0[arg0].unk_0A) * var_fa0) + 1.0f) * arg1; + D_8423D408[0][arg0].unk_030.y = ((COSS(D_84210DA0[arg0].unk_0A) * var_fa0) + 1.0f) * arg1; + + D_8423D408[1][arg0].unk_030.x = ((SINS(D_84210DA0[arg0].unk_0A) * var_fa0) + 1.0f) * arg1; + D_8423D408[1][arg0].unk_030.y = ((COSS(D_84210DA0[arg0].unk_0A) * var_fa0) + 1.0f) * arg1; + + D_84210DA0[arg0].unk_0A += var_a2 + ((MathUtil_Random16() & 0xF) * 0x10); +} + +void func_84204A3C(s16 arg0, f32 arg1) { + f32 var_fv0; + s16 var_v0; + + if (arg0 == D_8423E568) { + var_v0 = D_84210DA0[arg0].unk_0C * 2; + var_fv0 = 1.5f; + } else { + var_v0 = D_84210DA0[arg0].unk_0C; + var_fv0 = 1.0f; + } + + D_8423D408[0][arg0].unk_01E.z = SINS(D_84210DA0[arg0].unk_08) * (1536.0f * var_fv0); + + D_8423D408[0][arg0].unk_024.x = + (D_84210DA0[arg0].unk_02 - 320.0f) - (SINS(D_84210DA0[arg0].unk_08) * (6.0f * var_fv0)); + D_8423D408[1][arg0].unk_024.x = + (D_84210DA0[arg0].unk_02 - 320.0f) - (SINS(D_84210DA0[arg0].unk_08) * (6.0f * var_fv0)); + + D_84210DA0[arg0].unk_08 += var_v0; +} + +void func_84204B50(void) { + s16 i; + s16 var_v1; + s32 var_a0; + + if (D_8423E568 >= 4) { + if (D_8423E568 == 4) { + var_v1 = 0; + var_a0 = 1; + } else { + var_v1 = 3; + var_a0 = -1; + } + + for (i = 0; i < 4; i++) { + if (D_84210DA0[var_v1].unk_00 != 0) { + D_8423E568 = var_v1; + func_80048B90(1); + break; + } + var_v1 = (var_v1 + var_a0) & 3; + } + } +} + +void func_84204BF8(void) { + s16 var_v0; + s16 i; + + if (D_8423E568 < 4) { + var_v0 = D_8423E568 / 2 + 4; + for (i = 0; i < 2; i++) { + if (D_84210DA0[var_v0].unk_00 != 0) { + D_8423E568 = var_v0; + func_80048B90(1); + break; + } + var_v0 ^= 1; + } + } +} + +void func_84204C9C(void) { + s16 i; + + if ((D_8423E568 > 0) && (D_8423E568 < 4)) { + for (i = D_8423E568 - 1; i >= 0; i--) { + if (D_84210DA0[i].unk_00 != 0) { + D_8423E568 = i; + func_80048B90(1); + break; + } + } + } else if ((D_8423E568 == 5) && (D_84210DA0[4].unk_00 != 0)) { + D_8423E568 = 4; + func_80048B90(1); + } +} + +void func_84204D5C(void) { + s16 i; + + if (D_8423E568 < 3) { + for (i = D_8423E568 + 1; i < 4; i++) { + if (D_84210DA0[i].unk_00 != 0) { + D_8423E568 = i; + func_80048B90(1); + break; + } + } + } else if (D_8423E568 == 4) { + D_8423E568 = 5; + func_80048B90(1); + } +} + +void func_84204E0C(void) { + s16 i; + + if (BTN_IS_PRESSED(D_8423E570, BTN_A)) { + if (D_84210DA0[D_8423E568].unk_01 == 0) { + func_80048B90(0x01100012); + D_8423E56C = 4; + } else { + func_80048B90(8); + D_8423E56C = 6; + } + } else if ((D_8423E57C != 0) && (BTN_IS_PRESSED(D_8423E570, BTN_B))) { + D_8423E56C = 5; + func_80048B90(3); + } else if (BTN_IS_PRESSED(D_8423E570, BTN_DUP)) { + func_84204B50(); + } else if (BTN_IS_PRESSED(D_8423E570, BTN_DDOWN)) { + func_84204BF8(); + } else if (BTN_IS_PRESSED(D_8423E570, BTN_DLEFT)) { + func_84204C9C(); + } else if (BTN_IS_PRESSED(D_8423E570, BTN_DRIGHT)) { + func_84204D5C(); + } + + for (i = 0; i < 6; i++) { + func_84204934(i, 1.0f); + func_84204A3C(i, 1.0f); + } +} + +void func_84204F78(void) { + s16 i; + + for (i = 0; i < 12; i++) { + D_8423D408[0][i].unk_030.x = D_84211544[D_8423E56E] / 100.0f; + D_8423D408[0][i].unk_030.y = D_8421155C[D_8423E56E] / 100.0f; + } + + D_8423E574 = ((((D_8423E56E * 0x32) + 0x32) / 12) + 6) & (u16)~1; + D_8423E576 = ((((D_8423E56E * 0x24) + 0x24) / 12) + 4) & (u16)~1; + + D_8423E56E++; + if (D_8423E56E == 12) { + D_8423E56C = 3; + } +} + +void func_842050CC(void) { + if (D_8423E56E++ < 12) { + D_8423D408[0][D_8423E568].unk_030.x = D_84211574[D_8423E56E] / 100.0f; + D_8423D408[0][D_8423E568].unk_030.y = D_8421158C[D_8423E56E] / 100.0f; + + D_8423D408[1][D_8423E568].unk_030.x = D_84211574[D_8423E56E] / 100.0f; + D_8423D408[1][D_8423E568].unk_030.y = D_8421158C[D_8423E56E] / 100.0f; + + D_8423D408[0][D_8423E568].unk_01E.z = 0; + } else { + func_8001BCF0(&D_8423D408[0][D_8423E568]); + func_8001BCF0(&D_8423D408[1][D_8423E568]); + D_8423E56C = 0; + } +} + +void func_84205200(void) { + s16 i; + + D_8423E56E--; + if (D_8423E56E == 0) { + for (i = 0; i < 6; i++) { + if (i != D_8423E568) { + func_8001BCF0(&D_8423D408[0][i]); + func_8001BCF0(&D_8423D408[1][i]); + } + } + + D_8423E574 = 0; + D_8423E576 = 0; + D_8423E56C = 2; + } else { + for (i = 0; i < 6; i++) { + if (i == D_8423E568) { + func_84204934(i, 1.0f); + func_84204A3C(i, 1.0f); + } else { + func_84204934(i, D_8423E56E / 12.0f); + func_84204A3C(i, D_8423E56E / 12.0f); + } + + D_8423E574 = ((((D_8423E56E * 0x32) + 0x32) / 12) + 6) & (u16)~1; + D_8423E576 = ((((D_8423E56E * 0x24) + 0x24) / 12) + 4) & (u16)~1; + } + } +} + +void func_8420545C(void) { + s16 i; + + D_8423E56E--; + if (D_8423E56E == 0) { + + for (i = 0; i < 6; i++) { + func_8001BCF0(&D_8423D408[0][i]); + func_8001BCF0(&D_8423D408[1][i]); + } + + D_8423E568 = -2; + D_8423E574 = 0; + D_8423E576 = 0; + D_8423E56C = 0; + } else { + for (i = 0; i < 6; i++) { + func_84204934(i, D_8423E56E / 12.0f); + func_84204A3C(i, D_8423E56E / 12.0f); + } + + D_8423E574 = ((((D_8423E56E * 0x32) + 0x32) / 12) + 6) & (u16)~1; + D_8423E576 = ((((D_8423E56E * 0x24) + 0x24) / 12) + 4) & (u16)~1; + } +} + +void func_8420563C(void) { + s16 var_s0; + s16 i; + + if (D_84210DA0[D_8423E568].unk_01 == 0x15) { + var_s0 = 0x11; + } else { + var_s0 = 0x12; + } + + func_8420DA28(var_s0, D_8423E570); + + if (func_8420DB48(var_s0) != -1) { + D_8423E56C = 3; + } + + for (i = 0; i < 6; i++) { + func_84204934(i, 1.0f); + func_84204A3C(i, 1.0f); + } +} + +s32 func_8420570C(void) { + switch (D_8423E56C) { + case 1: + func_84204F78(); + break; + + case 3: + func_84204E0C(); + break; + + case 4: + func_84205200(); + break; + + case 2: + func_842050CC(); + break; + + case 5: + func_8420545C(); + break; + + case 6: + func_8420563C(); + break; + } + return 1; +} + +void func_842057AC(void) { + s16 i; + + for (i = 0; i < 4; i++) { + if (D_8423E518[i].unk_01 != 0) { + switch (D_8423E518[i].unk_01) { + case 1: + D_8423E508[i] = D_201E420; + break; + + case 2: + D_8423E508[i] = D_2020420; + break; + + case 3: + D_8423E508[i] = D_2022420; + break; + + case 7: + D_8423E508[i] = D_2024420; + break; + } + + if (D_8423E518[i].unk_00 != 0) { + D_84210DA0[i].unk_01 = 0x14; + } + } else { + D_8423E508[i] = D_2026420; + if (D_8423E518[i].unk_00 == 2) { + D_84210DA0[i].unk_01 = 0x15; + } else { + D_84210DA0[i].unk_00 = 0; + D_84210DA0[i].unk_01 = 1; + } + } + } +} + +void func_8420594C(void) { + s16 i; + + if (D_8423E56A != 0) { + D_84210DD8[0] = 0; + } else { + D_84210DD8[0] = 1; + } + + for (i = 0; i < 6; i++) { + if (D_84210DA0[i].unk_00 != 0) { + func_8001BC34(D_8423D408[0] + i, 0, 0, D_8423E4E8[i]); + func_8001BC34(D_8423D408[1] + i, 0, 0, D_8423E500); + func_8000E88C(&D_8423D408[0][i].unk_024, D_84210DA0[i].unk_02 - 0x140, 0xF0 - D_84210DA0[i].unk_04, -579.f); + func_8000E88C(&D_8423D408[1][i].unk_024, D_84210DA0[i].unk_02 - 0x140, 0xE4 - D_84210DA0[i].unk_04, + -579.0f); + D_8423D408[1][i].unk_01D = 0xB4; + } + } + + if (D_84210DD8[0] != 0) { + D_8423E578 = func_80028E68(); + if (D_8423E578 == 0) { + D_84210DD8[0] = 0; + D_8423D408[0][4].unk_01D = 0xA0; + D_8423D408[1][4].unk_01D = 0x64; + } + } + + if (!D_84210DA0) {} +} + +void func_84205B3C(void) { + s32 i; + u8 temp_s3 = Cont_GetControllerBits(); + unk_D_800AC910_040 sp48; + + for (i = 0; i < 4; i++) { + func_80025040(i, &sp48); + func_80021A90(D_8423E518[i].unk_06, sp48.unk_02); + D_8423E518[i].unk_04 = sp48.unk_00; + D_8423E518[i].unk_01 = func_80024F68(i); + D_8423E518[i].unk_00 = func_80024F00(i); + D_8423E518[i].unk_02 = func_80025370(i); + D_8423E518[i].unk_03 = (temp_s3 & (1 << i)) != 0; + } +} + +s32 func_84205C18(s16 arg0) { + s32 i; + MemoryBlock* temp_v0 = func_80002D10(main_pool_get_available(), 0); + unk_D_86002F58_004_000* var_s2; + + D_8423D400 = process_geo_layout(temp_v0, D_84210DF4); + D_8423E56A = arg0; + D_8423E4E8[3] = D_8423E4E8[2] = D_8423E4E8[1] = D_8423E4E8[0] = process_geo_layout(temp_v0, D_84210FF0); + D_8423E4E8[4] = process_geo_layout(temp_v0, D_842111D0); + D_8423E4E8[5] = process_geo_layout(temp_v0, D_84211430); + D_8423E500 = process_geo_layout(temp_v0, D_84211510); + + func_80002D60(temp_v0); + func_8001BB20(); + + var_s2 = &D_8423D408[0][0]; + for (i = 0; i < 12; var_s2++, i++) { + func_8001BB58(var_s2); + D_8423D408[0][i].unk_000.unk_14 = i; + } + + func_84205B3C(); + func_842057AC(); + return 8; +} + +s32 func_84205D48(s16 arg0, s32 arg1) { + if (D_8423E56C == 0) { + func_8420594C(); + if (D_84210DA0[arg0].unk_00 != 0) { + D_8423E568 = arg0; + } else { + for (D_8423E568 = 0; D_8423E568 < 5; D_8423E568++) { + if (D_84210DA0[D_8423E568].unk_00 != 0) { + break; + } + } + } + + D_8423E570 = &gControllers[arg0]; + D_8423E57C = arg1; + D_8423E56E = 0; + D_8423E56C = 1; + return 1; + } + + return 0; +} + +s16 func_84205E54(void) { + if (D_8423E56C == 0) { + return D_8423E568; + } + return -1; +} diff --git a/src/fragments/61/fragment61_2DD710.c b/src/fragments/61/fragment61_2DD710.c index c99c3e3..346a7d3 100644 --- a/src/fragments/61/fragment61_2DD710.c +++ b/src/fragments/61/fragment61_2DD710.c @@ -1,79 +1,942 @@ -#include "global.h" +#include "fragment61.h" +#include "src/1AB70.h" +#include "src/1CF30.h" +#include "src/232C0.h" +#include "src/26820.h" +#include "src/49790.h" +#include "src/hal_libc.h" -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DD710/func_84205E80.s") +s16 D_842115B0[] = { 0x78, 0xFC, 0x180, 0x78, 0xFC, 0x180 }; +s16 D_842115BC[] = { + 4, 4, 4, 0x30, 0x30, 0x30, +}; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DD710/func_84205F18.s") +void func_84205E80(s16 arg0, s16 arg1, s32 arg2) { + if (arg2 & 0x80000000) { + func_84200420(arg0, arg1, 0x84, 0x2C, 0x64, 0x64, 0xC8, 0xFF); + } else { + func_84200420(arg0, arg1, 0x84, 0x2C, 0x3C, 0x3C, 0xA0, 0xFF); + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DD710/func_84206144.s") +void func_84205F18(unk_D_84211B50* arg0, s16 arg1, s16 arg2) { + s16 i; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DD710/func_842062D4.s") + func_842001B8(arg1, arg2, 0x208, 0x60); + if (((D_800AE540.unk_0001 == 0) || (D_800AE540.unk_0001 == 8)) && (arg0->unk_0004 != 0) && (arg0->unk_0006 > 0) && + (arg0->unk_0006 < 6)) { + func_84200420(arg1 + 4, arg2 + 4, 0x74, 0x58, 0, 0, 0, 0xFF); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DD710/func_84206870.s") + gSPDisplayList(gDisplayListHead++, D_8006F518); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DD710/func_842068DC.s") + func_8001C6AC(arg1 + 0x32, arg2 + 0x32, 0x14, 0x14, D_20068E0, 0x14, 0); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DD710/func_84206990.s") + gSPDisplayList(gDisplayListHead++, D_8006F630); + } else { + func_84200420(arg1 + 4, arg2 + 4, 0x74, 0x58, 0x64, 0x64, 0xC8, 0xFF); + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DD710/func_84206A68.s") + for (i = 0; i < 6; i++) { + s16 tmp1 = D_842115B0[i] + arg1; + s16 tmp2 = D_842115BC[i] + arg2; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DD710/func_84206BC4.s") + func_84205E80(tmp1, tmp2, arg0->unk_0030[i].raw); + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DD710/func_84206BDC.s") +void func_84206144(unk_D_84211B50* arg0) { + s16 temp_s0 = arg0->unk_0018 + (arg0->unk_0010 * 0x84) + 0x78; + s16 temp_a1 = arg0->unk_001A + (arg0->unk_0012 * 0x2C) + 4; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DD710/func_84206BF0.s") + if (arg0->unk_0001 == 0xD) { + if (arg0->unk_000C > 0) { + temp_a1 = ((temp_a1 + ((arg0->unk_000C * 0x2C) / 4)) - 0x2C); + } else { + temp_a1 = (temp_a1 + ((arg0->unk_000C * 0x2C) / 4) + 0x2C); + } + func_84200738(temp_s0, temp_a1, 0x84, 0x2C); + } else if (arg0->unk_0001 == 0xC) { + if (arg0->unk_000C > 0) { + temp_s0 = ((temp_s0 + ((arg0->unk_000C * 0x84) / 4)) - 0x84); + } else { + temp_s0 = (temp_s0 + ((arg0->unk_000C * 0x84) / 4) + 0x84); + } + func_84200738(temp_s0, temp_a1, 0x84, 0x2C); + } else if (arg0->unk_0001 == 8) { + func_84200738(temp_s0, temp_a1, 0x84, 0x2C); + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DD710/func_84206D10.s") +void func_842062D4(unk_D_84211B50* arg0, s32 arg1) { + char* temp_v0_10; + char* temp_v0_4; + char* temp_v0_5; + char* temp_v0_6; + char* temp_v0_7; + char* temp_v0_8; + s32 i; + s16 sp42; + s16 sp40; + char* temp_v0_9; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DD710/func_84206DE8.s") + if ((arg0->unk_0001 != 1) && (arg0->unk_0001 != 0) && ((arg1 != 0) || (arg0->unk_0003 != 0))) { + func_84205F18(arg0, arg0->unk_0018, arg0->unk_001A); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DD710/func_84206E88.s") + gSPDisplayList(gDisplayListHead++, D_8006F518); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DD710/func_84206EE0.s") + for (i = 0; i < 6; i++) { + if (arg0->unk_0030[i].unk_004.unk_00.unk_00 != 0) { + s16 tmp1 = D_842115B0[i] + arg0->unk_0018 + 2; + s16 tmp2 = D_842115BC[i] + arg0->unk_001A + 2; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DD710/func_84206F1C.s") + func_8001C6AC(tmp1, tmp2, 0x28, 0x28, arg0->unk_0030[i].unk_058, 0x28, 0); + } + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DD710/func_84206F64.s") + gSPDisplayList(gDisplayListHead++, D_8006F630); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DD710/func_84206FB0.s") + func_8001F3F4(); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DD710/func_84206FF8.s") + if (((D_800AE540.unk_0001 == 0) || (D_800AE540.unk_0001 == 8)) && (arg0->unk_0004 != 0) && + (arg0->unk_0006 > 0) && (arg0->unk_0006 < 6)) { + func_8001EBE0(8, 0); + temp_v0_4 = func_84200130(arg0->unk_0006 + 0x2A); + func_8001F1E8((arg0->unk_0018 - (func_8001F5B0(8, 0, temp_v0_4) / 2)) + 0x3C, arg0->unk_001A + 8, + temp_v0_4); + if (arg0->unk_0000 == 0) { + temp_v0_5 = func_84200130(0x31); + func_8001F1E8((arg0->unk_0018 - (func_8001F5B0(8, 0, temp_v0_5) / 2)) + 0x3C, arg0->unk_001A + 0x1C, + temp_v0_5); + } else { + temp_v0_6 = func_84200130(0x32); + func_8001F1E8((arg0->unk_0018 - (func_8001F5B0(8, 0, temp_v0_6) / 2)) + 0x3C, arg0->unk_001A + 0x1C, + temp_v0_6); + } + func_8001EBE0(4, 0); + temp_v0_7 = func_84200130(0x33); + func_8001F1E8((arg0->unk_0018 - (func_8001F5B0(4, 0, temp_v0_7) / 2)) + 0x3C, arg0->unk_001A + 0x46, + temp_v0_7); + } else { + func_8001EBE0(4, 0); + if (arg0->unk_0000 == 0) { + temp_v0_8 = func_84200130(0x34); + func_8001F1E8((arg0->unk_0018 - (func_8001F5B0(4, 0, temp_v0_8) / 2)) + 0x3C, arg0->unk_001A + 9, + temp_v0_8); + } else { + temp_v0_9 = func_84200130(0x35); + func_8001F1E8((arg0->unk_0018 - (func_8001F5B0(4, 0, temp_v0_9) / 2)) + 0x3C, arg0->unk_001A + 9, + temp_v0_9); + } + temp_v0_10 = func_84200130(0x36); + func_8001F1E8((arg0->unk_0018 - (func_8001F5B0(4, 0, temp_v0_10) / 2)) + 0x3C, arg0->unk_001A + 0x1A, + temp_v0_10); + func_8001EBE0(8, 0); + func_8001F1E8((arg0->unk_0018 - (func_8001F5B0(8, 0, arg0->unk_001E) / 2)) + 0x3C, arg0->unk_001A + 0x2F, + arg0->unk_001E); + func_8001EBE0(4, 0); + func_8001F1E8((arg0->unk_0018 - (func_8001F5B0(4, 0, "ID 00000") / 2)) + 0x3C, arg0->unk_001A + 0x46, + "ID %05d", arg0->unk_001C); + } + func_8001EBE0(4, 0); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DD710/func_84207040.s") + for (i = 0; i < 6; i++) { + if (arg0->unk_0030[i].unk_004.unk_00.unk_00 != 0) { + s16 tmp1 = D_842115B0[i] + arg0->unk_0018 + 0x2C; + s16 tmp2 = D_842115BC[i] + arg0->unk_001A + 5; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DD710/func_84207190.s") + func_8001F1E8(tmp1, tmp2, arg0->unk_0030[i].unk_004.unk_30); + } + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DD710/func_8420720C.s") + func_8001EBE0(4, 0); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DD710/func_842073A4.s") + for (i = 0; i < 6; i++) { + if (arg0->unk_0030[i].unk_004.unk_00.unk_00 != 0) { + sp42 = D_842115B0[i] + arg0->unk_0018 + 0x2C; + sp40 = D_842115BC[i] + arg0->unk_001A + 0x17; + func_8001F1E8(sp42, sp40, "%s %d", func_84200160(0x15), arg0->unk_0030[i].unk_004.unk_24); + } + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DD710/func_84207530.s") + func_8001F444(); + func_84206144(arg0); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DD710/func_84207634.s") + if (arg0->unk_0003 > 0) { + arg0->unk_0003--; + } + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DD710/func_842076A0.s") +void func_84206870(unk_D_84211B50* arg0) { + s16 temp_v0 = arg0->unk_0010 + (arg0->unk_0012 * 3); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DD710/func_842076F8.s") + if (arg0->unk_0030[temp_v0].unk_004.unk_00.unk_00 != 0) { + arg0->unk_0030[temp_v0].unk_004.unk_00.unk_00 = 0; + arg0->unk_0030[temp_v0].raw = 0; + arg0->unk_0006 -= 1; + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DD710/func_8420776C.s") +void func_842068DC(unk_D_84211B50* arg0) { + s16 sp1E = arg0->unk_0010 + (arg0->unk_0012 * 3); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DD710/func_842078C0.s") + if (func_8420B334(arg0->unk_4D40) != 0) { + if (arg0->unk_0030[sp1E].unk_004.unk_00.unk_00 != 0) { + arg0->unk_0030[sp1E].unk_004.unk_00.unk_00 = 0; + arg0->unk_0030[sp1E].raw = 0; + arg0->unk_0006--; + } + arg0->unk_0030[sp1E].raw |= 0x80000000; + arg0->unk_0004 = 1; + arg0->unk_0001 = 3; + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DD710/func_842079B4.s") +s32 func_84206990(unk_D_84211B50* arg0) { + s16 i; + s16 temp_v0; + s32 var_s0 = 0; + unk_func_80022C28_ret* temp_s3; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DD710/func_842079F0.s") + temp_v0 = func_80028E68(); + if (temp_v0 < 0xA) { + temp_s3 = func_80022CC0(0x10, 0, temp_v0, arg0->unk_001E, arg0->unk_001E, arg0->unk_001C); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DD710/func_84207A1C.s") + for (i = 0; i < arg0->unk_0006; i++) { + func_80022F24(&arg0->unk_0030[i].unk_004.unk_00.unk_00, 1, temp_s3); + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DD710/func_84207AAC.s") + func_80022D8C(temp_s3); + func_800286D8(); + var_s0 = 1; + } + return var_s0; +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DD710/func_84207BD4.s") +s32 func_84206A68(unk_D_84211B50* arg0) { + UNUSED s32 pad; + s32 temp_v1; + s16 i; + s16 sp8[3]; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DD710/func_84207D5C.s") + for (i = 0; i < 3; i++) { + sp8[i] = 0x3E7; + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DD710/func_84207E3C.s") + for (i = 0; i < arg0->unk_0006; i++) { + temp_v1 = arg0->unk_0030[i].unk_004.unk_24; + if (sp8[2] >= temp_v1) { + sp8[2] = temp_v1; + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DD710/func_8420804C.s") + if (sp8[1] >= temp_v1) { + sp8[2] = sp8[1]; + sp8[1] = temp_v1; + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DD710/func_842081A8.s") + if (sp8[0] >= temp_v1) { + sp8[1] = sp8[0]; + sp8[0] = temp_v1; + } + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DD710/func_842081B4.s") + switch (D_800AE540.unk_0001) { + default: + temp_v1 = 0; + break; + + case 3: + temp_v1 = (s16)(sp8[0] + sp8[1] + sp8[2]); + temp_v1 = temp_v1 >= 0x9C; + break; + + case 4: + temp_v1 = (s16)(sp8[0] + sp8[1] + sp8[2]); + temp_v1 = temp_v1 >= 0x51; + break; + + case 5: + temp_v1 = (s16)(sp8[0] + sp8[1] + sp8[2]); + temp_v1 = temp_v1 >= 0x33; + break; + } + return temp_v1; +} + +void func_84206BC4(unk_D_84211B50* arg0) { + arg0->unk_0018 = arg0->unk_0014 + 0x280; + arg0->unk_001A = arg0->unk_0016; +} + +void func_84206BDC(unk_D_84211B50* arg0) { + arg0->unk_0018 = arg0->unk_0014; + arg0->unk_001A = arg0->unk_0016; +} + +void func_84206BF0(unk_D_84211B50* a0) { + unk_D_84211B50* arg0 = a0; + s16 temp_v0; + s16 temp_v1; + s16 tmp; + + func_8420DAF4(1); + if (func_8420DB48(1) >= 0) { + tmp = a0->unk_0010 + a0->unk_0012 * 3; + + temp_v0 = a0->unk_0014 + (a0->unk_0010 * 0x84) + 0x74; + temp_v1 = a0->unk_0016 + (a0->unk_0012 * 0x2C); + + arg0->unk_0030[tmp].raw |= 0x80000000; + func_8420C60C(a0->unk_4D44, a0->unk_0002, 0x30, 0xEC, temp_v0, temp_v1, &a0->unk_0030[tmp], 2); + a0->unk_0001 = 6; + } + a0->unk_0018 = a0->unk_0014; + a0->unk_001A = a0->unk_0016; + a0->unk_0003 = 2; +} + +void func_84206D10(unk_D_84211B50* arg0) { + s16 sp26 = arg0->unk_0010 + (arg0->unk_0012 * 3); + s32 temp_v0 = func_8420C788(arg0->unk_4D44); + + if (temp_v0 == 1) { + func_8420B334(arg0->unk_4D40); + arg0->unk_0004 = 0; + arg0->unk_0001 = 3; + } else if (temp_v0 == 2) { + arg0->unk_0030[sp26].raw &= ~0x80000000; + func_8420DA28(1, NULL); + arg0->unk_000A = 0; + arg0->unk_0001 = 8; + } + arg0->unk_0018 = arg0->unk_0014; + arg0->unk_001A = arg0->unk_0016; +} + +void func_84206DE8(unk_D_84211B50* arg0) { + arg0->unk_000A++; + if (arg0->unk_000A <= 0) { + arg0->unk_0018 = arg0->unk_0014 + 0x280; + arg0->unk_0003 = 2; + } else if (arg0->unk_000A == 0xA) { + arg0->unk_000A = 0; + arg0->unk_0018 = arg0->unk_0014; + if (arg0->unk_0006 == arg0->unk_0008) { + arg0->unk_0003 = 2; + arg0->unk_0001 = 7; + } else { + // clang-format off + *(s8*)&arg0->unk_0001 = 2; arg0->unk_0003 = 2; + // clang-format on + } + } else { + arg0->unk_0018 = (arg0->unk_0014 - (arg0->unk_000A << 6)) + 0x280; + arg0->unk_0003 = 2; + } + arg0->unk_001A = arg0->unk_0016; +} + +void func_84206E88(unk_D_84211B50* arg0) { + arg0->unk_000A++; + if (arg0->unk_000A == 0xA) { + arg0->unk_0001 = 0; + arg0->unk_000A = 0; + arg0->unk_0018 = arg0->unk_0014 + 0x280; + } else { + arg0->unk_0018 = arg0->unk_0014 - (arg0->unk_000A << 6); + } + arg0->unk_001A = arg0->unk_0016; + arg0->unk_0003 = 2; +} + +void func_84206EE0(unk_D_84211B50* arg0) { + func_842068DC(arg0); + arg0->unk_0018 = arg0->unk_0014; + arg0->unk_001A = arg0->unk_0016; + arg0->unk_0003 = 2; +} + +void func_84206F1C(unk_D_84211B50* arg0) { + if (arg0->unk_0010 > 0) { + arg0->unk_0010--; + arg0->unk_000C = -1; + arg0->unk_000E = -4; + arg0->unk_0001 = 0xC; + func_80048B90(1); + } +} + +void func_84206F64(unk_D_84211B50* arg0) { + if (arg0->unk_0010 < 2) { + arg0->unk_0010++; + arg0->unk_000C = 1; + arg0->unk_000E = 4; + arg0->unk_0001 = 0xC; + func_80048B90(1); + } +} + +void func_84206FB0(unk_D_84211B50* arg0) { + if (arg0->unk_0012 > 0) { + arg0->unk_0012--; + arg0->unk_000C = -1; + arg0->unk_000E = -4; + arg0->unk_0001 = 0xD; + func_80048B90(1); + } +} + +void func_84206FF8(unk_D_84211B50* arg0) { + if (arg0->unk_0012 <= 0) { + arg0->unk_0012++; + arg0->unk_000C = 1; + arg0->unk_000E = 4; + arg0->unk_0001 = 0xD; + func_80048B90(1); + } +} + +void func_84207040(unk_D_84211B50* arg0) { + Controller* cont = &gControllers[arg0->unk_0002]; + + if (arg0->unk_000A < 8) { + arg0->unk_000A++; + } else if (BTN_IS_PRESSED(cont, BTN_A)) { + s32 temp_v0 = arg0->unk_0010 + (arg0->unk_0012 * 3); + + if (arg0->unk_0030[temp_v0].unk_004.unk_00.unk_00 != 0) { + func_80048B90(2); + arg0->unk_0001 = 0xB; + } + } else if (BTN_IS_PRESSED(cont, BTN_B)) { + func_80048B90(3); + arg0->unk_0001 = 0x10; + } else if (BTN_IS_PRESSED(cont, BTN_DUP)) { + func_84206FB0(arg0); + } else if (BTN_IS_PRESSED(cont, BTN_DDOWN)) { + func_84206FF8(arg0); + } else if (BTN_IS_PRESSED(cont, BTN_DRIGHT)) { + func_84206F64(arg0); + } else if (BTN_IS_PRESSED(cont, BTN_DLEFT)) { + func_84206F1C(arg0); + } + + arg0->unk_0018 = arg0->unk_0014; + arg0->unk_001A = arg0->unk_0016; + arg0->unk_0003 = 2; +} + +void func_84207190(unk_D_84211B50* arg0) { + func_8420DAF4(1); + if (func_8420DB48(1) >= 0) { + if (func_84206A68(arg0) != 0) { + arg0->unk_0001 = 0xF; + } else if (arg0->unk_0000 == 0) { + arg0->unk_0001 = 7; + } else { + arg0->unk_0001 = 0xE; + } + } + arg0->unk_0003 = 2; +} + +void func_8420720C(unk_D_84211B50* arg0) { + Controller* cont = &gControllers[arg0->unk_0002]; + s16 i; + + func_8420DA28(0, cont); + + switch (func_8420DB48(0)) { + case 0: + i = arg0->unk_0006; + if (i == 6) { + i--; + } + arg0->unk_0010 = i % 3; + arg0->unk_0012 = i / 3; + arg0->unk_0008 = 6; + arg0->unk_0001 = 2; + break; + + case 1: + func_8420B238(arg0->unk_4D40); + arg0->unk_000A = 0; + arg0->unk_0001 = 5; + break; + + case 2: + if (func_84206990(arg0) != 0) { + arg0->unk_0001 = 9; + } else { + arg0->unk_0001 = 0xA; + } + break; + + case 3: + func_8420DA28(1, NULL); + arg0->unk_0010 = 0; + arg0->unk_0012 = 0; + arg0->unk_000A = 0; + arg0->unk_0001 = 8; + break; + + case 4: + for (i = 0; i < 6; i++) { + arg0->unk_0030[i].raw = 0; + arg0->unk_0030[i].unk_004.unk_00.unk_00 = 0; + } + + func_8420B264(arg0->unk_4D40); + + arg0->unk_0006 = 0; + arg0->unk_0010 = 0; + arg0->unk_0012 = 0; + arg0->unk_0008 = 6; + arg0->unk_0001 = 2; + break; + } + arg0->unk_0018 = arg0->unk_0014; + arg0->unk_001A = arg0->unk_0016; +} + +void func_842073A4(unk_D_84211B50* arg0) { + Controller* cont = &gControllers[arg0->unk_0002]; + s16 i; + + func_8420DA28(0xA, cont); + switch (func_8420DB48(0xA)) { + case 0: + i = arg0->unk_0006; + if (i == 6) { + i--; + } + arg0->unk_0010 = i % 3; + arg0->unk_0012 = i / 3; + arg0->unk_0008 = 6; + arg0->unk_0001 = 2; + break; + + case 1: + func_8420B238(arg0->unk_4D40); + func_84210A48(arg0->unk_4D48, arg0->unk_001C, arg0->unk_001E, arg0->unk_0030); + arg0->unk_0001 = 3; + break; + + case 2: + func_8420DA28(1, NULL); + arg0->unk_0010 = 0; + arg0->unk_0012 = 0; + arg0->unk_000A = 0; + arg0->unk_0001 = 8; + break; + + case 3: + for (i = 0; i < 6; i++) { + arg0->unk_0030[i].raw = 0; + arg0->unk_0030[i].unk_004.unk_00.unk_00 = 0; + } + + func_8420B264(arg0->unk_4D40); + + arg0->unk_0006 = 0; + arg0->unk_0010 = 0; + arg0->unk_0012 = 0; + arg0->unk_0008 = 6; + arg0->unk_0001 = 2; + break; + } + + arg0->unk_0018 = arg0->unk_0014; + arg0->unk_001A = arg0->unk_0016; +} + +void func_84207530(unk_D_84211B50* arg0) { + UNUSED s16 pad; + s16 sp1C = 0xD; + s32 temp_v0_2; + Controller* cont = &gControllers[arg0->unk_0002]; + + switch (D_800AE540.unk_0001) { + case 3: + break; + + case 4: + sp1C = 0xE; + break; + + case 5: + sp1C = 0xF; + break; + } + + func_8420DA28(sp1C, cont); + + temp_v0_2 = func_8420DB48(sp1C); + if (temp_v0_2 != -1) { + if (temp_v0_2 == 0) { + arg0->unk_0010 = 2; + arg0->unk_0012 = 1; + arg0->unk_0008 = 6; + arg0->unk_0001 = 2; + } else { + func_8420DA28(1, NULL); + arg0->unk_0010 = 0; + arg0->unk_0012 = 0; + arg0->unk_000A = 0; + arg0->unk_0001 = 8; + } + } + + arg0->unk_0018 = arg0->unk_0014; + arg0->unk_001A = arg0->unk_0016; +} + +void func_84207634(unk_D_84211B50* arg0) { + Controller* cont = &gControllers[arg0->unk_0002]; + + func_8420DA28(2, cont); + if (func_8420DB48(2) >= 0) { + func_8420B238(arg0->unk_4D40); + arg0->unk_000A = 0; + arg0->unk_0001 = 5; + } +} + +void func_842076A0(unk_D_84211B50* arg0) { + Controller* cont = &gControllers[arg0->unk_0002]; + + func_8420DA28(3, cont); + if (func_8420DB48(3) >= 0) { + arg0->unk_0001 = 7; + } +} + +void func_842076F8(unk_D_84211B50* arg0) { + if (arg0->unk_000E > 0) { + arg0->unk_000C++; + if (arg0->unk_000C >= arg0->unk_000E) { + arg0->unk_0001 = 8; + } + } else { + arg0->unk_000C--; + if (arg0->unk_000E >= arg0->unk_000C) { + arg0->unk_0001 = 8; + } + } + arg0->unk_0018 = arg0->unk_0014; + arg0->unk_001A = arg0->unk_0016; + arg0->unk_0003 = 2; +} + +s32 func_8420776C(unk_D_84211B50* arg0) { + s32 sp1C = 0; + + switch (arg0->unk_0001) { + case 0: + func_84206BC4(arg0); + break; + + case 1: + func_84206BC4(arg0); + break; + + case 3: + func_84206BDC(arg0); + break; + + case 2: + func_84206EE0(arg0); + break; + + case 4: + func_84206DE8(arg0); + sp1C = 1; + break; + + case 5: + func_84206E88(arg0); + sp1C = 1; + break; + + case 6: + func_84206D10(arg0); + break; + + case 7: + func_8420720C(arg0); + break; + + case 8: + func_84207040(arg0); + break; + + case 9: + func_84207634(arg0); + break; + + case 10: + func_842076A0(arg0); + break; + + case 11: + func_84206BF0(arg0); + break; + + case 12: + func_842076F8(arg0); + break; + + case 13: + func_842076F8(arg0); + break; + + case 14: + func_842073A4(arg0); + break; + + case 15: + func_84207530(arg0); + break; + + case 16: + func_84207190(arg0); + break; + } + return sp1C; +} + +s32 func_842078C0(unk_D_84211B50* arg0, unk_D_842168A0* arg1, unk_D_8423D3A8* arg2, unk_D_84229EB0* arg3, s16 arg4, + u16 arg5, char* arg6, s16 arg7, s16 arg8, s16 arg9) { + s32 i; + + arg0->unk_0000 = arg4; + arg0->unk_0001 = 1; + arg0->unk_0002 = arg9; + arg0->unk_0004 = 0; + arg0->unk_0006 = 0; + arg0->unk_0008 = 6; + arg0->unk_000A = 0; + arg0->unk_0010 = 0; + arg0->unk_0012 = 0; + arg0->unk_0014 = arg7; + arg0->unk_0016 = arg8; + arg0->unk_0018 = arg7 + 0x280; + arg0->unk_001A = arg8; + arg0->unk_001C = arg5; + + arg0->unk_4D40 = arg1; + arg0->unk_4D44 = arg2; + arg0->unk_4D48 = arg3; + + for (i = 0; i < 6; i++) { + arg0->unk_0030[i].raw = 0; + arg0->unk_0030[i].unk_004.unk_00.unk_00 = 0; + } + + HAL_Strcpy(arg0->unk_001E, arg6); + return 1; +} + +s32 func_842079B4(unk_D_84211B50* arg0, s16 arg1) { + if (arg0->unk_0001 != 1) { + return 0; + } + arg0->unk_0001 = 4; + arg0->unk_000A = -arg1; + return 1; +} + +s32 func_842079F0(unk_D_84211B50* arg0) { + if (arg0->unk_0001 != 3) { + return 0; + } + arg0->unk_0001 = 5; + arg0->unk_000A = 0; + return 1; +} + +s32 func_84207A1C(unk_D_84211B50* arg0) { + s16 i; + + if (arg0->unk_0001 != 3) { + return 0; + } + + for (i = 0; i < 6; i++) { + arg0->unk_0030[i].raw = 0; + arg0->unk_0030[i].unk_004.unk_00.unk_00 = 0; + } + + func_8420B264(arg0->unk_4D40); + arg0->unk_0006 = 0; + arg0->unk_0008 = 6; + arg0->unk_0010 = 0; + arg0->unk_0012 = 0; + arg0->unk_0001 = 2; + return 1; +} + +s32 func_84207AAC(unk_D_84211B50* arg0) { + s32 temp_v0; + s32 temp_v1; + + temp_v1 = arg0->unk_0010 + (arg0->unk_0012 * 3); + + if (arg0->unk_0001 == 3) { + if (arg0->unk_0006 == 0) { + arg0->unk_0001 = 5; + arg0->unk_000A = 0; + return -1; + } + + arg0->unk_0030[temp_v1].raw &= 0x7FFFFFFF; + + if (arg0->unk_0030[temp_v1].raw == 0) { + temp_v0 = temp_v1 - 1; + arg0->unk_0010 = temp_v0 % 3; + arg0->unk_0012 = temp_v0 / 3; + func_84206870(arg0); + arg0->unk_0001 = 2; + } else { + func_8420DA28(1, NULL); + arg0->unk_000A = 0; + arg0->unk_0001 = 8; + } + return 1; + } + + return 0; +} + +s32 func_84207BD4(unk_D_84211B50* arg0, unk_D_838067F0_0168_0000* arg1) { + s32 var_v0 = arg0->unk_0010 + (arg0->unk_0012 * 3); + + if (arg0->unk_0001 != 3) { + return 0; + } + + if (arg0->unk_0030[var_v0].unk_004.unk_00.unk_00 == 0) { + arg0->unk_0006 += 1; + } + + arg0->unk_0030[var_v0] = *arg1; + + if (arg0->unk_0006 == arg0->unk_0008) { + arg0->unk_0003 = 2; + arg0->unk_0004 = 0; + if (func_84206A68(arg0) != 0) { + arg0->unk_0001 = 15; + } else if (arg0->unk_0000 == 0) { + arg0->unk_0001 = 7; + } else { + arg0->unk_0001 = 0xE; + } + } else { + do { + var_v0 = (var_v0 + 1) % 6; + } while (arg0->unk_0030[var_v0].unk_004.unk_00.unk_00 != 0); + arg0->unk_0010 = var_v0 % 3; + arg0->unk_0012 = var_v0 / 3; + arg0->unk_0001 = 2; + } + return 1; +} + +s32 func_84207D5C(unk_D_84211B50* arg0) { + s32 idx = (arg0->unk_0010 + (arg0->unk_0012 * 3)); + + if (arg0->unk_0001 != 3) { + return 0; + } + + if (arg0->unk_0006 == 0) { + return 0; + } + + if (arg0->unk_0004 == 0) { + return 0; + } + + if ((D_800AE540.unk_0001 != 0) && (D_800AE540.unk_0000 != 8)) { + return 0; + } + + arg0->unk_0003 = 2; + arg0->unk_0004 = 0; + arg0->unk_0008 = arg0->unk_0006; + arg0->unk_0030[idx].raw = 0; + + if (arg0->unk_0000 == 0) { + arg0->unk_0001 = 7; + } else { + arg0->unk_0001 = 0xE; + } + return 1; +} + +s32 func_84207E3C(unk_D_84211B50* arg0, unk_D_838067F0_0168_0000* arg1) { + s32 i; + u8 temp_a2; + unk_D_838067F0_0168_0000* ptr; + + ptr = &arg0->unk_0030[0]; + temp_a2 = arg1->unk_004.unk_00.unk_00; + + if (arg1->unk_004.unk_00.unk_00 == 0) { + return 0; + } + + for (i = 0; i < 6; i++, ptr++) { + if ((ptr->unk_004.unk_00.unk_00 != 0) && !(ptr->raw & 0x80000000)) { + if (D_800AE540.unk_0001 == 0) { + if (ptr->raw == arg1->raw) { + return 0; + } + } else if (ptr->unk_004.unk_00.unk_00 == temp_a2) { + return 0; + } + } + } + + return 1; +} + +s32 func_8420804C(unk_D_84211B50* arg0, unk_D_838067F0_0168_0000* arg1) { + s32 i; + unk_D_838067F0_0168_0000* ptr; + + if (arg1->unk_004.unk_00.unk_00 == 0) { + return 0; + } + + ptr = &arg0->unk_0030[0]; + for (i = 0; i < 6; i++, ptr++) { + if ((ptr->unk_004.unk_00.unk_00 != 0) && !(ptr->raw & 0x80000000) && (ptr->raw == arg1->raw)) { + return 1; + } + } + + return 0; +} + +s32 func_842081A8(unk_D_84211B50* arg0) { + return arg0->unk_0001 == 0; +} + +void func_842081B4(unk_D_84211B50* arg0, unk_func_80026268_arg0* arg1, s16 arg2) { + s32 i; + + arg0->unk_0006 = arg2; + arg0->unk_0008 = arg2; + + for (i = 0; i < arg2; i++) { + func_8001B0DC(arg0->unk_0030[i].unk_058, 0, &arg1[i]); + + arg0->unk_0030[i].unk_004 = arg1[i]; + + arg0->unk_0030[i].unk_000 = (arg1[i].unk_52 & 0x70) >> 4; + arg0->unk_0030[i].unk_001 = arg1[i].unk_52 & 0xF; + arg0->unk_0030[i].unk_002 = arg1[i].unk_53; + arg0->unk_0030[i].unk_003 = arg1[i].unk_00.unk_00; + } +} diff --git a/src/fragments/61/fragment61_2DFB60.c b/src/fragments/61/fragment61_2DFB60.c index 84656e9..dd3c635 100644 --- a/src/fragments/61/fragment61_2DFB60.c +++ b/src/fragments/61/fragment61_2DFB60.c @@ -1,84 +1,1019 @@ -#include "global.h" +#include "fragment61.h" +#include "src/1AB70.h" +#include "src/1CF30.h" +#include "src/20470.h" +#include "src/232C0.h" +#include "src/2E110.h" +#include "src/49790.h" +#include "src/6BC0.h" -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DFB60/func_842082D0.s") +void func_842082D0(s16 arg0, s16 arg1, s16 arg2) { + gSPDisplayList(gDisplayListHead++, D_8006F518); + gDPSetEnvColor(gDisplayListHead++, 0, 0, 0, 255); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DFB60/func_84208410.s") + func_8001CF10(arg0, arg1, 0x10, 0x1C, D_20007C0, 0x10, 0); + func_8001CF10((arg0 + arg2) - 0x10, arg1, 0x10, 0x1C, D_20008A0, 0x10, 0); + func_8001C330(arg0 + 0x10, arg1, arg2 - 0x20, 0x1C, 0, 0, 0, 0x400, 0); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DFB60/func_842084BC.s") + gSPDisplayList(gDisplayListHead++, D_8006F630); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DFB60/func_84208820.s") +void func_84208410(s16 arg0, s16 arg1, u8* arg2, s16 arg3) { + 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); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DFB60/func_84208870.s") +void func_842084BC(unk_D_842168A0* arg0) { + s16 temp_s0 = arg0->unk_00014 - 0x2C; + s16 sp3C = arg0->unk_00016 - 0x20; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DFB60/func_842088A0.s") + func_842082D0(temp_s0, sp3C, 0x208); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DFB60/func_84208B04.s") + gSPDisplayList(gDisplayListHead++, D_8006F518); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DFB60/func_84208F64.s") + func_84208410(temp_s0 + 8, sp3C + 4, D_2001A20, arg0->unk_0001C[0].unk_00); + func_84208410(temp_s0 + 0x2C, sp3C + 4, D_2002560, arg0->unk_0001C[1].unk_00); + func_84208410(temp_s0 + 0x50, sp3C + 4, D_2002B00, arg0->unk_0001C[2].unk_00); + func_84208410(temp_s0 + 0x74, sp3C + 4, D_20030A0, arg0->unk_0001C[3].unk_00); + func_84208410(temp_s0 + 0x98, sp3C + 4, D_2003640, arg0->unk_0001C[4].unk_00); + func_84208410(temp_s0 + 0xBC, sp3C + 4, D_2003BE0, arg0->unk_0001C[5].unk_00); + func_84208410(temp_s0 + 0xE0, sp3C + 4, D_2004180, arg0->unk_0001C[6].unk_00); + func_84208410(temp_s0 + 0x104, sp3C + 4, D_2004720, arg0->unk_0001C[7].unk_00); + func_84208410(temp_s0 + 0x128, sp3C + 4, D_2004CC0, arg0->unk_0001C[8].unk_00); + func_84208410(temp_s0 + 0x14C, sp3C + 4, D_2005260, arg0->unk_0001C[9].unk_00); + func_84208410(temp_s0 + 0x170, sp3C + 4, D_2005800, arg0->unk_0001C[10].unk_00); + func_84208410(temp_s0 + 0x194, sp3C + 4, D_2005DA0, arg0->unk_0001C[11].unk_00); + func_84208410(temp_s0 + 0x1B8, sp3C + 4, D_2006340, arg0->unk_0001C[12].unk_00); + func_84208410(temp_s0 + 0x1DC, sp3C + 4, D_2001FC0, 0x97); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DFB60/func_84209340.s") + if (arg0->unk_00001 != 7) { + func_8001C6AC(temp_s0 + (arg0->unk_00005 * 0x24) + 4, sp3C, 0x2C, 0xE, D_2001080, 0x2C, 0); + func_8001C6AC(temp_s0 + (arg0->unk_00005 * 0x24) + 4, sp3C + 0xE, 0x2C, 0xE, D_2001550, 0x2C, 0); + } + + gSPDisplayList(gDisplayListHead++, D_8006F630); +} + +s32 func_84208820(unk_D_842168A0* arg0) { + s16 i; + s16 var_v1 = 1; + + for (i = 0; i < 13; i++) { + if (arg0->unk_0001C[i].unk_00 != 0) { + var_v1++; + } + } + + return var_v1; +} + +s32 func_84208870(unk_D_838067F0_0168* arg0) { + s32 ret; + + switch (arg0->unk_2692) { + case 0: + ret = 0; + break; + + case 13: + ret = 2; + break; + + default: + ret = 1; + break; + } + + return ret; +} + +void func_842088A0(s16 arg0, s16 arg1, unk_D_838067F0_0168* arg2) { + static Color_RGB8 D_842115D0[] = { + { 0xB4, 0x3C, 0x3C }, + { 0xBE, 0x96, 0x32 }, + { 0xAA, 0x3C, 0x96 }, + }; + static Color_RGB8 D_842115DC[] = { + { 0x3C, 0x14, 0x14 }, + { 0x46, 0x32, 0x1E }, + { 0x50, 0x28, 0x3C }, + }; + + char sp58[256]; + char* sp54; + s32 temp_v0; + + temp_v0 = func_84208870(arg2); + + gSPDisplayList(gDisplayListHead++, D_8006F558); + + gDPSetEnvColor(gDisplayListHead++, D_842115D0[temp_v0].r, D_842115D0[temp_v0].g, D_842115D0[temp_v0].b, 255); + gDPSetPrimColor(gDisplayListHead++, 0, 0, D_842115DC[temp_v0].r, D_842115DC[temp_v0].g, D_842115DC[temp_v0].b, 255); + + func_8001CADC(arg0, arg1, 8, 0x1C, D_2000980, 8, 0); + func_8001CADC(arg0 + 0x184, arg1, 8, 0x1C, D_2000A60, 8, 0); + func_8001C330(arg0 + 8, arg1, 0x17C, 0x1C, 0, 0, 0, 0x400, 0); + + gSPDisplayList(gDisplayListHead++, D_8006F630); + + func_8001F3F4(); + func_8001EBE0(8, 0); + + switch (arg2->unk_2692) { + case 0: + sp54 = func_84200130(0x12); + break; + + case 13: + sp54 = func_84200130(0x13); + break; + + default: + func_8002D600(1, arg2->unk_2692); + sp54 = func_84200190(sp58, 0x100, 0x14); + break; + } + + func_8001F1E8((arg0 - (func_8001F5B0(8, 0, sp54) / 2)) + 0xC6, arg1 + 4, sp54); + func_8001F444(); +} + +void func_84208B04(s16 arg0, s16 arg1, unk_D_842168A0* arg2) { + static s16 D_842115E8 = 0; + + s16 sp5E; + s16 temp_a3; + s16 var_v1; + + temp_a3 = arg2->unk_00006 + arg2->unk_0000E; + + if (arg2->unk_00005 < 0xD) { + var_v1 = ((arg2->unk_0001C[arg2->unk_00005].unk_00 + 2) / 3); + } else { + var_v1 = ((arg2->unk_0013C->unk_00 + 2) / 3); + } + + if (var_v1 < 4) { + var_v1 = 4; + } + + if ((arg2->unk_00001 == 8) || (arg2->unk_00001 == 0xA)) { + if (arg2->unk_00018 > 0) { + sp5E = ((((temp_a3 * 4) + arg2->unk_00018) * 0x98) - 0x260) / ((var_v1 * 4) - 4); + } else { + sp5E = ((((temp_a3 * 4) + arg2->unk_00018) * 0x98) + 0x260) / ((var_v1 * 4) - 4); + } + } else { + sp5E = (temp_a3 * 0x98) / (var_v1 - 1); + } + + gSPDisplayList(gDisplayListHead++, D_8006F470); + + func_8001C560(arg0, arg1, 0x18, 0xCC, 0x3C, 0x3C, 0xA0); + + gSPDisplayList(gDisplayListHead++, D_8006F558); + + gDPSetEnvColor(gDisplayListHead++, 130, 130, 220, 255); + gDPSetPrimColor(gDisplayListHead++, 0, 0, 60, 60, 150, 255); + + func_8001CADC(arg0 + 4, arg1 + 0x20, 0x10, 8, D_200A200, 0x10, 0); + func_8001CADC(arg0 + 4, arg1 + 0xC0, 0x10, 8, D_200A280, 0x10, 0); + func_8001C330(arg0 + 4, arg1 + 0x28, 0x10, 0x98, 0, 0, 0x400, 0, 0); + + gSPDisplayList(gDisplayListHead++, D_8006F518); + + if (D_842115E8 < 4) { + func_8001C6AC(arg0, arg1 + sp5E + 0x1C, 0x18, 0x18, D_200A300, 0x18, 0); + } else { + func_8001C6AC(arg0, arg1 + sp5E + 0x1C, 0x18, 0x18, D_200A780, 0x18, 0); + } + + gSPDisplayList(gDisplayListHead++, D_8006F630); + + if (arg2->unk_00001 == 3) { + D_842115E8 = (D_842115E8 + 1) % 8; + } +} + +void func_84208F64(unk_D_842168A0* arg0, s16 arg1, s16 arg2, unk_D_838067F0_0168* arg3) { + s32 i; + + for (i = 0; i < 3; i++) { + if ((arg3->unk_0000[i].unk_004.unk_00.unk_00 != 0) && + (func_84207E3C(arg0->unk_13608, &arg3->unk_0000[i & 0xFFFFFFFF]) != 0)) { + func_84200420(arg1 + i * 0x84, arg2, 0x84, 0x2C, 0x64, 0x64, 0xC8, 0xFF); + } else { + func_84200420(arg1 + i * 0x84, arg2, 0x84, 0x2C, 0x3C, 0x3C, 0xA0, 0xFF); + } + } + + gSPDisplayList(gDisplayListHead++, D_8006F518); + + for (i = 0; i < 3; i++) { + if (arg3->unk_0000[i].unk_004.unk_00.unk_00 != 0) { + func_8001C6AC(arg1 + (i * 0x84) + 2, arg2 + 2, 0x28, 0x28, arg3->unk_0000[i].unk_058, 0x28, 0); + } + } + + gDPSetCombineLERP(gDisplayListHead++, ENVIRONMENT, PRIMITIVE, TEXEL0, PRIMITIVE, TEXEL0, 0, ENVIRONMENT, 0, + ENVIRONMENT, PRIMITIVE, TEXEL0, PRIMITIVE, TEXEL0, 0, ENVIRONMENT, 0); + gDPSetEnvColor(gDisplayListHead++, 140, 220, 240, 255); + gDPSetPrimColor(gDisplayListHead++, 0, 0, 40, 100, 220, 255); + + for (i = 0; i < 3; i++) { + if (func_8420804C(arg0->unk_13608, &arg3->unk_0000[i & 0xFFFFFFFF]) != 0) { + func_8001CADC(arg1 + (i * 0x84) + 0x2E, arg2 + 0xB, 0x48, 0x1C, D_200AC00, 0x48, 0); + } + } + + gSPDisplayList(gDisplayListHead++, D_8006F630); + + func_8001F3F4(); + + for (i = 0; i < 3; i++) { + if ((arg3->unk_0000[i].unk_004.unk_00.unk_00 != 0) && + (func_8420804C(arg0->unk_13608, &arg3->unk_0000[i & 0xFFFFFFFF]) == 0)) { + if (func_84207E3C(arg0->unk_13608, &arg3->unk_0000[i & 0xFFFFFFFF]) != 0) { + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + } else { + func_8001F324(0x32, 0x32, 0xC8, 0x80); + } + func_8001EBE0(4, 0); + func_8001F1E8(arg1 + (i * 0x84) + 0x2C, arg2 + 5, arg3->unk_0000[i].unk_004.unk_30); + func_8001EBE0(4, 0); + func_8001F1E8(arg1 + (i * 0x84) + 0x2C, arg2 + 0x17, "%s%d", func_84200160(0x15), + arg3->unk_0000[i].unk_004.unk_24); + } + } + + func_8001F444(); +} + +void func_84209340(unk_D_842168A0* arg0, s32 arg1) { + unk_D_838067F0_0168* var_s1_2; + s16 i; + s16 spB0; + s16 temp_s3_3; + s16 temp_s7; + + spB0 = arg0->unk_00014; + temp_s7 = arg0->unk_00016; + + if ((arg0->unk_00001 != 1) && (arg0->unk_00001 != 2) && ((arg1 != 0) || (arg0->unk_00009 != 0))) { + func_842084BC(arg0); + + func_842001B8(spB0, temp_s7, 0x1B4, 0xD4); + func_84208B04(spB0 + 4, temp_s7 + 4, arg0); + + gSPDisplayList(gDisplayListHead++, D_8006F518); + + if (func_84208820(arg0) >= 2) { + func_8001C6AC(spB0 - 0x32, temp_s7 + 0x52, 0x30, 0x18, D_2007E00, 0x30, 0); + func_8001C6AC(spB0 - 0x32, temp_s7 + 0x6A, 0x30, 0x18, D_2008700, 0x30, 0); + func_8001C6AC(spB0 + 0x1BA, temp_s7 + 0x52, 0x30, 0x18, D_2009000, 0x30, 0); + func_8001C6AC(spB0 + 0x1BA, temp_s7 + 0x6A, 0x30, 0x18, D_2009900, 0x30, 0); + } + + gSPDisplayList(gDisplayListHead++, D_8006F470); + + func_8001C560(spB0 + 0x1C, temp_s7 + 4, 8, 0xCC, 0x32, 0x32, 0x32); + + gSPDisplayList(gDisplayListHead++, D_8006F630); + + if (arg0->unk_00001 == 7) { + s16 sp9E = spB0 - ((arg0->unk_00018 * 0x194) / 8); + s16 tmp3 = (((arg0->unk_0001A > 0) ? 0x194 : -0x194) + sp9E); + s32 pad; + + func_800060E0(&gDisplayListHead, spB0 + 0x24, temp_s7 + 4, 0x18C, 0xCC); + func_842088A0(sp9E + 0x24, temp_s7 + 4, arg0->unk_00140->unk_268C); + func_842088A0(tmp3 + 0x24, temp_s7 + 4, arg0->unk_00140); + + gSPDisplayList(gDisplayListHead++, D_8006F518); + gDPLoadTextureBlock(gDisplayListHead++, D_2000C40, G_IM_FMT_RGBA, G_IM_SIZ_16b, 8, 4, 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(sp9E + 0x1B0, temp_s7 + 4, 8, 0xCC, 0, 0, 0x400, 0, 0); + func_8001C330(tmp3 + 0x1B0, temp_s7 + 4, 8, 0xCC, 0, 0, 0x400, 0, 0); + + gSPDisplayList(gDisplayListHead++, D_8006F630); + + var_s1_2 = arg0->unk_00140; + for (i = 0; i < 4; i++) { + func_84208F64(arg0, tmp3 + 0x24, temp_s7 + (i * 0x2C) + 0x20, var_s1_2); + var_s1_2 = var_s1_2->unk_2688; + } + + for (i = 0; i < 4; i++) { + func_84208F64(arg0, sp9E + 0x24, temp_s7 + (i * 0x2C) + 0x20, var_s1_2); + var_s1_2 = var_s1_2->unk_2688; + } + + func_800060E0(&gDisplayListHead, 0, 0, 0x280, 0x1E0); + } else if (arg0->unk_00001 == 8) { + temp_s3_3 = temp_s7 - ((arg0->unk_00018 * 0x2C) / 4); + func_842088A0(spB0 + 0x24, temp_s7 + 4, arg0->unk_00140); + func_800060E0(&gDisplayListHead, spB0 + 0x24, temp_s7 + 0x20, 0x18C, 0xB0); + if (arg0->unk_0001A > 0) { + var_s1_2 = arg0->unk_00140->unk_268C; + for (i = 0; i < 5; i++) { + func_84208F64(arg0, spB0 + 0x24, temp_s3_3 + (i * 0x2C) + 0x20, var_s1_2); + var_s1_2 = var_s1_2->unk_2688; + } + } else { + var_s1_2 = arg0->unk_00140; + for (i = 0; i < 5; i++) { + func_84208F64(arg0, spB0 + 0x24, (temp_s3_3 + (i * 0x2C)) - 0xC, var_s1_2); + var_s1_2 = var_s1_2->unk_2688; + } + } + func_800060E0(&gDisplayListHead, 0, 0, 0x280, 0x1E0); + } else { + func_842088A0(spB0 + 0x24, temp_s7 + 4, arg0->unk_00140); + var_s1_2 = arg0->unk_00140; + + for (i = 0; i < 4; i++) { + func_84208F64(arg0, spB0 + 0x24, temp_s7 + (i * 0x2C) + 0x20, var_s1_2); + var_s1_2 = var_s1_2->unk_2688; + } + } + + if (arg0->unk_00001 == 0xA) { + s16 tmp1 = (arg0->unk_0000C * 0x84) + 0x24; + s16 tmp2 = (arg0->unk_0000E * 0x2C) + 0x20; + + if (arg0->unk_00018 > 0) { + tmp2 = ((tmp2 + ((arg0->unk_00018 * 0x2C) / 4)) - 0x2C); + } else { + tmp2 = (tmp2 + ((arg0->unk_00018 * 0x2C) / 4) + 0x2C); + } + func_84200738(spB0 + tmp1, temp_s7 + tmp2, 0x84, 0x2C); + } else if (arg0->unk_00001 == 9) { + s16 tmp1 = (arg0->unk_0000C * 0x84) + 0x24; + s16 tmp2 = (arg0->unk_0000E * 0x2C) + 0x20; + + if (arg0->unk_00018 > 0) { + tmp1 = ((tmp1 + ((arg0->unk_00018 * 0x84) / 4)) - 0x84); + } else { + tmp1 = (tmp1 + ((arg0->unk_00018 * 0x84) / 4) + 0x84); + } + func_84200738(spB0 + tmp1, temp_s7 + tmp2, 0x84, 0x2C); + } else if ((arg0->unk_00001 == 3) || (arg0->unk_00001 == 8)) { + s16 tmp1 = (arg0->unk_0000C * 0x84) + 0x24; + s16 tmp2 = (arg0->unk_0000E * 0x2C) + 0x20; + + func_84200738(spB0 + tmp1, temp_s7 + tmp2, 0x84, 0x2C); + } + + if (arg0->unk_00009 > 0) { + arg0->unk_00009--; + } + } +} void func_84209CEC(void) { } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DFB60/func_84209CF4.s") +unk_D_838067F0_0168* func_84209CF4(unk_D_838067F0_0168* arg0, s32 arg1) { + while (arg1-- > 0) { + arg0 = arg0->unk_2688; + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DFB60/func_84209D18.s") + return arg0; +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DFB60/func_84209DB8.s") +void func_84209D18(unk_D_842168A0* arg0, unk_func_80026268_arg0* arg1) { + unk_D_800AC910_040 sp38; + unk_D_800AC910_040 sp28; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DFB60/func_8420A0A4.s") + if ((arg0->unk_00004 < 4) && (func_80024F68(arg0->unk_00004) == 7) && (arg1->unk_00.unk_00 == 0x19)) { + func_80025040(arg0->unk_00004, &sp28); + _bcopy(arg1->unk_46, sp38.unk_02, 11); + sp38.unk_00 = arg1->unk_0E; + if (func_80022A04(&sp38, &sp28) != 0) { + arg1->unk_52 |= 0x80; + } + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DFB60/func_8420A0BC.s") +s32 func_84209DB8(unk_D_842168A0* arg0, unk_D_838067F0_0168* arg1, s32 arg2, unk_D_842168A0_0013C* arg3) { + s16 i; + s16 j; + s16 var_s3; + unk_D_838067F0_003C* temp_s5; + unk_func_80022C28_ret* var_v0; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DFB60/func_8420A0E4.s") + arg1->unk_2690 = arg0->unk_00004; + arg1->unk_2692 = arg0->unk_00005; + var_s3 = 0; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DFB60/func_8420A1B0.s") + for (i = 0; i < 3; i++) { + arg1->unk_0000[i].unk_004.unk_00.unk_00 = 0; + arg1->unk_0000[i].raw = 0; + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DFB60/func_8420A228.s") + if (arg0->unk_00005 < 0xD) { + temp_s5 = &arg0->unk_0001C[arg0->unk_00005]; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DFB60/func_8420A288.s") + if (arg0->unk_00004 < 4) { + if (arg0->unk_00005 == 0) { + var_v0 = func_80022C28(0x20, arg0->unk_00004, 0, 0); + } else { + var_v0 = func_80022C28(0x21, arg0->unk_00004, arg0->unk_00005 - 1, 0); + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DFB60/func_8420A3E4.s") + if (var_v0 != NULL) { + i = arg2 * 3; + for (j = 0; j < 3; j++) { + if (i < temp_s5->unk_00) { + if (func_80022DF4(var_v0, temp_s5->unk_02[i++]) != 0) { + var_s3 += func_80022E18(&arg1->unk_0000[j].unk_004.unk_00.unk_00, 1, var_v0); + } + } + } + func_80022D8C(var_v0); + } + } + } else if (arg3 != NULL) { + i = arg2 * 3; + for (j = 0; j < 3; j++) { + if (i < arg3->unk_00) { + _bcopy(&arg3->unk_04[i++], &arg1->unk_0000[var_s3].unk_004, sizeof(arg3->unk_04[0])); + func_800228B0(&arg1->unk_0000[var_s3++].unk_004); + } + } + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DFB60/func_8420A4B8.s") + for (i = 0; i < var_s3; i++) { + func_8001B0DC(arg1->unk_0000[i].unk_058, 0, &arg1->unk_0000[i].unk_004); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DFB60/func_8420A594.s") + arg1->unk_0000[i].unk_000 = arg0->unk_00004; + arg1->unk_0000[i].unk_001 = arg0->unk_00005; + arg1->unk_0000[i].unk_002 = (arg2 * 3) + i; + arg1->unk_0000[i].unk_003 = arg1->unk_0000[i].unk_004.unk_00.unk_00; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DFB60/func_8420A604.s") + arg1->unk_0000[i].unk_004.unk_53 = (arg2 * 3) + i; + arg1->unk_0000[i].unk_004.unk_52 = (arg0->unk_00004 * 0x10) | arg0->unk_00005; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DFB60/func_8420A678.s") + func_84209D18(arg0, &arg1->unk_0000[i].unk_004); + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DFB60/func_8420A7D8.s") + return var_s3; +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DFB60/func_8420A938.s") +void func_8420A0A4(unk_D_842168A0* arg0) { + arg0->unk_00014 = arg0->unk_00010; + arg0->unk_00016 = arg0->unk_00012 + 0x1E0; +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DFB60/func_8420A9B8.s") +void func_8420A0BC(unk_D_842168A0* arg0) { + arg0->unk_00014 = arg0->unk_00010; + arg0->unk_00016 = arg0->unk_00012; + if (arg0->unk_00002 != 0) { + arg0->unk_00001 = arg0->unk_00002; + arg0->unk_00002 = 0; + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DFB60/func_8420AA08.s") +void func_8420A0E4(unk_D_842168A0* arg0) { + unk_D_838067F0_0168* sp2C; + s32 temp_v0; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DFB60/func_8420AB50.s") + sp2C = func_84209CF4(arg0->unk_00140, arg0->unk_0000E); + temp_v0 = func_8420C788(arg0->unk_1360C); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DFB60/func_8420ABC4.s") + if (temp_v0 == 1) { + if (func_84207BD4(arg0->unk_13608, &sp2C->unk_0000[arg0->unk_0000C]) != 0) { + arg0->unk_00009 = 2; + arg0->unk_00001 = 4; + } + } else if ((s16)temp_v0 == 2) { + arg0->unk_00001 = 3; + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DFB60/func_8420AC00.s") + arg0->unk_00014 = arg0->unk_00010; + arg0->unk_00016 = arg0->unk_00012; +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DFB60/func_8420ACA8.s") +void func_8420A1B0(unk_D_842168A0* arg0) { + arg0->unk_0000A++; + if (arg0->unk_0000A <= 0) { + arg0->unk_00016 = arg0->unk_00012 + 0x1E0; + } else if (arg0->unk_0000A == 0xA) { + arg0->unk_00001 = 4; + arg0->unk_0000A = 0; + arg0->unk_00016 = arg0->unk_00012; + } else { + arg0->unk_00016 = (arg0->unk_00012 - (arg0->unk_0000A * 0x30)) + 0x1E0; + } + arg0->unk_00014 = arg0->unk_00010; + arg0->unk_00009 = 2; +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DFB60/func_8420AF1C.s") +void func_8420A228(unk_D_842168A0* arg0) { + arg0->unk_0000A++; + if (arg0->unk_0000A == 0xA) { + arg0->unk_00001 = 2; + arg0->unk_0000A = 0; + arg0->unk_00016 = arg0->unk_00012 + 0x1E0; + } else { + arg0->unk_00016 = arg0->unk_00012 + (arg0->unk_0000A * 0x30); + } + arg0->unk_00014 = arg0->unk_00010; + arg0->unk_00009 = 2; +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DFB60/func_8420B0C8.s") +void func_8420A288(unk_D_842168A0* arg0) { + unk_D_838067F0_0168* sp3C = func_84209CF4(arg0->unk_00140, arg0->unk_0000E); + s32 var_t1; + s16 tmp1; + s16 tmp2; -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DFB60/func_8420B1D0.s") + if (func_84207E3C(arg0->unk_13608, &sp3C->unk_0000[arg0->unk_0000C]) != 0) { + if (arg0->unk_00000 == 0) { + var_t1 = 1; + } else { + var_t1 = 3; + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DFB60/func_8420B20C.s") + tmp1 = arg0->unk_00010 + (arg0->unk_0000C * 0x84) + 0x20; + tmp2 = arg0->unk_00012 + (arg0->unk_0000E * 0x2C) + 0x1C; + tmp1 = func_8420C60C(arg0->unk_1360C, arg0->unk_00003, 0x30, 0xEC, tmp1, tmp2, &sp3C->unk_0000[arg0->unk_0000C], + var_t1); -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DFB60/func_8420B238.s") + if (tmp1 != 0) { + func_80048B90(2); + arg0->unk_00001 = 0xB; + } + } else { + func_80048B90(8); + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DFB60/func_8420B264.s") +void func_8420A3E4(unk_D_842168A0* arg0) { + if (arg0->unk_00007 == 0) { + if (arg0->unk_0000E != 0) { + arg0->unk_0000E--; + arg0->unk_00018 = -1; + arg0->unk_0001A = -4; + arg0->unk_00001 = 0xA; + func_80048B90(1); + } else if ((arg0->unk_00006 > 0) && + (func_84209DB8(arg0, arg0->unk_00140->unk_268C, arg0->unk_00006 - 1, arg0->unk_0013C) != 0)) { + arg0->unk_00006--; + arg0->unk_00140 = arg0->unk_00140->unk_268C; + arg0->unk_00018 = -1; + arg0->unk_0001A = -4; + arg0->unk_00001 = 8; + func_80048B90(1); + } -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DFB60/func_8420B270.s") + arg0->unk_00007 = arg0->unk_00008; + arg0->unk_00008 = 2; + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DFB60/func_8420B334.s") +void func_8420A4B8(unk_D_842168A0* arg0) { + if (arg0->unk_00007 == 0) { + if (arg0->unk_0000E != 3) { + arg0->unk_0000E++; + arg0->unk_00018 = 1; + arg0->unk_0001A = 4; + arg0->unk_00001 = 0xA; + func_80048B90(1); + } else if (func_84209DB8(arg0, func_84209CF4(arg0->unk_00140, 4), arg0->unk_00006 + 4, arg0->unk_0013C) != 0) { + arg0->unk_00006++; + arg0->unk_00140 = arg0->unk_00140->unk_2688; + arg0->unk_00018 = 1; + arg0->unk_0001A = 4; + arg0->unk_00001 = 8; + func_80048B90(1); + } + arg0->unk_00007 = arg0->unk_00008; + arg0->unk_00008 = 2; + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2DFB60/func_8420B37C.s") +void func_8420A594(unk_D_842168A0* arg0) { + if (arg0->unk_00007 == 0) { + if (arg0->unk_0000C > 0) { + arg0->unk_0000C--; + arg0->unk_00018 = -1; + arg0->unk_0001A = -4; + arg0->unk_00001 = 9; + func_80048B90(1); + } + arg0->unk_00007 = arg0->unk_00008; + arg0->unk_00008 = 2; + } +} + +void func_8420A604(unk_D_842168A0* arg0) { + if (arg0->unk_00007 == 0) { + if (arg0->unk_0000C < 2) { + arg0->unk_0000C++; + arg0->unk_00018 = 1; + arg0->unk_0001A = 4; + arg0->unk_00001 = 9; + func_80048B90(1); + } + arg0->unk_00007 = arg0->unk_00008; + arg0->unk_00008 = 2; + } +} + +void func_8420A678(unk_D_842168A0* arg0) { + s16 var_s0; + s16 i; + unk_D_838067F0_0168* var_s1; + + var_s0 = (arg0->unk_00005 + 1) % 14; + while ((var_s0 < 0xD) && (arg0->unk_0001C[var_s0].unk_00 == 0)) { + var_s0 = (var_s0 + 1) % 14; + } + + if (var_s0 != arg0->unk_00005) { + func_80048B90(0x27); + arg0->unk_00005 = var_s0; + arg0->unk_00140 = func_84209CF4(arg0->unk_00140, 4); + arg0->unk_00006 = 0; + + var_s1 = arg0->unk_00140; + for (i = 0; i < 4; i++) { + func_84209DB8(arg0, var_s1, arg0->unk_00006 + i, arg0->unk_0013C); + var_s1 = var_s1->unk_2688; + } + + arg0->unk_00018 = 0; + arg0->unk_0001A = 8; + arg0->unk_00001 = 7; + } +} + +void func_8420A7D8(unk_D_842168A0* arg0) { + s16 var_s0; + s16 i; + unk_D_838067F0_0168* var_s1; + + var_s0 = (arg0->unk_00005 + 0xD) % 14; + while ((var_s0 < 0xD) && (arg0->unk_0001C[var_s0].unk_00 == 0)) { + var_s0 = (var_s0 + 0xD) % 14; + } + + if (var_s0 != arg0->unk_00005) { + func_80048B90(0x27); + arg0->unk_00005 = var_s0; + arg0->unk_00140 = func_84209CF4(arg0->unk_00140, 4); + arg0->unk_00006 = 0; + + var_s1 = arg0->unk_00140; + for (i = 0; i < 4; i++) { + func_84209DB8(arg0, var_s1, arg0->unk_00006 + i, arg0->unk_0013C); + var_s1 = var_s1->unk_2688; + } + + arg0->unk_00018 = 0; + arg0->unk_0001A = -8; + arg0->unk_00001 = 7; + } +} + +void func_8420A938(unk_D_842168A0* arg0) { + s32 temp_v0 = func_84207AAC(arg0->unk_13608); + + if (temp_v0 != -1) { + if (temp_v0 == 1) { + arg0->unk_00009 = 2; + arg0->unk_00001 = 4; + func_80048B90(3); + } + } else { + arg0->unk_00009 = 2; + arg0->unk_0000A = 0; + arg0->unk_00001 = 6; + func_80048B90(3); + } +} + +void func_8420A9B8(unk_D_842168A0* arg0) { + if (func_84207D5C(arg0->unk_13608) != 0) { + arg0->unk_00009 = 2; + arg0->unk_00001 = 4; + func_80048B90(2); + } +} + +void func_8420AA08(unk_D_842168A0* arg0) { + Controller* cont = &gControllers[arg0->unk_00003]; + + if (BTN_IS_PRESSED(cont, BTN_A)) { + func_8420A288(arg0); + } else if (BTN_IS_PRESSED(cont, BTN_B)) { + func_8420A938(arg0); + } else if (BTN_IS_PRESSED(cont, BTN_START)) { + func_8420A9B8(arg0); + } else if (BTN_IS_PRESSED(cont, BTN_R)) { + func_8420A678(arg0); + } else if (BTN_IS_PRESSED(cont, BTN_L)) { + func_8420A7D8(arg0); + } else if (BTN_IS_DOWN(cont, BTN_DLEFT)) { + func_8420A594(arg0); + } else if (BTN_IS_DOWN(cont, BTN_DRIGHT)) { + func_8420A604(arg0); + } else if (BTN_IS_DOWN(cont, BTN_DUP)) { + func_8420A3E4(arg0); + } else if (BTN_IS_DOWN(cont, BTN_DDOWN)) { + func_8420A4B8(arg0); + } else { + arg0->unk_00008 = 8; + arg0->unk_00007 = 0; + } + + arg0->unk_00014 = arg0->unk_00010; + arg0->unk_00016 = arg0->unk_00012; + arg0->unk_00009 = 2; +} + +void func_8420AB50(unk_D_842168A0* arg0) { + if (arg0->unk_0001A > 0) { + arg0->unk_00018++; + if (arg0->unk_00018 >= arg0->unk_0001A) { + arg0->unk_00001 = 3; + } + } else { + arg0->unk_00018--; + if (arg0->unk_0001A >= arg0->unk_00018) { + arg0->unk_00001 = 3; + } + } + arg0->unk_00014 = arg0->unk_00010; + arg0->unk_00016 = arg0->unk_00012; + arg0->unk_00009 = 2; +} + +s32 func_8420ABC4(unk_func_80026268_arg0* arg0) { + s32 i; + s32 var_v1 = 1; + + for (i = 0; i < 4; i++) { + if (arg0->unk_09[i] == 0) { + break; + } + + if (arg0->unk_09[i] >= 0xA6) { + var_v1 = 0; + } + } + + return var_v1; +} + +s32 func_8420AC00(unk_func_80026268_arg0* arg0, s16 arg1, s16 arg2, s16 arg3) { + s32 sp1C = 0; + + if ((arg0->unk_00.unk_00 > 0) && (arg0->unk_00.unk_00 < 0x98)) { + if ((func_8420ABC4(arg0) != 0) && (D_8006FEE8[arg0->unk_00.unk_00][8] & arg3)) { + if ((arg0->unk_24 >= arg1) && (arg2 >= arg0->unk_24)) { + sp1C = 1; + } + } + } + return sp1C; +} + +s32 func_8420ACA8(unk_D_842168A0* arg0, s16 arg1, s16 arg2) { + unk_D_838067F0_003C* ptr = &arg0->unk_0001C[arg1]; + unk_func_80026268_arg0 sp50; + s32 var_s0; + s16 var_s2; + unk_D_838067F0_003C* temp_v0; + unk_func_80022C28_ret* var_v0; + + ptr->unk_00 = 0; + var_s2 = 0; + + if (arg0->unk_00004 < 4) { + if (arg1 == 0) { + var_v0 = func_80022C28(0x20, arg0->unk_00004, 0, 0); + } else { + var_v0 = func_80022C28(0x21, arg0->unk_00004, arg1 - 1, 0); + } + + if (var_v0 != NULL) { + while (func_80022E18(&sp50, 1, var_v0) == 1) { + switch (arg2) { + case 0: + var_s0 = func_8420AC00(&sp50, 1, 0x64, 0x20); + break; + + case 1: + var_s0 = func_8420AC00(&sp50, 0x32, 0x37, 1); + break; + + case 2: + var_s0 = func_8420AC00(&sp50, 0x32, 0x37, 1); + break; + + case 3: + var_s0 = func_8420AC00(&sp50, 0x32, 0x37, 1); + break; + case 4: + var_s0 = func_8420AC00(&sp50, 0x19, 0x1E, 8); + break; + + case 5: + var_s0 = func_8420AC00(&sp50, 0xF, 0x14, 0x10); + break; + + case 6: + var_s0 = func_8420AC00(&sp50, 1, 0x64, 0x20); + break; + + case 7: + var_s0 = func_8420AC00(&sp50, 1, 0x64, 0x20); + break; + + case 8: + var_s0 = func_8420AC00(&sp50, 1, 0x64, 0x20); + break; + } + + if (var_s0 != 0) { + temp_v0 = ptr; + temp_v0->unk_02[temp_v0->unk_00] = var_s2; + temp_v0->unk_00 += 1; + } + + var_s2++; + } + func_80022D8C(var_v0); + } + } + return ptr->unk_00; +} + +s32 func_8420AF1C(unk_D_842168A0* arg0, unk_D_84211B50* arg1, unk_D_8423D3A8* arg2, s16 arg3, s16 arg4, s16 arg5, + s16 arg6, s16 arg7, unk_D_842168A0_0013C* arg8) { + s16 i; + + arg0->unk_00000 = arg3; + arg0->unk_00001 = 1; + arg0->unk_00002 = 0; + arg0->unk_00003 = arg6; + arg0->unk_00004 = arg7; + arg0->unk_00005 = 0xD; + arg0->unk_00006 = 0; + arg0->unk_00007 = 0; + arg0->unk_00008 = 8; + arg0->unk_0000A = 0; + arg0->unk_0000C = 0; + arg0->unk_0000E = 0; + arg0->unk_00016 = arg5 + 0x1E0; + arg0->unk_00010 = arg4; + arg0->unk_00014 = arg4; + arg0->unk_00012 = arg5; + arg0->unk_0013C = arg8; + arg0->unk_13608 = arg1; + arg0->unk_1360C = arg2; + arg0->unk_00140 = &arg0->unk_00148[0]; + + for (i = 0; i < 8; i++) { + arg0->unk_00148[i].unk_2688 = &arg0->unk_00148[(i + 1) & 7]; + arg0->unk_00148[i].unk_268C = &arg0->unk_00148[(i - 1) & 7]; + } + + for (i = 12; i >= 0; i--) { + if (func_8420ACA8(arg0, i, D_800AE540.unk_0001) > 0) { + arg0->unk_00005 = i; + } + } + + for (i = 0; i < 4; i++) { + func_84209DB8(arg0, &arg0->unk_00148[i], i, arg0->unk_0013C); + } + + return 2; +} + +s32 func_8420B0C8(unk_D_842168A0* arg0) { + s32 sp1C = 0; + + if (arg0->unk_00007 > 0) { + arg0->unk_00007--; + } + + switch (arg0->unk_00001) { + case 1: + func_8420A0A4(arg0); + break; + + case 2: + func_8420A0A4(arg0); + break; + + case 4: + func_8420A0BC(arg0); + break; + + case 3: + func_8420AA08(arg0); + break; + + case 7: + func_8420AB50(arg0); + break; + + case 8: + func_8420AB50(arg0); + break; + + case 9: + func_8420AB50(arg0); + break; + + case 10: + func_8420AB50(arg0); + break; + + case 5: + func_8420A1B0(arg0); + sp1C = 1; + break; + + case 6: + func_8420A228(arg0); + sp1C = 1; + break; + + case 11: + func_8420A0E4(arg0); + break; + } + return sp1C; +} + +s32 func_8420B1D0(unk_D_842168A0* arg0, s16 arg1) { + if (arg0->unk_00001 != 1) { + return 0; + } + arg0->unk_00001 = 5; + arg0->unk_0000A = -arg1; + return 1; +} + +s32 func_8420B20C(unk_D_842168A0* arg0) { + if (arg0->unk_00001 != 2) { + return 0; + } + arg0->unk_00001 = 5; + arg0->unk_0000A = 0; + return 1; +} + +s32 func_8420B238(unk_D_842168A0* arg0) { + if (arg0->unk_00001 != 4) { + return 0; + } + arg0->unk_00002 = 6; + arg0->unk_0000A = 0; + return 1; +} + +void func_8420B264(unk_D_842168A0* arg0) { + arg0->unk_00009 = 2; +} + +void func_8420B270(unk_D_842168A0* arg0) { + s32 i; + + for (i = 0; i < 12; i++) { + if (func_84207E3C(arg0->unk_13608, + &func_84209CF4(arg0->unk_00140, arg0->unk_0000E)->unk_0000[arg0->unk_0000C]) != 0) { + break; + } + + arg0->unk_0000C++; + if (arg0->unk_0000C == 3) { + arg0->unk_0000C = 0; + arg0->unk_0000E = (arg0->unk_0000E + 1) & 3; + } + } +} + +s32 func_8420B334(unk_D_842168A0* arg0) { + if (arg0->unk_00001 == 4) { + func_8420B270(arg0); + arg0->unk_00002 = 3; + return 1; + } + return 0; +} + +s32 func_8420B37C(unk_D_842168A0* arg0) { + return arg0->unk_00001 == 2; +} diff --git a/src/fragments/61/fragment61_2E2C20.c b/src/fragments/61/fragment61_2E2C20.c index 0729238..79d1bc3 100644 --- a/src/fragments/61/fragment61_2E2C20.c +++ b/src/fragments/61/fragment61_2E2C20.c @@ -1,161 +1,510 @@ -#include "global.h" - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420B390.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420B40C.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420B5A4.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420B71C.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420B870.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420B8CC.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420C360.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420C368.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420C484.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420C4DC.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420C504.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420C580.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420C60C.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420C6D8.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420C788.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420C7B0.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420C844.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420C930.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420CA00.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420CAD0.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420CBA0.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420CC54.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420CCAC.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420CE24.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420CFC4.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420D144.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420D2BC.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420D370.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420D464.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420D4F8.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420D75C.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420D938.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420D978.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420D9B0.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420DA28.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420DAF4.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420DB48.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420DBA0.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420DC78.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420DD14.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420E46C.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420E63C.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420EA88.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420EB7C.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420ED0C.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420EE54.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420F1BC.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420F1E0.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420F204.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420F37C.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420F4FC.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420F524.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420F53C.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420F598.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420F5F0.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420F654.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420F754.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420F86C.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420F9C8.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420FA88.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420FB4C.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420FC0C.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420FCCC.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420FDDC.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420FE50.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420FE90.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420FEC0.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8420FFB0.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8421009C.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8421015C.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_84210328.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8421059C.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_84210668.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_842106FC.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_8421089C.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_84210A18.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_84210A48.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_84210B54.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_84210B60.s") - -#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/61/fragment61_2E2C20/func_84210C80.s") +#include "fragment61.h" +#include "src/19840.h" +#include "src/1AB70.h" +#include "src/1CF30.h" +#include "src/20470.h" +#include "src/225A0.h" +#include "src/22630.h" +#include "src/232C0.h" +#include "src/26820.h" +#include "src/2E110.h" +#include "src/49790.h" +#include "src/6BC0.h" +#include "src/F420.h" +#include "src/dp_intro.h" +#include "src/hal_libc.h" + +typedef struct unk_D_842115F0 { + /* 0x00 */ Color_RGB8 unk_00[4]; + /* 0x0C */ u8* unk_0C; +} unk_D_842115F0; // size = 0x10 + +unk_D_842115F0 D_842115F0[] = { + { + { + { 0xB4, 0xB4, 0xB4 }, + { 0x5A, 0x5A, 0x5A }, + { 0xF0, 0xF0, 0xF0 }, + { 0x00, 0x00, 0x00 }, + }, + D_2017740, + }, + { + { + { 0xD2, 0x64, 0x28 }, + { 0xA0, 0x32, 0x1E }, + { 0xF0, 0x96, 0x32 }, + { 0x00, 0x00, 0x00 }, + }, + D_2019040, + }, + { + { + { 0x3C, 0x64, 0xDC }, + { 0x1E, 0x1E, 0x96 }, + { 0x50, 0x96, 0xF0 }, + { 0x00, 0x00, 0x00 }, + }, + D_20199A0, + }, + { + { + { 0xAA, 0x46, 0xDC }, + { 0x64, 0x1E, 0xA0 }, + { 0xC8, 0x96, 0xF0 }, + { 0x00, 0x00, 0x00 }, + }, + D_2019680, + }, + { + { + { 0x96, 0x82, 0x3C }, + { 0x5A, 0x50, 0x1E }, + { 0xF0, 0xC8, 0x78 }, + { 0x00, 0x00, 0x00 }, + }, + D_2018D20, + }, + { + { + { 0x64, 0x96, 0x96 }, + { 0x1E, 0x50, 0x50 }, + { 0x64, 0xB4, 0xB4 }, + { 0x00, 0x00, 0x00 }, + }, + D_2018A00, + }, + { + { + { 0x3C, 0x64, 0xDC }, + { 0x1E, 0x1E, 0x96 }, + { 0x50, 0x96, 0xF0 }, + { 0x00, 0x00, 0x00 }, + }, + D_20199A0, + }, + { + { + { 0x6E, 0xA0, 0x1E }, + { 0x28, 0x5A, 0x1E }, + { 0xC8, 0xF0, 0x50 }, + { 0x00, 0x00, 0x00 }, + }, + D_2019360, + }, + { + { + { 0xA0, 0x8C, 0xB4 }, + { 0x5A, 0x46, 0x6E }, + { 0xDC, 0xC8, 0xF0 }, + { 0x00, 0x00, 0x00 }, + }, + D_2019FE0, + }, + { + { + { 0xC8, 0x3C, 0x3C }, + { 0x8C, 0x1E, 0x1E }, + { 0xF0, 0x64, 0x64 }, + { 0x00, 0x00, 0x00 }, + }, + D_2017A60, + }, + { + { + { 0x32, 0x96, 0xDC }, + { 0x1E, 0x64, 0xA0 }, + { 0x46, 0xB4, 0xF0 }, + { 0x00, 0x00, 0x00 }, + }, + D_2017D80, + }, + { + { + { 0x1E, 0xAA, 0x1E }, + { 0x1E, 0x6E, 0x1E }, + { 0x64, 0xC8, 0x64 }, + { 0x00, 0x00, 0x00 }, + }, + D_20183C0, + }, + { + { + { 0xB4, 0x96, 0x1E }, + { 0x78, 0x64, 0x1E }, + { 0xF0, 0xF0, 0x32 }, + { 0x00, 0x00, 0x00 }, + }, + D_20186E0, + }, + { + { + { 0xC8, 0x5A, 0x96 }, + { 0x8C, 0x1E, 0x5A }, + { 0xF0, 0x8C, 0xB4 }, + { 0x00, 0x00, 0x00 }, + }, + D_2019CC0, + }, + { + { + { 0x64, 0xBE, 0xBE }, + { 0x1E, 0x8C, 0x8C }, + { 0xB4, 0xF0, 0xF0 }, + { 0x00, 0x00, 0x00 }, + }, + D_20180A0, + }, + { + { + { 0x1E, 0xA0, 0x8C }, + { 0x1E, 0x64, 0x50 }, + { 0x64, 0xDC, 0xC8 }, + { 0x00, 0x00, 0x00 }, + }, + D_201A300, + }, +}; +s16 D_842116F0[] = { 0x14A, 0x15E, 0xFC, 0xE4 }; +s16 D_842116F8[] = { 0x7C, 0x95, 0xAE, 0x95 }; + +void func_8420B390(s16 arg0, s16 arg1, s16 arg2, s16 arg3, s8* arg4) { + if (arg2 == arg3) { + func_8001F324(0xFF, 0xFF, 0, 0xFF); + } else { + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + } + func_8001F1E8(arg0, arg1, arg4); +} + +void func_8420B40C(s16 arg0, s16 arg1, s16 arg2, s16 arg3) { + if (arg2 != 0) { + func_80020928(arg0 + 0x19C, arg1 + (arg3 * 0x16) + 0x3A); + func_8001F3F4(); + func_8001EBE0(8, 0); + func_8001F3B4(0x16); + + switch (arg2) { + case 1: + func_8001F1E8(arg0 + 0x19C, arg1 + 0x20, func_84200130(0)); + break; + + case 2: + func_8001F1E8(arg0 + 0x19C, arg1 + 0x20, func_84200130(1)); + break; + + case 3: + func_8001F1E8(arg0 + 0x19C, arg1 + 0xA, func_84200130(2)); + break; + } + + func_8001EBE0(8, 0); + func_8420B390(arg0 + 0x1CE, arg1 + 0x3A, 0, arg3, func_84200130(3)); + func_8420B390(arg0 + 0x1CE, arg1 + 0x50, 1, arg3, func_84200130(4)); + func_8001F444(); + } +} + +void func_8420B5A4(s16 arg0, s16 arg1, s16 arg2) { + unk_D_842115F0* sp34 = &D_842115F0[func_800219FC(arg2)]; + unk_D_842115F0* sp30 = &D_842115F0[func_800219FC(arg2)]; + + gDPSetEnvColor(gDisplayListHead++, sp34->unk_00->r, sp34->unk_00->g, sp34->unk_00->b, 255); + gDPSetPrimColor(gDisplayListHead++, 0, 0, (sp30->unk_00 + 1)->r, (sp30->unk_00 + 1)->g, (sp30->unk_00 + 1)->b, 255); + + func_8001CADC(arg0, arg1, 0x14, 0x28, D_20165C0, 0x18, 0); + func_8001CADC(arg0 + 0x38, arg1, 0x14, 0x28, D_2016980, 0x18, 0); + func_8001C330(arg0 + 0x14, arg1, 0x24, 0x28, 0, 0, 0, 0x400, 0); +} + +void func_8420B71C(s16 arg0, s16 arg1, s32 arg2) { + s16 i; + s16 var_a3; + + if (arg2 != 0) { + gSPDisplayList(gDisplayListHead++, D_8006F4E0); + gDPSetAlphaCompare(gDisplayListHead++, G_AC_NONE); + + for (i = 0; i < 0x54; i += 0x14) { + var_a3 = CLAMP_MIN(0x54 - i, 20); + func_8001C6AC(arg0, arg1 + i, 0x64, var_a3, (i * 0xC8) + arg2, 0x64, 0x200000); + } + + gSPDisplayList(gDisplayListHead++, D_8006F630); + } +} + +s16 func_8420B870(s16 arg0, s16 arg1, char* arg2) { + if (arg0 >= 2) { + arg1 -= func_8001F5B0(8, 0, arg2, arg1); + } + return arg1; +} + +void func_8420B8CC(unk_D_8423D3A8* arg0, s32 arg1) { + UNUSED s32 pad[2]; + s16 i; + s16 temp_s4; + s16 temp_s5; + char* temp_v0_8; + unk_func_80026268_arg0* temp_s6; + + temp_s4 = arg0->unk_06; + temp_s5 = arg0->unk_08; + temp_s6 = &arg0->unk_2C->unk_004; + + if (arg0->unk_00 != 0) { + func_842001B8(temp_s4, temp_s5, arg0->unk_0A, arg0->unk_0C); + if ((arg0->unk_0A == 0x228) && (arg0->unk_0C == 0xCC)) { + if (arg0->unk_2C->unk_000 == 4) { + func_84200420(temp_s4 + 4, temp_s5 + 4, 0x190, 0x1C, 0xAA, 0x3C, 0x96, 0xFF); + } else { + switch (arg0->unk_2C->unk_001) { + case 0: + func_84200420(temp_s4 + 4, temp_s5 + 4, 0x190, 0x1C, 0xAA, 0x3C, 0x3C, 0xFF); + break; + + case 9: + func_84200420(temp_s4 + 4, temp_s5 + 4, 0x190, 0x1C, 0xAA, 0x3C, 0x96, 0xFF); + break; + + default: + func_84200420(temp_s4 + 4, temp_s5 + 4, 0x190, 0x1C, 0xB4, 0x8C, 0x28, 0xFF); + break; + } + } + + func_84200420(temp_s4 + 0x68, temp_s5 + 0x20, 0x12C, 0x54, 0xB4, 0xAA, 0x64, 0xFF); + func_84200420(temp_s4 + 0x194, temp_s5 + 4, 0x90, 0x78, 0x32, 0x32, 0x82, 0xFF); + func_84200420(temp_s4 + 4, temp_s5 + 0x74, 0x220, 0x54, 0xA0, 0x96, 0x32, 0xFF); + + gSPDisplayList(gDisplayListHead++, D_8006F518); + + func_8001C6AC(temp_s4 + 0x108, temp_s5 + 0x77, 0x1C, 0x1A, D_2014F00, 0x1C, 0); + func_8001C6AC(temp_s4 + 0xF0, temp_s5 + 0x90, 0x1C, 0x1A, D_20154B0, 0x1C, 0); + func_8001C6AC(temp_s4 + 0x11C, temp_s5 + 0x90, 0x1C, 0x1A, D_2016010, 0x1C, 0); + func_8001C6AC(temp_s4 + 0x108, temp_s5 + 0xA9, 0x1C, 0x1A, D_2015A60, 0x1C, 0); + + if ((arg0->unk_2C->unk_000 != 4) && (arg0->unk_2C->unk_001 == 0xD)) { + func_8001C6AC(temp_s4 + 0x14, temp_s5 + 0x78, 0x40, 0x14, D_2016D40, 0x40, 0); + } + + gDPSetCombineLERP(gDisplayListHead++, ENVIRONMENT, PRIMITIVE, TEXEL0, PRIMITIVE, TEXEL0, 0, ENVIRONMENT, 0, + ENVIRONMENT, PRIMITIVE, TEXEL0, PRIMITIVE, TEXEL0, 0, ENVIRONMENT, 0); + + func_8420B5A4(temp_s4 + 0x6A, temp_s5 + 0x26, temp_s6->unk_06); + + if (temp_s6->unk_06 != temp_s6->unk_07) { + func_8420B5A4(temp_s4 + 0xBA, temp_s5 + 0x26, temp_s6->unk_07); + } + + gSPDisplayList(gDisplayListHead++, D_8006F630); + + func_8420B71C(temp_s4 + 4, temp_s5 + 0x20, arg0->unk_20); + func_8420B40C(temp_s4, temp_s5, arg0->unk_01, arg0->unk_02); + func_8001F3F4(); + func_8001EBE0(8, 0); + func_8001F1E8(temp_s4 + 0xC, temp_s5 + 8, temp_s6->unk_30); + func_8001EBE0(8, 0); + func_8001F1E8(temp_s4 + 0x84, temp_s5 + 8, "%s %d", func_84200160(0x15), temp_s6->unk_24); + func_8001EBE0(4, 0); + func_8001F1E8(temp_s4 + 0xE8, temp_s5 + 0xC, "%s%03d", func_84200160(0x16), temp_s6->unk_00.unk_00); + func_8001EBE0(4, 0); + func_8001F1E8(temp_s4 + 0x13C, temp_s5 + 0xC, func_84200088(temp_s6->unk_00.unk_00)); + func_8001EBE0(8, 0); + func_8001F1E8(temp_s4 + 0x76, temp_s5 + 0x5A, "%s", func_84200160(8)); + func_8001EBE0(8, 0); + func_8001F1E8(temp_s4 + 0xA4, temp_s5 + 0x5A, "%3d", temp_s6->unk_26); + func_8001EBE0(4, 0); + func_8001F1E8(temp_s4 + 0x116, temp_s5 + 0x25, func_84200130(5)); + func_8001F1E8(temp_s4 + 0x116, temp_s5 + 0x38, func_84200130(6)); + func_8001F1E8(temp_s4 + 0x116, temp_s5 + 0x4B, func_84200130(7)); + func_8001F1E8(temp_s4 + 0x116, temp_s5 + 0x5E, func_84200130(8)); + func_8001EBE0(4, 0); + func_8001F1E8(temp_s4 + 0x15E, temp_s5 + 0x25, "%3d", temp_s6->unk_28); + func_8001F1E8(temp_s4 + 0x15E, temp_s5 + 0x38, "%3d", temp_s6->unk_2A); + func_8001F1E8(temp_s4 + 0x15E, temp_s5 + 0x4B, "%3d", temp_s6->unk_2C); + func_8001F1E8(temp_s4 + 0x15E, temp_s5 + 0x5E, "%3d", temp_s6->unk_2E); + func_8001EBE0(4, 0); + temp_v0_8 = func_84200130(9); + func_8001F1E8((temp_s4 - (func_8001F5B0(4, 0, temp_v0_8) / 2)) + 0x90, temp_s5 + 0x26, temp_v0_8); + temp_v0_8 = func_842000F8(func_800219FC(temp_s6->unk_06)); + func_8001F1E8((temp_s4 - (func_8001F5B0(4, 0, temp_v0_8) / 2)) + 0x90, temp_s5 + 0x3A, temp_v0_8); + + if (temp_s6->unk_06 != temp_s6->unk_07) { + temp_v0_8 = func_84200130(0xA); + func_8001F1E8((temp_s4 - (func_8001F5B0(4, 0, temp_v0_8) / 2)) + 0xE0, temp_s5 + 0x26, temp_v0_8); + temp_v0_8 = func_842000F8(func_800219FC(temp_s6->unk_07)); + func_8001F1E8((temp_s4 - (func_8001F5B0(4, 0, temp_v0_8) / 2)) + 0xE0, temp_s5 + 0x3A, temp_v0_8); + } + + func_8001EBE0(8, 0); + + { + s16 sp80; + Color_RGB8* color; + u8 temp_a0; + + for (i = 0; i < 4; i++) { + temp_a0 = temp_s6->unk_09[i]; + if (temp_a0 == 0) { + break; + } + color = &D_842115F0[D_80072338[temp_a0 - 1].unk_01].unk_00[2]; + sp80 = func_8420B870(i, D_842116F0[i], func_842000C0(temp_a0)); + func_8001F324(color->r, color->g, color->b, 0xFF); + func_8001F1E8(temp_s4 + sp80, D_842116F8[i] + temp_s5, func_842000C0(temp_s6->unk_09[i])); + } + + func_8001F444(); + + gSPDisplayList(gDisplayListHead++, D_8006F518); + + for (i = 0; i < 4; i++) { + if (temp_s6->unk_09[i] == 0) { + break; + } + + sp80 = func_8420B870(i, D_842116F0[i], func_842000C0(temp_s6->unk_09[i])); + func_8001C6AC((temp_s4 + sp80) - 0x18, D_842116F8[i] + temp_s5, 0x14, 0x14, + D_842115F0[D_80072338[temp_s6->unk_09[i] - 1].unk_01].unk_0C, 0x14, 0); + } + } + + gSPDisplayList(gDisplayListHead++, D_8006F630); + + arg0->unk_20 = 0; + } + } +} + +void func_8420C360(unk_D_8423D3A8* arg0) { +} + +void func_8420C368(unk_D_8423D3A8* arg0) { + Controller* cont = &gControllers[arg0->unk_03]; + + if (BTN_IS_PRESSED(cont, BTN_A)) { + if (arg0->unk_01 == 0) { + func_80048B90(3); + } else if (arg0->unk_02 == 0) { + func_80048B90(0x22); + } else { + func_80048B90(3); + } + arg0->unk_04 = 0; + arg0->unk_00 = 3; + } else if (BTN_IS_PRESSED(cont, BTN_B)) { + func_80048B90(3); + arg0->unk_04 = 0; + arg0->unk_02 = 1; + arg0->unk_00 = 3; + } else if (BTN_IS_PRESSED(cont, BTN_DUP | BTN_DDOWN) && (arg0->unk_01 != 0)) { + func_80048B90(1); + arg0->unk_02 ^= 1; + } + + arg0->unk_06 = arg0->unk_0E.x1; + arg0->unk_08 = arg0->unk_0E.y2; + arg0->unk_0A = 0x228; + arg0->unk_0C = 0xCC; + arg0->unk_20 = func_8001B9D4(arg0->unk_28); +} + +void func_8420C484(unk_D_8423D3A8* arg0) { + arg0->unk_06 = arg0->unk_0E.x1; + arg0->unk_08 = arg0->unk_0E.y2; + arg0->unk_0A = 0x228; + arg0->unk_0C = 0xCC; + arg0->unk_00 = 1; + arg0->unk_20 = func_8001B9D4(arg0->unk_28); +} + +void func_8420C4DC(unk_D_8423D3A8* arg0) { + arg0->unk_06 = arg0->unk_16.x1; + arg0->unk_08 = arg0->unk_16.y2; + arg0->unk_0A = 0x8C; + arg0->unk_0C = 0x34; + arg0->unk_00 = 0; +} + +s32 func_8420C504(unk_D_8423D3A8* arg0) { + arg0->unk_24 = func_80019760(1); + arg0->unk_28 = func_8001B1FC(arg0->unk_24, 0x64, 0x54, 0, 0, 0x64, 0x54, NULL); + arg0->unk_28->unk_00 &= ~2; + arg0->unk_00 = 0; + arg0->unk_03 = 0; + arg0->unk_04 = 0; + arg0->unk_20 = 0; + return 0x10; +} + +s32 func_8420C580(unk_D_8423D3A8* arg0) { + s32 sp1C = 0; + + switch (arg0->unk_00) { + case 0: + sp1C = 0; + func_8420C360(arg0); + break; + + case 1: + sp1C = 0; + func_8420C368(arg0); + break; + + case 2: + func_8420C484(arg0); + sp1C = 1; + break; + + case 3: + func_8420C4DC(arg0); + sp1C = 1; + break; + } + return sp1C; +} + +s32 func_8420C60C(unk_D_8423D3A8* arg0, s16 arg1, s16 arg2, s16 arg3, s16 arg4, s16 arg5, + unk_D_838067F0_0168_0000* arg6, s16 arg7) { + if (arg0->unk_00 != 0) { + return 0; + } + + func_8001B2D8(arg0->unk_28, &arg6->unk_004, 0x108D); + + arg0->unk_00 = 2; + arg0->unk_01 = arg7; + arg0->unk_02 = 0; + arg0->unk_03 = arg1; + arg0->unk_04 = 0; + arg0->unk_20 = 0; + arg0->unk_2C = arg6; + + func_80005FC0(&arg0->unk_0E, arg2, arg3, arg2 + 0x227, arg3 + 0xCB); + func_80005FC0(&arg0->unk_16, arg4, arg5, arg4 + 0x8B, arg5 + 0x33); + return 1; +} + +s32 func_8420C6D8(unk_D_8423D3A8* arg0, s16 arg1, s16 arg2, unk_D_838067F0_0168_0000* arg3) { + if (arg0->unk_00 != 1) { + return 0; + } + + while (func_80001C90() == 0) {} + + func_8001B2D8(arg0->unk_28, &arg3->unk_004, 0x108D); + arg0->unk_2C = arg3; + func_80005FC0(&arg0->unk_16, arg1, arg2, arg1 + 0x8B, arg2 + 0x33); + return 1; +} + +s32 func_8420C788(unk_D_8423D3A8* arg0) { + s16 var_v1 = 0; + + if (arg0->unk_00 == 0) { + var_v1 = arg0->unk_02 + 1; + } + return var_v1; +} diff --git a/src/fragments/61/fragment61_2E4040.c b/src/fragments/61/fragment61_2E4040.c new file mode 100644 index 0000000..b7d6062 --- /dev/null +++ b/src/fragments/61/fragment61_2E4040.c @@ -0,0 +1,646 @@ +#include "fragment61.h" +#include "src/19840.h" +#include "src/1AB70.h" +#include "src/1CF30.h" +#include "src/20470.h" +#include "src/225A0.h" +#include "src/22630.h" +#include "src/232C0.h" +#include "src/26820.h" +#include "src/2E110.h" +#include "src/49790.h" +#include "src/6BC0.h" +#include "src/F420.h" +#include "src/dp_intro.h" +#include "src/hal_libc.h" + +s16 D_8423E580; +Controller* D_8423E584; +s16 D_8423E588; +s16 D_8423E58A; + +s16 D_84211700 = 0; +unk_D_84211704 D_84211704[] = { + { + 132, + 300, + 376, + 136, + 0, + 4, + 0, + 8481, + 0x0374, + }, + { + 132, + 300, + 376, + 136, + 0, + 1, + 0, + 8481, + 0x0002, + }, + { + 132, + 300, + 376, + 136, + 0, + 1, + 0, + 26907, + 0x0002, + }, + { + 132, + 300, + 376, + 136, + 0, + 1, + 0, + -32503, + 0x0001, + }, + { + 210, + 300, + 220, + 108, + 0, + 3, + 0, + 8481, + 0x006C, + }, + { + 210, + 150, + 220, + 108, + 0, + 3, + 0, + 8481, + 0x006C, + }, + { + 210, + 300, + 290, + 108, + 0, + 3, + 2, + -32503, + 0x0052, + }, + { + 210, + 150, + 290, + 108, + 0, + 3, + 2, + -32503, + 0x0052, + }, + { + 110, + 300, + 420, + 92, + 0, + 1, + 0, + 26907, + 0x0002, + }, + { + 210, + 300, + 290, + 82, + 0, + 2, + 0, + 8481, + 0x000A, + }, + { + 132, + 300, + 376, + 136, + 0, + 3, + 0, + 8481, + 0x0052, + }, + { + 70, + 320, + 500, + 92, + 0, + 1, + 0, + 26907, + 0x0002, + }, + { + 160, + 320, + 320, + 82, + 0, + 2, + 0, + 8481, + 0x000A, + }, + { + 110, + 300, + 420, + 136, + 0, + 1, + 0, + -32503, + 0x0002, + }, + { + 110, + 300, + 420, + 136, + 0, + 1, + 0, + -32503, + 0x0002, + }, + { + 110, + 300, + 420, + 136, + 0, + 1, + 0, + -32503, + 0x0002, + }, + { + 132, + 180, + 376, + 92, + -22, + 1, + 0, + 26889, + 0x0002, + }, + { + 120, + 160, + 400, + 64, + 0, + 1, + 0, + 26889, + 0x0002, + }, + { + 120, + 160, + 400, + 64, + 0, + 1, + 0, + 26889, + 0x0002, + }, + { + 210, + 300, + 290, + 82, + 0, + 2, + 1, + 8481, + 0x000A, + }, +}; + +void func_8420C7B0(s16 arg0, s16 arg1, s16 arg2, char* arg3) { + if (arg2 == D_8423E58A) { + func_8001F324(0xFF, 0xFF, 0, 0xFF); + } else { + func_8001F324(0xFF, 0xFF, 0xFF, 0xFF); + } + func_8001F1E8(arg0 + 0x3C, arg1 + (arg2 * 0x1C) + 0xC, arg3); +} + +void func_8420C844(unk_D_84211704* arg0) { + func_8001F3F4(); + func_8001EBE0(0x10, 0); + func_8420C7B0(arg0->unk_00, arg0->unk_02, 0, func_84200130(0x15)); + func_8420C7B0(arg0->unk_00, arg0->unk_02, 1, func_84200130(0x16)); + func_8420C7B0(arg0->unk_00, arg0->unk_02, 2, func_84200130(0x17)); + func_8420C7B0(arg0->unk_00, arg0->unk_02, 3, func_84200130(0x18)); + func_8001F444(); + + if (D_8423E58A >= 0) { + func_80020928(arg0->unk_00 + 0x10, arg0->unk_02 + (D_8423E58A * 0x1C) + 0xC); + } +} + +void func_8420C930(unk_D_84211704* arg0) { + func_8001F3F4(); + func_8001EBE0(0x10, 0); + func_8420C7B0(arg0->unk_00, arg0->unk_02, 0, func_84200130(0x19)); + func_8420C7B0(arg0->unk_00, arg0->unk_02, 1, func_84200130(0x1A)); + func_8420C7B0(arg0->unk_00, arg0->unk_02, 2, func_84200130(0x1B)); + func_8001F444(); + + if (D_8423E58A >= 0) { + func_80020928(arg0->unk_00 + 0x10, arg0->unk_02 + (D_8423E58A * 0x1C) + 0xC); + } +} + +void func_8420CA00(unk_D_84211704* arg0) { + func_8001F3F4(); + func_8001EBE0(0x10, 0); + func_8420C7B0(arg0->unk_00, arg0->unk_02, 0, func_84200130(0x15)); + func_8420C7B0(arg0->unk_00, arg0->unk_02, 1, func_84200130(0x17)); + func_8420C7B0(arg0->unk_00, arg0->unk_02, 2, func_84200130(0x18)); + func_8001F444(); + + if (D_8423E58A >= 0) { + func_80020928(arg0->unk_00 + 0x10, arg0->unk_02 + (D_8423E58A * 0x1C) + 0xC); + } +} + +void func_8420CAD0(unk_D_84211704* arg0) { + func_8001F3F4(); + func_8001EBE0(0x10, 0); + func_8420C7B0(arg0->unk_00, arg0->unk_02, 0, func_84200130(0x1C)); + func_8420C7B0(arg0->unk_00, arg0->unk_02, 1, func_84200130(0x1D)); + func_8420C7B0(arg0->unk_00, arg0->unk_02, 2, func_84200130(0x1E)); + func_8001F444(); + + if (D_8423E58A >= 0) { + func_80020928(arg0->unk_00 + 0x10, arg0->unk_02 + (D_8423E58A * 0x1C) + 0xC); + } +} + +void func_8420CBA0(unk_D_84211704* arg0) { + func_8001F3F4(); + func_8001EBE0(0x10, 0); + func_8420C7B0(arg0->unk_00, arg0->unk_02, 0, func_84200130(0x1F)); + func_8420C7B0(arg0->unk_00, arg0->unk_02, 1, func_84200130(0x20)); + func_8001F444(); + + if (D_8423E58A >= 0) { + func_80020928(arg0->unk_00 + 0x10, arg0->unk_02 + (D_8423E58A * 0x1C) + 0xC); + } +} + +void func_8420CC54(unk_D_84211704* arg0) { + func_8001F3F4(); + func_8001EBE0(0x10, 0); + func_8001F1E8(arg0->unk_00 + 0x2D, arg0->unk_02 + 0x38, func_84200130(0x21)); + func_8001F444(); +} + +void func_8420CCAC(unk_D_84211704* arg0) { + gSPDisplayList(gDisplayListHead++, D_8006F518); + + func_8001C6AC(arg0->unk_00 + 0x18, arg0->unk_02 + 0x26, 0x4C, 0x14, D_2029CE0, 0x4C, 0); + func_8001C6AC(arg0->unk_00 + 0x18, arg0->unk_02 + 0x3A, 0x4C, 0x14, D_202A8C0, 0x4C, 0); + func_8001C6AC(arg0->unk_00 + 0x18, arg0->unk_02 + 0x4E, 0x4C, 0x14, D_202B4A0, 0x4C, 0); + + gSPDisplayList(gDisplayListHead++, D_8006F630); + + func_8001F3F4(); + func_8001EBE0(0x10, 0); + func_8001F1E8(arg0->unk_00 + 0x78, arg0->unk_02 + 0x38, func_84200130(0x22)); + func_8001F444(); +} + +void func_8420CE24(unk_D_84211704* arg0) { + gSPDisplayList(gDisplayListHead++, D_8006F518); + + func_8001C6AC(arg0->unk_00 + 0x18, arg0->unk_02 + arg0->unk_08 + 0x26, 0x4C, 0x14, D_2029CE0, 0x4C, 0); + func_8001C6AC(arg0->unk_00 + 0x18, arg0->unk_02 + arg0->unk_08 + 0x3A, 0x4C, 0x14, D_202A8C0, 0x4C, 0); + func_8001C6AC(arg0->unk_00 + 0x18, arg0->unk_02 + arg0->unk_08 + 0x4E, 0x4C, 0x14, D_202B4A0, 0x4C, 0); + + gSPDisplayList(gDisplayListHead++, D_8006F630); + + func_8001F3F4(); + func_8001EBE0(0x10, 0); + func_8001F3B4(0x1E); + func_8001F1E8(arg0->unk_00 + 0x78, arg0->unk_02 + arg0->unk_08 + 0x29, func_84200130(0x23)); + func_8001F444(); +} + +void func_8420CFC4(unk_D_84211704* arg0) { + gSPDisplayList(gDisplayListHead++, D_8006F518); + + func_8001C6AC(arg0->unk_00 + 0x10, arg0->unk_02 + 0x10, 0x4C, 0x14, D_2029CE0, 0x4C, 0); + func_8001C6AC(arg0->unk_00 + 0x10, arg0->unk_02 + 0x24, 0x4C, 0x14, D_202A8C0, 0x4C, 0); + func_8001C6AC(arg0->unk_00 + 0x10, arg0->unk_02 + 0x38, 0x4C, 0x14, D_202B4A0, 0x4C, 0); + + gSPDisplayList(gDisplayListHead++, D_8006F630); + + func_8001F3F4(); + func_8001EBE0(0x10, 0); + func_8001F3B4(0x1C); + func_8001F1E8(arg0->unk_00 + 0x68, arg0->unk_02 + 0x14, func_84200130(0x24)); + func_8001F444(); +} + +void func_8420D144(unk_D_84211704* arg0) { + gSPDisplayList(gDisplayListHead++, D_8006F518); + + func_8001C6AC(arg0->unk_00 + 0x10, arg0->unk_02 + 0x10, 0x4C, 0x14, D_2029CE0, 0x4C, 0); + func_8001C6AC(arg0->unk_00 + 0x10, arg0->unk_02 + 0x24, 0x4C, 0x14, D_202A8C0, 0x4C, 0); + func_8001C6AC(arg0->unk_00 + 0x10, arg0->unk_02 + 0x38, 0x4C, 0x14, D_202B4A0, 0x4C, 0); + + gSPDisplayList(gDisplayListHead++, D_8006F630); + + func_8001F3F4(); + func_8001EBE0(0x10, 0); + func_8001F1E8(arg0->unk_00 + 0x68, arg0->unk_02 + 0x22, func_84200130(0x25)); + func_8001F444(); +} + +void func_8420D2BC(unk_D_84211704* arg0) { + func_8001F3F4(); + func_8001EBE0(0x10, 0); + func_8420C7B0(arg0->unk_00, arg0->unk_02, 0, func_84200130(0x26)); + func_8420C7B0(arg0->unk_00, arg0->unk_02, 1, func_84200130(0x20)); + func_8001F444(); + + if (D_8423E58A >= 0) { + func_80020928(arg0->unk_00 + 0x10, arg0->unk_02 + (D_8423E58A * 0x1C) + 0xC); + } +} + +void func_8420D370(unk_D_84211704* arg0, s16 arg1) { + char sp28[0x100]; + s32 tmp; + char* sp20; + + func_8001F3F4(); + func_8001EBE0(0x10, 0); + func_8001F3B4(0x1C); + func_8002D600(2, arg1); + sp20 = func_84200190(sp28, sizeof(sp28), 0x27); + tmp = ((arg0->unk_04 - func_8001F5B0(0, 0, sp20)) / 2); + func_8001F1E8(arg0->unk_00 + tmp, arg0->unk_02 + 0x14, sp20); + sp20 = func_84200130(0x28); + tmp = ((arg0->unk_04 - func_8001F5B0(0, 0, sp20)) / 2); + func_8001F1E8(arg0->unk_00 + tmp, arg0->unk_02 + 0x56, sp20); + func_8001F444(); +} + +void func_8420D464(unk_D_84211704* arg0, s16 arg1) { + func_8001F3F4(); + func_8001EBE0(0x10, 0); + if (arg1 == 0) { + func_8001F1E8(arg0->unk_00 + 0x18, arg0->unk_02 + 0x14, func_84200130(0x29)); + } else { + func_8001F1E8(arg0->unk_00 + 0x39, arg0->unk_02 + 0x14, func_84200130(0x2A)); + } + func_8001F444(); +} + +void func_8420D4F8(s32 arg0) { + s16 tmp2; + s16 var_a3; + unk_D_84211704* temp_s0; + + if ((D_84211700 != 0) && (D_8423E588 > 0)) { + temp_s0 = &D_84211704[D_8423E580]; + if (D_8423E588 < 4) { + var_a3 = (temp_s0->unk_06 * D_8423E588) / 4; + if (var_a3 < 0x10) { + var_a3 = 0x10; + } + tmp2 = temp_s0->unk_02 + ((temp_s0->unk_06 - var_a3) / 2); + func_80020460(temp_s0->unk_00, tmp2, temp_s0->unk_04, var_a3, temp_s0->unk_0C); + } else { + func_80020460(temp_s0->unk_00, temp_s0->unk_02, temp_s0->unk_04, temp_s0->unk_06, temp_s0->unk_0C); + + switch (D_8423E580) { + case 0: + func_8420C844(temp_s0); + break; + case 1: + func_8420CC54(temp_s0); + break; + case 2: + func_8420CCAC(temp_s0); + break; + case 3: + func_8420CE24(temp_s0); + break; + case 4: + func_8420C930(temp_s0); + break; + case 5: + func_8420C930(temp_s0); + break; + case 6: + func_8420CAD0(temp_s0); + break; + case 7: + func_8420CAD0(temp_s0); + break; + case 8: + func_8420CFC4(temp_s0); + break; + case 9: + func_8420CBA0(temp_s0); + break; + case 10: + func_8420CA00(temp_s0); + break; + case 11: + func_8420D144(temp_s0); + break; + case 12: + func_8420D2BC(temp_s0); + break; + case 13: + func_8420D370(temp_s0, 0x9B); + break; + case 14: + func_8420D370(temp_s0, 0x50); + break; + case 15: + func_8420D370(temp_s0, 0x32); + break; + case 16: + func_8420CE24(temp_s0); + break; + case 17: + func_8420D464(temp_s0, 0); + break; + case 18: + func_8420D464(temp_s0, 1); + break; + case 19: + func_8420CBA0(temp_s0); + break; + } + } + } +} + +void func_8420D75C(void) { + s16 tmp = D_84211704[D_8423E580].unk_0A; + + if (D_8423E584 != NULL) { + if (BTN_IS_PRESSED(D_8423E584, BTN_A)) { + s32 tmp2 = (D_84211704[D_8423E580].unk_0E >> (D_8423E58A * 3)); + + switch (tmp2 & 7) { + case 1: + func_80048B90(3); + break; + + case 2: + func_80048B90(2); + break; + + case 3: + func_80048B90(0x1C); + break; + + case 4: + func_80048B90(0x20); + break; + + case 5: + func_80048B90(0x21); + break; + + case 6: + if (func_80028E68() < 0xC) { + func_80048B90(0x20); + } else { + func_80048B90(8); + } + break; + } + D_84211700 = 3; + } else if (BTN_IS_PRESSED(D_8423E584, BTN_B)) { + func_80048B90(3); + D_8423E58A = -1; + D_84211700 = 3; + } else if (BTN_IS_PRESSED(D_8423E584, BTN_DUP)) { + func_80048B90(1); + D_8423E58A -= 1; + if (D_8423E58A < 0) { + D_8423E58A = tmp - 1; + } + } else if (BTN_IS_PRESSED(D_8423E584, BTN_DDOWN)) { + func_80048B90(1); + D_8423E58A += 1; + if (D_8423E58A >= tmp) { + D_8423E58A = 0; + } + } + } + D_8423E588 = 4; +} + +void func_8420D938(void) { + D_8423E588++; + if (D_8423E588 >= 5) { + D_8423E588 = 4; + D_84211700 = 2; + } +} + +void func_8420D978(void) { + D_8423E588--; + if (D_8423E588 < 0) { + D_8423E588 = 0; + D_84211700 = 4; + } +} + +s32 func_8420D9B0(void) { + s32 sp1C = 0; + + switch (D_84211700) { + case 2: + sp1C = 0; + func_8420D75C(); + break; + + case 1: + func_8420D938(); + sp1C = 1; + break; + + case 3: + func_8420D978(); + sp1C = 1; + break; + } + + return sp1C; +} + +s32 func_8420DA28(s16 arg0, Controller* arg1) { + if (D_84211700 == 0) { + switch (arg0) { + case 8: + func_80048B90(0x1F); + + case 11: + func_80048B90(0x1E); + break; + } + func_80048B90(4); + D_8423E580 = arg0; + D_8423E58A = D_84211704[arg0].unk_0B; + D_8423E588 = 0; + D_8423E584 = arg1; + D_84211700 = 1; + return 1; + } + return 0; +} + +s32 func_8420DAF4(s16 arg0) { + if ((D_84211700 == 2) && (arg0 == D_8423E580)) { + D_8423E58A = -1; + D_84211700 = 3; + return 1; + } + return 0; +} + +s16 func_8420DB48(s16 arg0) { + if ((D_84211700 == 4) && (arg0 == D_8423E580)) { + D_84211700 = 0; + return D_8423E58A + 1; + } + return -1; +} diff --git a/src/fragments/61/fragment61_2E5430.c b/src/fragments/61/fragment61_2E5430.c new file mode 100644 index 0000000..d2eebac --- /dev/null +++ b/src/fragments/61/fragment61_2E5430.c @@ -0,0 +1,1196 @@ +#include "fragment61.h" +#include "src/20470.h" +#include "src/22630.h" +#include "src/232C0.h" +#include "src/26820.h" +#include "src/49790.h" +#include "src/19840.h" +#include "src/1AB70.h" +#include "src/1CF30.h" +#include "src/225A0.h" +#include "src/2E110.h" +#include "src/6BC0.h" +#include "src/F420.h" +#include "src/dp_intro.h" +#include "src/hal_libc.h" + +u8* D_84211850[] = { + D_202C080, D_202C500, D_202C980, D_202CE00, D_202D280, D_202D700, D_202DB80, D_202E000, +}; +s16 D_84211870[] = { 0x74, 0xF8, 0x17C, 0x74, 0xF8, 0x17C }; +s16 D_8421187C[] = { 0, 0, 0, 0x2C, 0x2C, 0x2C }; + +s32 func_8420DBA0(unk_D_84229EB0_00024* arg0) { + s16 temp_v0; + s16 i; + s32 ret = 0; + unk_func_80022C28_ret* temp_s3; + + temp_v0 = func_80028E68(); + if (temp_v0 < 0xA) { + temp_s3 = func_80022CC0(0x10, 0, temp_v0, &arg0->unk_4D12, &arg0->unk_4D12, arg0->unk_4D10); + + for (i = 0; i < arg0->unk_4D20; i++) { + func_80022F24(&arg0->unk_0000[i].unk_004.unk_00.unk_00, 1, temp_s3); + } + + func_80022D8C(temp_s3); + func_800286D8(); + ret = 1; + } + return ret; +} + +void func_8420DC78(unk_D_84229EB0_00024* arg0) { + unk_D_800AE4E8_004_1_000 sp30; + s16 tmp = arg0->unk_4D1E; + s16 i; + + if (tmp >= 0xA) { + return; + } + + for (i = tmp; i < 9; i++) { + func_80028C7C(&sp30, i + 1); + func_80028D60(&sp30, i); + func_80026684(0x10, i); + } + + func_8002707C(0x10, 9); + func_800286D8(); +} + +void func_8420DD14(unk_D_84229EB0* arg0, s16 arg1, s16 arg2, unk_D_84229EB0_00024* arg3) { + UNUSED s32 pad; + s16 i; + s16 j; + Color_RGBA8 sp8C; + s16 temp_a0; + s16 temp_a1; + s16 temp_s2; + s16 temp_s3; + s16 var_s1; + + if ((arg0->unk_00001 == 8) || (arg0->unk_00001 == 9) || (arg0->unk_00001 == 0xA)) { + func_84200420(arg1, arg2, 0x74, 0x58, 0x64, 0x64, 0xC8, 0xFF); + + for (var_s1 = 0, i = 0; i < 2; i++) { + for (j = 0; j < 3; j++, var_s1++) { + temp_a0 = D_84211870[var_s1] + arg1; + temp_a1 = D_8421187C[var_s1] + arg2; + if ((j == arg0->unk_00008) && (i == arg0->unk_0000A)) { + func_84200420(temp_a0, temp_a1, 0x84, 0x2C, 0x64, 0x64, 0xC8, 0xFF); + } else { + func_84200420(temp_a0, temp_a1, 0x84, 0x2C, 0x3C, 0x3C, 0xA0, 0xFF); + } + } + } + } else { + if (arg3->unk_4D1E == arg0->unk_0000D) { + func_8000E820(&sp8C, 0x64, 0x64, 0xC8); + } else { + func_8000E820(&sp8C, 0x3C, 0x3C, 0xC8); + } + func_84200420(arg1, arg2, 0x74, 0x58, sp8C.r, sp8C.g, sp8C.b, 0xFF); + + for (var_s1 = 0; var_s1 < 6; var_s1++) { + temp_a0 = D_84211870[var_s1] + arg1; + temp_a1 = D_8421187C[var_s1] + arg2; + + func_84200420(temp_a0, temp_a1, 0x84, 0x2C, sp8C.r, sp8C.g, sp8C.b, 0xFF); + } + } + + gSPDisplayList(gDisplayListHead++, D_8006F470); + + func_8001C560(arg1, arg2 + 0x58, 0x200, 4, 0x32, 0x32, 0x32); + + gSPDisplayList(gDisplayListHead++, D_8006F518); + + if (arg3->unk_4D20 != 0) { + if (arg3->unk_4D20 > 0) { + gDPSetEnvColor(gDisplayListHead++, 255, 255, 255, 128); + } else { + gDPSetEnvColor(gDisplayListHead++, 255, 255, 255, 255); + } + func_8001C6AC(arg1 + 0x14, arg2 + 0xE, 0x4C, 0x14, D_2029CE0, 0x4C, 0); + func_8001C6AC(arg1 + 0x14, arg2 + 0x22, 0x4C, 0x14, D_202A8C0, 0x4C, 0); + func_8001C6AC(arg1 + 0x14, arg2 + 0x36, 0x4C, 0x14, D_202B4A0, 0x4C, 0); + } + + gDPSetEnvColor(gDisplayListHead++, 255, 255, 255, 255); + + for (var_s1 = 0; var_s1 < 6; var_s1++) { + if (arg3->unk_0000[var_s1].raw != 0) { + temp_s2 = D_84211870[var_s1] + arg1 + 2; + temp_s3 = D_8421187C[var_s1] + arg2 + 2; + func_8001C6AC(temp_s2, temp_s3, 0x28, 0x28, arg3->unk_0000[var_s1].unk_058, 0x28, 0); + if (arg3->unk_0000[var_s1].raw & 0x80000000) { + u8* ptr = D_84211850[arg3->unk_0000[var_s1].raw & 7]; + + func_8001CF10(temp_s2 - 4, temp_s3 - 4, 0x30, 0x30, ptr, 0x30, 0); + } + } + } + + gSPDisplayList(gDisplayListHead++, D_8006F630); + + func_8001F3F4(); + func_8001EBE0(8, 0); + func_8001F1E8(arg1 + 2, arg2 + 2, "%d", arg3->unk_4D1E + 1); + + if (arg3->unk_4D20 > 0) { + func_8001EBE0(8, 0); + func_8001F1E8(arg1 + 8, arg2 + 0x2B, &arg3->unk_4D12); + func_8001EBE0(4, 0); + func_8001F1E8(arg1 + 8, arg2 + 0x42, "ID %05d", arg3->unk_4D10); + } + + func_8001EBE0(4, 0); + + for (var_s1 = 0; var_s1 < 6; var_s1++) { + if (arg3->unk_0000[var_s1].unk_004.unk_00.unk_00 != 0) { + s16 tmp1 = D_84211870[var_s1] + arg1 + 0x2C; + s16 tmp2 = D_8421187C[var_s1] + arg2 + 5; + + func_8001F1E8(tmp1, tmp2, arg3->unk_0000[var_s1].unk_004.unk_30); + } + } + + func_8001EBE0(4, 0); + + for (var_s1 = 0; var_s1 < 6; var_s1++) { + if (arg3->unk_0000[var_s1].unk_004.unk_00.unk_00 != 0) { + temp_s2 = D_84211870[var_s1] + arg1 + 0x2C; + temp_s3 = D_8421187C[var_s1] + arg2 + 0x17; + func_8001F1E8(temp_s2, temp_s3, "%s%d", func_84200160(0x15), arg3->unk_0000[var_s1].unk_004.unk_24); + } + } + + func_8001F444(); +} + +void func_8420E46C(s16 arg0, s16 arg1) { + char* sp54 = func_84200130(D_800AE540.unk_0001 + 0x3F); + s32 sp50 = func_8001F5B0(8, 0, sp54); + + gSPDisplayList(gDisplayListHead++, D_8006F558); + + gDPSetEnvColor(gDisplayListHead++, 170, 60, 150, 255); + gDPSetPrimColor(gDisplayListHead++, 0, 0, 80, 40, 60, 255); + + func_8001CADC(arg0, arg1, 8, 0x1C, D_2000980, 8, 0); + func_8001CADC(arg0 + 0x218, arg1, 8, 0x1C, D_2000A60, 8, 0); + func_8001C330(arg0 + 4, arg1, 0x218, 0x1C, 0, 0, 0, 0x400, 0); + + gSPDisplayList(gDisplayListHead++, D_8006F630); + + func_8001F3F4(); + func_8001EBE0(8, 0); + func_8001F1E8(arg0 + 8, arg1 + 3, func_84200130(0xE)); + func_8001F1E8((arg0 - sp50) + 0x20E, arg1 + 3, sp54); + func_8001F444(); +} + +void func_8420E63C(unk_D_84229EB0* arg0) { + static s16 D_84211888 = 0; + + s16 sp66; + s16 sp64; + s16 sp62; + s16 temp_s2; + + sp62 = arg0->unk_00012 + 4; + temp_s2 = arg0->unk_00014 + 0x20; + sp64 = arg0->unk_0001C; + + gSPDisplayList(gDisplayListHead++, D_8006F470); + + func_8001C560(sp62 + 0, temp_s2, 0x18, arg0->unk_00016, 0x3C, 0x3C, 0xA0); + func_8001C560(sp62 + 0x18, temp_s2, 8, arg0->unk_00016, 0x32, 0x32, 0x32); + + if (sp64 < 3) { + sp64 = 3; + } + + if (arg0->unk_00016 == 0x110) { + if ((arg0->unk_00001 == 0xC) || (arg0->unk_00001 == 0xB)) { + if (arg0->unk_00018 > 0) { + sp66 = ((((arg0->unk_0000D * 4) + arg0->unk_00018) * 0xF8) - 0x3E0) / ((sp64 * 4) - 4); + } else { + sp66 = ((((arg0->unk_0000D * 4) + arg0->unk_00018) * 0xF8) + 0x3E0) / ((sp64 * 4) - 4); + } + } else { + sp66 = (arg0->unk_0000D * 0xF8) / (sp64 - 1); + } + + gSPDisplayList(gDisplayListHead++, D_8006F558); + gDPSetEnvColor(gDisplayListHead++, 130, 130, 220, 255); + gDPSetPrimColor(gDisplayListHead++, 0, 0, 60, 60, 150, 255); + + func_8001CADC(sp62 + 4, temp_s2 + 4, 0x10, 8, D_200A200, 0x10, 0); + func_8001CADC(sp62 + 4, temp_s2 + 0x104, 0x10, 8, D_200A280, 0x10, 0); + func_8001C330(sp62 + 4, temp_s2 + 0xC, 0x10, 0xF8, 0, 0, 0x400, 0, 0); + + gSPDisplayList(gDisplayListHead++, D_8006F518); + + if (D_84211888 < 4) { + func_8001C6AC(sp62, temp_s2 + sp66, 0x18, 0x18, D_200A300, 0x18, 0); + } else { + func_8001C6AC(sp62, temp_s2 + sp66, 0x18, 0x18, D_200A780, 0x18, 0); + } + } + + gSPDisplayList(gDisplayListHead++, D_8006F630); + + if (arg0->unk_00001 == 2) { + D_84211888 = (D_84211888 + 1) % 8; + } +} + +void func_8420EA88(unk_D_84229EB0* arg0) { + s16 sp1E = arg0->unk_00012 + 0x24; + s16 temp_a1 = arg0->unk_00014 + ((arg0->unk_0000D - arg0->unk_0000C) * 0x5C) + 0x20; + + if (arg0->unk_00001 == 0xB) { + if (arg0->unk_00018 > 0) { + temp_a1 = ((temp_a1 + ((arg0->unk_00018 * 0x5C) / 4)) - 0x5C); + } else { + temp_a1 = (temp_a1 + ((arg0->unk_00018 * 0x5C) / 4) + 0x5C); + } + func_84200738(sp1E, temp_a1, 0x200, 0x58); + } else if ((arg0->unk_00001 == 2) || (arg0->unk_00001 == 0xC)) { + func_84200738(sp1E, temp_a1, 0x200, 0x58); + } +} + +void func_8420EB7C(unk_D_84229EB0* arg0) { + s16 temp_s0 = arg0->unk_00012 + (arg0->unk_00008 * 0x84) + 0x98; + s16 temp_a1 = arg0->unk_00014 + (arg0->unk_0000A * 0x2C) + 0x20; + + if (arg0->unk_00001 == 0xA) { + if (arg0->unk_00018 > 0) { + temp_a1 = ((temp_a1 + ((arg0->unk_00018 * 0x2C) / 4)) - 0x2C); + } else { + temp_a1 = (temp_a1 + ((arg0->unk_00018 * 0x2C) / 4) + 0x2C); + } + func_84200738(temp_s0, temp_a1, 0x84, 0x2C); + } else if (arg0->unk_00001 == 9) { + if (arg0->unk_00018 > 0) { + temp_s0 = ((temp_s0 + ((arg0->unk_00018 * 0x84) / 4)) - 0x84); + } else { + temp_s0 = (temp_s0 + ((arg0->unk_00018 * 0x84) / 4) + 0x84); + } + func_84200738(temp_s0, temp_a1, 0x84, 0x2C); + } else if (arg0->unk_00001 == 8) { + func_84200738(temp_s0, temp_a1, 0x84, 0x2C); + } +} + +void func_8420ED0C(unk_D_84229EB0* arg0) { + s16 i; + s16 temp_s4; + s16 temp_s5; + s16 var_s0; + unk_D_84229EB0_00024* var_s1; + + var_s1 = arg0->unk_00024; + temp_s5 = arg0->unk_00012 + 0x24; + temp_s4 = arg0->unk_00014 + 0x20; + + var_s0 = (arg0->unk_00016 - ((arg0->unk_0000D - arg0->unk_0000C) * 0x5C)) - 0x58; + if (var_s0 > 0) { + var_s0 = 0; + } + func_800060E0(&gDisplayListHead, 0, temp_s4, 0x280, arg0->unk_00016); + + for (i = 0; i < 3; i++) { + if ((var_s0 >= -0x5B) && (var_s0 < arg0->unk_00016)) { + func_8420DD14(arg0, temp_s5, temp_s4 + var_s0, var_s1); + } + var_s0 += 0x5C; + var_s1 = var_s1->unk_4D24; + } + + func_800060E0(&gDisplayListHead, 0, 0, 0x280, 0x1E0); +} + +void func_8420EE54(unk_D_84229EB0* arg0, s32 arg1) { + UNUSED s32 pad; + s32 i; + char* temp_v0_3; + unk_D_84229EB0_00024* var_s0; + s16 tmp1; + s16 tmp2; + s16 sp42; + + tmp1 = arg0->unk_00012; + tmp2 = arg0->unk_00014; + + if ((arg0->unk_00001 != 1) && (arg0->unk_00001 != 0) && ((arg1 != 0) || (arg0->unk_00004 != 0))) { + func_842001B8(tmp1, tmp2, 0x228, arg0->unk_00016 + 0x24); + func_8420E46C(tmp1 + 4, tmp2 + 4); + func_8420E63C(arg0); + + if (arg0->unk_00001 == 0xC) { + sp42 = tmp2 - ((arg0->unk_00018 * 0x5C) / 4); + func_800060E0(&gDisplayListHead, tmp1 + 0x24, tmp2 + 0x20, 0x200, 0x110); + if (arg0->unk_0001A > 0) { + var_s0 = arg0->unk_00024->unk_4D28; + for (i = 0; i < 4; i++) { + func_8420DD14(arg0, tmp1 + 0x24, sp42 + 0x20 + i * 0x5C, var_s0); + var_s0 = var_s0->unk_4D24; + } + } else { + var_s0 = arg0->unk_00024; + for (i = 0; i < 4; i++) { + func_8420DD14(arg0, tmp1 + 0x24, sp42 - 0x3C + i * 0x5C, var_s0); + var_s0 = var_s0->unk_4D24; + } + } + func_800060E0(&gDisplayListHead, 0, 0, 0x280, 0x1E0); + } else { + func_8420ED0C(arg0); + } + + func_8420EA88(arg0); + func_8420EB7C(arg0); + + if ((arg1 != 0) && (arg0->unk_00000 == 1)) { + func_8420112C(0x38, 0x190, 0x210, 0x28, 0x1E, 0x1E, 0x82, 0x96); + func_8001F3F4(); + func_8001EBE0(0x10, 0); + temp_v0_3 = func_84200130(0x10); + func_8001F1E8(0x140 - (func_8001F5B0(0x10, 0, temp_v0_3) / 2), 0x198, temp_v0_3); + func_8001F444(); + } + + if ((arg1 != 0) && (arg0->unk_00000 == 2)) { + func_8420112C(0x38, 0x190, 0x210, 0x28, 0x64, 0x1E, 0x1E, 0x96); + func_8001F3F4(); + func_8001EBE0(0x10, 0); + temp_v0_3 = func_84200130(0x11); + func_8001F1E8(0x140 - (func_8001F5B0(0x10, 0, temp_v0_3) / 2), 0x198, temp_v0_3); + func_8001F444(); + } + + if (arg0->unk_00004 > 0) { + arg0->unk_00004--; + } + } +} + +unk_D_84229EB0_00024* func_8420F1BC(unk_D_84229EB0_00024* arg0, s32 arg1) { + while (arg1-- > 0) { + arg0 = arg0->unk_4D28; + } + + return arg0; +} + +unk_D_84229EB0_00024* func_8420F1E0(unk_D_84229EB0_00024* arg0, s32 arg1) { + while (arg1-- > 0) { + arg0 = arg0->unk_4D24; + } + + return arg0; +} + +s32 func_8420F204(unk_D_84229EB0_00024* arg0, s16 arg1) { + s16 i; + s16 var_s4; + unk_func_80022C28_ret* temp_v0; + + var_s4 = 0; + arg0->unk_4D10 = 0; + arg0->unk_4D12[0] = 0; + + for (i = 0; i < 6; i++) { + arg0->unk_0000[i].unk_004.unk_00.unk_00 = 0; + arg0->unk_0000[i].raw = 0; + } + + temp_v0 = func_80022C28(0x10, 0, arg1, 0); + if (temp_v0 != NULL) { + for (i = 0; i < 6; i++) { + var_s4 += func_80022E18(&arg0->unk_0000[i].unk_004, 1, temp_v0); + } + func_80022D8C(temp_v0); + arg0->unk_4D10 = func_80027184(0x10, arg1); + func_800272BC(0x10, arg1, arg0->unk_4D12); + } + + for (i = 0; i < var_s4; i++) { + func_8001B0DC(arg0->unk_0000[i].unk_058, 0, &arg0->unk_0000[i].unk_004); + arg0->unk_0000[i].unk_000 = 4; + arg0->unk_0000[i].unk_001 = arg1; + arg0->unk_0000[i].unk_002 = i; + arg0->unk_0000[i].unk_003 = arg0->unk_0000[i].unk_004.unk_00.unk_00; + } + + arg0->unk_4D1E = arg1; + arg0->unk_4D20 = var_s4; + + return var_s4; +} + +void func_8420F37C(unk_D_84229EB0* arg0) { + s16 temp_s1; + s16 sp34; + s16 sp32; + unk_D_84229EB0_00024* temp_v0_2; + + if (arg0->unk_00006 == 1) { + temp_s1 = arg0->unk_00008 + (arg0->unk_0000A * 3); + sp34 = arg0->unk_0000E + (arg0->unk_00008 * 0x84) + 0x94; + sp32 = arg0->unk_00010 + (arg0->unk_0000A * 0x2C) + 0x1C; + temp_v0_2 = func_8420F1E0(arg0->unk_00024, arg0->unk_0000D - arg0->unk_0000C); + if (arg0->unk_00005 == -1) { + func_8420C60C(arg0->unk_134F0, arg0->unk_00003, 0x30, 0xEC, sp34, sp32, &temp_v0_2->unk_0000[temp_s1], 0); + } else if (temp_s1 != arg0->unk_00005) { + func_8420C6D8(arg0->unk_134F0, sp34, sp32, &temp_v0_2->unk_0000[temp_s1]); + arg0->unk_00006 = 0xA; + } + arg0->unk_00005 = temp_s1; + } + + if (arg0->unk_00006 < 0xA) { + arg0->unk_00006++; + } +} + +void func_8420F4FC(unk_D_84229EB0* arg0) { + arg0->unk_00008 = 0; + arg0->unk_0000A = 0; + arg0->unk_00006 = 0; + arg0->unk_00005 = -1; + arg0->unk_00001 = 0xD; + arg0->unk_00002 = 8; +} + +void func_8420F524(unk_D_84229EB0* arg0) { + arg0->unk_00012 = arg0->unk_0000E + 0x280; + arg0->unk_00014 = arg0->unk_00010; +} + +void func_8420F53C(unk_D_84229EB0* arg0) { + arg0->unk_00006++; + if (arg0->unk_00006 == 0xA) { + arg0->unk_00001 = 2; + arg0->unk_00006 = 0; + arg0->unk_00012 = arg0->unk_0000E; + } else { + arg0->unk_00012 = (arg0->unk_0000E - (arg0->unk_00006 << 6)) + 0x280; + } + arg0->unk_00014 = arg0->unk_00010; + arg0->unk_00004 = 2; +} + +void func_8420F598(unk_D_84229EB0* arg0) { + arg0->unk_00006++; + if (arg0->unk_00006 == 0xA) { + arg0->unk_00001 = 0; + arg0->unk_00006 = 0; + arg0->unk_00012 = arg0->unk_0000E + 0x280; + } else { + arg0->unk_00012 = arg0->unk_0000E - (arg0->unk_00006 << 6); + } + arg0->unk_00014 = arg0->unk_00010; + arg0->unk_00004 = 2; +} + +void func_8420F5F0(unk_D_84229EB0* arg0) { + arg0->unk_00006++; + if (arg0->unk_00006 == 0x14) { + arg0->unk_00001 = 0x11; + arg0->unk_00006 = 0; + arg0->unk_00012 = arg0->unk_0000E; + } else { + arg0->unk_00012 = (arg0->unk_0000E - (arg0->unk_00006 << 5)) + 0x280; + } + arg0->unk_00016 = 0x58; + arg0->unk_00014 = arg0->unk_00010; + arg0->unk_00004 = 2; +} + +void func_8420F654(unk_D_84229EB0* arg0) { + unk_D_84229EB0_00024* sp24; + + if (arg0->unk_0001E == 0) { + if ((arg0->unk_0000D - arg0->unk_0000C) > 0) { + arg0->unk_0000D--; + arg0->unk_00018 = -1; + arg0->unk_0001A = -4; + arg0->unk_00002 = 2; + arg0->unk_00001 = 0xB; + func_80048B90(1); + } else if (arg0->unk_0000C > 0) { + sp24 = func_8420F1BC(arg0->unk_00024, 1); + func_80048B90(1); + func_8420F204(sp24, arg0->unk_0000D - 1); + arg0->unk_0000C -= 1; + arg0->unk_0000D -= 1; + arg0->unk_00024 = arg0->unk_00024->unk_4D28; + arg0->unk_00018 = -1; + arg0->unk_0001A = -4; + arg0->unk_00002 = 2; + arg0->unk_00001 = 0xC; + } + arg0->unk_0001E = arg0->unk_0001F; + arg0->unk_0001F = 2; + } +} + +void func_8420F754(unk_D_84229EB0* arg0) { + if (arg0->unk_0001E == 0) { + if ((arg0->unk_0000D - arg0->unk_0000C) < 2) { + arg0->unk_0000D++; + arg0->unk_00018 = 1; + arg0->unk_0001A = 4; + arg0->unk_00002 = 2; + arg0->unk_00001 = 0xB; + func_80048B90(1); + } else if ((arg0->unk_0000C < 7) && + ((func_8420F204(func_8420F1E0(arg0->unk_00024, 3), arg0->unk_0000D + 1) != 0) || + (arg0->unk_00000 != 0))) { + func_80048B90(1); + arg0->unk_0000C += 1; + arg0->unk_0000D += 1; + arg0->unk_00024 = arg0->unk_00024->unk_4D24; + arg0->unk_00018 = 1; + arg0->unk_0001A = 4; + arg0->unk_00002 = 2; + arg0->unk_00001 = 0xC; + } + arg0->unk_0001E = arg0->unk_0001F; + arg0->unk_0001F = 2; + } +} + +void func_8420F86C(unk_D_84229EB0* arg0) { + Controller* cont = &gControllers[arg0->unk_00003]; + unk_D_84229EB0_00024* temp_v0 = func_8420F1E0(arg0->unk_00024, arg0->unk_0000D - arg0->unk_0000C); + + if (BTN_IS_PRESSED(cont, BTN_A)) { + if (temp_v0->unk_0000[0].unk_004.unk_00.unk_00 != 0) { + func_80048B90(2); + + switch (arg0->unk_00000) { + case 0: + arg0->unk_00001 = 5; + break; + + case 1: + func_8420F4FC(arg0); + break; + + case 2: + arg0->unk_00001 = 6; + break; + } + } else { + func_80048B90(8); + } + } else if (BTN_IS_PRESSED(cont, BTN_B)) { + func_80048B90(3); + arg0->unk_00020 = 1; + arg0->unk_00006 = 0; + arg0->unk_00001 = 4; + } else if (BTN_IS_DOWN(cont, BTN_DUP)) { + func_8420F654(arg0); + } else if (BTN_IS_DOWN(cont, BTN_DDOWN)) { + func_8420F754(arg0); + } else { + arg0->unk_0001F = 8; + arg0->unk_0001E = 0; + } + arg0->unk_00012 = arg0->unk_0000E; + arg0->unk_00014 = arg0->unk_00010; + arg0->unk_00004 = 2; +} + +void func_8420F9C8(unk_D_84229EB0* arg0) { + if (arg0->unk_00008 > 0) { + unk_D_84229EB0_00024* ptr = func_8420F1E0(arg0->unk_00024, arg0->unk_0000D - arg0->unk_0000C); + s32 idx = ((arg0->unk_0000A * 3) + arg0->unk_00008) - 1; + + if (ptr->unk_0000[idx].unk_004.unk_00.unk_00 != 0) { + arg0->unk_00008 = arg0->unk_00008 - 1; + arg0->unk_00018 = -1; + arg0->unk_0001A = -4; + arg0->unk_00006 = 0; + arg0->unk_00002 = 8; + arg0->unk_00001 = 9; + func_80048B90(1); + } + } +} + +void func_8420FA88(unk_D_84229EB0* arg0) { + if (arg0->unk_00008 < 2) { + unk_D_84229EB0_00024* ptr = func_8420F1E0(arg0->unk_00024, arg0->unk_0000D - arg0->unk_0000C); + s32 idx = ((arg0->unk_0000A * 3) + arg0->unk_00008) + 1; + + if (ptr->unk_0000[idx].unk_004.unk_00.unk_00 != 0) { + arg0->unk_00008++; + arg0->unk_00018 = 1; + arg0->unk_0001A = 4; + arg0->unk_00006 = 0; + arg0->unk_00002 = 8; + arg0->unk_00001 = 9; + func_80048B90(1); + } + } +} + +void func_8420FB4C(unk_D_84229EB0* arg0) { + if (arg0->unk_0000A > 0) { + unk_D_84229EB0_00024* ptr = func_8420F1E0(arg0->unk_00024, arg0->unk_0000D - arg0->unk_0000C); + s32 idx = ((arg0->unk_0000A * 3) + arg0->unk_00008) - 3; + + if (ptr->unk_0000[idx].unk_004.unk_00.unk_00 != 0) { + arg0->unk_0000A--; + arg0->unk_00018 = -1; + arg0->unk_0001A = -4; + arg0->unk_00006 = 0; + arg0->unk_00002 = 8; + arg0->unk_00001 = 0xA; + func_80048B90(1); + } + } +} + +void func_8420FC0C(unk_D_84229EB0* arg0) { + if (arg0->unk_0000A <= 0) { + unk_D_84229EB0_00024* ptr = func_8420F1E0(arg0->unk_00024, arg0->unk_0000D - arg0->unk_0000C); + s32 idx = ((arg0->unk_0000A * 3) + arg0->unk_00008) + 3; + + if (ptr->unk_0000[idx].unk_004.unk_00.unk_00 != 0) { + arg0->unk_0000A = arg0->unk_0000A + 1; + arg0->unk_00018 = 1; + arg0->unk_0001A = 4; + arg0->unk_00006 = 0; + arg0->unk_00002 = 8; + arg0->unk_00001 = 0xA; + func_80048B90(1); + } + } +} + +void func_8420FCCC(unk_D_84229EB0* arg0) { + Controller* cont = &gControllers[arg0->unk_00003]; + + func_8420F37C(arg0); + + if (arg0->unk_00006 == 0xA) { + if (func_8420C788(arg0->unk_134F0) != 0) { + if (arg0->unk_00000 == 2) { + arg0->unk_00002 = 6; + } else { + arg0->unk_00002 = 2; + } + arg0->unk_00001 = 0xE; + } else if (BTN_IS_PRESSED(cont, BTN_DUP)) { + func_8420FB4C(arg0); + } else if (BTN_IS_PRESSED(cont, BTN_DDOWN)) { + func_8420FC0C(arg0); + } else if (BTN_IS_PRESSED(cont, BTN_DRIGHT)) { + func_8420FA88(arg0); + } else if (BTN_IS_PRESSED(cont, BTN_DLEFT)) { + func_8420F9C8(arg0); + } + } + arg0->unk_00012 = arg0->unk_0000E; + arg0->unk_00014 = arg0->unk_00010; + arg0->unk_00004 = 2; +} + +void func_8420FDDC(unk_D_84229EB0* arg0) { + if (arg0->unk_0001A > 0) { + arg0->unk_00018++; + if (arg0->unk_00018 >= arg0->unk_0001A) { + arg0->unk_00001 = arg0->unk_00002; + } + } else { + arg0->unk_00018--; + if (arg0->unk_0001A >= arg0->unk_00018) { + arg0->unk_00001 = arg0->unk_00002; + } + } + arg0->unk_00012 = arg0->unk_0000E; + arg0->unk_00014 = arg0->unk_00010; + arg0->unk_00004 = 2; +} + +void func_8420FE50(unk_D_84229EB0* arg0) { + if (arg0->unk_00016 == 0x58) { + if (arg0->unk_00006 == 0) { + arg0->unk_00001 = arg0->unk_00002; + } else { + arg0->unk_00006--; + } + } else { + arg0->unk_00016 -= 0x2E; + } + arg0->unk_00004 = 2; +} + +void func_8420FE90(unk_D_84229EB0* arg0) { + arg0->unk_00016 += 0x2E; + if (arg0->unk_00016 == 0x110) { + arg0->unk_00001 = arg0->unk_00002; + } + arg0->unk_00004 = 2; +} + +void func_8420FEC0(unk_D_84229EB0* arg0) { + s16 sp26 = 4; + + if ((arg0->unk_0000D - arg0->unk_0000C) == 2) { + sp26 = 5; + } + + func_8420DA28(sp26, &gControllers[arg0->unk_00003]); + + switch (func_8420DB48(sp26)) { + case 0: + arg0->unk_00001 = 2; + break; + + case 1: + arg0->unk_00006 = 8; + arg0->unk_00001 = 0xD; + arg0->unk_00002 = 4; + break; + + case 2: + arg0->unk_00001 = 2; + break; + + case 3: + func_8420F4FC(arg0); + break; + } + + arg0->unk_00012 = arg0->unk_0000E; + arg0->unk_00014 = arg0->unk_00010; +} + +void func_8420FFB0(unk_D_84229EB0* arg0) { + s16 sp26 = 6; + + if ((arg0->unk_0000D - arg0->unk_0000C) == 2) { + sp26 = 7; + } + + func_8420DA28(sp26, &gControllers[arg0->unk_00003]); + + switch (func_8420DB48(sp26)) { + case 0: + arg0->unk_00001 = 2; + break; + + case 1: + arg0->unk_00006 = 0; + arg0->unk_00001 = 0xD; + arg0->unk_00002 = 0xF; + break; + + case 2: + func_8420F4FC(arg0); + break; + + case 3: + arg0->unk_00001 = 2; + break; + } + + arg0->unk_00012 = arg0->unk_0000E; + arg0->unk_00014 = arg0->unk_00010; +} + +void func_8421009C(unk_D_84229EB0* arg0) { + s32 sp24; + + if (func_80028E68() == 0) { + sp24 = 0x13; + } else { + sp24 = 9; + } + + func_8420DA28(sp24, &gControllers[arg0->unk_00003]); + + switch (func_8420DB48(sp24)) { + case 1: + arg0->unk_00006 = 0; + arg0->unk_00001 = 0xE; + arg0->unk_00002 = 0x13; + break; + + case 0: + case 2: + arg0->unk_00006 = 0; + arg0->unk_00001 = 4; + break; + } + + arg0->unk_00012 = arg0->unk_0000E; + arg0->unk_00014 = arg0->unk_00010; +} + +void func_8421015C(unk_D_84229EB0* arg0) { + unk_D_84229EB0_00024* temp_v0; + s16 temp_hi; + s16 temp_lo; + + temp_v0 = func_8420F1E0(arg0->unk_00024, arg0->unk_0000D - arg0->unk_0000C); + temp_lo = arg0->unk_00006 / 12; + temp_hi = arg0->unk_00006 % 12; + + if (temp_lo < temp_v0->unk_4D20) { + if (temp_hi < 8) { + temp_v0->unk_0000[temp_lo].raw = temp_hi + 0x80000000; + } else { + temp_v0->unk_0000[temp_lo].raw = 1; + } + + if (temp_hi == 4) { + temp_v0->unk_0000[temp_lo].unk_004.unk_00.unk_00 = 0; + func_8001B0DC(temp_v0->unk_0000[temp_lo].unk_058, 0x84, NULL); + func_80048B90(0x01100010); + } + } + + if (((temp_v0->unk_4D20 * 0xC) - 1) >= arg0->unk_00006) { + if (arg0->unk_00006 == ((temp_v0->unk_4D20 * 0xC) - 1)) { + temp_v0->unk_4D20 = -1; + func_8420DC78(temp_v0); + func_8420DA28(8, &gControllers[arg0->unk_00003]); + } + arg0->unk_00006 += 1; + } else if (func_8420DB48(8) >= 0) { + arg0->unk_00001 = 7; + } + + arg0->unk_00012 = arg0->unk_0000E; + arg0->unk_00014 = arg0->unk_00010; + arg0->unk_00004 = 2; +} + +void func_84210328(unk_D_84229EB0* arg0) { + s32 i; + unk_D_84229EB0_00024* temp_a3; + s16 temp_hi; + s16 temp_lo; + unk_D_84229EB0_00024* temp_v0; + + temp_a3 = arg0->unk_00024; + temp_v0 = temp_a3->unk_4D24; + + temp_lo = arg0->unk_00006 / 12; + temp_hi = arg0->unk_00006 % 12; + + if (arg0->unk_00006 == 0) { + temp_a3->unk_4D20 = 0; + for (i = 0; i < 6; i++) { + if (temp_v0->unk_0000[i].unk_004.unk_00.unk_00 != 0) { + temp_a3->unk_4D20++; + } + } + } + + if (temp_lo < temp_a3->unk_4D20) { + if (temp_hi < 8) { + temp_a3->unk_0000[temp_lo].raw = temp_hi + 0x80000000; + } else { + temp_a3->unk_0000[temp_lo].raw = temp_v0->unk_0000[temp_lo].raw; + } + + if (temp_hi == 4) { + temp_a3->unk_0000[temp_lo].unk_004.unk_00.unk_00 = temp_v0->unk_0000[temp_lo].unk_004.unk_00.unk_00; + _bcopy(temp_v0->unk_0000[temp_lo].unk_058, temp_a3->unk_0000[temp_lo].unk_058, + sizeof(temp_v0->unk_0000[temp_lo].unk_058)); + func_80048B90(0x01100010); + } + } + + if ((temp_a3->unk_4D20 * 0xC) - 1 >= arg0->unk_00006) { + if (arg0->unk_00006 == (temp_a3->unk_4D20 * 0xC) - 1) { + func_8420DBA0(temp_a3); + func_8420DA28(0xB, &gControllers[arg0->unk_00003]); + } + arg0->unk_00006++; + } else if (func_8420DB48(0xB) >= 0) { + if (func_80028E68() >= 0xA) { + func_842079F0(arg0->unk_134E8); + arg0->unk_00006 = 0; + arg0->unk_00001 = 4; + } else { + arg0->unk_00001 = 0x12; + } + } + + arg0->unk_00012 = arg0->unk_0000E; + arg0->unk_00014 = arg0->unk_00010; + arg0->unk_00004 = 2; +} + +void func_8421059C(unk_D_84229EB0* arg0) { + func_8420DA28(0xC, &gControllers[arg0->unk_00003]); + + switch (func_8420DB48(0xC)) { + case 1: + func_84207A1C(arg0->unk_134E8); + func_8420B20C(arg0->unk_134EC); + arg0->unk_00006 = 0; + arg0->unk_00001 = 4; + break; + + case 0: + case 2: + func_842079F0(arg0->unk_134E8); + arg0->unk_00006 = 0; + arg0->unk_00001 = 4; + break; + } + + arg0->unk_00012 = arg0->unk_0000E; + arg0->unk_00014 = arg0->unk_00010; +} + +void func_84210668(unk_D_84229EB0* arg0) { + s32 i; + unk_D_84229EB0_00024* var_s1; + + arg0->unk_00006++; + + if (arg0->unk_00006 == 4) { + var_s1 = arg0->unk_00024; + for (i = 0; i < 3; i++) { + func_8420F204(var_s1, arg0->unk_0000C + i); + var_s1 = var_s1->unk_4D24; + } + + arg0->unk_00004 = 2; + arg0->unk_00006 = 0; + arg0->unk_00001 = 2; + } +} + +s32 func_842106FC(unk_D_84229EB0* arg0) { + s32 sp1C = 0; + + if (arg0->unk_0001E > 0) { + arg0->unk_0001E--; + } + + switch (arg0->unk_00001) { + case 0: + func_8420F524(arg0); + break; + + case 1: + func_8420F524(arg0); + break; + + case 2: + func_8420F86C(arg0); + break; + + case 3: + func_8420F53C(arg0); + sp1C = 1; + break; + + case 4: + func_8420F598(arg0); + sp1C = 1; + break; + + case 8: + func_8420FCCC(arg0); + break; + + case 9: + func_8420FDDC(arg0); + break; + + case 10: + func_8420FDDC(arg0); + break; + + case 12: + func_8420FDDC(arg0); + break; + + case 11: + func_8420FDDC(arg0); + break; + + case 5: + func_8420FEC0(arg0); + break; + + case 6: + func_8420FFB0(arg0); + break; + + case 7: + func_8421009C(arg0); + break; + + case 13: + func_8420FE50(arg0); + sp1C = 1; + break; + + case 14: + func_8420FE90(arg0); + sp1C = 1; + break; + + case 15: + func_8421015C(arg0); + break; + + case 16: + func_8420F5F0(arg0); + sp1C = 1; + break; + + case 17: + func_84210328(arg0); + break; + + case 18: + func_8421059C(arg0); + break; + + case 19: + func_84210668(arg0); + break; + } + return sp1C; +} + +s32 func_8421089C(unk_D_84229EB0* arg0, unk_D_84211B50* arg1, unk_D_842168A0* arg2, unk_D_8423D3A8* arg3, s16 arg4, + s16 arg5, s16 arg6, s16 arg7) { + s32 i; + + arg0->unk_00000 = arg4; + arg0->unk_00001 = 1; + arg0->unk_00003 = arg7; + arg0->unk_00006 = 0; + arg0->unk_0000C = 0; + arg0->unk_0000D = 0; + arg0->unk_00008 = 0; + arg0->unk_0000A = 0; + arg0->unk_0000E = arg5; + arg0->unk_00010 = arg6; + arg0->unk_00012 = arg5 + 0x280; + arg0->unk_00014 = arg6; + arg0->unk_00016 = 0x110; + arg0->unk_0001C = 0xA; + arg0->unk_0001E = 0; + arg0->unk_0001F = 8; + arg0->unk_134E8 = arg1; + arg0->unk_134EC = arg2; + arg0->unk_134F0 = arg3; + arg0->unk_00024 = arg0->unk_00028; + + for (i = 0; i < 4; i++) { + arg0->unk_00028[i].unk_4D24 = &arg0->unk_00028[(i + 1) & 3]; + arg0->unk_00028[i].unk_4D28 = &arg0->unk_00028[(i - 1) & 3]; + } + + if (arg4 != 3) { + if (arg4 != 4) { + for (i = 0; i < 3; i++) { + func_8420F204(&arg0->unk_00028[i], arg0->unk_0000C + i); + } + } + } + + if (arg0->unk_00000 == 0) { + arg0->unk_0001C = func_80028E68(); + } + return 4; +} + +s32 func_84210A18(unk_D_84229EB0* arg0) { + if (arg0->unk_00001 != 1) { + return 0; + } + arg0->unk_00020 = 0; + arg0->unk_00006 = 0; + arg0->unk_00001 = 3; + return 1; +} + +s32 func_84210A48(unk_D_84229EB0* arg0, u16 arg1, char* arg2, unk_D_838067F0_0168_0000* arg3) { + unk_D_84229EB0_00024* ptr = arg0->unk_00028; + s16 i; + + _bcopy(arg3, &arg0->unk_00028[0], sizeof(unk_D_838067F0_0168_0000) * 6); + _bcopy(arg3, &arg0->unk_00028[1], sizeof(unk_D_838067F0_0168_0000) * 6); + ptr->unk_4D1E = func_80028E68(); + ptr->unk_4D20 = -1; + ptr->unk_4D10 = arg1; + HAL_Strcpy(ptr->unk_4D12, arg2); + + for (i = 0; i < 6; i++) { + if (ptr->unk_0000[i].unk_004.unk_00.unk_00 != 0) { + ptr->unk_0000[i].unk_004.unk_00.unk_00 = 0; + ptr->unk_0000[i].raw = 1; + func_8001B0DC(ptr->unk_0000[i].unk_058, 0x84, NULL); + } else { + ptr->unk_0000[i].raw = 0; + } + } + + arg0->unk_00006 = 0; + arg0->unk_00001 = 0x10; + return 1; +} + +s32 func_84210B54(unk_D_84229EB0* arg0) { + return arg0->unk_00001 == 0; +} + +s32 func_84210B60(unk_D_84229EB0* arg0, unk_D_84229EB0_00024** arg1) { + s32 i; + s16 var_t0 = 0; + + *arg1 = NULL; + + if (arg0->unk_00020 == 0) { + *arg1 = func_8420F1E0(arg0->unk_00024, arg0->unk_0000D - arg0->unk_0000C); + var_t0 = (*arg1)->unk_4D20; + + for (i = 0; i < 6; i++) { + (*arg1)->unk_0000[i].unk_004.unk_52 = 0x40; + (*arg1)->unk_0000[i].unk_004.unk_53 = arg0->unk_0000D; + } + } + return var_t0; +} + +void func_84210C80(unk_D_84229EB0* arg0, s16 arg1) { + s32 tmp; + + arg0->unk_0000D = arg1; + if (arg0->unk_0001C < 4) { + arg0->unk_0000C = 0; + } else { + tmp = arg0->unk_0001C - 3; + if (arg1 < tmp) { + arg0->unk_0000C = arg1; + } else { + arg0->unk_0000C = tmp; + } + } + + for (arg1 = 0; arg1 < 3; arg1++) { + func_8420F204(&arg0->unk_00028[arg1], arg0->unk_0000C + arg1); + } +} diff --git a/src/fragments/62/fragment62_2F1D60.c b/src/fragments/62/fragment62_2F1D60.c index ff8e98b..35eaa1e 100644 --- a/src/fragments/62/fragment62_2F1D60.c +++ b/src/fragments/62/fragment62_2F1D60.c @@ -16,6 +16,8 @@ #pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2F1D60/func_843075D0.s") +void func_84307630(void) {} + #pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2F1D60/func_84307638.s") #pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/62/fragment62_2F1D60/func_84307748.s") diff --git a/tools/data2c.py b/tools/data2c.py index da52e26..41c6b9d 100755 --- a/tools/data2c.py +++ b/tools/data2c.py @@ -590,7 +590,8 @@ def dump_data(offset, struct, counts): for count in member["counts"]: for i in range(count): if member["type"] in STRUCTS: - out = output_struct(data, member["type"], out, offset + member["offset"], indent + (" " * i)) + #print(f"Reading {member['type']} from offset {offset + member['offset']} with size {STRUCTS[member['type']]['size']}") + out = output_struct(data, member["type"], out, offset + member["offset"] + (i * STRUCTS[member['type']]['size']), indent + (" " * i)) else: base_size = BASE_TYPES[member["type"]] out = output_type(member["type"], base_size, offset + member["offset"] + (i * base_size), out) @@ -657,11 +658,13 @@ def dump_data(offset, struct, counts): ####################################################################### parse_structs() -#for s in STRUCTS: -# if "unk_D_83407B00" in s: -# print(s) -#exit() calc_struct_sizes() +# for s in STRUCTS: +# if "unk_D_842115F0" in s or "Color_RGB" in s: +# print(s) +# print(f"\t\t{STRUCTS[s]}") +# print() +# exit() #print(f"{len(STRUCTS)} structs parsed in") def dump(offset, type_name): diff --git a/yamls/us/rom.yaml b/yamls/us/rom.yaml index 43c21b2..13ee745 100644 --- a/yamls/us/rom.yaml +++ b/yamls/us/rom.yaml @@ -2100,16 +2100,29 @@ - [0x2DD710, c, fragments/61/fragment61_2DD710] - [0x2DFB60, c, fragments/61/fragment61_2DFB60] - [0x2E2C20, c, fragments/61/fragment61_2E2C20] - - [0x2E85D0, data, fragments/61/fragment61_data] - - [0x2E9120, rodata, fragments/61/fragment61_rodata_2E9120] - - [0x2E9150, rodata, fragments/61/fragment61_rodata_2E9150] - - [0x2E91D0, rodata, fragments/61/fragment61_rodata_2E91D0] - - [0x2E9250, rodata, fragments/61/fragment61_rodata_2E9250] - - [0x2E92B0, rodata, fragments/61/fragment61_rodata_2E92B0] - - [0x2E92E0, rodata, fragments/61/fragment61_rodata_2E92E0] - - [0x2E9350, rodata, fragments/61/fragment61_rodata_2E9350] + - [0x2E4040, c, fragments/61/fragment61_2E4040] + - [0x2E5430, c, fragments/61/fragment61_2E5430] - - {vram: 0x84211B30, type: bss, name: fragments/61/fragment61_bss} + - [0x2E85D0, .data, fragments/61/fragment61_2D78B0] + - [0x2E8630, .data, fragments/61/fragment61_2DB900] + - [0x2E8E40, .data, fragments/61/fragment61_2DD710] + - [0x2E8E60, .data, fragments/61/fragment61_2DFB60] + - [0x2E8E80, .data, fragments/61/fragment61_2E2C20] + - [0x2E8F90, .data, fragments/61/fragment61_2E4040] + - [0x2E90E0, .data, fragments/61/fragment61_2E5430] + + - [0x2E9120, .rodata, fragments/61/fragment61_2D78B0] + - [0x2E9150, .rodata, fragments/61/fragment61_2DB900] + - [0x2E91D0, .rodata, fragments/61/fragment61_2DD710] + - [0x2E9250, .rodata, fragments/61/fragment61_2DFB60] + - [0x2E92B0, .rodata, fragments/61/fragment61_2E2C20] + - [0x2E92E0, .rodata, fragments/61/fragment61_2E4040] + - [0x2E9350, .rodata, fragments/61/fragment61_2E5430] + + - {vram: 0x84211B30, type: .bss, name: fragments/61/fragment61_2D78B0} + - {vram: 0x8423D400, type: .bss, name: fragments/61/fragment61_2DB900} + - {vram: 0x8423E580, type: .bss, name: fragments/61/fragment61_2E4040} + - name: fragment61_relocs type: code