diff --git a/config/overlays.mk b/config/overlays.mk index 0ed8d7827d..3ae4de427b 100644 --- a/config/overlays.mk +++ b/config/overlays.mk @@ -4993,7 +4993,7 @@ ov_MAIN_012_ELF := $(ov_MAIN_012_OUT).elf ov_MAIN_012_MAPFILE := $(ov_MAIN_012_OUT).map ov_MAIN_012_LD_SCRIPT := $(ov_MAIN_012_OUT).ld ov_MAIN_012_SPLAT_YAML := config/splat.ov_MAIN_012.yaml -ov_MAIN_012_JTBL_INTERLEAVE := --order tail.data.o,ov_MAIN_012.o,ov_MAIN_012_jr_80131340.o,tail2.data.o,ov_MAIN_012_jr_80135A4C.o,tail3.data.o,ov_MAIN_012_jr_80135EB0.o,tail4.data.o,ov_MAIN_012_jr_801380E0.o,ov_MAIN_012_o0c.o,tail5.data.o,ov_MAIN_012_jr_8013F350.o,tail6.data.o,ov_MAIN_012_jr_801549F8.o,ov_MAIN_012_jr_801555F4.o,tail7.data.o,ov_MAIN_012_jr_801594E8.o,ov_MAIN_012_jr_80159C84.o,tail8.data.o,ov_MAIN_012_jr_8015A3C8.o,tail9.data.o,ov_MAIN_012_jr_8016AB6C.o,ov_MAIN_012_jr_8016AE5C.o,tail10.data.o,ov_MAIN_012_jr_80171B4C.o,tail11.data.o,ov_MAIN_012_jr_801789AC.o,tail12.data.o,ov_MAIN_012_jr_8017C3BC.o,tail13.data.o,ov_MAIN_012_jr_8017CA18.o,tail14.data.o,ov_MAIN_012_jr_8017CF3C.o,tail15.data.o,trailing.o # Phase-26 §8 jtbl-rodata carve +ov_MAIN_012_JTBL_INTERLEAVE := --order tail.data.o,ov_MAIN_012.o,ov_MAIN_012_jr_80131340.o,tail2.data.o,ov_MAIN_012_jr_80135A4C.o,tail3.data.o,ov_MAIN_012_jr_80135EB0.o,tail4.data.o,ov_MAIN_012_jr_801380E0.o,ov_MAIN_012_o0c.o,tail5.data.o,ov_MAIN_012_jr_8013F350.o,tail6.data.o,ov_MAIN_012_jr_8015444C.o,tail7.data.o,ov_MAIN_012_jr_801549F8.o,ov_MAIN_012_jr_801555F4.o,tail8.data.o,ov_MAIN_012_jr_801594E8.o,ov_MAIN_012_jr_80159C84.o,tail9.data.o,ov_MAIN_012_jr_8015A3C8.o,tail10.data.o,ov_MAIN_012_jr_8016AB6C.o,ov_MAIN_012_jr_8016AE5C.o,tail11.data.o,ov_MAIN_012_jr_80171B4C.o,tail12.data.o,ov_MAIN_012_jr_801789AC.o,tail13.data.o,ov_MAIN_012_jr_8017C3BC.o,tail14.data.o,ov_MAIN_012_jr_8017CA18.o,tail15.data.o,ov_MAIN_012_jr_8017CF3C.o,tail16.data.o,trailing.o # Phase-26 §8 jtbl-rodata carve build/src/ov_MAIN_012/ov_MAIN_012.o: JTBL_PADS := 0,0,0 # §8e pads (jtbl_carve.py) tables=+0x0,+0x14,+0xdc build/src/ov_MAIN_012/ov_MAIN_012_jr_80131340.o: JTBL_PADS := 0,0,4 # §8e pads (jtbl_carve.py) tables=+0x0,+0x14,+0x2c build/src/ov_MAIN_012/ov_MAIN_012_jr_80135A4C.o: JTBL_PADS := 0,4 # §8e pads (jtbl_carve.py) tables=+0x0,+0x18 diff --git a/src/md_SC03_076/md_SC03_076.c b/src/md_SC03_076/md_SC03_076.c index 5514e97595..34e3abdc48 100644 --- a/src/md_SC03_076/md_SC03_076.c +++ b/src/md_SC03_076/md_SC03_076.c @@ -295,9 +295,369 @@ INCLUDE_RODATA("asm/md_SC03_076/nonmatchings/md_SC03_076", D_801EF468); INCLUDE_RODATA("asm/md_SC03_076/nonmatchings/md_SC03_076", D_801EF540); -INCLUDE_ASM("asm/md_SC03_076/nonmatchings/md_SC03_076", func_801EFBB4); +s32 func_801EFBB4(void) { + extern s16 D_80115126; + extern s16 D_8011512C; + extern s16 D_801F9AB8; + extern s16 D_801F9ABC; + extern s16 D_801F9AC0; + extern s16 func_8014168C(s16 a0); + extern s32 D_801F3248; + extern s32 D_801F32E0; + extern s32 D_801F3380; + extern s32 D_801F9DA0; + extern s32 D_801F9DA4; + extern s32 func_80014ED4(s32); + extern s32 func_80015018(s32); + extern void func_8002AF18(void); + extern u16 D_8011511A; + extern s16 D_80115118; + extern s32 D_801F9AC4; + extern u8 D_801F9DAB[]; + extern u8 D_801F9DB1; + extern void func_8002AF70(void *, u32); + extern s32 func_8002D4C8(s32, s32); + extern void func_801F1710(void); + extern void func_801F1738(s32); + + s32 *p; + s32 *p2; + u16 *ph; + s16 *q; + s32 pad; + s32 flag; + s32 st; + s32 t; + s32 t2; + s32 sv; + s32 x; + s32 r; + s32 unused[4]; + + flag = 0; + pad = func_80014ED4(0); + func_80015018(0); + func_8014168C(D_8011511A); + + if (pad & 0x40) { + st = D_8011512C; + switch (st) { + case 1: + if (D_80115126 == 0) { + if (D_801F9DAB[D_8011511A] == 1) { + D_801F32E0 = 0x19; + } else { + func_8002D4C8(0x472, 0); + return 0; + } + } else if (D_801F9DAB[D_8011511A] == 1) { + D_801F32E0 = 0x16; + } else { + D_801F32E0 = 0x19; + } + D_8011512C = 2; + func_8002D4C8(0x45D, 0); + return 0; + case 2: + func_801F1710(); + if (D_80115126 == 0) { + D_801F3380 = 0x14; + D_801F9DA0 = 2; + D_801F9DA4 = D_8011511A - 1; + } else { + D_801F9DA4 = D_8011511A - 1; + func_801F1738(1); + func_8002AF70(&D_801F9AC4, D_801F9DA4); + D_801F3380 = 0xE; + D_801F9DA0 = 1; + } + D_8011512C = 3; + func_8002D4C8(0x45D, 0); + return 0; + case 4: + case 7: + Lcheck47: + ph = (u16 *)&D_80115118; + if (*ph < 0x47) { + goto Lreset; + } + return 0; + case 9: + p = &D_801F32E0; + if (*p == 0x1D || *p == 0x21) { + goto Lmsg473ret1; + } + D_801F9AB8 = 0; + D_801F9AC0 = 1; + D_8011512C = 0; + *p = D_801F3248; + func_8002D4C8(0x45D, 0); + return 0; + case 5: + goto Lload; + case 0: + case 3: + case 6: + case 8: + case 10: + case 11: + case 12: + break; + default: + goto Ltail; + } + return 0; + } else if (pad & 0x10) { + st = D_8011512C; + switch (st) { + case 0: + if (D_801F32E0 != 0xB) { + return 0; + } + /* fallthrough */ + case 1: + Lmsg473: + func_8002D4C8(0x473, 0); + t = D_801F9ABC; + sv = t; + if (t == 0) { + return 1; + } + x = (t == 1) ? 0x1D : 0x21; + r = 0; + t = 9; + D_8011512C = t; + D_801F32E0 = x; + t = 0xFF; + goto Lstore; + case 2: + if (D_80115126 == 0) { + D_801F32E0 = 0xC; + } else { + D_801F32E0 = 0xD; + } + D_8011512C = 1; + func_8002D4C8(0x473, 0); + return 0; + case 5: + case 8: + if (D_80115126 != 0) { + goto Lmsg473; + } + Lmsg473ret1: + func_8002D4C8(0x473, 0); + return 1; + case 9: + p2 = &D_801F32E0; + if (*p2 == 0x1D || *p2 == 0x21) { + if (D_801F9AC0 == 0) { + *p2 = 0x1A; + func_8002D4C8(0x45D, 0); + return 0; + } + D_801F9AB8 = 0; + D_8011512C = 0; + *p2 = D_801F3248; + func_8002AF18(); + func_8002D4C8(0x45D, 0); + return 0; + } + *p2 = (D_801F9ABC == 1) ? 0x1D : 0x21; + func_8002D4C8(0x473, 0); + return 0; + case 4: + case 7: + goto Lcheck47; + case 3: + case 6: + case 10: + case 11: + case 12: + break; + default: + goto Ltail; + } + return 0; + } else if (pad & 0x20) { + st = D_8011512C; + if (st == 5) { + D_801F3380 = 0x17; + D_8011512C = 6; + func_8002D4C8(0x45D, 0); + D_801F9DA0 = 3; + return 0; + } + goto Ltail; + } +Lload: + st = D_8011512C; +Ltail: + if (st == 4 || st == 7 || st >= 10) { + ph = (u16 *)&D_80115118; + if (*ph != 0) { + *ph = *ph - 1; + goto Lmid; + } + Lreset: + D_80115118 = 0; + if (D_80115126 == 0) { + if (D_8011512C == 4) { + return -1; + } + D_801F32E0 = 0xC; + } else { + t2 = D_801F9ABC; + sv = t2; + if (t2 != 0 && D_8011512C == 4) { + t = (t2 == 1) ? 0x1D : 0x21; + r = 0; + D_801F32E0 = t; + t = 9; + D_8011512C = t; + t = 0xFF; + Lstore: + D_801F9AB8 = sv; + D_801F9DB1 = t; + return r; + } + D_801F32E0 = 0xD; + q = &D_8011512C; + if (*q == 0xC) { + *q = 1; + return 0; + } + } + D_8011512C = 1; + return 0; + } +Lmid: + if (D_8011512C != 1) { + return 0; + } + if (pad & 0x1000) { + t = D_8011511A; + D_8011511A = t - 2; + flag = 1; + if (D_8011511A == 0 || D_8011511A >= 5) { + D_8011511A = t + 2; + } + } + if (pad & 0x4000) { + ph = &D_8011511A; + t2 = *ph; + *ph = t2 + 2; + flag = 1; + if (*ph >= 5) { + *ph = t2 - 2; + } + } + if (pad & 0x8000) { + ph = &D_8011511A; + t2 = *ph; + *ph = t2 + 1; + flag = 1; + if (*ph & 1) { + *ph = t2 - 1; + } + } + if (pad & 0x2000) { + ph = &D_8011511A; + t2 = *ph; + *ph = t2 - 1; + flag = 1; + if (!(*ph & 1)) { + *ph = t2 + 1; + } + } + r = flag; + if (r) { + func_8002D4C8(0x45A, 0); + } + return 0; +} + + +void func_801F0210(void) { + typedef struct { u32 *ot; u32 pad[4]; } Env_801F1520; /* 0x14 stride */ + typedef struct { u16 f0; u16 f2; } Prim4_801F1520; + typedef struct { + s16 f0; /* 0x00 */ + s16 f2; /* 0x02 */ + void *f4; /* 0x04 */ + void *f8; /* 0x08 */ + s16 fC; /* 0x0C */ + s16 fE; /* 0x0E */ + s16 f10; /* 0x10 */ + s16 f12; /* 0x12 */ + void *f14; /* 0x14 */ + Prim4_801F1520 *f18; /* 0x18 */ + void *f1C; /* 0x1C */ + } Panel_801F1520; /* 0x20 stride */ + + extern Env_801F1520 D_800AE7BC[]; + extern s16 D_8011512C; + extern Panel_801F1520 *D_80115134; + extern s32 D_801151D0; + extern s16 D_800B9A02; + + extern s32 *func_801F1520(s32 *out); + extern s32 func_801F03C0(s32 ot, u8 *s, s16 c); + extern s32 func_8005A600(s32, s32, s32, s32, s32); + + s32 ot; + Panel_801F1520 *s2; + s16 n; + s16 i; + + ot = D_801151D0; + s2 = D_80115134; + + if (D_8011512C == 1 || D_8011512C == 2) { + ot = (s32)func_801F1520((s32 *)ot); + } + + switch (D_8011512C) { + case 0: + case 5: + case 8: + case 9: + n = 1; + break; + case 1: + case 2: + n = 5; + break; + case 3: + case 4: + case 10: + case 11: + n = 5; + goto CALL; + case 6: + case 7: + case 12: + n = 1; + CALL: + ot = func_801F03C0(ot, (u8 *)(s2 + 5), 0); + break; + } + + for (i = 0; i < n; i++) { + ot = func_801F03C0(ot, (u8 *)s2, i); + s2 += 1; + } + + func_8005A600(ot, 0, 0, 0x15, 0); + + *(s32 *)ot = 0x02000000; + *(s32 *)ot = (D_800AE7BC[*(u16 *)&D_800B9A02].ot[2] & 0xFFFFFF) | 0x02000000; + D_800AE7BC[*(u16 *)&D_800B9A02].ot[2] = + (D_800AE7BC[*(u16 *)&D_800B9A02].ot[2] & 0xFF000000) | ((u32)ot & 0xFFFFFF); + + ot += 0x28; + ((struct { s32 f; } *)&D_801151D0)->f = ot; +} -INCLUDE_ASM("asm/md_SC03_076/nonmatchings/md_SC03_076", func_801F0210); typedef struct { s8 c[8]; } Blk8_8012C890_8017C348_801F03C0; typedef struct { s16 m[3][3]; s32 t[3]; } MTX_C974_801F03C0; @@ -448,7 +808,135 @@ s32 func_801F06B0(s32 a0, s16 a1, s16 a2, s16 a3, s32 *p) { } -INCLUDE_ASM("asm/md_SC03_076/nonmatchings/md_SC03_076", func_801F0734); +s32 func_801F0734(void) { + extern s32 D_801F9DB8; + extern s16 D_8011512C; + extern u8 D_801F9DA9; + extern void func_8002B00C(void *); + extern void func_801F1738(s32); + extern void func_80029774(s32); + extern s16 D_80115118; + extern u16 D_8011511A; + extern s32 D_801F3380; + extern s16 D_801150D4; + extern s32 func_8002D4C8(s32, s32); + extern s32 D_801F9DA0; + extern u8 D_801F9DB1; + extern u8 D_801F9DA8[]; + extern u8 D_801F9DB0[]; + extern s32 D_801F32E0; + extern s32 D_801F9AC4; + extern u8 D_801F9DAC[]; + extern u8 D_801F9DAD; + extern u8 D_801F9DAE; + extern u8 D_801F9DAF; + extern s32 func_8002AF48(s32); + extern void *D_801F9DBC[]; + extern s32 D_801F9DC0; + extern s32 D_801F9DC4; + extern s32 D_801F9DC8; + extern s32 func_8002AF60(void); + extern void func_801F0F28(void); + + s32 ret; + short i; + + ret = 0; + if (D_801F9DB8 != 0) { + if (D_801F9DB8 == 1) { + s16 *p = &D_8011512C; + + if (*p == 3 && D_801F9DA9 == 8) { + func_8002B00C(&D_801F9AC4); + func_801F1738(0); + func_80029774(0); + *p = 4; + D_80115118 = 0x4B; + D_801F3380 = 0x15; + D_801150D4 = D_8011511A; + func_8002D4C8(0xB3B, 0); + } else { + *p = 0; + } + } else { + D_8011512C = 0xA; + D_801F3380 = 0x1B; + D_80115118 = 0x4B; + D_801F9DA0 = 0; + return; + } + D_801F9DA0 = 0; + D_801F9DB1 = 0xFF; + } + + if (D_8011512C == 4 || D_8011512C == 0xA) { + return; + } + if (D_801F9DA9 == D_801F9DB1) { + return; + } + + for (i = 0; i < 8; i++) { + D_801F9DB0[i] = D_801F9DA8[i]; + } + + switch (D_801F9DA9) { + case 0: + break; + case 1: + ret = 0xA; + D_8011512C = 0; + D_8011511A = 0; + break; + case 2: + ret = 0xB; + D_801150D4 = 0; + D_8011512C = 0; + D_8011511A = 0; + break; + case 3: + ret = 0x1F; + D_801150D4 = 0; + D_8011512C = 8; + break; + case 4: + case 5: + case 6: + reset_state: + ret = 0x13; + D_801150D4 = 0; + D_8011512C = 8; + break; + case 7: + ret = 0xA; + break; + case 8: + ret = 0xC; + if ((D_801F9DAC[0] | D_801F9DAD | D_801F9DAE | D_801F9DAF) == 0) { + goto reset_state; + } + for (i = 0; i < 4; i++) { + if (D_801F9DAC[i] == 1) { + ((s32 *)D_801F9DBC)[i] = func_8002AF48(i); + } else { + ((s32 *)D_801F9DBC)[i] = 0; + } + } + if (((s32 *)D_801F9DBC)[0] == 0 && ((s32 *)D_801F9DBC)[1] == 0 && ((s32 *)D_801F9DBC)[2] == 0 && + ((s32 *)D_801F9DBC)[3] == 0) { + goto reset_state; + } + D_8011512C = 1; + D_8011511A = (func_8002AF60() & 3) + 1; + func_801F0F28(); + break; + } + + if (ret != 0) { + D_801F32E0 = ret; + } +} + void func_801F0A9C(void) { extern s32 D_801F9DB8; diff --git a/src/md_SC03_135/md_SC03_135.c b/src/md_SC03_135/md_SC03_135.c index d72b32dbf7..8edf135857 100644 --- a/src/md_SC03_135/md_SC03_135.c +++ b/src/md_SC03_135/md_SC03_135.c @@ -283,9 +283,352 @@ INCLUDE_RODATA("asm/md_SC03_135/nonmatchings/md_SC03_135", D_801E25E8); INCLUDE_RODATA("asm/md_SC03_135/nonmatchings/md_SC03_135", D_801E26C0); -INCLUDE_ASM("asm/md_SC03_135/nonmatchings/md_SC03_135", func_801E2D34); +s32 func_801E2D34(void) { + extern s16 D_80115126; + extern s16 D_8011512C; + extern s16 D_801EA954; + extern s16 D_801EA958; + extern s16 D_801EA95C; + extern s16 func_8014168C(s16 a0); + extern s32 D_801E63B0; + extern s32 D_801E6448; + extern s32 D_801E64E8; + extern s32 D_801EAC3C; + extern u32 D_801EAC40; + extern s32 func_80014ED4(s32); + extern s32 func_80015018(s32); + extern void func_8002AF18(void); + extern u16 D_8011511A; + extern unsigned short D_80115118; + extern u8 D_801EA960[]; + extern u8 D_801EAC47[]; + extern u8 D_801EAC4D; + extern void func_8002AF70(void *, s32); + extern s32 func_8002D4C8(s32, s32); + extern void func_801E4890(void); + extern void func_801E48B8(s32); + + s32 *p; + s32 *p2; + u16 *ph; + s16 *q; + s32 pad; + s32 flag; + s32 st; + s32 t; + s32 t2; + s32 sv; + s32 x; + s32 r; + s32 unused[4]; + + flag = 0; + pad = func_80014ED4(0); + func_80015018(0); + func_8014168C(D_8011511A); + + if (pad & 0x40) { + st = D_8011512C; + switch (st) { + case 1: + if (D_80115126 == 0) { + if (D_801EAC47[D_8011511A] == 1) { + D_801E6448 = 0x19; + } else { + func_8002D4C8(0x472, 0); + return 0; + } + } else if (D_801EAC47[D_8011511A] == 1) { + D_801E6448 = 0x16; + } else { + D_801E6448 = 0x19; + } + D_8011512C = 2; + func_8002D4C8(0x45D, 0); + return 0; + case 2: + func_801E4890(); + if (D_80115126 == 0) { + D_801E64E8 = 0x14; + D_801EAC3C = 2; + D_801EAC40 = D_8011511A - 1; + } else { + D_801EAC40 = D_8011511A - 1; + func_801E48B8(1); + func_8002AF70(D_801EA960, D_801EAC40); + D_801E64E8 = 0xE; + D_801EAC3C = 1; + } + D_8011512C = 3; + func_8002D4C8(0x45D, 0); + return 0; + case 4: + case 7: + Lcheck47: + if (D_80115118 < 0x47) { + goto Lreset; + } + return 0; + case 9: + p = &D_801E6448; + if (*p == 0x1D || *p == 0x21) { + goto Lmsg473ret1; + } + D_801EA954 = 0; + D_801EA95C = 1; + D_8011512C = 0; + *p = D_801E63B0; + func_8002D4C8(0x45D, 0); + return 0; + case 5: + goto Lload; + case 0: + case 3: + case 6: + case 8: + case 10: + case 11: + case 12: + break; + default: + goto Ltail; + } + return 0; + } else if (pad & 0x10) { + st = D_8011512C; + switch (st) { + case 0: + if (D_801E6448 != 0xB) { + return 0; + } + /* fallthrough */ + case 1: + Lmsg473: + func_8002D4C8(0x473, 0); + t = D_801EA958; + sv = t; + if (t == 0) { + return 1; + } + x = (t == 1) ? 0x1D : 0x21; + r = 0; + t = 9; + D_8011512C = t; + D_801E6448 = x; + t = 0xFF; + goto Lstore; + case 2: + if (D_80115126 == 0) { + D_801E6448 = 0xC; + } else { + D_801E6448 = 0xD; + } + D_8011512C = 1; + func_8002D4C8(0x473, 0); + return 0; + case 5: + case 8: + if (D_80115126 != 0) { + goto Lmsg473; + } + Lmsg473ret1: + func_8002D4C8(0x473, 0); + return 1; + case 9: + p2 = &D_801E6448; + if (*p2 == 0x1D || *p2 == 0x21) { + if (D_801EA95C == 0) { + *p2 = 0x1A; + func_8002D4C8(0x45D, 0); + return 0; + } + D_801EA954 = 0; + D_8011512C = 0; + *p2 = D_801E63B0; + func_8002AF18(); + func_8002D4C8(0x45D, 0); + return 0; + } + *p2 = (D_801EA958 == 1) ? 0x1D : 0x21; + func_8002D4C8(0x473, 0); + return 0; + case 4: + case 7: + goto Lcheck47; + case 3: + case 6: + case 10: + case 11: + case 12: + break; + default: + goto Ltail; + } + return 0; + } else if (pad & 0x20) { + st = D_8011512C; + if (st == 5) { + D_801E64E8 = 0x17; + D_8011512C = 6; + func_8002D4C8(0x45D, 0); + D_801EAC3C = 3; + return 0; + } + goto Ltail; + } +Lload: + st = D_8011512C; +Ltail: + if (st == 4 || st == 7 || st >= 10) { + ph = &D_80115118; + if (*ph != 0) { + *ph = *ph - 1; + goto Lmid; + } + Lreset: + D_80115118 = 0; + if (D_80115126 == 0) { + if (D_8011512C == 4) { + return -1; + } + D_801E6448 = 0xC; + } else { + t2 = D_801EA958; + sv = t2; + if (t2 != 0 && D_8011512C == 4) { + t = (t2 == 1) ? 0x1D : 0x21; + r = 0; + D_801E6448 = t; + t = 9; + D_8011512C = t; + t = 0xFF; + Lstore: + D_801EA954 = sv; + D_801EAC4D = t; + return r; + } + D_801E6448 = 0xD; + q = &D_8011512C; + if (*q == 0xC) { + *q = 1; + return 0; + } + } + D_8011512C = 1; + return 0; + } +Lmid: + if (D_8011512C != 1) { + return 0; + } + if (pad & 0x1000) { + t = D_8011511A; + D_8011511A = t - 2; + flag = 1; + if (D_8011511A == 0 || D_8011511A >= 5) { + D_8011511A = t + 2; + } + } + if (pad & 0x4000) { + ph = &D_8011511A; + t2 = *ph; + *ph = t2 + 2; + flag = 1; + if (*ph >= 5) { + *ph = t2 - 2; + } + } + if (pad & 0x8000) { + ph = &D_8011511A; + t2 = *ph; + *ph = t2 + 1; + flag = 1; + if (*ph & 1) { + *ph = t2 - 1; + } + } + if (pad & 0x2000) { + ph = &D_8011511A; + t2 = *ph; + *ph = t2 - 1; + flag = 1; + if (!(*ph & 1)) { + *ph = t2 + 1; + } + } + r = flag; + if (r) { + func_8002D4C8(0x45A, 0); + } + return 0; +} + + +s32 func_801E3390(void) { + typedef struct { u32 *ot; u32 pad[4]; } Env_801E46A0; + extern s32 *func_801E46A0(s32 *); + extern s32 func_801E3540(s32, u8 *, s16); + extern s32 func_8005A600(s32, s32, s32, s32, s32); + extern s32 D_801151D0; + extern s16 D_8011512C; + extern s32 D_80115134; + extern s16 D_800B9A02; + extern Env_801E46A0 D_800AE7BC[]; + + s32 ot; + u8 *s2; + s16 n; + s16 i; + + ot = D_801151D0; + s2 = D_80115134; + + if (D_8011512C == 1 || D_8011512C == 2) { + ot = (s32)func_801E46A0((s32 *)ot); + } + + switch (D_8011512C) { + case 0: + case 5: + case 8: + case 9: + n = 1; + break; + case 1: + case 2: + n = 5; + break; + case 3: + case 4: + case 10: + case 11: + n = 5; + goto CALL; + case 6: + case 7: + case 12: + n = 1; + CALL: + ot = func_801E3540(ot, s2 + 0xA0, 0); + break; + } + + for (i = 0; i < n; i++) { + ot = func_801E3540(ot, s2, i); + s2 += 0x20; + } + + func_8005A600(ot, 0, 0, 0x15, 0); + + *(s32 *)ot = 0x02000000; + *(s32 *)ot = (D_800AE7BC[*(u16 *)&D_800B9A02].ot[2] & 0xFFFFFF) | 0x02000000; + D_800AE7BC[*(u16 *)&D_800B9A02].ot[2] = + (D_800AE7BC[*(u16 *)&D_800B9A02].ot[2] & 0xFF000000) | ((u32)ot & 0xFFFFFF); + + ot += 0x28; + ((struct { s32 f; } *)&D_801151D0)->f = ot; +} -INCLUDE_ASM("asm/md_SC03_135/nonmatchings/md_SC03_135", func_801E3390); typedef struct { s8 c[8]; } Blk8_8012C890_8017C348_801E3540; typedef struct { s16 m[3][3]; s32 t[3]; } MTX_C974_801E3540; @@ -438,9 +781,365 @@ s32 func_801E3830(s32 arg0, s16 arg1, s16 arg2, s16 arg3, s32 *arg4) { INCLUDE_ASM("asm/md_SC03_135/nonmatchings/md_SC03_135", func_801E38B4); -INCLUDE_ASM("asm/md_SC03_135/nonmatchings/md_SC03_135", func_801E3C1C); +#include "common.h" + +/* func_801E3C1C — md_SC03_135, 291 ins, switch on D_801EAC45 via jtbl_801E27FC + * (9 entries + §8a pad word, bound `sltiu $v0,$v1,0x9`, entry[0] -> merge label + * => §161a case-0-break). + * + * BANKING NOTE (banker: read before gating): + * jtbl_801E27FC sits at island file offset 0x214 (vram 0x801E27FC, base + * D_801E25E8@0x0). Per cookbook §260-A the md_* leading island is a STACK: + * only the END-ADJACENT table converts. This module's island-end member + * func_801E5358 was already peeled by the gate (commit commit:2664). Island + * stack census (verified against each .s): jtbl_801E272C @0x144 (owner is + * func_801E2D34 or func_801E3390 — both still INCLUDE_ASM stubs, TU :286/ + * :288), jtbl_801E27D4 @0x1EC (func_801E38B4, stub @TU :439), THIS table + * @0x214, jtbl_801E2824 @0x23C (func_801E40A8, stub @TU :443). Every + * matched-C function above :443 was read line-by-line: no switches. So the + * ONLY later-stack owner above this table is func_801E40A8 — and after the + * sibling peel ITS table is the current island end, i.e. convertible NOW; + * one peel later this table becomes end-adjacent and converts. Class: + * island-blocked, depth 1 — "convert as peels land". + * REMEDY: bank func_801E40A8 first (same lane), then run + * tools/jtbl_lane.py --targets func_801E3C1C@md_SC03_135 --draft-dir + * (gate-time _jtbl_prep_one isolates -> island-splits -> carves; §81 chain, + * §88d order). Proof shapes: func_801F218C@md_SC03_076 commit commit:2663 + * (covered), func_801E5358@md_SC03_135 commit commit:2664 (island-end). + * DO NOT substitute a hand-emitted table or computed-goto dispatch: the + * gate's covered/no-op path requires cc1 itself to emit this switch's + * table (plain switch only). + * + * Body levers that ARE load-bearing (do not "clean up"): + * - K&R int() signature: caller func_801E2BE0 (TU :216) uses implicit-int; + * no prototype exists anywhere in the TU (INCLUDE_ASM expands to bare + * __asm__), so void(void) hard-errors conflicting-types at splice. + * VERIFIED EXHAUSTIVELY: grep over all 943 TU lines shows func_801E3C1C + * at exactly TWO sites — the :216 call and the :441 stub. No file-scope + * decl, no prototype, no address-take => the §138 splice-conflict class + * (which cost func_801856A8 21 rounds) is excluded for this function. + * - bare `return;`: caller discards; `return 0;` adds move $v0,$zero. + * - ret lives across the switch ($s3), zeroed at entry. + * - case 3 COMPONENT_REF via struct hack (lh test vs 0xC); + * case 6 lhu + sign-ext pair; case 8 lh tests vs 0xB/3/4. + * - fresh block-scoped q per &D_8011512C site (three distinct lui/addiu). + * - D_801E64E8 declared s32 (its stores are sw despite s16 fleet majority). + * - D_801EAC44 tu-verbatim u16[] accessed via (u8*) cast (byte copy loop). + */ +int func_801E3C1C() { + extern s32 D_801EAC54; + extern u32 D_801EAC3C; + extern u8 D_801EAC45; + extern u8 D_801EAC4D; + extern u16 D_801EAC44[]; + extern u8 D_801EAC4C[]; + extern u8 D_801EAC48[]; + extern void *D_801EAC58[]; + extern s32 D_801EAC5C; + extern s32 D_801EAC60; + extern s32 D_801EAC64; + extern s32 D_801E6448; + extern s32 D_801E64E8; + extern s16 D_8011512C; + extern s16 D_80115118; + extern u16 D_8011511A; + extern u16 D_801150D4; + extern void func_80029774(s32 a0); + extern s32 func_8002D4C8(s32 a0, s32 a1); + extern s32 func_8002AF48(s32 a0); + extern s32 func_8002AF60(void); + extern void func_801E40A8(void); + + s32 ret; + s16 i; + s16 *p; + + ret = 0; + if (D_801EAC54 != 0) { + if (D_801EAC54 == 1) { + p = &D_8011512C; + if (*p == 3) { + if (D_801EAC45 == 8) { + func_80029774(0); + *p = 4; + D_80115118 = 0x4B; + D_801150D4 = 0; + D_801E64E8 = 0xF; + func_8002D4C8(0xB3B, 0); + } else { + *p = 0; + } + } else { + if (D_801EAC45 == 6) { + *p = 7; + D_80115118 = 0x4B; + D_801E64E8 = 0x18; + } else { + *p = 0; + } + } + } else { + if ((D_801EAC3C & 3) == 1) { + D_8011512C = 0xB; + D_801E64E8 = 0x12; + } else { + D_8011512C = 0xC; + D_801E64E8 = 0x1C; + } + D_80115118 = 0x4B; + } + D_801EAC3C = 0; + D_801EAC4D = 0xFF; + } + + if (D_8011512C == 0xB || D_8011512C == 0xC) { + return; + } + if (D_801EAC45 == D_801EAC4D) { + return; + } + + for (i = 0; i < 8; i++) { + D_801EAC4C[i] = ((u8 *)D_801EAC44)[i]; + } + + switch (D_801EAC45) { + case 0: + break; + case 1: + ret = 0xA; + D_8011512C = 0; + D_8011511A = 0; + break; + case 2: + ret = 0xB; + D_801150D4 = 0; + D_8011512C = 0; + D_8011511A = 0; + break; + case 3: { + s16 *q = &D_8011512C; + D_801150D4 = 0; + if (((struct { s16 h; } *)q)->h != 0xC) { + ret = 0x11; + *q = 5; + } + break; + } + case 4: + D_801150D4 = 0; + D_8011512C = 8; + ret = 0xB; + break; + case 5: + D_8011512C = 8; + ret = 0x10; + break; + case 6: { + s16 *q = &D_8011512C; + D_801150D4 = 0; + if ((*q != 6) && (*q != 7) && (*q != 0xB)) { + ret = 0xD; + *q = 1; + } + for (i = 0; i < 4; i++) { + ((s32 *)D_801EAC58)[i] = 0; + } + D_8011511A = 1; + func_801E40A8(); + break; + } + case 7: + ret = 0xA; + break; + case 8: { + s16 *q; + if ((D_8011512C != 0xB) && (D_8011512C != 3) && (D_8011512C != 4)) { + ret = 0xD; + } + for (i = 0; i < 4; i++) { + if (D_801EAC48[i] == 1) { + ((s32 *)D_801EAC58)[i] = func_8002AF48(i); + } else { + ((s32 *)D_801EAC58)[i] = 0; + } + } + q = &D_8011512C; + if (*q == 0) { + *q = 1; + if ((u32)(D_801150D4 - 1) < 4) { + D_8011511A = D_801150D4; + } else { + D_8011511A = (func_8002AF60() & 3) + 1; + } + if ((((s32 *)D_801EAC58)[0] == 0) && (((s32 *)D_801EAC58)[1] == 0) && (((s32 *)D_801EAC58)[2] == 0) && + (((s32 *)D_801EAC58)[3] == 0)) { + D_801150D4 = 0; + D_8011511A = 1; + } + } + func_801E40A8(); + break; + } + } + + if (ret != 0) { + D_801E6448 = ret; + } +} + + +typedef struct { + char c[3]; +} Blk3_801E40A8; + +extern char *strcpy(char *, const char *); +extern u32 func_801E45C0(s32 a0, s32 a1); +extern void func_801E4628(val, n, dst, flag); + +extern void *D_801EAC58[]; /* status ptr per slot */ +extern void *D_801E6424[]; /* HUD prim ptr array per slot */ +extern char *D_801E632C[]; /* label strings */ +extern s32 D_801E65B8[]; /* level thresholds */ +extern u16 *D_801E6390[]; /* icon tables */ +extern char *D_801E634C; +extern Blk3_801E40A8 D_801E26C0; + +void func_801E40A8(void) { + s16 k; + s16 i; + s16 j; + u8 *p; + void **arr; + u32 a; + u32 b; + s32 r; + s32 n; + u16 *ico; + + for (k = 0; k < 4; k++) { + p = (u8 *)D_801EAC58[k]; + arr = (void **)D_801E6424[k]; + if (p != NULL) { + for (i = 0; i < 7; i++) { + strcpy((char *)arr[i], D_801E632C[i]); + switch (i) { + case 0: + for (j = 0; j < 5; j++) { + if (*(s16 *)(p + 8) < D_801E65B8[j]) { + break; + } + } + if (p[0x4E] != 0) { + j = (*(s32 *)p == 0) ? 0x1A : 0x1C; + } + *(s32 *)arr = j + 4; + break; + case 1: + a = p[7]; + if (a >= 100) { + a = 99; + } + b = p[6]; + if (b >= 60) { + b = 59; + } + ((void (*)(unsigned int, short, unsigned short *, short))func_801E4628)((func_801E45C0((u16)a, 0x18) | 0xB00000) | + func_801E45C0(b, 0xC), + 5, (u8 *)arr[1] + 0x12, 0); + break; + case 2: + a = *(u16 *)(p + 0x34); + if (a >= 1000) { + a = 999; + } + ((void (*)(unsigned int, short, unsigned short *, short))func_801E4628)(func_801E45C0((u16)a, 0x14), 3, (u8 *)arr[2] + 8, 1); + n = p[0x42]; + if (n >= 7) { + n = 6; + } + ico = D_801E6390[n]; + *(u16 *)((u8 *)arr[2] + 0x10) = *ico++; + *(u16 *)((u8 *)arr[2] + 0x12) = ico[0]; + *(u16 *)((u8 *)arr[2] + 0x14) = ico[1]; + a = p[0x39]; + if (a >= 0x18) { + a = 0x17; + } + b = p[0x38]; + if (b >= 0x3C) { + b = 0x3B; + } + ((void (*)(unsigned int, short, unsigned short *, short))func_801E4628)((func_801E45C0((u16)a, 0x18) | 0xB00000) | + func_801E45C0(b, 0xC), + 5, (u8 *)arr[2] + 0x18, 0); + break; + case 3: + a = *(u16 *)(p + 0x3C); + if (a >= 1000) { + a = 999; + } + b = *(u16 *)(p + 0x3A); + if (b >= 1000) { + b = 999; + } + r = func_801E45C0((u16)a, 0x14); + if (r == 0) { + r = 0xD00000; + } + ((void (*)(unsigned int, short, unsigned short *, short))func_801E4628)(r | (func_801E45C0(b, 4) | 0xC0000), 7, (u8 *)arr[3] + 6, 1); + break; + case 4: + a = *(u16 *)(p + 0x40); + if (a >= 1000) { + a = 999; + } + b = *(u16 *)(p + 0x3E); + if (b >= 1000) { + b = 999; + } + r = func_801E45C0((u16)a, 0x14); + if (r == 0) { + r = 0xD00000; + } + ((void (*)(unsigned int, short, unsigned short *, short))func_801E4628)(r | (func_801E45C0(b, 4) | 0xC0000), 7, (u8 *)arr[4] + 6, 1); + break; + case 5: + a = *(u32 *)(p + 0x14); + if (a > 99999) { + a = 99999; + } + ((void (*)(unsigned int, short, unsigned short *, short))func_801E4628)(func_801E45C0(a, 0xC), 5, (u8 *)arr[5] + 2, 1); + break; + case 6: + a = *(u16 *)(p + 0xC); + if (a >= 0x24) { + a = 0x23; + } + r = func_801E45C0((u16)a, 0x18); + if (r == 0) { + r = 0xD000000; + } + ((void (*)(unsigned int, short, unsigned short *, short))func_801E4628)(r, 2, (u8 *)arr[6] + 0x10, 1); + break; + } + } + } else { + for (i = 0; i < 7; i++) { + if (i == 0) { + *(s32 *)arr = 4; + } else if (i == 1) { + strcpy((char *)arr[i], D_801E632C[i]); + } else if (i == 4) { + strcpy((char *)arr[i], D_801E634C); + } else { + *(Blk3_801E40A8 *)arr[i] = D_801E26C0; + } + } + } + } +} -INCLUDE_ASM("asm/md_SC03_135/nonmatchings/md_SC03_135", func_801E40A8); u32 func_801E45C0(s32 a0, s32 a1) { s32 t0; diff --git a/src/md_SC04_027/md_SC04_027.c b/src/md_SC04_027/md_SC04_027.c index 03b4313369..c1c043be57 100644 --- a/src/md_SC04_027/md_SC04_027.c +++ b/src/md_SC04_027/md_SC04_027.c @@ -294,9 +294,351 @@ INCLUDE_RODATA("asm/md_SC04_027/nonmatchings/md_SC04_027", D_801E7B28); INCLUDE_RODATA("asm/md_SC04_027/nonmatchings/md_SC04_027", D_801E7C00); -INCLUDE_ASM("asm/md_SC04_027/nonmatchings/md_SC04_027", func_801E8274); +extern s16 D_80115126; +extern s16 D_8011512C; +extern s16 D_801F2188; +extern s16 D_801F218C; +extern s16 D_801F2190; +extern s16 func_8014168C(s16); +extern s32 D_801EB918; +extern void *D_801EB9B0; +extern s32 D_801EBA50; +extern s32 D_801F2470; +extern s32 D_801F2474; +extern s32 func_80014ED4(s32); +extern s32 func_80015018(s32); +extern void func_8002AF18(void); +extern u16 D_8011511A; +extern s16 D_80115118; +extern u8 D_801F247B[]; +extern u8 D_801F2481; +extern void func_8002AF70(void *, s32); +extern s32 func_8002D4C8(s32, s32); +extern void func_801E9DD0(void); +extern void func_801E9DF8(s32); +extern s8 D_801F2194; + +s32 func_801E8274(void) { + s32 *p; + s32 *p2; + u16 *ph; + s16 *q; + s32 pad; + s32 flag; + s32 st; + s32 t; + s32 t2; + s32 sv; + s32 x; + s32 r; + s32 unused[4]; + + flag = 0; + pad = func_80014ED4(0); + func_80015018(0); + func_8014168C(D_8011511A); + + if (pad & 0x40) { + st = D_8011512C; + switch (st) { + case 1: + if (D_80115126 == 0) { + if (D_801F247B[D_8011511A] == 1) { + D_801EB9B0 = (void *)0x19; + } else { + func_8002D4C8(0x472, 0); + return 0; + } + } else if (D_801F247B[D_8011511A] == 1) { + D_801EB9B0 = (void *)0x16; + } else { + D_801EB9B0 = (void *)0x19; + } + D_8011512C = 2; + func_8002D4C8(0x45D, 0); + return 0; + case 2: + func_801E9DD0(); + if (D_80115126 == 0) { + D_801EBA50 = 0x14; + D_801F2470 = 2; + D_801F2474 = D_8011511A - 1; + } else { + D_801F2474 = D_8011511A - 1; + func_801E9DF8(1); + func_8002AF70(&D_801F2194, D_801F2474); + D_801EBA50 = 0xE; + D_801F2470 = 1; + } + D_8011512C = 3; + func_8002D4C8(0x45D, 0); + return 0; + case 4: + case 7: + Lcheck47: + if (*(u16 *)&D_80115118 < 0x47) { + goto Lreset; + } + return 0; + case 9: + p = (s32 *)&D_801EB9B0; + if (*p == 0x1D || *p == 0x21) { + goto Lmsg473ret1; + } + D_801F2188 = 0; + D_801F2190 = 1; + D_8011512C = 0; + *p = D_801EB918; + func_8002D4C8(0x45D, 0); + return 0; + case 5: + goto Lload; + case 0: + case 3: + case 6: + case 8: + case 10: + case 11: + case 12: + break; + default: + goto Ltail; + } + return 0; + } else if (pad & 0x10) { + st = D_8011512C; + switch (st) { + case 0: + if (D_801EB9B0 != (void *)0xB) { + return 0; + } + /* fallthrough */ + case 1: + Lmsg473: + func_8002D4C8(0x473, 0); + t = D_801F218C; + sv = t; + if (t == 0) { + return 1; + } + x = (t == 1) ? 0x1D : 0x21; + r = 0; + t = 9; + D_8011512C = t; + D_801EB9B0 = (void *)x; + t = 0xFF; + goto Lstore; + case 2: + if (D_80115126 == 0) { + D_801EB9B0 = (void *)0xC; + } else { + D_801EB9B0 = (void *)0xD; + } + D_8011512C = 1; + func_8002D4C8(0x473, 0); + return 0; + case 5: + case 8: + if (D_80115126 != 0) { + goto Lmsg473; + } + Lmsg473ret1: + func_8002D4C8(0x473, 0); + return 1; + case 9: + p2 = (s32 *)&D_801EB9B0; + if (*p2 == 0x1D || *p2 == 0x21) { + if (D_801F2190 == 0) { + *p2 = 0x1A; + func_8002D4C8(0x45D, 0); + return 0; + } + D_801F2188 = 0; + D_8011512C = 0; + *p2 = D_801EB918; + func_8002AF18(); + func_8002D4C8(0x45D, 0); + return 0; + } + *p2 = (D_801F218C == 1) ? 0x1D : 0x21; + func_8002D4C8(0x473, 0); + return 0; + case 4: + case 7: + goto Lcheck47; + case 3: + case 6: + case 10: + case 11: + case 12: + break; + default: + goto Ltail; + } + return 0; + } else if (pad & 0x20) { + st = D_8011512C; + if (st == 5) { + D_801EBA50 = 0x17; + D_8011512C = 6; + func_8002D4C8(0x45D, 0); + D_801F2470 = 3; + return 0; + } + goto Ltail; + } +Lload: + st = D_8011512C; +Ltail: + if (st == 4 || st == 7 || st >= 10) { + ph = (u16 *)&D_80115118; + if (*ph != 0) { + *ph = *ph - 1; + goto Lmid; + } + Lreset: + *(u16 *)&D_80115118 = 0; + if (D_80115126 == 0) { + if (D_8011512C == 4) { + return -1; + } + D_801EB9B0 = (void *)0xC; + } else { + t2 = D_801F218C; + sv = t2; + if (t2 != 0 && D_8011512C == 4) { + t = (t2 == 1) ? 0x1D : 0x21; + r = 0; + D_801EB9B0 = (void *)t; + t = 9; + D_8011512C = t; + t = 0xFF; + Lstore: + D_801F2188 = sv; + D_801F2481 = t; + return r; + } + D_801EB9B0 = (void *)0xD; + q = &D_8011512C; + if (*q == 0xC) { + *q = 1; + return 0; + } + } + D_8011512C = 1; + return 0; + } +Lmid: + if (D_8011512C != 1) { + return 0; + } + if (pad & 0x1000) { + t = D_8011511A; + D_8011511A = t - 2; + flag = 1; + if (D_8011511A == 0 || D_8011511A >= 5) { + D_8011511A = t + 2; + } + } + if (pad & 0x4000) { + ph = &D_8011511A; + t2 = *ph; + *ph = t2 + 2; + flag = 1; + if (*ph >= 5) { + *ph = t2 - 2; + } + } + if (pad & 0x8000) { + ph = &D_8011511A; + t2 = *ph; + *ph = t2 + 1; + flag = 1; + if (*ph & 1) { + *ph = t2 - 1; + } + } + if (pad & 0x2000) { + ph = &D_8011511A; + t2 = *ph; + *ph = t2 - 1; + flag = 1; + if (!(*ph & 1)) { + *ph = t2 + 1; + } + } + r = flag; + if (r) { + func_8002D4C8(0x45A, 0); + } + return 0; +} + + +void func_801E88D0(void) { + typedef struct { u32 *ot; u32 pad[4]; } Env_801E9BE0; /* 0x14 stride */ + extern s32 D_801151D0; + extern s16 D_8011512C; + extern s32 D_80115134; + extern s16 D_800B9A02; + extern Env_801E9BE0 D_800AE7BC[]; + extern s32 *func_801E9BE0(s32 *); + extern s32 func_801E8A80(s32, u8 *, s16); + extern s32 func_8005A600(s32, s32, s32, s32, s32); + s32 ot; + u8 *s2; + s16 n; + s16 i; + + ot = D_801151D0; + s2 = (u8 *)D_80115134; + + if (D_8011512C == 1 || D_8011512C == 2) { + ot = (s32)func_801E9BE0((s32 *)ot); + } + + switch (D_8011512C) { + case 0: + case 5: + case 8: + case 9: + n = 1; + break; + case 1: + case 2: + n = 5; + break; + case 3: + case 4: + case 10: + case 11: + n = 5; + goto CALL; + case 6: + case 7: + case 12: + n = 1; + CALL: + ot = func_801E8A80(ot, s2 + 0xA0, 0); + break; + } + + for (i = 0; i < n; i++) { + ot = func_801E8A80(ot, s2, i); + s2 += 0x20; + } + + func_8005A600(ot, 0, 0, 0x15, 0); + + *(s32 *)ot = 0x02000000; + *(s32 *)ot = (D_800AE7BC[*(u16 *)&D_800B9A02].ot[2] & 0xFFFFFF) | 0x02000000; + D_800AE7BC[*(u16 *)&D_800B9A02].ot[2] = + (D_800AE7BC[*(u16 *)&D_800B9A02].ot[2] & 0xFF000000) | ((u32)ot & 0xFFFFFF); + + ot += 0x28; + ((struct { s32 f; } *)&D_801151D0)->f = ot; +} -INCLUDE_ASM("asm/md_SC04_027/nonmatchings/md_SC04_027", func_801E88D0); typedef struct { s8 c[8]; } Blk8_8012C890_8017C348_801E8A80; typedef struct { s16 m[3][3]; s32 t[3]; } MTX_C974_801E8A80; @@ -454,11 +796,458 @@ end: } -INCLUDE_ASM("asm/md_SC04_027/nonmatchings/md_SC04_027", func_801E8DF4); +void func_801E8DF4(void) { + extern s32 D_801F2488; + extern s16 D_8011512C; + extern u8 D_801F2479; + extern void func_8002B00C(void *); + extern void func_801E9DF8(s32); + extern void func_80029774(s32); + extern s16 D_80115118; + extern s32 D_801EBA50; + extern s16 D_801150D4; + extern s32 func_8002D4C8(s32, s32); + extern u16 D_8011511A; + extern s32 D_801F2470; + extern u8 D_801F2481; + extern u8 D_801F2478[]; + extern u8 D_801F2480[]; + extern u8 D_801F247C[]; + extern u8 D_801F247D; + extern u8 D_801F247E; + extern u8 D_801F247F; + extern s32 D_801F248C[]; + extern s32 D_801F2490; + extern s32 D_801F2494; + extern s32 D_801F2498; + extern s32 func_8002AF48(s32); + extern s32 func_8002AF60(void); + extern void func_801E95E8(void); + extern void *D_801EB9B0; + extern s8 D_801F2194; -INCLUDE_ASM("asm/md_SC04_027/nonmatchings/md_SC04_027", func_801E915C); + s32 ret; + short i; + + ret = 0; + if (D_801F2488 != 0) { + if (D_801F2488 == 1) { + s16 *p = &D_8011512C; + + if (*p == 3 && D_801F2479 == 8) { + func_8002B00C(&D_801F2194); + func_801E9DF8(0); + func_80029774(0); + *p = 4; + D_80115118 = 0x4B; + D_801EBA50 = 0x15; + D_801150D4 = D_8011511A; + func_8002D4C8(0xB3B, 0); + } else { + *p = 0; + } + } else { + D_8011512C = 0xA; + D_801EBA50 = 0x1B; + D_80115118 = 0x4B; + D_801F2470 = 0; + return; + } + D_801F2470 = 0; + D_801F2481 = 0xFF; + } + + if (D_8011512C == 4) { + return; + } + __asm__ __volatile__(""); + if (D_8011512C == 0xA) { + return; + } + if (D_801F2479 == D_801F2481) { + return; + } + + for (i = 0; i < 8; i++) { + D_801F2480[i] = D_801F2478[i]; + } + + switch (D_801F2479) { + case 0: + break; + case 1: + ret = 0xA; + D_8011512C = 0; + D_8011511A = 0; + break; + case 2: + ret = 0xB; + D_801150D4 = 0; + D_8011512C = 0; + D_8011511A = 0; + break; + case 3: + ret = 0x1F; + D_801150D4 = 0; + D_8011512C = 8; + break; + case 4: + case 5: + case 6: + reset_state: + ret = 0x13; + D_801150D4 = 0; + D_8011512C = 8; + break; + case 7: + ret = 0xA; + break; + case 8: + ret = 0xC; + if ((D_801F247C[0] | D_801F247D | D_801F247E | D_801F247F) == 0) { + goto reset_state; + } + for (i = 0; i < 4; i++) { + if (D_801F247C[i] == 1) { + D_801F248C[i] = func_8002AF48(i); + } else { + D_801F248C[i] = 0; + } + } + if (D_801F248C[0] == 0 && D_801F248C[1] == 0 && D_801F248C[2] == 0 && + D_801F248C[3] == 0) { + goto reset_state; + } + D_8011512C = 1; + D_8011511A = (func_8002AF60() & 3) + 1; + func_801E95E8(); + break; + } + + if (ret != 0) { + D_801EB9B0 = (void *)ret; + } +} + + +void func_801E915C(void) { + extern s32 D_801F2488; + extern s32 D_801F2470; + extern u8 D_801F2478[]; + extern u8 D_801F2479; + extern u8 D_801F247C[]; + extern u8 D_801F2480[]; + extern u8 D_801F2481; + extern s32 D_801F248C[]; + extern s32 D_801F2490; + extern s32 D_801F2494; + extern s32 D_801F2498; + extern s16 D_8011512C; + extern s16 D_80115118; + extern u16 D_8011511A; + extern u16 D_801150D4; + extern s32 D_801EBA50; + extern void *D_801EB9B0; + extern void func_80029774(s32 a0); + extern s32 func_8002D4C8(s32 a0, s32 a1); + extern s32 func_8002AF48(s32 a0); + extern s32 func_8002AF60(void); + extern void func_801E95E8(void); + + s32 ret; + s16 i; + s16 *p; + + ret = 0; + if (D_801F2488 != 0) { + if (D_801F2488 == 1) { + p = &D_8011512C; + if (*p == 3) { + if (D_801F2479 == 8) { + func_80029774(0); + *p = 4; + D_80115118 = 0x4B; + D_801150D4 = 0; + D_801EBA50 = 0xF; + func_8002D4C8(0xB3B, 0); + } else { + *p = 0; + } + } else { + if (D_801F2479 == 6) { + *p = 7; + D_80115118 = 0x4B; + D_801EBA50 = 0x18; + } else { + *p = 0; + } + } + } else { + if ((D_801F2470 & 3) == 1) { + D_8011512C = 0xB; + D_801EBA50 = 0x12; + } else { + D_8011512C = 0xC; + D_801EBA50 = 0x1C; + } + D_80115118 = 0x4B; + } + D_801F2470 = 0; + D_801F2481 = 0xFF; + } + + if (D_8011512C == 0xB || D_8011512C == 0xC) { + return; + } + if (D_801F2479 == D_801F2481) { + return; + } + + for (i = 0; i < 8; i++) { + D_801F2480[i] = D_801F2478[i]; + } + + switch (D_801F2479) { + case 0: + break; + case 1: + ret = 0xA; + D_8011512C = 0; + D_8011511A = 0; + break; + case 2: + ret = 0xB; + D_801150D4 = 0; + D_8011512C = 0; + D_8011511A = 0; + break; + case 3: { + s16 *q = &D_8011512C; + D_801150D4 = 0; + if (((struct { s16 h; } *)q)->h != 0xC) { + ret = 0x11; + *q = 5; + } + break; + } + case 4: + D_801150D4 = 0; + D_8011512C = 8; + ret = 0xB; + break; + case 5: + D_8011512C = 8; + ret = 0x10; + break; + case 6: { + s16 *q = &D_8011512C; + D_801150D4 = 0; + if ((*q != 6) && (*q != 7) && (*q != 0xB)) { + ret = 0xD; + *q = 1; + } + for (i = 0; i < 4; i++) { + D_801F248C[i] = 0; + } + D_8011511A = 1; + func_801E95E8(); + break; + } + case 7: + ret = 0xA; + break; + case 8: { + s16 *q; + if ((D_8011512C != 0xB) && (D_8011512C != 3) && (D_8011512C != 4)) { + ret = 0xD; + } + for (i = 0; i < 4; i++) { + if (D_801F247C[i] == 1) { + D_801F248C[i] = func_8002AF48(i); + } else { + D_801F248C[i] = 0; + } + } + q = &D_8011512C; + if (*q == 0) { + *q = 1; + if ((u32)(D_801150D4 - 1) < 4) { + D_8011511A = D_801150D4; + } else { + D_8011511A = (func_8002AF60() & 3) + 1; + } + if ((D_801F248C[0] == 0) && (D_801F2490 == 0) && (D_801F2494 == 0) && + (D_801F2498 == 0)) { + D_801150D4 = 0; + D_8011511A = 1; + } + } + func_801E95E8(); + break; + } + } + + if (ret != 0) { + D_801EB9B0 = (void *)ret; + } +} + + +typedef struct { + char c[3]; +} Blk3_801E95E8; + +extern char *strcpy(char *, const char *); +extern u32 func_801E9B00(s32 a0, s32 a1); +extern void func_801E9B68(unsigned int val, short n, unsigned short *dst, short flag); + +extern void *D_801F248C[]; /* status ptr per slot */ +extern void *D_801EB98C[]; /* HUD prim ptr array per slot */ +extern char *D_801EB894[]; /* label strings */ +extern s32 D_801EBB20[]; /* level thresholds */ +extern u16 *D_801EB8F8[]; /* icon tables */ +extern char *D_801EB8B4; +extern Blk3_801E95E8 D_801E7C00; + +void func_801E95E8(void) { + s16 k; + s16 i; + s16 j; + u8 *p; + void **arr; + u32 a; + u32 b; + s32 r; + s32 n; + u16 *ico; + + for (k = 0; k < 4; k++) { + p = (u8 *)D_801F248C[k]; + arr = (void **)D_801EB98C[k]; + if (p != NULL) { + for (i = 0; i < 7; i++) { + strcpy((char *)arr[i], D_801EB894[i]); + switch (i) { + case 0: + for (j = 0; j < 5; j++) { + if (*(s16 *)(p + 8) < D_801EBB20[j]) { + break; + } + } + if (p[0x4E] != 0) { + j = (*(s32 *)p == 0) ? 0x1A : 0x1C; + } + *(s32 *)arr = j + 4; + break; + case 1: + a = p[7]; + if (a >= 100) { + a = 99; + } + b = p[6]; + if (b >= 60) { + b = 59; + } + func_801E9B68((func_801E9B00((u16)a, 0x18) | 0xB00000) | + func_801E9B00(b, 0xC), + 5, (unsigned short *)((u8 *)arr[1] + 0x12), 0); + break; + case 2: + a = *(u16 *)(p + 0x34); + if (a >= 1000) { + a = 999; + } + func_801E9B68(func_801E9B00((u16)a, 0x14), 3, + (unsigned short *)((u8 *)arr[2] + 8), 1); + n = p[0x42]; + if (n >= 7) { + n = 6; + } + ico = D_801EB8F8[n]; + *(u16 *)((u8 *)arr[2] + 0x10) = *ico++; + *(u16 *)((u8 *)arr[2] + 0x12) = ico[0]; + *(u16 *)((u8 *)arr[2] + 0x14) = ico[1]; + a = p[0x39]; + if (a >= 0x18) { + a = 0x17; + } + b = p[0x38]; + if (b >= 0x3C) { + b = 0x3B; + } + func_801E9B68((func_801E9B00((u16)a, 0x18) | 0xB00000) | + func_801E9B00(b, 0xC), + 5, (unsigned short *)((u8 *)arr[2] + 0x18), 0); + break; + case 3: + a = *(u16 *)(p + 0x3C); + if (a >= 1000) { + a = 999; + } + b = *(u16 *)(p + 0x3A); + if (b >= 1000) { + b = 999; + } + r = func_801E9B00((u16)a, 0x14); + if (r == 0) { + r = 0xD00000; + } + func_801E9B68(r | (func_801E9B00(b, 4) | 0xC0000), 7, + (unsigned short *)((u8 *)arr[3] + 6), 1); + break; + case 4: + a = *(u16 *)(p + 0x40); + if (a >= 1000) { + a = 999; + } + b = *(u16 *)(p + 0x3E); + if (b >= 1000) { + b = 999; + } + r = func_801E9B00((u16)a, 0x14); + if (r == 0) { + r = 0xD00000; + } + func_801E9B68(r | (func_801E9B00(b, 4) | 0xC0000), 7, + (unsigned short *)((u8 *)arr[4] + 6), 1); + break; + case 5: + a = *(u32 *)(p + 0x14); + if (a > 99999) { + a = 99999; + } + func_801E9B68(func_801E9B00(a, 0xC), 5, + (unsigned short *)((u8 *)arr[5] + 2), 1); + break; + case 6: + a = *(u16 *)(p + 0xC); + if (a >= 0x24) { + a = 0x23; + } + r = func_801E9B00((u16)a, 0x18); + if (r == 0) { + r = 0xD000000; + } + func_801E9B68(r, 2, (unsigned short *)((u8 *)arr[6] + 0x10), 1); + break; + } + } + } else { + for (i = 0; i < 7; i++) { + if (i == 0) { + *(s32 *)arr = 4; + } else if (i == 1) { + strcpy((char *)arr[i], D_801EB894[i]); + } else if (i == 4) { + strcpy((char *)arr[i], D_801EB8B4); + } else { + *(Blk3_801E95E8 *)arr[i] = D_801E7C00; + } + } + } + } +} -INCLUDE_ASM("asm/md_SC04_027/nonmatchings/md_SC04_027", func_801E95E8); u32 func_801E9B00(s32 a0, s32 a1) { s32 t0; diff --git a/src/md_SC05_026/md_SC05_026.c b/src/md_SC05_026/md_SC05_026.c index 338b1d4e6d..eeb1dcb9c5 100644 --- a/src/md_SC05_026/md_SC05_026.c +++ b/src/md_SC05_026/md_SC05_026.c @@ -300,7 +300,73 @@ INCLUDE_RODATA("asm/md_SC05_026/nonmatchings/md_SC05_026", D_801EDA60); INCLUDE_ASM("asm/md_SC05_026/nonmatchings/md_SC05_026", func_801EE0D4); -INCLUDE_ASM("asm/md_SC05_026/nonmatchings/md_SC05_026", func_801EE730); +void func_801EE730(void) { + typedef struct { u32 *ot; u32 pad[4]; } Env_801EFA40; /* 0x14 stride */ + + extern s32 D_801151D0; + extern s16 D_8011512C; + extern s32 D_80115134; + extern s16 D_800B9A02; + extern Env_801EFA40 D_800AE7BC[]; + + extern s32 *func_801EFA40(s32 *out); + extern s32 func_801EE8E0(s32 ot, u8 *s, s16 c); + extern s32 func_8005A600(s32, s32, s32, s32, s32); + + s32 ot; + u8 *s2; + s16 n; + s16 i; + + ot = D_801151D0; + s2 = (u8 *)D_80115134; + + if (D_8011512C == 1 || D_8011512C == 2) { + ot = (s32)func_801EFA40((s32 *)ot); + } + + switch (D_8011512C) { + case 0: + case 5: + case 8: + case 9: + n = 1; + break; + case 1: + case 2: + n = 5; + break; + case 3: + case 4: + case 10: + case 11: + n = 5; + goto CALL; + case 6: + case 7: + case 12: + n = 1; + CALL: + ot = func_801EE8E0(ot, s2 + 0xA0, 0); + break; + } + + for (i = 0; i < n; i++) { + ot = func_801EE8E0(ot, s2, i); + s2 += 0x20; + } + + func_8005A600(ot, 0, 0, 0x15, 0); + + *(s32 *)ot = 0x02000000; + *(s32 *)ot = (D_800AE7BC[*(u16 *)&D_800B9A02].ot[2] & 0xFFFFFF) | 0x02000000; + D_800AE7BC[*(u16 *)&D_800B9A02].ot[2] = + (D_800AE7BC[*(u16 *)&D_800B9A02].ot[2] & 0xFF000000) | ((u32)ot & 0xFFFFFF); + + ot += 0x28; + ((struct { s32 f; } *)&D_801151D0)->f = ot; +} + typedef struct { s8 c[8]; } Blk8_8012C890_8017C348_801EE8E0; typedef struct { s16 m[3][3]; s32 t[3]; } MTX_C974_801EE8E0; @@ -459,11 +525,406 @@ end: } -INCLUDE_ASM("asm/md_SC05_026/nonmatchings/md_SC05_026", func_801EEC54); +s32 func_801EEC54(void) +{ + extern s32 D_801F8310; + extern s16 D_8011512C; + extern u8 D_801F8301; + extern u8 D_801F8300[]; + extern s16 D_80115118; + extern u16 D_8011511A; + extern s32 D_801F18D8; + extern s16 D_801150D4; + extern s32 D_801F82F8; + extern u8 D_801F8309; + extern u8 D_801F8308[]; + extern u8 D_801F8304[]; + extern u8 D_801F8305; + extern u8 D_801F8306; + extern u8 D_801F8307; + extern s32 D_801F8314[]; + extern s32 D_801F1838; + extern char D_801F801C; + extern void func_8002B00C(void *); + extern void func_801EFC58(s32); + extern void func_80029774(s32); + extern s32 func_8002D4C8(s32, s32); + extern s32 func_8002AF48(s32); + extern s32 func_8002AF60(void); + extern void func_801EF448(void); -INCLUDE_ASM("asm/md_SC05_026/nonmatchings/md_SC05_026", func_801EEFBC); + s32 ret; + short i; + + ret = 0; + if (D_801F8310 != 0) { + if (D_801F8310 == 1) { + s16 *p = &D_8011512C; + + if (*p == 3 && D_801F8301 == 8) { + func_8002B00C(&D_801F801C); + func_801EFC58(0); + func_80029774(0); + *p = 4; + D_80115118 = 0x4B; + D_801F18D8 = 0x15; + D_801150D4 = D_8011511A; + func_8002D4C8(0xB3B, 0); + } else { + *p = 0; + } + } else { + D_8011512C = 0xA; + D_801F18D8 = 0x1B; + D_80115118 = 0x4B; + D_801F82F8 = 0; + return; + } + D_801F82F8 = 0; + D_801F8309 = 0xFF; + } + + if (D_8011512C == 4 || D_8011512C == 0xA) { + return; + } + if (D_801F8301 == D_801F8309) { + return; + } + + for (i = 0; i < 8; i++) { + D_801F8308[i] = D_801F8300[i]; + } + + switch (D_801F8301) { + case 0: + break; + case 1: + ret = 0xA; + D_8011512C = 0; + D_8011511A = 0; + break; + case 2: + ret = 0xB; + D_801150D4 = 0; + D_8011512C = 0; + D_8011511A = 0; + break; + case 3: + ret = 0x1F; + D_801150D4 = 0; + D_8011512C = 8; + break; + case 4: + case 5: + case 6: + reset_state: + ret = 0x13; + D_801150D4 = 0; + D_8011512C = 8; + break; + case 7: + ret = 0xA; + break; + case 8: + ret = 0xC; + if ((D_801F8304[0] | D_801F8305 | D_801F8306 | D_801F8307) == 0) { + goto reset_state; + } + for (i = 0; i < 4; i++) { + if (D_801F8304[i] == 1) { + D_801F8314[i] = func_8002AF48(i); + } else { + D_801F8314[i] = 0; + } + } + if (D_801F8314[0] == 0 && D_801F8314[1] == 0 && D_801F8314[2] == 0 && + D_801F8314[3] == 0) { + goto reset_state; + } + D_8011512C = 1; + D_8011511A = (func_8002AF60() & 3) + 1; + func_801EF448(); + break; + } + + if (ret != 0) { + D_801F1838 = ret; + } +} + + +void func_801EEFBC(void) { + extern s32 D_801F8310; + extern s32 D_801F82F8; + extern u8 D_801F8301; + extern u8 D_801F8309; + extern u8 D_801F8300[]; + extern u8 D_801F8308[]; + extern u8 D_801F8304[]; + extern s32 D_801F8314[]; + extern s32 D_801F8318; + extern s32 D_801F831C; + extern s32 D_801F8320; + extern s16 D_8011512C; + extern s16 D_80115118; + extern u16 D_8011511A; + extern u16 D_801150D4; + extern s32 D_801F18D8; + extern s32 D_801F1838; + extern void func_80029774(s32 a0); + extern s32 func_8002AF48(s32 a0); + extern s32 func_8002AF60(void); + extern s32 func_8002D4C8(s32 a0, s32 a1); + extern void func_801EF448(void); + + s32 ret; + s16 i; + s16 *p; + + ret = 0; + if (D_801F8310 != 0) { + if (D_801F8310 == 1) { + p = &D_8011512C; + if (*p == 3) { + if (D_801F8301 == 8) { + func_80029774(0); + *p = 4; + D_80115118 = 0x4B; + D_801150D4 = 0; + D_801F18D8 = 0xF; + func_8002D4C8(0xB3B, 0); + } else { + *p = 0; + } + } else { + if (D_801F8301 == 6) { + *p = 7; + D_80115118 = 0x4B; + D_801F18D8 = 0x18; + } else { + *p = 0; + } + } + } else { + if ((D_801F82F8 & 3) == 1) { + D_8011512C = 0xB; + D_801F18D8 = 0x12; + } else { + D_8011512C = 0xC; + D_801F18D8 = 0x1C; + } + D_80115118 = 0x4B; + } + D_801F82F8 = 0; + D_801F8309 = 0xFF; + } + + if (D_8011512C == 0xB || D_8011512C == 0xC) { + return; + } + if (D_801F8301 == D_801F8309) { + return; + } + + for (i = 0; i < 8; i++) { + D_801F8308[i] = D_801F8300[i]; + } + + switch (D_801F8301) { + case 0: + break; + case 1: + ret = 0xA; + D_8011512C = 0; + D_8011511A = 0; + break; + case 2: + ret = 0xB; + D_801150D4 = 0; + D_8011512C = 0; + D_8011511A = 0; + break; + case 3: { + s16 *q = &D_8011512C; + D_801150D4 = 0; + if (((struct { s16 h; } *)q)->h != 0xC) { + ret = 0x11; + *q = 5; + } + break; + } + case 4: + D_801150D4 = 0; + D_8011512C = 8; + ret = 0xB; + break; + case 5: + D_8011512C = 8; + ret = 0x10; + break; + case 6: { + s16 *q = &D_8011512C; + D_801150D4 = 0; + if ((*q != 6) && (*q != 7) && (*q != 0xB)) { + ret = 0xD; + *q = 1; + } + for (i = 0; i < 4; i++) { + D_801F8314[i] = 0; + } + D_8011511A = 1; + func_801EF448(); + break; + } + case 7: + ret = 0xA; + break; + case 8: { + s16 *q; + if ((D_8011512C != 0xB) && (D_8011512C != 3) && (D_8011512C != 4)) { + ret = 0xD; + } + for (i = 0; i < 4; i++) { + if (D_801F8304[i] == 1) { + D_801F8314[i] = func_8002AF48(i); + } else { + D_801F8314[i] = 0; + } + } + q = &D_8011512C; + if (*q == 0) { + *q = 1; + if ((u32)(D_801150D4 - 1) < 4) { + D_8011511A = D_801150D4; + } else { + D_8011511A = (func_8002AF60() & 3) + 1; + } + if ((D_801F8314[0] == 0) && (D_801F8314[1] == 0) && (D_801F8314[2] == 0) && + (D_801F8314[3] == 0)) { + D_801150D4 = 0; + D_8011511A = 1; + } + } + func_801EF448(); + break; + } + } + + if (ret != 0) { + D_801F1838 = ret; + } +} + + +typedef struct { char c[3]; } Blk3_801EF448; + +extern char *strcpy(char *, const char *); +extern u32 func_801EF960(s32 a0, s32 a1); +extern void func_801EF9C8(); + +extern void *D_801F8314[]; +extern void *D_801F1814[]; +extern char *D_801F171C[]; +extern s32 D_801F19A8[]; +extern u16 *D_801F1780[]; +extern char *D_801F173C; +extern Blk3_801EF448 D_801EDA60; + +void func_801EF448(void) { + s16 k; s16 i; s16 j; + u8 *p; + void **arr; + u32 a; u32 b; + s32 r; s32 n; + u16 *ico; + + for (k = 0; k < 4; k++) { + p = (u8 *)D_801F8314[k]; + arr = (void **)D_801F1814[k]; + if (p != NULL) { + for (i = 0; i < 7; i++) { + strcpy((char *)arr[i], D_801F171C[i]); + switch (i) { + case 0: + for (j = 0; j < 5; j++) { + if (*(s16 *)(p + 8) < D_801F19A8[j]) break; + } + if (p[0x4E] != 0) { + j = (*(s32 *)p == 0) ? 0x1A : 0x1C; + } + *(s32 *)arr = j + 4; + break; + case 1: + a = p[7]; + if (a >= 100) a = 99; + b = p[6]; + if (b >= 60) b = 59; + func_801EF9C8((func_801EF960((u16)a, 0x18) | 0xB00000) | func_801EF960(b, 0xC), 5, (u8 *)arr[1] + 0x12, 0); + break; + case 2: + a = *(u16 *)(p + 0x34); + if (a >= 1000) a = 999; + func_801EF9C8(func_801EF960((u16)a, 0x14), 3, (u8 *)arr[2] + 8, 1); + n = p[0x42]; + if (n >= 7) n = 6; + ico = D_801F1780[n]; + *(u16 *)((u8 *)arr[2] + 0x10) = *ico++; + *(u16 *)((u8 *)arr[2] + 0x12) = ico[0]; + *(u16 *)((u8 *)arr[2] + 0x14) = ico[1]; + a = p[0x39]; + if (a >= 0x18) a = 0x17; + b = p[0x38]; + if (b >= 0x3C) b = 0x3B; + func_801EF9C8((func_801EF960((u16)a, 0x18) | 0xB00000) | func_801EF960(b, 0xC), 5, (u8 *)arr[2] + 0x18, 0); + break; + case 3: + a = *(u16 *)(p + 0x3C); + if (a >= 1000) a = 999; + b = *(u16 *)(p + 0x3A); + if (b >= 1000) b = 999; + r = func_801EF960((u16)a, 0x14); + if (r == 0) r = 0xD00000; + func_801EF9C8(r | (func_801EF960(b, 4) | 0xC0000), 7, (u8 *)arr[3] + 6, 1); + break; + case 4: + a = *(u16 *)(p + 0x40); + if (a >= 1000) a = 999; + b = *(u16 *)(p + 0x3E); + if (b >= 1000) b = 999; + r = func_801EF960((u16)a, 0x14); + if (r == 0) r = 0xD00000; + func_801EF9C8(r | (func_801EF960(b, 4) | 0xC0000), 7, (u8 *)arr[4] + 6, 1); + break; + case 5: + a = *(u32 *)(p + 0x14); + if (a > 99999) a = 99999; + func_801EF9C8(func_801EF960(a, 0xC), 5, (u8 *)arr[5] + 2, 1); + break; + case 6: + a = *(u16 *)(p + 0xC); + if (a >= 0x24) a = 0x23; + r = func_801EF960((u16)a, 0x18); + if (r == 0) r = 0xD000000; + func_801EF9C8(r, 2, (u8 *)arr[6] + 0x10, 1); + break; + } + } + } else { + for (i = 0; i < 7; i++) { + if (i == 0) { + *(s32 *)arr = 4; + } else if (i == 1) { + strcpy((char *)arr[i], D_801F171C[i]); + } else if (i == 4) { + strcpy((char *)arr[i], D_801F173C); + } else { + *(Blk3_801EF448 *)arr[i] = D_801EDA60; + } + } + } + } +} -INCLUDE_ASM("asm/md_SC05_026/nonmatchings/md_SC05_026", func_801EF448); u32 func_801EF960(s32 a0, s32 a1) { s32 t0; diff --git a/src/md_SC07_003/md_SC07_003.c b/src/md_SC07_003/md_SC07_003.c index 8c6743b367..64fe837307 100644 --- a/src/md_SC07_003/md_SC07_003.c +++ b/src/md_SC07_003/md_SC07_003.c @@ -666,7 +666,75 @@ void func_801A16BC(s32 arg0) { } -INCLUDE_ASM("asm/md_SC07_003/nonmatchings/md_SC07_003", func_801A1724); +#include "common.h" + +extern s32 func_801A19C8(s32 a0); +extern s32 func_80153BD8(s32 a0); +extern void func_801A1924(s32 a0); +extern void func_8012A828(s32 a0, void *a1); +extern void func_8002D4C8(s32 a0, s32 a1); +extern void func_80153C44(s32 a0, s32 a1, s16 a2); + +extern u8 D_801F1340[]; +extern u8 D_801F1238[]; + +void func_801A1724(s32 arg0) { + volatile s32 pad[10]; + + switch (*(u16 *)(arg0 + 0x34)) { + case 0: + if (func_801A19C8(arg0) == 1) { + *(u16 *)(arg0 + 0x34) += 1; + *(s32 *)(arg0 + 0xE0) |= 0x40; + } else if (*(s16 *)(arg0 + 0x98) == 0) { + func_8012A828(arg0, D_801F1238); + *(u16 *)(arg0 + 0x34) = 4; + } + break; + case 1: + if (func_80153BD8(arg0) != 0) { + *(s32 *)(arg0 + 0xE0) |= 8; + *(u16 *)(arg0 + 0x5C) &= ~0x800; + } else { + *(s32 *)(arg0 + 0xE0) &= ~0x40; + } + *(u16 *)(arg0 + 0x34) += 1; + case 2: + if ((*(s32 *)(arg0 + 0xE0) & 8) != 0) { + func_801A1924(arg0); + } + if (*(s16 *)(arg0 + 0x98) == 0) { + if ((*(s32 *)(arg0 + 0xE0) & 8) != 0) { + func_8012A828(arg0, D_801F1340); + *(u16 *)(arg0 + 0x34) = 3; + } else { + func_8012A828(arg0, D_801F1238); + *(u16 *)(arg0 + 0x34) = 4; + } + } + break; + case 3: + if (*(s32 *)(arg0 + 0x94) < 0x86) { + func_801A1924(arg0); + } + if (*(s32 *)(arg0 + 0x94) == 0x3E) { + func_8002D4C8(0xC18, 0); + } + if (*(s32 *)(arg0 + 0x94) == 0x86) { + func_80153C44(1, 0x50, *(s16 *)(*(s32 *)(arg0 + 0x20) + 0x12)); + func_8002D4C8(0xC17, 0); + func_8002D4C8(0xC7B, 0); + } + case 4: + if (*(s16 *)(arg0 + 0x98) == 0) { + *(u16 *)(arg0 + 2) = 3; + *(u16 *)(arg0 + 0x5C) |= 0x800; + *(s32 *)(arg0 + 0xE0) &= ~0x40; + } + break; + } +} + #include "common.h" @@ -1621,7 +1689,72 @@ void func_801A3190(void *a0) { } -INCLUDE_ASM("asm/md_SC07_003/nonmatchings/md_SC07_003", func_801A31CC); +void func_801A31CC(void *arg0) { + s32 v0; + u8 *a1; + + extern u8 D_801A6D58[]; + extern s32 func_8012C1B8(void); + extern void func_8012CAE4(void *a0); + extern void func_8001C214(s32 a0, s32 a1); + + *(s32 *)((u8 *)arg0 + 0x78) = (s32)D_801A6D58; + v0 = func_8012C1B8(); + *(s32 *)((u8 *)arg0 + 0x20) = v0; + if (v0 == 0) { + func_8012CAE4(arg0); + return; + } + func_8001C214(v0, 0); + a1 = (u8 *)arg0 + 0xCC; + *(s32 *)((u8 *)arg0 + 0x58) = (s32)a1 | 0x50000000; + *(u8 *)((u8 *)arg0 + 0x75) = 2; + *(s32 *)((u8 *)arg0 + 0xF8) = *(s16 *)(*(s32 *)((u8 *)arg0 + 0x64) + 0x36); + switch (*(s16 *)((u8 *)arg0 + 0x70)) { + case 0: { + s32 link; + link = (s32)(a1 + 0x10); + *(s32 *)a1 = link; + a1 = (u8 *)link; + link = (s32)(a1 + 0x10); + *(s32 *)a1 = link; + __asm__ __volatile__("" : "=r"(link) : "0"(link)); + *(s32 *)link = 0; + __asm__ __volatile__("" : : : "memory"); + *(u16 *)((u8 *)arg0 + 0x5C) = 0xC800; + *(s16 *)((u8 *)arg0 + 0xAE) = -1; + *(s16 *)((u8 *)arg0 + 0x2) = 1; + break; + } + case 1: + *(s16 *)((u8 *)arg0 + 0xAE) = -3; + *(u16 *)((u8 *)arg0 + 0x5C) = 0x8800; + *(s16 *)((u8 *)arg0 + 0x2) = 2; + break; + case 2: + *(u16 *)((u8 *)arg0 + 0x5C) = 0x8800; + *(s16 *)((u8 *)arg0 + 0xAE) = -0x10; + *(s16 *)((u8 *)arg0 + 0x2) = 3; + break; + case 3: + *(u16 *)((u8 *)arg0 + 0x5C) = 0xC000; + *(s16 *)((u8 *)arg0 + 0xAE) = -1; + *(s16 *)((u8 *)arg0 + 0x2) = 4; + break; + case 4: + *(u16 *)((u8 *)arg0 + 0x5C) = 0x800; + *(s16 *)((u8 *)arg0 + 0xAE) = -1; + *(s16 *)((u8 *)arg0 + 0x2) = 5; + *(s16 *)(a1 + 4) = -0x10; + *(s16 *)(a1 + 6) = 0x10; + *(s16 *)(a1 + 8) = -0x100; + *(s16 *)(a1 + 0xA) = 0; + *(s16 *)(a1 + 0xC) = -0x10; + *(s16 *)(a1 + 0xE) = 0x10; + break; + } +} + #include "common.h" diff --git a/src/ov_SC03_118/ov_SC03_118_o0d.c b/src/ov_SC03_118/ov_SC03_118_o0d.c index c96eb1dbf6..5f1f48decd 100644 --- a/src/ov_SC03_118/ov_SC03_118_o0d.c +++ b/src/ov_SC03_118/ov_SC03_118_o0d.c @@ -2862,7 +2862,14 @@ INCLUDE_ASM("asm/ov_SC03_118/nonmatchings/ov_SC03_118_o0d", func_801831D0); INCLUDE_ASM("asm/ov_SC03_118/nonmatchings/ov_SC03_118_o0d", func_80183228); -INCLUDE_ASM("asm/ov_SC03_118/nonmatchings/ov_SC03_118_o0d", func_80183280); +typedef struct { u8 unk0[2]; u16 unk2; } Ent_80183280; + +extern void (*D_8018E14C[])(Ent_80183280 *); + +void func_80183280(Ent_80183280 *arg) { + D_8018E14C[arg->unk2](arg); +} + INCLUDE_ASM("asm/ov_SC03_118/nonmatchings/ov_SC03_118_o0d", func_801832E0); diff --git a/src/ov_SC03_119/ov_SC03_119_o0d.c b/src/ov_SC03_119/ov_SC03_119_o0d.c index 1e7395391b..d7781d37ea 100644 --- a/src/ov_SC03_119/ov_SC03_119_o0d.c +++ b/src/ov_SC03_119/ov_SC03_119_o0d.c @@ -2834,14 +2834,111 @@ INCLUDE_ASM("asm/ov_SC03_119/nonmatchings/ov_SC03_119_o0d", func_801831D0); INCLUDE_ASM("asm/ov_SC03_119/nonmatchings/ov_SC03_119_o0d", func_80183228); -INCLUDE_ASM("asm/ov_SC03_119/nonmatchings/ov_SC03_119_o0d", func_80183280); +typedef struct { u8 unk0[2]; u16 unk2; } Ent_80183280; + +extern void (*D_8018E14C[])(Ent_80183280 *); + +void func_80183280(Ent_80183280 *arg) { + D_8018E14C[arg->unk2](arg); +} + INCLUDE_ASM("asm/ov_SC03_119/nonmatchings/ov_SC03_119_o0d", func_801832E0); -INCLUDE_ASM("asm/ov_SC03_119/nonmatchings/ov_SC03_119_o0d", func_801833C4); +void func_801833C4(s32 arg0) +{ + extern u8 D_801D47E0[]; + extern u8 D_801B5D38[]; + extern u8 D_801B86B4[]; + extern s32 D_801270C8; + + typedef struct { + u8 pad0[2]; + union { s16 s; u16 u; } f02; + u8 pad1[0xD8]; + union { s16 s; u16 u; } fDC; + u8 pad2[4]; + s16 fE2; + u8 pad3[2]; + s16 fE6; + u8 pad4[4]; + u16 fEC; + u16 fEE; + } St; + +#define P ((St *)arg0) + + func_80180A64(D_801D47E0, D_801B5D38, P->fDC.s, P->fE2); + func_80180A64(D_801D47E0, D_801B86B4, P->fDC.s, P->fE6); + P->fDC.u = P->fDC.u + 8; + if (D_801270C8 != 0) { + func_8002D4C8(0x77B, 0); + P->fEC = 1; + P->fEE = 0x3C; + P->f02.u++; + } +} + INCLUDE_ASM("asm/ov_SC03_119/nonmatchings/ov_SC03_119_o0d", func_801834DC); -INCLUDE_ASM("asm/ov_SC03_119/nonmatchings/ov_SC03_119_o0d", func_80183634); +extern s32 D_801D47E0; +extern s32 D_801B5D38; +extern s32 D_801B86B4; +extern s32 D_801270C8; +extern void func_8013373C(s32 a0); + +typedef struct { + u8 pad0[2]; + u16 f002; + u8 pad1[0xD8]; + struct { + s16 f0DC; + u16 f0DE; + union { + struct { s32 f0E0; s32 f0E4; } l; + struct { u8 p[2]; s16 f0E2; u8 q[2]; s16 f0E6; } h; + } u; + u16 f0E8; + } f; +} Work_80183634; + +void func_80183634(Work_80183634 *work) +{ + func_80180A64(&D_801D47E0, &D_801B5D38, work->f.f0DC, work->f.u.h.f0E2); + func_80180A64(&D_801D47E0, &D_801B86B4, work->f.f0DC, work->f.u.h.f0E6); + work->f.u.l.f0E0 = work->f.u.l.f0E0 + -0x252E5; + work->f.u.l.f0E4 = work->f.u.l.f0E4 + 0x168D6; + work->f.f0DC = work->f.f0DC + 0xC; + if ((s16)(++work->f.f0E8) >= 0x6A) { + func_8002D4C8(4, 0x77B); + D_801270C8 = 2; + func_8013373C(0); + ++work->f002; + } +} + + +void func_801837B0(s32 arg0) +{ + typedef struct { + u8 _[0xDC]; + s16 fDC; + u8 _2[4]; + s16 fE2; + } Args_801837B0; + typedef struct { + u8 _[0xDC]; + u16 fDC; + } Rmw_801837B0; + + extern s32 D_801D47E0; + extern s32 D_801B5D38; + extern void func_80180A64(s32 arg0, s32 arg1, s32 arg2, s32 arg3); + + func_80180A64(&D_801D47E0, &D_801B5D38, + ((Args_801837B0 *)arg0)->fDC, + ((Args_801837B0 *)arg0)->fE2); + ((Rmw_801837B0 *)arg0)->fDC += 7; +} -INCLUDE_ASM("asm/ov_SC03_119/nonmatchings/ov_SC03_119_o0d", func_801837B0); diff --git a/src/ov_SC04_018/ov_SC04_018_jr_8017AE2C.c b/src/ov_SC04_018/ov_SC04_018_jr_8017AE2C.c index 9b9da64bbf..c9ce2fe916 100644 --- a/src/ov_SC04_018/ov_SC04_018_jr_8017AE2C.c +++ b/src/ov_SC04_018/ov_SC04_018_jr_8017AE2C.c @@ -4856,9 +4856,38 @@ extern void func_80178CBC(s32*, s32); INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_jr_8017AE2C", func_8017E8A4); -INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_jr_8017AE2C", func_8017E8FC); +extern s16 D_80191110[]; +extern s32 D_80191270; +extern s32 D_801E7AAC; +extern s32 func_80029504(void); + +void func_8017E8FC() { + extern s16 D_80191110[]; + extern s32 D_80191270; + extern s32 D_801E7AAC; + + if (func_80029504() < 0x2BC) { + *(s32 *)(D_801E7AAC + 4) = (s32)D_80191110; + } else { + *(s32 *)(D_801E7AAC + 4) = (s32)&D_80191270; + } +} + + +extern s32 func_80029504(void); +extern s32 func_8012E544(s32 a0); +extern void func_80029514(s32); + +void func_8017E950() { + s32 v1 = func_8012E544(0x22B); + if (v1 != 0) { + *(s16 *)(v1 + 0x34) = 1; + } + if (func_80029504() < 0x2BC) { + func_80029514(0x2BC); + } +} -INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_jr_8017AE2C", func_8017E950); extern void func_8012C588(s32, s32); void func_8017E99C(void) { @@ -4896,7 +4925,37 @@ void func_8017EAAC(void * arg0) { } -INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_jr_8017AE2C", func_8017EAFC); +extern s16 D_8019107C; +extern s32 func_80029504(void); +extern s32 func_801788B8(s32 arg0, s32 arg1); +extern s32 func_801847BC(void *a0, void *a1); +extern s32 func_80184BAC(s32 arg0, s32 arg1); +extern short D_80191074; +extern void func_8012CAE4(void *a0); +extern s32 func_8017EDA4(void*); +extern void func_80184CB8(s32*, s32); + +void func_8017EAFC(a0) +void *a0; +{ + s32 v0; + void *v1; + + if (func_80029504() < 0x2A8) { + func_8012CAE4(a0); + } else { + v0 = func_801847BC(a0, &D_8019107C); + if (v0 != 0) { + v0 = func_80184BAC(8, 0x14); + *(s16 *)((char *)a0 + 0x2) = (v0 != 0) ? 2 : 1; + func_80184CB8((s32 *)a0, (s32)&D_80191074); + v1 = *(void **)((char *)a0 + 0x68); + *(s16 *)((char *)v1 + 0xC) = 0x7FFF; + *(s32 *)((char *)a0 + 0xD4) = func_801788B8((s32)a0, (s32)&func_8017EDA4); + } + } +} + extern void func_8012AD80(s32 a0); extern s32 func_8012BEE8(s32 a0); @@ -4993,7 +5052,62 @@ s32 func_8017EDA4(void *a0) } -INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_jr_8017AE2C", func_8017EE6C); +extern s32 D_8019133C; +extern s32 D_80191364; +extern s32 D_8019138C; +extern s32 D_801913B4; +extern s32 D_80191484; +extern s32 D_80191494; +extern s32 D_8019151C; +extern s32 D_8019152C; +extern s32 D_8019153C; +extern s32 D_8019154C; +extern s32 D_801E7AAC; + +void func_8017EE6C(void) +{ + s32 t; + s32 c; + + t = func_80029504(); + if (t < 0x276) { + c = func_80029178(0x10C) & 0xFF; + if (c != 0) { + *(s32 *)(D_801E7AAC + 4) = (s32)&D_80191364; + } else { + c = func_80029178(0x10D) & 0xFF; + if (c != 0) { + *(s32 *)(D_801E7AAC + 4) = (s32)&D_80191484; + } else { + *(s32 *)(D_801E7AAC + 4) = (s32)&D_8019133C; + } + } + } else if (t < 0x280) { + c = func_80029178(0x10C) & 0xFF; + if (c != 0) { + *(s32 *)(D_801E7AAC + 4) = (s32)&D_8019138C; + } else { + c = func_80029178(0x10D) & 0xFF; + if (c != 0) { + *(s32 *)(D_801E7AAC + 4) = (s32)&D_80191494; + } else { + *(s32 *)(D_801E7AAC + 4) = (s32)&D_801913B4; + } + } + } else if (t < 0x294) { + if (func_800D0F8C(0x63) != 0 || func_800D0F8C(0x64) != 0 || + func_800D0F8C(0x65) != 0 || func_800D0F8C(0x66) != 0) { + *(s32 *)(D_801E7AAC + 4) = (s32)&D_8019152C; + } else { + *(s32 *)(D_801E7AAC + 4) = (s32)&D_8019151C; + } + } else if (t < 0x2E4) { + *(s32 *)(D_801E7AAC + 4) = (s32)&D_8019153C; + } else { + *(s32 *)(D_801E7AAC + 4) = (s32)&D_8019154C; + } +} + extern void func_80184CB8(s32*, s32); @@ -5025,7 +5139,13 @@ s32 func_8017F0C0(void) { } -INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_jr_8017AE2C", func_8017F0D8); +extern void func_80029124(s32, s32); + +void func_8017F0D8() { + func_80029124(0x10C, 1); + func_80029124(0x10D, 0); +} + extern void func_80029124(s32 arg0, s32 arg1); @@ -5035,7 +5155,19 @@ extern void func_80029124(s32 arg0, s32 arg1); } -INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_jr_8017AE2C", func_8017F138); +extern s32 D_801E79A0; +extern s32 D_801E7AAC; + +void func_8017F138() { + extern s32 D_801E79A0; + + if (D_801E79A0 == 1) { + *(s32 *)(D_801E7AAC + 4) = D_801E7AAC + 8; + } else { + *(s32 *)(D_801E7AAC + 4) = D_801E7AAC + 0x18; + } +} + #include "common.h" @@ -5068,7 +5200,34 @@ void func_8017F28C(void * arg0) { } -INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_jr_8017AE2C", func_8017F2DC); +extern s32 func_801788B8(s32 arg0, s32 arg1); +extern s32 func_801847BC(void *a0, void *a1); +extern s32 func_80184BAC(s32 arg0, s32 arg1); +extern short D_801912D8; +extern u8 D_801912E0; +extern void func_8017F35C(); +extern void func_80184CB8(s32 *a0, s32 a1); + +void func_8017F2DC(a0) +void *a0; +{ + s32 v0; + void *v1; + + if (func_801847BC(a0, &D_801912E0) != 0) { + v0 = func_80184BAC(8, 0x14); + if (v0 != 0) { + *(s16 *)((char *)a0 + 0x2) = 2; + } else { + *(s16 *)((char *)a0 + 0x2) = 1; + } + func_80184CB8((s32 *)a0, (s32)&D_801912D8); + v1 = *(void **)((char *)a0 + 0x68); + *(s16 *)((char *)v1 + 0xC) = 0x7FFF; + *(s32 *)((char *)a0 + 0xD4) = func_801788B8((s32)a0, (s32)&func_8017F35C); + } +} + INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_jr_8017AE2C", func_8017F35C); @@ -5127,7 +5286,27 @@ ret0: } -INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_jr_8017AE2C", func_8017F500); +extern short D_801B99A8; +extern u8 D_801E396C[]; +extern void func_8012A828(s32*, s32); +extern void func_8012E88C(s32); +extern void func_80184C90(s32); +extern void func_80184ED4(s32, s32, s32, s32); + +void func_8017F500(arg0) +void *arg0; +{ + extern short D_801B99A8; + extern u8 D_801E396C[]; + + *(short *)((char *)arg0 + 0x2) = 5; + *(short *)((char *)arg0 + 0x34) = 0; + func_8012E88C((s32)arg0); + ((void (*)(s32, s32))func_8012A828)((s32)arg0, (s32)&D_801B99A8); + func_80184C90((s32)arg0); + func_80184ED4((s32)arg0, (s32)D_801E396C, 0, 0x60); +} + INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_jr_8017AE2C", func_8017F564); @@ -5327,7 +5506,42 @@ void func_8017F898(void *a0) { } -INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_jr_8017AE2C", func_8017F978); +extern int func_800D0F8C(int a0); +extern s32 D_801E7AAC; +extern s32 func_80029178(s32 arg); +extern s32 func_80029504(void); +extern void (*D_801915D4[])(void); + +void func_8017F978() +{ + s32 a0 = func_80029504(); + s32 v1; + + if (a0 < 0x280) { + v1 = 0; + } else if (a0 < 0x2B2) { + if ((func_80029178(0x107) & 0xFF) == 0) { + v1 = 1; + } else if (func_800D0F8C(0x63) != 0) { + v1 = 3; + } else if (func_800D0F8C(0x64) != 0) { + v1 = 3; + } else if (func_800D0F8C(0x65) != 0) { + v1 = 3; + } else if (func_800D0F8C(0x66) != 0) { + v1 = 3; + } else { + v1 = 2; + } + } else if (a0 < 0x2E4) { + v1 = 4; + } else { + v1 = 5; + } + + *(s32 *)(D_801E7AAC + 4) = (s32)D_801915D4[v1]; +} + extern void func_80029124(s32 arg0, s32 arg1); void func_8017FA34(void) { @@ -5424,7 +5638,30 @@ void func_8017FBB0(void *a0) { } -INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_jr_8017AE2C", func_8017FC58); +extern s32 func_80184BD0(u8 a0, u8 a1, u8 a2, u8 a3); +extern short D_801B99A8; +extern u8 D_801E3978[]; +extern void func_8012A828(s32*, s32); +extern void func_8012E88C(s32); +extern void func_80184C90(s32); +extern void func_80184ED4(s32, s32, s32, s32); + +void func_8017FC58(arg0) +void *arg0; +{ + + extern short D_801B99A8; + if (func_80184BD0(0xB, 0, 0xE, 0xF) != 0) { + return; + } + *(short *)((char *)arg0 + 0x2) = 0xB; + *(short *)((char *)arg0 + 0x34) = 0; + func_8012E88C((s32)arg0); + func_8012A828((s32 *)arg0, (s32)&D_801B99A8); + func_80184C90((s32)arg0); + func_80184ED4((s32)arg0, (s32)D_801E3978, 1, 0x60); +} + extern int func_80178970(void); @@ -5464,10 +5701,88 @@ void func_8017FF34(void *a0) { } -INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_jr_8017AE2C", func_8017FF70); +extern int func_80178970(void); +extern s32 D_80126B9C; +extern s32 D_8019171C; +extern s32 D_80191744; +extern s32 func_80178B18(s32 param_1, s32 param_2); +extern void func_80029514(s32); +extern void func_80178D18(void); +extern void func_80184CB8(s32*, s32); + +void func_8017FF70(a0) +void *a0; +{ + u16 v1; + + v1 = *(u16 *)((s32)a0 + 0x34); + switch (v1) { + case 0: + if ((D_80126B9C & 0x8000000) != 0) { + *(u16 *)((s32)a0 + 0x34) = 1; + func_80178B18((s32)a0, (s32)&D_80191744); + } + break; + case 1: + if (((s32 (*)(s32))func_80178970)((s32)a0) != 0) { + ((void (*)(s32))func_80178D18)((s32)a0); + func_80029514(0x2B2); + *(u16 *)((s32)a0 + 0x34) = 2; + ((void (*)(s32, s32))func_80184CB8)((s32)a0, (s32)&D_8019171C); + } + break; + case 2: + break; + } +} -INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_jr_8017AE2C", func_8018001C); + +extern s32 D_8019171C; +extern s32 func_80029504(void); +extern short D_801B9B50; +extern short D_801C7A90; +extern void func_8001C214(s32, s32); +extern void func_8012A828(s32*, s32); +extern void func_8012B2CC(s32 a0); +extern void func_8012C1B8(void); +extern void func_8012CAE4(void *a0); +extern void func_8012E88C(s32); +extern void func_8012E8E0(s32 a0, s32 a1); +extern void func_80184C90(s32); + +void func_8018001C(arg0) +void *arg0; +{ + extern short D_801C7A90; + extern s32 D_8019171C; + extern short D_801B9B50; + s32 t; + s32 v; + s32 v1; + + t = func_80029504(); + if ((u32)(t - 0x2A8) >= 10) { + func_8012CAE4(arg0); + return; + } + v = ((s32 (*)())func_8012C1B8)(); + *(s32 *)((s32)arg0 + 0x20) = v; + if (v == 0) { + func_8012CAE4(arg0); + } + func_8001C214(*(s32 *)((s32)arg0 + 0x20), (s32)&D_801C7A90); + func_80184C90((s32)arg0); + v1 = *(s32 *)((s32)arg0 + 0x68); + *(short *)((s32)arg0 + 0x2) = 1; + *(short *)((s32)arg0 + 0x34) = 0; + *(short *)(v1 + 0xC) = 0x7FFF; + func_8012E8E0((s32)arg0, (s32)&(*(short *)&D_8019171C)); + func_8012B2CC((s32)arg0); + func_8012E88C((s32)arg0); + func_8012A828((s32 *)arg0, (s32)&D_801B9B50); +} + DEFINE_func_801800E0() /* dedup: shared engine-core @0x801800E0 (src/shared) */ @@ -5502,7 +5817,41 @@ extern void func_80178CBC(s32*, s32); DEFINE_func_80180190() /* dedup: shared engine-core @0x80180190 (src/shared) */ -INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_jr_8017AE2C", func_801801E0); +extern s32 func_80029504(void); +extern s32 func_801788B8(s32 arg0, s32 arg1); +extern s32 func_80180284(void); +extern short D_8019181C; +extern void func_8001C214(s32, s32); +extern void func_8012C1B8(void); +extern void func_8012CAE4(void *a0); +extern void func_80184CB8(s32*, s32); + +void func_801801E0(arg0) +void *arg0; +{ + extern short D_8019181C; + s32 t; + s32 v; + void *v1; + + t = func_80029504(); + if ((u32)(t - 0xC8) >= 0x1AE) { + func_8012CAE4(arg0); + return; + } + v = ((s32 (*)())func_8012C1B8)(); + *(s32 *)((char *)arg0 + 0x20) = v; + if (v == 0) { + func_8012CAE4(arg0); + } + func_8001C214(*(s32 *)((char *)arg0 + 0x20), 0); + *(s16 *)((char *)arg0 + 2) = 1; + func_80184CB8((s32 *)arg0, (s32)&D_8019181C); + v1 = *(void **)((char *)arg0 + 0x68); + *(s16 *)((char *)v1 + 0xC) = 0x7FFF; + *(s32 *)((char *)arg0 + 0xD4) = func_801788B8((s32)arg0, (s32)&func_80180284); +} + INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_jr_8017AE2C", func_80180284); @@ -5548,7 +5897,15 @@ DEFINE_func_8018042C() /* dedup: shared engine-core @0x8018042C (src/shared) */ DEFINE_func_8018048C() /* dedup: shared engine-core @0x8018048C (src/shared) */ -INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_jr_8017AE2C", func_801804C8); +extern void func_80178CBC(s32*, s32); +extern short D_8019195C; + +void func_801804C8(s32 arg0) { + *(short *)((char *)arg0 + 0x2) = 0x5; + ((void (*)(s32 *, s32))func_80178CBC)((s32 *)arg0, (s32)&D_8019195C); + *(short *)((char *)arg0 + 0x34) = 0; +} + extern s32 func_80184DD0(s32 a0); extern s32 D_80191918[]; @@ -5738,7 +6095,87 @@ extern void func_80184CB8(s32*, s32); } -INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_jr_8017AE2C", func_80180A08); +extern s32 func_801847BC(void *a0, void *a1); +extern s32 func_80184BAC(s32 a0, s32 a1); +extern void func_8012E88C(s32); +extern void func_8012A828(s32*, s32); +extern void func_80184C90(s32); +extern s32 func_801788B8(s32, s32); +extern void func_80184CB8(s32*, s32); +extern void func_8012E8E0(s32, s32); +extern s32 func_80184DD0(); +extern s32 func_80029504(void); +extern s32 func_80180CC0(void*); +extern s32 func_80180D38(void*); + +void func_80180A08(void *arg0) { + + extern short D_801919F0; + extern short D_801919E0; + extern short D_801919E8; + extern short D_801B9B50; + + void *s0 = arg0; + void *ptr; + s32 code; + s32 a0val; + s32 dd; + s32 sel; + + if (func_801847BC(arg0, &D_801919F0) == 0) { + return; + } + + func_80184CB8((s32 *)s0, (s32)&D_801919E0); + + ptr = *(void **)((u8 *)s0 + 0x68); + *(s16 *)((u8 *)ptr + 0xC) = 0x7FFF; + + *(s32 *)((u8 *)s0 + 0xD4) = func_801788B8((s32)s0, (s32)&func_80180CC0); + *(s32 *)((u8 *)s0 + 0xD8) = func_801788B8((s32)s0, (s32)&func_80180D38); + + dd = ((s32 (*)(void))func_80184DD0)(); + sel = func_80029504(); + + if (dd == 2 && sel < 0x276) { + a0val = 0xA; + } else { + if (func_80184BAC(0xA, 0x10) != 0) { + code = 0; + goto ladder_done; + } + a0val = 0x10; + } + if (func_80184BAC(a0val, 0x16) != 0) { + code = 1; + } else { + code = 2; + } +ladder_done: + + { + s16 next_state; + switch (code) { + case 0: + *(s16 *)((u8 *)s0 + 0x2) = 3; + func_8012E8E0((s32)s0, (s32)&D_801919E8); + func_8012E88C((s32)s0); + func_8012A828((s32)s0, (s32)&D_801B9B50); + func_80184C90((s32)s0); + break; + case 1: + next_state = 5; + goto set_and_notify; + case 2: + next_state = 1; + set_and_notify: + *(s16 *)((u8 *)s0 + 0x2) = next_state; + func_80184CB8((s32 *)s0, (s32)&D_801919E0); + break; + } + } +} + extern void (*D_80191A80[])(void); @@ -5835,7 +6272,46 @@ s32 func_80180CC0(void *a0) DEFINE_func_80180D38() /* dedup: shared engine-core @0x80180D38 (src/shared) */ -INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_jr_8017AE2C", func_80180E28); +void func_80180E28(s32 a0) { + s32 s2; + s32 code; + s32 a0val; + s32 dd; + s32 sel; + + s2 = a0; + *(s32 *)(*(s32 *)(s2 + 0xCC) + 0xB0) = 2; + dd = func_80184DD0(a0); + sel = func_80029504(); + + if (dd == 2 && sel < 0x276) { + a0val = 0xA; + } else { + if (func_80184BAC(0xA, 0x10) != 0) { + code = 0; + goto ladder_done; + } + a0val = 0x10; + } + if (func_80184BAC(a0val, 0x16) != 0) { + code = 1; + } else { + code = 2; + } +ladder_done: + + switch (code) { + case 0: + func_80180888((void *)a0); + break; + case 1: + func_801809DC((void *)a0); + break; + case 2: + break; + } +} + #include "common.h" @@ -5912,7 +6388,63 @@ void func_80181090(void *arg0) { } -INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_jr_8017AE2C", func_80181124); +extern s32 func_80029504(void); +extern s32 func_80184BAC(s32 arg0, s32 arg1); +extern s32 func_80184DD0(s32 a0); +extern short D_801919E0; +extern void func_80184CB8(s32*, s32); + +void func_80181124(arg0) +void *arg0; +{ + extern s32 func_80029504(void); + extern s32 func_80184BAC(s32 arg0, s32 arg1); + extern void func_80184CB8(s32*, s32); + extern s32 func_80184DD0(s32 a0); + extern short D_801919E0; + + void *s2 = arg0; + s32 state; + s32 dd; + s32 sel; + s32 code; + s32 a0val; + + state = 2; + *(s32 *)(*(s32 *)((char *)s2 + 0xCC) + 0xB0) = state; + dd = func_80184DD0((s32)arg0); + sel = func_80029504(); + + if (dd == state && sel < 0x276) { + a0val = 0xA; + } else { + if (func_80184BAC(0xA, 0x10) != 0) { + code = 0; + goto ladder_done; + } + a0val = 0x10; + } + if (func_80184BAC(a0val, 0x16) != 0) { + code = 1; + } else { + code = 2; + } +ladder_done: + + switch (code) { + case 0: + *(s16 *)((char *)s2 + 0x2) = 1; + func_80184CB8((s32 *)s2, (s32)&D_801919E0); + break; + case 1: + break; + case 2: + *(s16 *)((char *)s2 + 0x2) = 1; + func_80184CB8((s32 *)s2, (s32)&D_801919E0); + break; + } +} + DEFINE_func_801811F4() /* dedup: shared engine-core @0x801811F4 (src/shared) */ @@ -5962,7 +6494,26 @@ void func_80181364(s32 a0) { INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_jr_8017AE2C", func_801813A4); -INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_jr_8017AE2C", func_80181400); +extern s32 func_8012E544(s32 a0); +extern void func_80184CB8(s32 *a0, s32 a1); +extern short D_80191AB0; + +void func_80181400(s32 *arg0) { + s32 res; + s32 flag; + *(s32 *)(*(s32 *)((s32)arg0 + 0xCC) + 0xB0) = 2; + res = func_8012E544(0x2A0); + if (res == 0) { + flag = 0; + } else { + flag = (*(u16 *)((char *)res + 2) == 3); + } + if (flag == 0) { + *(short *)((char *)arg0 + 0x2) = 1; + func_80184CB8((s32 *)arg0, (s32)&D_80191AB0); + } +} + extern int func_80178970(void); @@ -6025,7 +6576,18 @@ DEFINE_func_801815DC() /* dedup: shared engine-core @0x801815DC (src/shared) */ DEFINE_func_80181648() /* dedup: shared engine-core @0x80181648 (src/shared) */ -INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_jr_8017AE2C", func_801816A8); +void func_801816A8(void* arg0) +{ + extern s16 D_801B99A8; + extern u8 D_801B6638[]; + *(short *)((char *)arg0 + 0x2) = 6; + func_8012E88C((s32)arg0); + func_8012A828((s32 *)arg0, (s32)&D_801B99A8); + func_80184C90((s32)arg0); + *(short *)((char *)arg0 + 0x34) = 0; + func_80184ED4((s32)arg0, (s32)&D_801B6638, 1, 0x80); +} + extern void func_80184CB8(s32*, s32); @@ -6042,7 +6604,22 @@ INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_jr_8017AE2C", func_8018173 DEFINE_func_8018178C() /* dedup: shared engine-core @0x8018178C (src/shared) */ -INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_jr_8017AE2C", func_801817B8); +#include "common.h" + +void func_801817B8(void* arg0) +{ + extern short D_801B99A8; + extern void func_8012E88C(s32); + extern void func_8012A828(s32 *a0, s32 a1); + extern void func_80184C90(s32); + + *(short *)((char *)arg0 + 0x2) = 0xA; + func_8012E88C((s32)arg0); + func_8012A828((s32 *)arg0, (s32)&D_801B99A8); + func_80184C90((s32)arg0); + *(short *)((char *)arg0 + 0x34) = 0; +} + INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_jr_8017AE2C", func_80181804); @@ -6152,7 +6729,29 @@ void func_80181B34(void *arg0) { } -INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_jr_8017AE2C", func_80181B74); +extern int func_80178970(void); +extern void func_80178D18(void); + +void func_80181B74(void *a0) { + extern void func_8012E8E0(s32 a0, s32 a1); + extern void func_8012E88C(s32 a0); + extern void func_8012A828(s32 *a0, s32 a1); + extern void func_80184C90(s32 a0); + extern void func_80181998(void); + extern s32 D_80191B3C; + extern short D_801C0D40; + + if (func_80178970() != 0) { + ((void (*)(s32))func_80178D18)((s32)a0); + *(short *)((char *)a0 + 0x2) = 3; + func_8012E8E0((s32)a0, (s32)&D_80191B3C); + func_8012E88C((s32)a0); + func_8012A828((s32 *)a0, (s32)&D_801C0D40); + func_80184C90((s32)a0); + ((void (*)(void))func_80181998)(); + } +} + #include "common.h" @@ -6210,7 +6809,52 @@ void func_80181DC4(void *arg0) { } -INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_jr_8017AE2C", func_80181E04); +void func_80181E04(void *a0) { + extern s32 func_801847BC(void *a0, void *a1); + extern void func_80181960(); + extern s32 func_80184BAC(s32 a0, s32 a1); + extern void func_8012E8E0(s32 a0, s32 a1); + extern void func_8012E88C(s32 a0); + extern void func_8012A828(s32 *a0, s32 a1); + extern void func_80184C90(s32 a0); + extern void func_80181998(void); + extern void func_80184CB8(s32 *a0, s32 a1); + extern s32 func_801788B8(s32 a0, s32 a1); + extern s32 func_80181EFC(void *a0); + extern s16 D_80191B44; + extern s32 D_80191B3C; + extern short D_80191B34; + extern short D_801C0D40; + void *s0 = a0; + s32 v0; + void *v1; + + if (func_801847BC(a0, &D_80191B44) != 0) { + func_80181960(); + v0 = func_80184BAC(9, 0xF); + if (v0 != 0) { + *(short *)((char *)s0 + 2) = 3; + func_8012E8E0((s32)s0, (s32)&(*(short *)&D_80191B3C)); + func_8012E88C((s32)s0); + func_8012A828((s32 *)s0, (s32)&D_801C0D40); + func_80184C90((s32)s0); + func_80181998(); + } else { + if (func_80184BAC(0xF, 0x11) != 0) { + *(short *)((char *)s0 + 2) = 7; + } else if (func_80184BAC(0x11, 0x12) != 0) { + *(short *)((char *)s0 + 2) = 9; + } else { + *(short *)((char *)s0 + 2) = 1; + } + func_80184CB8((s32 *)s0, (s32)&D_80191B34); + } + v1 = *(void **)((char *)s0 + 0xD4 - 0xD4 + 0x68); + *(short *)((char *)v1 + 0xC) = 0x7FFF; + *(s32 *)((char *)s0 + 0xD4) = func_801788B8((s32)s0, (s32)&func_80181EFC); + } +} + extern s32 func_8012BD14(s32 a0); @@ -6288,7 +6932,54 @@ void func_80181FE4(void *a0) { } -INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_jr_8017AE2C", func_8018203C); +extern s32 func_8012E544(s32 a0); +extern s32 func_80029504(void); + +s32 func_8018203C(s32 a0) { + + extern short D_80191E60; + extern short D_80191E88; + extern short D_80191CD8; + extern short D_80191D30; + extern short D_80191D88; + + s32 v; + s32 r; + + if (*(u16 *)a0 == 0x2A0) { + v = func_8012E544(0x2A3); + if (v == 0) { + goto zero; + } + goto chk; + } else { + v = func_8012E544(0x2A0); + if (v != 0) { + goto chk; + } + } +zero: + v = 0; + goto join; +chk: + v = (*(u16 *)(v + 2) == 3); +join: + if (v == 0) { + if (*(u16 *)a0 == 0x2A0) { + return (s32)&D_80191E60; + } + return (s32)&D_80191E88; + } + r = func_80029504(); + if (r < 0x2A8) { + return (s32)&D_80191CD8; + } + if (r < 0x2DA) { + return (s32)&D_80191D30; + } + return (s32)&D_80191D88; +} + DEFINE_func_80182120() /* dedup: shared engine-core @0x80182120 (src/shared) */ @@ -6378,7 +7069,31 @@ extern void func_80178CBC(s32 *a0, s32 a1); } -INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_jr_8017AE2C", func_801824BC); +extern s32 D_80191C2C[]; +extern s32 D_801E2428[]; +extern s32 D_801E24BC[]; +extern s32 func_80029504(void); +extern s32 func_80184DD0(s32 a0); + +void func_801824BC(a0) +void *a0; +{ + s32 s1; + s32 v1; + + s1 = func_80184DD0((s32)a0); + v1 = func_80029504(); + if (s1 == 2) { + if (v1 < 0x276) { + *(s32 *)((s32)a0 + 0xE4) = (s32)D_801E24BC; + } else { + *(s32 *)((s32)a0 + 0xE4) = (s32)D_801E2428; + } + } else { + *(s32 *)((s32)a0 + 0xE4) = D_80191C2C[s1]; + } +} + extern void func_80172710(void); @@ -6480,7 +7195,59 @@ s32 func_801825BC(void *a0) } -INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_jr_8017AE2C", func_801826AC); +extern s32 func_80029504(void); +extern s32 func_80184BAC(s32 arg0, s32 arg1); +extern s32 func_80184DD0(s32 a0); + +void func_801826AC(arg0) +void *arg0; +{ + extern s32 func_80029504(void); + extern s32 func_80184BAC(s32 arg0, s32 arg1); + extern s32 func_80184DD0(s32 a0); + extern void func_80181F70(void *); + extern void func_801821A8(short*); + + void *s2 = arg0; + s32 state; + s32 dd; + s32 sel; + s32 code; + s32 a0val; + + state = 2; + *(s32 *)(*(s32 *)((char *)s2 + 0xCC) + 0xB0) = state; + dd = func_80184DD0((s32)arg0); + sel = func_80029504(); + + if (dd == state && sel < 0x276) { + a0val = 0xA; + } else { + if (func_80184BAC(0xA, 0x10) != 0) { + code = 0; + goto ladder_done; + } + a0val = 0x10; + } + if (func_80184BAC(a0val, 0x15) != 0) { + code = 1; + } else { + code = 2; + } +ladder_done: + + switch (code) { + case 0: + func_80181F70(s2); + break; + case 1: + ((void (*)(void *))func_801821A8)(s2); + break; + case 2: + break; + } +} + extern s32 func_80185BE0(s32 a0); @@ -6558,7 +7325,55 @@ void func_80182920(void *arg0) { } -INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_jr_8017AE2C", func_801829AC); +void func_801829AC(void *arg0) { + extern s32 func_80029504(void); + extern s32 func_80184BAC(s32 arg0, s32 arg1); + extern void func_80184CB8(s32*, s32); + extern s32 func_80184DD0(s32 a0); + extern short D_80191C08; + + void *s2 = arg0; + s32 state; + s32 dd; + s32 sel; + s32 code; + s32 a0val; + + state = 2; + *(s32 *)(*(s32 *)((char *)s2 + 0xCC) + 0xB0) = state; + dd = func_80184DD0((s32)arg0); + sel = func_80029504(); + + if (dd == state && sel < 0x276) { + a0val = 0xA; + } else { + if (func_80184BAC(0xA, 0x10) != 0) { + code = 0; + goto ladder_done; + } + a0val = 0x10; + } + if (func_80184BAC(a0val, 0x15) != 0) { + code = 1; + } else { + code = 2; + } +ladder_done: + + switch (code) { + case 0: + *(s16 *)((char *)s2 + 0x2) = 1; + func_80184CB8((s32 *)s2, (s32)&D_80191C08); + break; + case 1: + break; + case 2: + *(s16 *)((char *)s2 + 0x2) = 1; + func_80184CB8((s32 *)s2, (s32)&D_80191C08); + break; + } +} + DEFINE_func_80182A7C() /* dedup: shared engine-core @0x80182A7C (src/shared) */ @@ -6791,7 +7606,51 @@ void func_80182F88(s32 a0) { INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_jr_8017AE2C", func_80183024); -INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_jr_8017AE2C", func_801830F4); +extern s32 func_8012BD14(s32 a0); +extern s32 func_8012E544(s32 a0); +extern s32 func_80178BF8(); +extern void func_80172710(void); + +s32 func_801830F4(a0) +void *a0; +{ + s32 ptr; + u16 st; + s32 cur; + s32 other; + + ptr = *(s32 *)((s32)a0 + 0x64); + st = *(u16 *)((s32)ptr + 0x2); + if (st != 3) { + return 0; + } + + cur = func_8012BD14(ptr); + if (cur >= 0x4001) { + return 0; + } + + other = func_8012E544(0x227); + if (other != 0) { + if (*(u16 *)((s32)other + 0x2) == 8) { + if (func_8012BD14(other) < cur) { + return 0; + } + } + } + + { + s32 p; + u16 st2; + p = *(s32 *)((s32)a0 + 0x64); + st2 = *(u16 *)((s32)p + 0x2); + st2++; + *(u16 *)((s32)p + 0x2) = st2; + } + func_80178BF8(); + return (s32)func_80172710; +} + extern void func_80184CB8(s32*, s32); @@ -6802,7 +7661,25 @@ extern void func_80184CB8(s32*, s32); } -INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_jr_8017AE2C", func_801831D8); +extern void func_8012E8E0(s32, s32); +extern void func_8012E88C(s32); +extern void func_8012A828(s32 *a0, s32 a1); +extern void func_80184C90(s32); +extern void func_80184ED4(s32, s32, s32, s32); + +void func_801831D8(s32* a0) +{ + extern short D_80192030; + extern s32 D_801B9AA8; + extern short D_801B6730; + *(u16 *)((s32)a0 + 2) = 5; + func_8012E8E0((s32)a0, (s32)&D_80192030); + func_8012E88C((s32)a0); + func_8012A828(a0, (s32)&(*(short *)&D_801B9AA8)); + func_80184C90((s32)a0); + func_80184ED4((s32)a0, (s32)&D_801B6730, 0, 0x40); +} + void func_8012E88C(s32 a0); extern void func_8012A828(s32*, s32); @@ -6954,7 +7831,16 @@ void func_8018375C(void *a0) { } -INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_jr_8017AE2C", func_801837A8); +extern s32 func_80184FA4(); +extern void func_801832A8(); + +void func_801837A8(void *a0) { + *(s32 *)(*(s32 *)((char *)a0 + 0xCC) + 0xB0) = 2; + if (((s32 (*)(s32))func_80184FA4)((s32)a0)) { + func_801832A8(a0); + } +} + extern s32 func_80184FA4(s32 a0); extern s32 func_80185BE0(s32 arg0); @@ -6974,7 +7860,28 @@ DEFINE_func_80183838() /* dedup: shared engine-core @0x80183838 (src/shared) */ DEFINE_func_80183890() /* dedup: shared engine-core @0x80183890 (src/shared) */ -INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_jr_8017AE2C", func_801838E0); +extern int func_80178970(void); +extern void func_8012A828(s32 *a0, s32 a1); +extern void func_8012E88C(s32); +extern void func_80178D18(void); + +void func_801838E0(arg0) +void *arg0; +{ + extern int func_80178970(void); + extern void func_80178D18(void); + extern void func_8012E88C(s32); + extern void func_8012A828(s32 *a0, s32 a1); + extern short D_801B9AA8; + + if (func_80178970() != 0) { + ((void (*)(s32))func_80178D18)((s32)arg0); + *(s16 *)((s32)arg0 + 2) = 6; + func_8012E88C((s32)arg0); + func_8012A828((s32 *)arg0, (s32)&D_801B9AA8); + } +} + /* func_80183938 — state-entry init (family exemplar, reach x11). @@ -7168,4 +8075,23 @@ extern void func_80184CB8(s32 *a0, s32 a1); } -INCLUDE_ASM("asm/ov_SC04_018/nonmatchings/ov_SC04_018_jr_8017AE2C", func_80183E20); +extern short D_801B99A8; +extern void func_8012A828(s32*, s32); +extern void func_8012E88C(s32); +extern void func_80184C90(s32); + +void func_80183E20(arg0) +void *arg0; +{ + extern short D_801B99A8; + extern void func_8012E88C(s32); + extern void func_8012A828(s32 *a0, s32 a1); + extern void func_80184C90(s32); + + *(short *)((char *)arg0 + 0x2) = 0x2; + func_8012E88C((s32)arg0); + func_8012A828((s32 *)arg0, (s32)&D_801B99A8); + func_80184C90((s32)arg0); + *(short *)((char *)arg0 + 0x34) = 0; +} +