From a2f43ac792e26a1cd28843d2508bb291dabc363b Mon Sep 17 00:00:00 2001 From: Drew T <50529377+Druthulu@users.noreply.github.com> Date: Mon, 24 Aug 2026 12:02:21 -0600 Subject: [PATCH] =?UTF-8?q?feat(decomp):=20ox=20wave=20bk=20overlays=20?= =?UTF-8?q?=E2=80=94=20110=20banked?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Committed before the main batch: gate_main reverts on failure and would take these with it. --- src/md_MAIN_027/md_MAIN_027.c | 329 +++++++++++++++++++++- src/md_SC04_027/md_SC04_027.c | 87 +++++- src/md_SC07_004/md_SC07_004.c | 30 +- src/ov_SC01_001/ov_SC01_001_jr_8017D2DC.c | 8 +- src/ov_SC01_080/ov_SC01_080_jr_8017AE2C.c | 18 +- src/ov_SC02_005/ov_SC02_005_jr_8017CF90.c | 109 ++++++- src/ov_SC02_035/ov_SC02_035_jr_8017BEBC.c | 47 +++- src/ov_SC03_023/ov_SC03_023_jr_8017AE2C.c | 158 ++++++++++- src/ov_SC03_096/ov_SC03_096_jr_8017BEBC.c | 70 ++++- src/ov_SC03_116/ov_SC03_116_jr_8017AE2C.c | 147 +++++++++- src/ov_SC05_003/ov_SC05_003_jr_8017BEBC.c | 167 ++++++++++- src/ov_SC05_007/ov_SC05_007_jr_8017BEBC.c | 245 +++++++++++++++- src/ov_SC05_010/ov_SC05_010_jr_80181CDC.c | 76 ++++- src/ov_SC06_016/ov_SC06_016_jr_8017C8D0.c | 321 ++++++++++++++++++++- src/ov_SC06_022/ov_SC06_022_jr_8017BEBC.c | 162 ++++++++++- src/ov_SC06_024/ov_SC06_024_jr_801851E0.c | 2 +- src/ov_SC06_024/ov_SC06_024_jr_801867DC.c | 2 +- src/ov_SC06_024/ov_SC06_024_jr_80186F00.c | 209 +++++++++++++- src/ov_SC06_032/ov_SC06_032_jr_80182890.c | 168 ++++++++++- src/ov_SC06_033/ov_SC06_033_jr_8017C24C.c | 65 ++++- src/ov_SC07_001/ov_SC07_001_jr_8017BEBC.c | 62 +++- src/ov_SC07_007/ov_SC07_007_jr_8017BEBC.c | 58 +++- src/ov_SC07_010/ov_SC07_010_jr_8017AE2C.c | 107 ++++++- 23 files changed, 2530 insertions(+), 117 deletions(-) diff --git a/src/md_MAIN_027/md_MAIN_027.c b/src/md_MAIN_027/md_MAIN_027.c index 6f264ee8e..a393566c9 100644 --- a/src/md_MAIN_027/md_MAIN_027.c +++ b/src/md_MAIN_027/md_MAIN_027.c @@ -1,6 +1,13 @@ #include "common.h" -INCLUDE_ASM("asm/md_MAIN_027/nonmatchings/md_MAIN_027", func_800CAE0C); +void func_800CAE0C(void) { + extern void func_800183E0(s32 a0); + extern s32 D_800CC22C; + extern s32 D_800CC1EC; + ((void (*)(void *))func_800183E0)(&D_800CC22C); + ((void (*)(s32))func_800183E0)((s32)&D_800CC1EC); +} + @@ -28,7 +35,7 @@ void func_800CAF20(void) { } extern void func_80147078(s32 *a0, s16 a1); -extern void func_800CAFEC(void); +extern void func_800CAFEC(); void func_800CAF28(s32 *a0) { func_80147078(a0, 32); ((void (*)(void *))func_800CAFEC)(a0); @@ -52,21 +59,96 @@ void func_800CAF90(void *a0) { } -extern void func_800CAFEC(void); +extern void func_800CAFEC(); void func_800CAFCC(void) { func_800CAFEC(); } -INCLUDE_ASM("asm/md_MAIN_027/nonmatchings/md_MAIN_027", func_800CAFEC); +void func_800CAFEC(s32 *a0) { + s32 *v1; + extern s32 func_80161208(); + extern s32 func_80165A20(s32); + extern void func_801553A8(s32 *a0); + extern void func_80155440(s32 *a0); + extern void func_80154150(s32 a0, s32 a1); + extern void func_80154A74(s32 a0, s32 a1); + extern void func_80146CA0(void *a0); -INCLUDE_ASM("asm/md_MAIN_027/nonmatchings/md_MAIN_027", func_800CB06C); + if (func_80161208(a0) != 0) { + ((void (*)(s32))func_80165A20)((s32)a0); + return; + } + func_801553A8(a0); + func_80155440(a0); + func_80154150((s32)a0, 0x26); + func_80154A74((s32)a0, 0x1E); + v1 = (s32 *)a0[0x20 / 4]; + *(s16 *)((u8 *)v1 + 0x10) = 0xFE9; + a0[0x238 / 4] = 0; + func_80146CA0(a0); +} + + +extern s32 func_80161208(); +extern s32 func_80165A20(s32 a0); +extern void func_80146CA0(void *a0); + +void func_800CB06C(void *arg0) { + s32 p; + s32 q; + register void *a __asm__("$4"); + if (func_80161208(arg0) != 0) { + func_80165A20(arg0); + return; + } + *(s32 *)((u8 *)arg0 + 0x238) += 0x1c000; + p = *(s32 *)((u8 *)arg0 + 0x20); + *(u16 *)((u8 *)p + 0x10) = + (*(u16 *)((u8 *)p + 0x10) - *(u16 *)((u8 *)arg0 + 0x23a)) & 0xfff; + q = *(s32 *)((u8 *)arg0 + 0x20); + if (*(s16 *)((u8 *)q + 0x10) < 0xc00) { + a = arg0; + __asm__ __volatile__("" : : "r"(a)); + *(u16 *)((u8 *)q + 0x10) = 0xc00; + *(u16 *)((u8 *)a + 0xb8) = 1; + func_80146CA0(a); + } +} + + +extern s32 func_80161208(); +extern s32 func_80165A20(s32 a0); +extern void func_80154150(s32 a0, s32 a1); +extern void func_80154A74(s32 a0, s32 a1); +extern void func_801466F0(s32 a0, s32 a1, s32 a2, s32 a3, s32 a4, s32 a5, s32 a6, s32 a7); +extern void func_80147324(s32 a0); +extern void func_80146CA0(void *a0); + +void func_800CB108(s32 a0) { + if (func_80161208()) { + func_80165A20(a0); + } else if (*(u16 *)((s32)a0 + 0xB8) == 0x8000) { + func_80154150(a0, 0x27); + func_80154A74(a0, 0x1F); + func_801466F0(0xD, a0, 0, -0x40, 0, 0, 0, 0); + func_80147324(0x6E2); + func_80146CA0((void *)a0); + } +} -INCLUDE_ASM("asm/md_MAIN_027/nonmatchings/md_MAIN_027", func_800CB108); INCLUDE_ASM("asm/md_MAIN_027/nonmatchings/md_MAIN_027", func_800CB1A0); -INCLUDE_ASM("asm/md_MAIN_027/nonmatchings/md_MAIN_027", func_800CB234); +extern void func_801553C0(s32 a0); +extern void func_80154A74(s32 a0, s32 a1); + +void func_800CB234(void *a0) { + *(u16 *)(*(s32 *)((s32)a0 + 0x20) + 0x10) = 0; + func_801553C0((s32)a0); + func_80154A74((s32)a0, 0x11); +} + extern u8 D_80078EC1; extern void (*D_800CC180[])(); @@ -82,7 +164,49 @@ void func_800CB270(int param_1) } -INCLUDE_ASM("asm/md_MAIN_027/nonmatchings/md_MAIN_027", func_800CB2CC); +extern s32 func_8014659C(void); +extern void func_8001C2C4(s32 a0); +extern void func_80146E90(s32 *a0, s32 a1); +extern void func_80149374(s32 a0, s32 a1); +extern void func_801466B4(u16 a0, s32 a1, s32 a2, s32 a3, s32 a4); +extern void func_80146CA0(void *a0); +extern void func_800CB7FC(); + +extern u8 D_800CC150[]; +extern u8 D_800CC298[]; + +void func_800CB2CC(s32 arg0) { + s32 s2; + s32 s0; + s32 v; + u16 h; + + s2 = *(s32 *)(arg0 + 0x4C); + s0 = func_8014659C(); + *(s32 *)(arg0 + 0x20) = s0; + if (s0 != 0) { + func_8001C2C4(s0); + v = *(s32 *)(s2 + 0x20); + h = *(u16 *)(v + 0x12); + *(u16 *)(s0 + 0x1A) = 0; + *(u16 *)(s0 + 0x18) = 0; + *(u16 *)(s0 + 0x1C) = 0x1000; + *(u16 *)(s0 + 0x12) = h; + func_80146E90((s32 *)arg0, 0x20); + func_80149374(s2, arg0 + 4); + *(u32 *)(arg0 + 0x58) = (u32)&D_800CC150[0]; + *(u16 *)(arg0 + 0x60) = 0; + *(u16 *)(arg0 + 0x62) = 0; + *(u16 *)(arg0 + 0x64) = 0; + func_801466B4(0x28, arg0, 0, 0, 1); + func_801466B4(0x28, arg0, 1, 0, 1); + memcpy(&D_800CC298[0], (void *)(s2 + 0x154), 8); + func_80146CA0((void *)arg0); + } else { + func_800CB7FC(arg0); + } +} + INCLUDE_ASM("asm/md_MAIN_027/nonmatchings/md_MAIN_027", func_800CB3E0); @@ -98,11 +222,196 @@ void func_800CB7FC(s32 a0) { INCLUDE_ASM("asm/md_MAIN_027/nonmatchings/md_MAIN_027", func_800CB82C); -INCLUDE_ASM("asm/md_MAIN_027/nonmatchings/md_MAIN_027", func_800CBA44); +void func_800CBA44() +{ + __asm__ __volatile__( + ".set\tnoreorder\n" + "lhu $2, 0($5)\n" + "lhu $3, 16($6)\n" + "addu $8, $4, $0\n" + "addu $2, $2, $3\n" + "sh $2, 0($8)\n" + "lhu $2, 2($5)\n" + "lhu $3, 18($6)\n" + "nop\n" + "addu $2, $2, $3\n" + "sh $2, 2($8)\n" + "lhu $2, 4($5)\n" + "lhu $3, 16($6)\n" + "nop\n" + "addu $2, $2, $3\n" + "sh $2, 8($8)\n" + "lhu $2, 6($5)\n" + "lhu $3, 18($6)\n" + "addiu $29, $29, -8\n" + "addu $2, $2, $3\n" + "sh $2, 10($8)\n" + "lhu $3, 8($5)\n" + "lhu $4, 16($6)\n" + "lhu $2, 0($7)\n" + "addu $3, $3, $4\n" + "addu $2, $2, $3\n" + "sh $2, 16($8)\n" + "lhu $3, 10($5)\n" + "lhu $4, 18($6)\n" + "lhu $2, 2($7)\n" + "addu $3, $3, $4\n" + "addu $2, $2, $3\n" + "sh $2, 18($8)\n" + "lhu $3, 12($5)\n" + "lhu $4, 16($6)\n" + "lhu $2, 0($7)\n" + "addu $3, $3, $4\n" + "addu $2, $2, $3\n" + "sh $2, 24($8)\n" + "lhu $3, 14($5)\n" + "lhu $4, 18($6)\n" + "lhu $2, 2($7)\n" + "addu $3, $3, $4\n" + "addu $2, $2, $3\n" + "addiu $3, $8, 8\n" + "sh $2, 26($8)\n" + "addiu $2, $8, 16\n" + "lw $5, 24($29)\n" + "lw $4, 28($29)\n" + "lwc2 $0, 0($8)\n" + "lwc2 $1, 4($8)\n" + "lwc2 $2, 0($3)\n" + "lwc2 $3, 4($3)\n" + "lwc2 $4, 0($2)\n" + "lwc2 $5, 4($2)\n" + "nop\n" + "nop\n" + "rtpt\n" + "addiu $2, $5, 16\n" + "addiu $3, $5, 8\n" + "swc2 $12, 0($5)\n" + "swc2 $13, 0($3)\n" + "swc2 $14, 0($2)\n" + "cfc2 $12, $31\n" + "nop\n" + "sw $12, 0($29)\n" + "lw $2, 0($29)\n" + "addiu $3, $0, -4097\n" + "and $2, $2, $3\n" + "bnez $2, 99f\n" + " addiu $2, $0, 1\n" + "addiu $2, $8, 24\n" + "lwc2 $0, 0($2)\n" + "lwc2 $1, 4($2)\n" + "nop\n" + "nop\n" + "rtps\n" + "addiu $2, $5, 24\n" + "swc2 $14, 0($2)\n" + "cfc2 $12, $31\n" + "nop\n" + "sw $12, 0($29)\n" + "lw $2, 0($29)\n" + "nop\n" + "and $2, $2, $3\n" + "bnez $2, 99f\n" + " addiu $2, $0, 1\n" + "lw $2, 0($6)\n" + "lw $3, 0($4)\n" + "nop\n" + "addu $2, $2, $3\n" + "sw $2, 32($5)\n" + "lw $2, 4($6)\n" + "lw $3, 0($4)\n" + "nop\n" + "addu $2, $2, $3\n" + "sw $2, 36($5)\n" + "lw $2, 8($6)\n" + "lw $3, 0($4)\n" + "nop\n" + "addu $2, $2, $3\n" + "sw $2, 40($5)\n" + "lw $3, 12($6)\n" + "lw $4, 0($4)\n" + "addu $2, $0, $0\n" + "addu $3, $3, $4\n" + "sw $3, 44($5)\n" + "99:\n" + "addiu $29, $29, 8\n" + ".set\treorder\n" + ); +} + INCLUDE_ASM("asm/md_MAIN_027/nonmatchings/md_MAIN_027", func_800CBBF8); -INCLUDE_ASM("asm/md_MAIN_027/nonmatchings/md_MAIN_027", func_800CBCB4); +extern s16 currentLocationId; + +void func_800CBCB4(void *a0) { + s16 sp[4]; + + func_80015978((s32)a0 + 4, sp); + switch (currentLocationId) { + case 0x3035: + if (sp[0] < -0x93E) { + sp[0] = -0x93E; + } + if (sp[0] >= -0x3C1) { + sp[0] = -0x3C2; + } + if (sp[2] < 0x3C2) { + sp[2] = 0x3C2; + } + if (sp[2] >= 0xCBF) { + sp[2] = 0xCBE; + goto after; + } + break; + case 0x3037: + if (sp[0] < 0x4C2) { + sp[0] = 0x4C2; + } + if (sp[0] >= 0xA3F) { + sp[0] = 0xA3E; + } + if (sp[2] < 0xAC2) { + sp[2] = 0xAC2; + } + if (sp[2] >= 0x13BF) { + sp[2] = 0x13BE; + goto after; + } + break; + case 0x3038: + if (sp[0] < -0xF3E) { + sp[0] = -0xF3E; + } + if (sp[0] >= -0x9C1) { + sp[0] = -0x9C2; + } + if (sp[1] < -0xA00) { + sp[1] = -0xA00; + } + if (sp[1] >= -0x201) { + sp[1] = -0x202; + goto after; + } + break; + case 0x3039: + if (sp[0] < -0x153E) { + sp[0] = -0x153E; + } + if (sp[0] >= -0xFC1) { + sp[0] = -0xFC2; + } + if (sp[2] < 0x3C2) { + sp[2] = 0x3C2; + } + if (sp[2] >= 0xFBF) { + sp[2] = 0xFBE; + } + break; + } +after: + func_80015954(sp, (s32)a0 + 4); +} + extern u8 D_80078EC1; extern void (*D_800CC1C4[])(); diff --git a/src/md_SC04_027/md_SC04_027.c b/src/md_SC04_027/md_SC04_027.c index 2cb8fd0ba..5b2d6f53a 100644 --- a/src/md_SC04_027/md_SC04_027.c +++ b/src/md_SC04_027/md_SC04_027.c @@ -1,6 +1,11 @@ #include "common.h" -INCLUDE_ASM("asm/md_SC04_027/nonmatchings/md_SC04_027", func_801E7DA4); +void func_801E7DA4(void) { + extern void func_80016714(s8 *a0, s32 a1); + extern u16 D_801F1D88; + func_80016714((s8 *)&D_801F1D88, 8); +} + s32 func_801E7DCC(void) { @@ -682,7 +687,12 @@ void func_801EA600(void *a0) { } -INCLUDE_ASM("asm/md_SC04_027/nonmatchings/md_SC04_027", func_801EA63C); +void func_801EA63C(s32 arg0) { + extern s16 D_801274E8; + extern void func_801EA664(s32, s16 *); + func_801EA664(arg0, &D_801274E8); +} + /* MATRIX 0x20: short m[3][3] @0x00 (18B) + 2B pad, long t[3] @0x14 (PsyQ layout) */ @@ -799,9 +809,78 @@ INCLUDE_ASM("asm/md_SC04_027/nonmatchings/md_SC04_027", func_801EAA7C); INCLUDE_ASM("asm/md_SC04_027/nonmatchings/md_SC04_027", func_801EAB04); -INCLUDE_ASM("asm/md_SC04_027/nonmatchings/md_SC04_027", func_801EAB8C); +extern s32 func_80029504(void); +extern s32 func_80029178(s32 arg); +extern void func_80029124(s32, s32); + +s32 func_801EAB8C(void) { + s32 val = func_80029504(); + s32 flag; + + if ((u32)(val - 200) >= 100) { + if (val < 300 || !(func_80029178(250) & 0xFF)) { + flag = 1; + } else { + flag = 0; + } + } else { + flag = 0; + } + + if (flag == 0) { + return 0; + } + if (func_80029178(276) & 0xFF) { + return 0; + } + func_80029124(276, 1); + return 1; +} + + +extern s32 func_80029504(void); +extern s32 func_80029178(s32); +extern s32 func_80184D00(void); +extern s32 func_80184DD0(void); +extern s32 func_80184E44(void); +extern void func_80184EA0(void); +extern s32 D_801EBCBC[]; +extern s32 D_801EBCD0[]; +extern s32 D_801EBCEC[]; +extern s32 D_801EC35C; +extern s32 D_801EC3A8; + +void func_801EAC10(s32 a0) { + s32 v0, v1 = func_80029504(); + if (v1 < 0x258) { + v1 = func_80029504(); + if ((u32)(v1 - 0xC8) < 0x64) { + v0 = 0; + } else if (v1 < 0x12C) { + v0 = 1; + } else { + v0 = func_80029178(0xFA) & 0xFF; + if (v0 != 0) { + v0 = 0; + } else { + v0 = 1; + } + } + if (v0 != 0) { + *(s32 *)(a0 + 0xE4) = D_801EBCBC[func_80184D00()]; + } else if ((u32)func_80029504() < 0x12C) { + *(s32 *)(a0 + 0xE4) = (s32)&D_801EC35C; + } else { + *(s32 *)(a0 + 0xE4) = (s32)&D_801EC3A8; + } + } else if (v1 < 0x384) { + *(s32 *)(a0 + 0xE4) = D_801EBCD0[func_80184DD0()]; + } else { + *(s32 *)(a0 + 0xE4) = D_801EBCEC[func_80184E44()]; + func_80184EA0(); + } +} -INCLUDE_ASM("asm/md_SC04_027/nonmatchings/md_SC04_027", func_801EAC10); extern void func_8012C1B8(void); diff --git a/src/md_SC07_004/md_SC07_004.c b/src/md_SC07_004/md_SC07_004.c index bbfcc685c..506e6e832 100644 --- a/src/md_SC07_004/md_SC07_004.c +++ b/src/md_SC07_004/md_SC07_004.c @@ -1588,7 +1588,10 @@ void func_801A57E8(void *a0) { INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A5AA0); -INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801A5AC0); +void func_801A5AC0(void *a0) { + func_8012AD44((s32 *)a0, 2); +} + void func_801A5AE0(void *a0) { func_8012AD44((s32 *)a0, 3); @@ -6968,7 +6971,30 @@ void func_801AEAE4(void *a0) { } -INCLUDE_ASM("asm/md_SC07_004/nonmatchings/md_SC07_004", func_801AEB04); +typedef struct { + u8 unk0[8]; +} B8_801AEB04; + +typedef struct { + u8 unk0[4]; +} M4_801AEB04; + +const s8 D_801A022C[4] = { 0, 0, 0, 0 }; + +void func_801AEB04(s32 a0, s16 a1, s32 a2, s32 a3) { + *(u16 *)(a0 + 0x00) = 1; + *(u16 *)(a0 + 0x02) = a1; + *(B8_801AEB04 *)(a0 + 0x04) = *(B8_801AEB04 *)a2; + *(u16 *)(a0 + 0x10) = 0x1000; + *(u16 *)(a0 + 0x0E) = 0x1000; + *(u16 *)(a0 + 0x0C) = 0x1000; + *(u16 *)(a0 + 0x12) = 0; + *(s32 *)(a0 + 0x20) = a3; + *(M4_801AEB04 *)(a0 + 0x14) = *(M4_801AEB04 *)&D_801A022C; + *(M4_801AEB04 *)(a0 + 0x18) = *(M4_801AEB04 *)&D_801A022C; + *(M4_801AEB04 *)(a0 + 0x1C) = *(M4_801AEB04 *)&D_801A022C; +} + diff --git a/src/ov_SC01_001/ov_SC01_001_jr_8017D2DC.c b/src/ov_SC01_001/ov_SC01_001_jr_8017D2DC.c index bed4ec479..328742290 100644 --- a/src/ov_SC01_001/ov_SC01_001_jr_8017D2DC.c +++ b/src/ov_SC01_001/ov_SC01_001_jr_8017D2DC.c @@ -3983,7 +3983,13 @@ void func_8017F28C(s32 a0) INCLUDE_ASM("asm/ov_SC01_001/nonmatchings/ov_SC01_001_jr_8017D2DC", func_8017F328); -INCLUDE_ASM("asm/ov_SC01_001/nonmatchings/ov_SC01_001_jr_8017D2DC", func_8017F7F4); +void func_8017F7F4(s32 param_1) { + extern s32 D_801EDA10; + if (*(s16 *)(param_1 + 0x98) == 0 || D_801EDA10 != 0) { + *(u16 *)(param_1 + 2) = *(u16 *)(param_1 + 2) - 1; + } +} + INCLUDE_ASM("asm/ov_SC01_001/nonmatchings/ov_SC01_001_jr_8017D2DC", func_8017F830); diff --git a/src/ov_SC01_080/ov_SC01_080_jr_8017AE2C.c b/src/ov_SC01_080/ov_SC01_080_jr_8017AE2C.c index 59849432d..ecfe0108c 100644 --- a/src/ov_SC01_080/ov_SC01_080_jr_8017AE2C.c +++ b/src/ov_SC01_080/ov_SC01_080_jr_8017AE2C.c @@ -5838,7 +5838,23 @@ void func_80182B90(void *a0, s32 a1, s16 a2) { INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_80182CB8); -INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_80182EF8); +extern u8 D_801202A0[]; +extern s32 D_801C7550[]; + +void func_80182EF8(u8 *a0) { + s32 i; + + for (i = 0; i < 0x60; i++) { + u8 *p = &D_801202A0[i * 0x10C]; + + if (*(u16 *)(p + 0x00) == 0x14) { + if (*(s16 *)(p + 0x76) < 3) { + D_801C7550[*(u16 *)(p + 0x70) & 3] = 0; + } + } + } +} + extern void func_801832C0(void *a0); extern void (*D_8018A468[])(int); diff --git a/src/ov_SC02_005/ov_SC02_005_jr_8017CF90.c b/src/ov_SC02_005/ov_SC02_005_jr_8017CF90.c index d392cc998..20ea77d86 100644 --- a/src/ov_SC02_005/ov_SC02_005_jr_8017CF90.c +++ b/src/ov_SC02_005/ov_SC02_005_jr_8017CF90.c @@ -3594,7 +3594,34 @@ void func_8017E664(void) { } -INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8017E6FC); +extern void func_8012A018(s32 a, s32 b); +extern void func_8012A094(s32 a0); +extern void func_8017E97C(void *a0); + +void func_8017E6FC(void) { + + extern u8 D_80126948[]; + extern s32 D_80126954; + extern s32 D_8012695C; + extern s16 D_80126968; + extern s16 D_8012696A; + extern s16 D_8012696C; + extern s16 D_80126976; + extern s16 D_80126978; + extern s16 D_8012697A; + D_80126954 = 0x1f4; + D_8012695C = 0x384; + D_80126968 = -0x271; + D_8012696A = 0xC00; + D_8012696C = 0; + D_80126976 = 0x20; + D_80126978 = 0; + D_8012697A = 0; + func_8012A018((s32)func_8017E97C, 1); + func_8012A094((s32)D_80126948); + func_8017E97C(D_80126948); +} + INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8017E798); @@ -3661,7 +3688,22 @@ INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8017EAD void func_8017EB30(void) { } -INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8017EB38); +void func_8017EB38(s32 a0) { + extern u16 D_80126B5E; + extern u16 D_80126B62; + extern u16 D_80126B66; + extern s16 D_801E4C50; + extern s16 D_801E4C52; + extern s16 D_801E4C54; + extern void func_8017EDF8(); + + s16 *p = &D_801E4C50; + p[0] = D_80126B5E; + p[1] = D_80126B62; + p[2] = D_80126B66; + func_8017EDF8(a0, p); +} + #include "common.h" @@ -4021,9 +4063,40 @@ void func_8017F464(void *a0) INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8017F530); -INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8017F5B0); +extern s32 func_801399F0(s32 a0); +extern void func_80139914(s32 a0); +extern s16 D_80126968; +extern s16 D_8012696A; +extern s16 D_80126976; +extern s16 D_80126978; + +void func_8017F5B0(s32 param_1) { + s32 s0 = param_1; + if (func_801399F0(*(s32 *)(s0 + 0x198)) != 0) { + func_80139914(*(s32 *)(s0 + 0x198)); + *(s32 *)(s0 + 0x204) = 0x20; + D_80126968 = 0xE3; + D_8012696A = -0x71C; + D_80126976 = -0x20; + D_80126978 = -0x60; + *(u8 *)(s0 + 0x214) = *(u8 *)(s0 + 0x214) + 1; + } +} + + +extern s32 D_801270C8; + +void func_8017F63C(void *a0) { + s32 temp; + temp = *(s32 *)((s32)a0 + 0x204); + temp -= 1; + *(s32 *)((s32)a0 + 0x204) = temp; + if (temp == -1) { + D_801270C8 = 3; + *(u8 *)((s32)a0 + 0x214) += 1; + } +} -INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8017F63C); extern s32 D_801270C8; @@ -4293,7 +4366,20 @@ void func_8017FEA0(s32 arg0) { } -INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_8017FF2C); +extern s32 func_801399F0(s32 a0); +extern void func_80139914(s32 a0); +extern void func_80147060(u8 *a0); + +void func_8017FF2C(s32 param_1) { + s32 s0 = param_1; + if (func_801399F0(*(s32 *)(s0 + 0x198)) != 0) { + func_80139914(*(s32 *)(s0 + 0x198)); + func_80147060((u8 *)s0); + *(s32 *)(s0 + 0x204) = 0x20; + ++*(u8 *)(s0 + 0x214); + } +} + extern s32 D_8012695C; extern s16 D_80126968; @@ -4387,7 +4473,18 @@ s32 func_801801DC(void *a0) { INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_80180234); -INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_801802CC); +extern s32 func_801399F0(s32 a0); +extern void func_80139914(s32 a0); +extern void func_8017DE5C(void); + +void func_801802CC(s32 param_1) { + if (func_801399F0(*(s32 *)(param_1 + 0x198)) != 0) { + func_80139914(*(s32 *)(param_1 + 0x198)); + func_8017DE5C(); + *(u8 *)(param_1 + 0x214) = *(u8 *)(param_1 + 0x214) + 1; + } +} + INCLUDE_ASM("asm/ov_SC02_005/nonmatchings/ov_SC02_005_jr_8017CF90", func_80180328); diff --git a/src/ov_SC02_035/ov_SC02_035_jr_8017BEBC.c b/src/ov_SC02_035/ov_SC02_035_jr_8017BEBC.c index bc67f17cf..cf2f462c0 100644 --- a/src/ov_SC02_035/ov_SC02_035_jr_8017BEBC.c +++ b/src/ov_SC02_035/ov_SC02_035_jr_8017BEBC.c @@ -3493,7 +3493,21 @@ void func_8017D610(s32 a0) { } -INCLUDE_ASM("asm/ov_SC02_035/nonmatchings/ov_SC02_035_jr_8017BEBC", func_8017D710); +extern s32 *D_80126B78; + +void func_8017D710(s32 a0) { + s16 t; + + *(u16 *)(*(u32 *)(a0 + 0x20) + 0x10) += *(u16 *)(a0 + 0xFE); + *(u16 *)(*(u32 *)(a0 + 0x20) + 0x12) += *(u16 *)(a0 + 0x100); + *(u16 *)(*(u32 *)(a0 + 0x20) + 0x14) += *(u16 *)(a0 + 0x102); + + t = *(s16 *)(a0 + 0x100); + if (t != 0 && *(u8 *)(a0 + 0x74) != 0) { + *(u16 *)((s32)D_80126B78 + 0x12) += t; + } +} + #include "common.h" @@ -5203,7 +5217,20 @@ void func_801805FC(void *a0) { INCLUDE_ASM("asm/ov_SC02_035/nonmatchings/ov_SC02_035_jr_8017BEBC", func_80180638); -INCLUDE_ASM("asm/ov_SC02_035/nonmatchings/ov_SC02_035_jr_8017BEBC", func_8018071C); +extern void func_80180C10(s32 a0); + +void func_8018071C(s32 arg0) { + s32 temp_v0; + func_80180C10(arg0); + if (*(s32 *)(arg0 + 0x30) == 0) { + *(s16 *)(arg0 + 0x2) = 6; + *(s32 *)(arg0 + 0x1c) = 0; + } else { + temp_v0 = *(s32 *)(arg0 + 0x1c) + 1; + *(s32 *)(arg0 + 0x1c) = temp_v0; + } +} + extern s32 func_80180B38(s32 a0, s32 a1); @@ -5317,7 +5344,21 @@ s32 func_801809E4(s32 a0, s32 a1, s32 a2) { INCLUDE_ASM("asm/ov_SC02_035/nonmatchings/ov_SC02_035_jr_8017BEBC", func_80180B38); -INCLUDE_ASM("asm/ov_SC02_035/nonmatchings/ov_SC02_035_jr_8017BEBC", func_80180C10); +void func_80180C10(s32 param) +{ + s32 base = param; + s32 x = *(s32 *)(base + 0x1C); + s32 r = func_8004787C((x << 7) & 0x780); + s32 y = *(s32 *)(base + 0x34); + s32 q = y >> 2; + s32 prod = q * r; + s32 ptr = *(s32 *)(base + 0x20); + s32 hi = prod >> 12; + y = y - hi; + *(s16 *)(ptr + 0x1A) = y; + *(s16 *)(ptr + 0x18) = y; +} + extern void (*D_80198EC4[])(void); diff --git a/src/ov_SC03_023/ov_SC03_023_jr_8017AE2C.c b/src/ov_SC03_023/ov_SC03_023_jr_8017AE2C.c index 0dd1ce8e5..8958bf732 100644 --- a/src/ov_SC03_023/ov_SC03_023_jr_8017AE2C.c +++ b/src/ov_SC03_023/ov_SC03_023_jr_8017AE2C.c @@ -4257,7 +4257,19 @@ void func_8017DF1C(s32 a0) { } -INCLUDE_ASM("asm/ov_SC03_023/nonmatchings/ov_SC03_023_jr_8017AE2C", func_8017DFA0); +void func_8017DFA0(s32 a0) { + *(s16 *)(a0 + 0xAA) = 0; + *(s16 *)(a0 + 0x5C) = 0; + *(s16 *)(*(s32 *)(a0 + 0x20) + 0x18) = 0x1800; + *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1C) = 0x1800; + *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1A) = 0x100; + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x2C) |= 0x10; + *(s16 *)(a0 + 0x34) = 0; + *(s32 *)(a0 + 0x1C) = 0x1E; + *(s16 *)(a0 + 0x98) = 0; + func_8002D4C8(0x526, 0); +} + void func_8017E014(s32 a0) { @@ -4321,7 +4333,42 @@ void func_8017E1F4(void *a0) { } -INCLUDE_ASM("asm/ov_SC03_023/nonmatchings/ov_SC03_023_jr_8017AE2C", func_8017E230); +extern void func_8002D4C8(s32 a0, s32 a1); +extern void func_8012A828(s32, void*); +extern s32 rand(void); +extern u8 D_80182BAC; +extern u8 D_80182BD4; +extern u8 D_80182BFC; +extern u8 D_80182C24; + +void func_8017E230(void *a0) +{ + register void *s0 __asm__("$16"); + + s0 = a0; + if (--*(s16 *)((s32)s0 + 0x70) == 0) { + *(s16 *)((s32)s0 + 0x12) = (rand() & 0xF) - 7; + *(s16 *)((s32)s0 + 0x16) -= rand() & 0xF; + *(s16 *)((s32)s0 + 0x16) -= 8; + *(s16 *)((s32)s0 + 0x1A) -= rand() & 0xF; + if (rand() & 1) { + func_8012A828((s32)s0, &D_80182BAC); + } else { + func_8012A828((s32)s0, &D_80182BD4); + } + *(s16 *)((s32)s0 + 2) = 2; + if (rand() % 3 == 0) { + func_8002D4C8(0x532, 0); + } + } else if (*(u16 *)((s32)s0 + 0x72) & 0x4000) { + if (rand() & 1) { + func_8012A828((s32)s0, &D_80182BFC); + } else { + func_8012A828((s32)s0, &D_80182C24); + } + } +} + extern void (*D_80182C3C[])(void); @@ -4331,9 +4378,61 @@ void func_8017E36C(void *a0) { } -INCLUDE_ASM("asm/ov_SC03_023/nonmatchings/ov_SC03_023_jr_8017AE2C", func_8017E3A8); +extern s32 func_8012C354(s32 a0, s32 a1); +extern void func_8012A828(s32, void*); +extern u8 D_80182A08; +extern s32 D_8017F214; +extern u8 D_80182A3C; + +void func_8017E3A8(s32 a0) { + s32 s0 = a0; + if (func_8012C354(a0, (s32)&D_80182A08)) { + *(u8 *)(s0 + 0xC0) = 1; + *(s32 *)(s0 + 0xB4) = 1; + func_8012A828(s0, &D_8017F214); + *(u16 *)(s0 + 0x2) = 1; + *(s32 *)(s0 + 0xBC) = (s32)&D_80182A3C; + *(u8 *)(s0 + 0x75) = 0; + } +} + + +extern volatile s32 D_801270C8; +extern s32 *D_80126B78; +extern s32 D_80126B58; +extern u8 D_801932E8[]; +extern void func_8017D6C0(void); +extern void func_8012A828(s32, void *); +extern s32 func_8012C658(s32, s32, s32); +extern void func_8002D4C8(s32, s32); + +void func_8017E414(s32 arg0) { + s32 *pa; + + pa = (s32 *) &D_80126B58; + if (D_801270C8 == 0) { + *(u16 *)(arg0 + 0x5C) &= ~0x1000; + return; + } + if (*(s16 *)((s8 *)D_80126B78 + 0x12) == 0x800) { + *(u16 *)(arg0 + 0x5C) |= 0x1000; + } else { + *(u16 *)(arg0 + 0x5C) &= ~0x1000; + } + if (arg0 == *(s32 *)((s8 *)pa + 0x170)) { + *(u16 *)(arg0 + 0x5C) &= ~0x1000; + func_8017D6C0(); + *(s16 *)(arg0 + 2) = 2; + *(s32 *)(arg0 + 0x1C) = 0x28; + *(s16 *)((s8 *)D_801270C8 + 2) = 4; + *(s32 *)((s8 *)D_801270C8 + 0x1C) = 0x14; + func_8012A828(D_801270C8, &D_801932E8); + func_8012C658(0x88, 0, arg0); + func_8002D4C8(0x529, 0); + *(u16 *)(arg0 + 0x84) = 0; + } +} -INCLUDE_ASM("asm/ov_SC03_023/nonmatchings/ov_SC03_023_jr_8017AE2C", func_8017E414); extern s32 func_80143B6C(s32 a0, s32 a1); @@ -4370,7 +4469,31 @@ INCLUDE_ASM("asm/ov_SC03_023/nonmatchings/ov_SC03_023_jr_8017AE2C", func_8017E61 INCLUDE_ASM("asm/ov_SC03_023/nonmatchings/ov_SC03_023_jr_8017AE2C", func_8017E70C); -INCLUDE_ASM("asm/ov_SC03_023/nonmatchings/ov_SC03_023_jr_8017AE2C", func_8017E79C); +extern void func_8012A828(s32 a0, void *a1); +extern void func_8012B1B4(s32 a0, s32 a1); +extern s32 func_8012CBCC(s32 a0); +extern u8 D_80182AB8[]; +extern u8 D_801933C0[]; + +void func_8017E79C(s32 a0) { + s32 v; + + if (*(s16 *)(a0 + 6) < -0xA9) { + *(s16 *)(a0 + 2) = 3; + func_8012A828(a0, D_801933C0); + *(s32 *)(a0 + 0x1C) = 0xF; + } + *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) = 0x400; + func_8012B1B4(a0, (s32)D_80182AB8); + v = func_8012CBCC(a0); + if (v & 0x6000) { + *(s16 *)(a0 + 0x16) = -4; + } + if (v & 0x8000) { + *(s16 *)(a0 + 0x16) = -0xA; + } +} + INCLUDE_ASM("asm/ov_SC03_023/nonmatchings/ov_SC03_023_jr_8017AE2C", func_8017E834); @@ -4378,7 +4501,30 @@ INCLUDE_ASM("asm/ov_SC03_023/nonmatchings/ov_SC03_023_jr_8017AE2C", func_8017E8E INCLUDE_ASM("asm/ov_SC03_023/nonmatchings/ov_SC03_023_jr_8017AE2C", func_8017E948); -INCLUDE_ASM("asm/ov_SC03_023/nonmatchings/ov_SC03_023_jr_8017AE2C", func_8017E988); +extern s32 D_801270C8; +extern s16 D_80193608[]; +extern void func_8012A828(s32, void*); +extern s32 func_800291B4(s32 arg); +extern void func_800291A0(s32, s32); + +void func_8017E988(s32 param_1) { + func_8012A828(param_1, &D_80193608); + if ((*(s16 *)(param_1 + 6) - *(s16 *)(param_1 + 0xDC)) < -0x60) { + *(s16 *)(*(s32 *)(param_1 + 0x20) + 0x12) = 0xC00; + } else if ((*(s16 *)(param_1 + 6) - *(s16 *)(param_1 + 0xDC)) >= 0x61) { + *(s16 *)(*(s32 *)(param_1 + 0x20) + 0x12) = 0x400; + } else { + *(s16 *)(*(s32 *)(param_1 + 0x20) + 0x12) = 0; + } + *(s16 *)(param_1 + 0x84) = 0xA; + *(s16 *)(param_1 + 0x102) = 1; + *(s16 *)(param_1 + 0x5C) = 0; + if ((func_800291B4(0xCC) & 0xFF) != 0xF) { + func_800291A0(0xCC, 1); + } + D_801270C8 = 0; +} + INCLUDE_ASM("asm/ov_SC03_023/nonmatchings/ov_SC03_023_jr_8017AE2C", func_8017EA40); diff --git a/src/ov_SC03_096/ov_SC03_096_jr_8017BEBC.c b/src/ov_SC03_096/ov_SC03_096_jr_8017BEBC.c index ab4d3d12f..c966a3baf 100644 --- a/src/ov_SC03_096/ov_SC03_096_jr_8017BEBC.c +++ b/src/ov_SC03_096/ov_SC03_096_jr_8017BEBC.c @@ -4539,7 +4539,20 @@ void func_8017F200(void *a0) { } -INCLUDE_ASM("asm/ov_SC03_096/nonmatchings/ov_SC03_096_jr_8017BEBC", func_8017F23C); +extern void func_80016224(s32 a0, s32 a1); + +void func_8017F23C(void *a0) { + s16 t; + if (*(s16 *)((s32)a0 + 0xFE) != 0) { + func_80016224(*(s16 *)((s32)a0 + 0xFE) & 0xFF, 4); + *(s16 *)((s32)a0 + 0x2A) = -2; + t = 0x80 - *(s16 *)((s32)a0 + 0xFE) * 3; + *(s16 *)((s32)a0 + 0x28) = t; + *(s16 *)((s32)a0 + 0x26) = t; + *(s16 *)((s32)a0 + 0x24) = t; + } +} + INCLUDE_ASM("asm/ov_SC03_096/nonmatchings/ov_SC03_096_jr_8017BEBC", func_8017F2A4); @@ -4553,13 +4566,51 @@ void func_8017F370(void *a0) { } -INCLUDE_ASM("asm/ov_SC03_096/nonmatchings/ov_SC03_096_jr_8017BEBC", func_8017F3AC); +extern s32 D_80192A34[]; +extern s32 D_80192A04[]; +extern void (*D_80192A18[])(void); +extern void func_8017EDAC(s32, void *, s32); +extern s32 D_8019A7D0; + +void func_8017F3AC(s32 a0) { + s32 v1 = *(s16 *)((s32)a0 + 0x70); + + if (v1 < 3) { + func_8017EDAC(a0, (void *)D_80192A34[v1], 0); + } else { + func_8017EDAC(a0, (void *)D_80192A04, 1); + func_8017EDAC(a0, (void *)D_80192A18, 2); + } + + { + u16 v0 = *(u16 *)((s32)a0 + 0x72); + *(u16 *)((s32)a0 + 0xFE) = 0; + D_8019A7D0 = 0; + *(u16 *)((s32)a0 + 0x72) = v0 | 0x1000; + } + func_8017EE48(a0); +} + INCLUDE_ASM("asm/ov_SC03_096/nonmatchings/ov_SC03_096_jr_8017BEBC", func_8017F444); INCLUDE_ASM("asm/ov_SC03_096/nonmatchings/ov_SC03_096_jr_8017BEBC", func_8017F4D4); -INCLUDE_ASM("asm/ov_SC03_096/nonmatchings/ov_SC03_096_jr_8017BEBC", func_8017F528); +extern void (*D_80193A78[])(void); +extern void func_80180148(); +extern void func_8012F214(s32 a0, s32 a1, s32 a2); +extern s32 D_80193A18; + +void func_8017F528(s32 *arg0) { + D_80193A78[*(u16 *)((s32)arg0 + 2)](); + if (*(s32 *)((s32)arg0 + 0xE4) != 0) { + func_80180148(arg0); + } + if ((*(u16 *)arg0 != 0) && (*(s32 *)((s32)arg0 + 0xD4) != 0)) { + func_8012F214((s32)arg0, (s32)&D_80193A18, *(s32 *)((s32)arg0 + 0xD4) + 8); + } +} + extern s32 func_8012C354(s32 a0, s32 a1); @@ -4845,7 +4896,18 @@ extern void func_8018028C(s32); INCLUDE_ASM("asm/ov_SC03_096/nonmatchings/ov_SC03_096_jr_8017BEBC", func_8017FE4C); -INCLUDE_ASM("asm/ov_SC03_096/nonmatchings/ov_SC03_096_jr_8017BEBC", func_8017FEA8); +void func_8017FEA8(s32 a0) { + s32 v1; + + func_801801D4(*(s32 *)(a0 + 0xD4), 0); + *(s16 *)(a0 + 0x2) = 4; + *(s16 *)(a0 + 0x5C) = *(u16 *)(*(s32 *)(a0 + 0x78) + 2); + v1 = *(s32 *)(a0 + 0x20); + *(s16 *)(v1 + 0x1A) = 0x2000; + *(s16 *)(v1 + 0x18) = 0x2000; + func_8018026C(*(s32 *)(a0 + 0xD4)); +} + extern void func_8002A04C(s32 a0); diff --git a/src/ov_SC03_116/ov_SC03_116_jr_8017AE2C.c b/src/ov_SC03_116/ov_SC03_116_jr_8017AE2C.c index 2ddd1b947..8ae23e22a 100644 --- a/src/ov_SC03_116/ov_SC03_116_jr_8017AE2C.c +++ b/src/ov_SC03_116/ov_SC03_116_jr_8017AE2C.c @@ -3311,7 +3311,24 @@ DEFINE_func_8017BEAC() /* dedup: shared engine-core @0x8017BEAC (src/shared) */ DEFINE_func_8017BEB4() /* dedup: shared engine-core @0x8017BEB4 (src/shared) */ -INCLUDE_ASM("asm/ov_SC03_116/nonmatchings/ov_SC03_116_jr_8017AE2C", func_8017BEBC); +void func_8017BEBC(s32 arg0) +{ + typedef struct { s16 m[3][3]; s16 pad; s32 t[3]; } MTX; + + extern s32 func_800491EC(void); + extern void func_800547D8(s32, MTX *); + extern void func_80052E38(MTX *); + extern void func_8017BF14(s32, s32); + + MTX mtx; + s32 lim; + + lim = func_800491EC() + *(s32 *)(arg0 + 0x64); + func_800547D8(arg0 + 0x10, &mtx); + func_80052E38(&mtx); + func_8017BF14(arg0, lim); +} + #include "common.h" #include "../shared/engine_types.h" @@ -4411,7 +4428,27 @@ INCLUDE_ASM("asm/ov_SC03_116/nonmatchings/ov_SC03_116_jr_8017AE2C", func_8018103 INCLUDE_ASM("asm/ov_SC03_116/nonmatchings/ov_SC03_116_jr_8017AE2C", func_801810C8); -INCLUDE_ASM("asm/ov_SC03_116/nonmatchings/ov_SC03_116_jr_8017AE2C", func_8018117C); +extern s32 func_8012BEE8(s32 a0); +extern s32 func_8012AD50(void *a0); +extern void func_801812AC(s32 a0, void *a1, void *a2, s32 a3, s32 a4); +extern u16 D_800B99DA; +extern u16 D_8018631C[]; + +void func_8018117C(s32 a0) +{ + s16 buf[2]; + s32 color; + + if (func_8012BEE8(a0) != 0) { + *(s16 *)(a0 + 0x100) = 0xF0; + func_8012AD50((void *)a0); + } + color = (D_800B99DA & 1) ? 0x4020FF : 0x4020F0; + buf[0] = 0; + buf[1] = 0x20; + func_801812AC(a0, buf, D_8018631C, 0, color); +} + INCLUDE_ASM("asm/ov_SC03_116/nonmatchings/ov_SC03_116_jr_8017AE2C", func_80181204); @@ -4429,7 +4466,30 @@ INCLUDE_ASM("asm/ov_SC03_116/nonmatchings/ov_SC03_116_jr_8017AE2C", func_801814E INCLUDE_ASM("asm/ov_SC03_116/nonmatchings/ov_SC03_116_jr_8017AE2C", func_80181550); -INCLUDE_ASM("asm/ov_SC03_116/nonmatchings/ov_SC03_116_jr_8017AE2C", func_80181580); +#include "common.h" + +extern void func_8001CD50(s32 a0, s32 a1); +extern void func_800233CC(void *, unsigned short); +extern void func_80181844(); +extern void func_801818B8(); +extern s32 func_8012AD50(void *a0); +extern u8 D_80197B60[]; + +void func_80181580(s32 arg0) { + u8 *ptr; + s32 var_s2; + + var_s2 = *(s32 *)(arg0 + 0x20); + ptr = D_80197B60 + (*(s16 *)(arg0 + 0x70) * 0x40); + func_8001CD50(var_s2, (s32) ptr); + func_800233CC(ptr, 0x80); + func_80181844(arg0, ptr); + *(u16 *)(var_s2 + 0x2C) = 0xC040; + *(s32 *)(var_s2 + 4) |= 0x50000000; + func_801818B8(arg0); + func_8012AD50(arg0); +} + INCLUDE_ASM("asm/ov_SC03_116/nonmatchings/ov_SC03_116_jr_8017AE2C", func_80181618); @@ -4487,11 +4547,73 @@ INCLUDE_ASM("asm/ov_SC03_116/nonmatchings/ov_SC03_116_jr_8017AE2C", func_80181A5 INCLUDE_ASM("asm/ov_SC03_116/nonmatchings/ov_SC03_116_jr_8017AE2C", func_80181B44); -INCLUDE_ASM("asm/ov_SC03_116/nonmatchings/ov_SC03_116_jr_8017AE2C", func_80181B88); +void func_80181B88(s32 a0) { + s32 s0 = a0; + s16 sp10[3]; + + *(u16 *)(*(s32 *)(s0 + 0x20) + 0x18) -= 0x80; + *(u16 *)(*(s32 *)(s0 + 0x20) + 0x1A) -= 0x80; + *(u16 *)(*(s32 *)(s0 + 0x20) + 0x1C) -= 0x80; + if (*(s16 *)(*(s32 *)(s0 + 0x20) + 0x18) <= 0) { + sp10[0] = *(u16 *)(s0 + 0x6); + sp10[1] = *(u16 *)(s0 + 0xA); + sp10[2] = *(u16 *)(s0 + 0xE); + sp10[1] -= 0x10; + func_80143BDC(sp10); + func_8018232C((s16 *)(s32)*(s16 *)(s0 + 0x70)); + func_8012C218((void *)s0); + } +} + INCLUDE_ASM("asm/ov_SC03_116/nonmatchings/ov_SC03_116_jr_8017AE2C", func_80181C4C); -INCLUDE_ASM("asm/ov_SC03_116/nonmatchings/ov_SC03_116_jr_8017AE2C", func_80181E28); +extern void func_8012EFB8(s32); +extern s32 func_800132BC(s32 a0, s32 a1); +extern void func_8002D4C8(s32 a0, s32 a1); +extern u16 D_80126B5E; +extern u16 D_80126B62; +extern u16 D_80126B66; + +s32 func_80181E28(void *arg0) +{ + s16 sp10[3]; + s16 sp18[3]; + s16 sp20[3]; + s16 sp28[3]; + s32 x; + s32 var; + + x = 0x7F; + if (*(s16 *)((s32)arg0 + 0xFE) == -1) { + return 0; + } + sp10[0] = *(u16 *)((s32)arg0 + 6); + sp10[1] = *(u16 *)((s32)arg0 + 0xA); + sp10[2] = *(u16 *)((s32)arg0 + 0xE); + ((void (*)(s32, s32))func_8012EFB8)((s32)sp10, (s32)sp18); + sp18[2] = 0; + sp20[0] = D_80126B5E; + sp20[1] = D_80126B62; + sp20[2] = D_80126B66; + ((void (*)(s32, s32))func_8012EFB8)((s32)sp20, (s32)sp28); + sp28[2] = 0; + if ((var = func_800132BC((s32)sp18, (s32)sp28) - 0x400) > 0) { + if (var < 0x6E40) { + *(s16 *)((s32)arg0 + 0xFE) = 1; + x -= var * 111 / 28224; + } else { + if (*(s16 *)((s32)arg0 + 0xFE) != 0) { + func_8002D4C8(4, 0xA2C); + *(s16 *)((s32)arg0 + 0xFE) = 0; + } + return 0; + } + func_8002D4C8(0xA2C, (x | 0x1000) & 0xFFFF); + } + return 1; +} + extern void (*D_80186578[])(void); @@ -4720,7 +4842,20 @@ void func_801825A8(void *a0) { } -INCLUDE_ASM("asm/ov_SC03_116/nonmatchings/ov_SC03_116_jr_8017AE2C", func_80182658); +void func_80182658(void *a0) { + struct B16_80185634 { s32 w[4]; }; + + extern struct B16_80185634 D_800A5EA8; + extern struct B16_80185634 D_801950F4; + extern s32 D_800A5EB0; + extern s32 func_8004787C(s32 a0); + extern void func_80028620(s32 a0, void *a1); + D_800A5EA8 = D_801950F4; + D_800A5EB0 = func_8004787C(*(s16 *)((s32)a0 + 0xFE)) * 6 / 4096 - 3; + *(u16 *)((s32)a0 + 0xFE) = (*(u16 *)((s32)a0 + 0xFE) + 0x71) & 0xFFF; + func_80028620(2, &D_800A5EA8); +} + /* §71 sibling-first: func_80185634 (same TU, already MATCHed) is the exact template. diff --git a/src/ov_SC05_003/ov_SC05_003_jr_8017BEBC.c b/src/ov_SC05_003/ov_SC05_003_jr_8017BEBC.c index bb44bad7b..d74ad6e9e 100644 --- a/src/ov_SC05_003/ov_SC05_003_jr_8017BEBC.c +++ b/src/ov_SC05_003/ov_SC05_003_jr_8017BEBC.c @@ -4774,9 +4774,72 @@ void func_8017FB9C(s32 param_1) { } -INCLUDE_ASM("asm/ov_SC05_003/nonmatchings/ov_SC05_003_jr_8017BEBC", func_8017FC3C); +extern void func_8012A828(s32 a0, s32 a1); +extern s32 func_80134510(s32 arg); +extern void func_80180D70(s32 a0, s32 a1); +extern u8 D_801152A8[]; +extern s16 D_801152AA; +extern s16 D_801152AC; +extern s32 D_801A9620; + +void func_8017FC3C(s32 param_1) { + u16 local[3]; + + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x12) = *(u16 *)(param_1 + 0xFC); + func_8012A828(param_1, (s32)&D_801A9620); + local[0] = *(u16 *)(param_1 + 0x6); + local[1] = *(u16 *)(param_1 + 0xA); + local[2] = *(u16 *)(param_1 + 0xE); + if (func_80134510((s32)local) != 0) { + *(u16 *)(param_1 + 0x6) = local[0]; + *(u16 *)(param_1 + 0xA) = local[1]; + *(u16 *)(param_1 + 0xE) = local[2]; + *(u16 *)(param_1 + 0xE8) = *(u16 *)D_801152A8; + *(u16 *)(param_1 + 0xEA) = *(u16 *)&D_801152AA; + *(u16 *)(param_1 + 0xEC) = *(u16 *)&D_801152AC; + func_80180D70(param_1, param_1 + 0xE8); + *(u16 *)(param_1 + 0x2) = 7; + } +} + + +#include "common.h" + +extern s32 func_80180B04(s32 a0, s32 a1, s32 a2); +extern void func_8012C218(void *a0); +extern void func_80180E34(s32 arg0); +extern s32 func_801808E8(s32 a0, void *a1, s32 a2, s32 a3); +extern void func_80180CE8(s32, void *, s32); +extern void func_8012B178(s32 a0, s32 a1); + +extern u8 D_800D3918[]; +extern u8 D_801A45C4[]; +extern u8 D_801152A8[]; +extern s16 D_801152B0; + +void func_8017FD08(s32 a0) { + s32 s0 = a0; + s32 sp10[2]; + s32 v1; + void *ptr; + + v1 = func_80180B04(s0, (s32)D_800D3918, 1); + if ((v1 & 0xE000) == 0) { + ((void (*)(s32, void *, void *))func_80180E34)(s0, D_801A45C4, sp10); + v1 = func_801808E8(s0, sp10, 1, 1); + if ((v1 & 0xE000) == 0) { + func_8012C218((void *)s0); + return; + } + } + ptr = D_801152A8; + if ((v1 & 0xC000) != 0) { + ptr = &D_801152B0; + } + func_80180CE8(s0, ptr, 4); + func_8012B178(s0, 0xFFF80000); +} -INCLUDE_ASM("asm/ov_SC05_003/nonmatchings/ov_SC05_003_jr_8017BEBC", func_8017FD08); INCLUDE_ASM("asm/ov_SC05_003/nonmatchings/ov_SC05_003_jr_8017BEBC", func_8017FDC0); @@ -5231,7 +5294,18 @@ void func_80180D70(s32 a0, s32 a1) { INCLUDE_ASM("asm/ov_SC05_003/nonmatchings/ov_SC05_003_jr_8017BEBC", func_80180E58); -INCLUDE_ASM("asm/ov_SC05_003/nonmatchings/ov_SC05_003_jr_8017BEBC", func_80180F44); +extern u16 D_800B99DA; +extern s32 D_801A46B4[]; +extern s32 D_801A46EC[]; +extern s32 D_801A4724[]; + +void func_80180F44(void) +{ + func_800183E0(D_801A46B4[D_800B99DA % 14]); + func_800183E0(D_801A46EC[D_800B99DA % 14]); + func_800183E0(D_801A4724[D_800B99DA & 0xF]); +} + extern void (*D_801A4770[])(void); @@ -5277,7 +5351,36 @@ void func_8018105C(void *param_1) INCLUDE_ASM("asm/ov_SC05_003/nonmatchings/ov_SC05_003_jr_8017BEBC", func_8018111C); -INCLUDE_ASM("asm/ov_SC05_003/nonmatchings/ov_SC05_003_jr_8017BEBC", func_801811EC); +#include "common.h" + +extern void func_8012B2CC(s32 a0); +extern s32 func_80013328(s32 a0, s32 a1); +extern void func_8012B14C(s32 a0, s32 a1); +extern void func_8012CBF4(s32 a0); +extern s32 func_80181CDC(s32 a0, s32 a1); + +extern u8 D_80126B5C; + +void func_801811EC(s32 a0) +{ + s32 vec[3]; + + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) = + *(u16 *)(*(s32 *)(*(s32 *)(a0 + 0x64) + 0x20) + 0x12) + 0x800; + func_8012B2CC(a0); + + vec[0] = 0; + vec[1] = -0x100000; + vec[2] = -((func_80013328((s32)&D_80126B5C, a0 + 4) << 16) / 34); + + func_8012B14C(a0, vec); + + *(s32 *)(a0 + 0x48) = 0x18000; + func_8012CBF4(a0); + func_80181CDC(a0, 0x7FA); + *(u16 *)(a0 + 2) = 3; +} + #include "common.h" @@ -5553,7 +5656,28 @@ void func_801818B8(s32 arg0) { } -INCLUDE_ASM("asm/ov_SC05_003/nonmatchings/ov_SC05_003_jr_8017BEBC", func_80181A08); +extern void func_801292C8(u8 *a0); +extern s32 func_80181AAC(s32 a0, s32 a1, s32 a2); +extern u8 D_800D3918[]; + +void func_80181A08(s32 arg0) { + s32 var; + + if (*(s16 *)(arg0 + 0xA) >= 0x10) { + func_801292C8((u8 *)arg0); + return; + } + if (func_80181AAC(arg0, (s32)D_800D3918, 0x11) & 0x6000) { + func_801292C8((u8 *)arg0); + return; + } + var = *(s32 *)(arg0 + 0x1C) - 1; + *(s32 *)(arg0 + 0x1C) = var; + if (var < 0x23) { + *(s32 *)(arg0 + 0x14) += 0x10000; + } +} + extern void func_8012931C(struct vec *a0); @@ -5600,7 +5724,38 @@ s32 func_80181AAC(s32 a0, s32 a1, s32 a2) { } -INCLUDE_ASM("asm/ov_SC05_003/nonmatchings/ov_SC05_003_jr_8017BEBC", func_80181C00); +typedef struct { + s16 f0, f2, f4, f6, f8, fA, fC, fE; + s32 f10; +} S80190C84L; + +extern s32 func_8012BE54(s32 a0); +extern s32 func_8012C51C(void *a0, s32 a1); + +void func_80181C00(s32 arg0) { + S80190C84L sp; + s32 counter; + s32 divisor; + + counter = *(s32 *)(arg0 + 0x1C); + divisor = *(s16 *)(arg0 + 0xFC); + *(s32 *)(arg0 + 0x1C) = counter + 1; + if (counter % divisor == 0) { + if (func_8012BE54(arg0) < 0x240001) { + sp.f0 = *(u16 *)(arg0 + 0x06); + sp.f2 = *(u16 *)(arg0 + 0x0A); + sp.f4 = *(u16 *)(arg0 + 0x0E); + sp.f6 = 0x1FB; + sp.f8 = *(u16 *)(arg0 + 0x70); + sp.fA = 0; + sp.fE = *(u16 *)(*(s32 *)(arg0 + 0x68) + 0x0C); + sp.f10 = *(s32 *)(arg0 + 0xDC); + sp.fC = 0x7FFF; + func_8012C51C(&sp, arg0); + } + } +} + #include "common.h" diff --git a/src/ov_SC05_007/ov_SC05_007_jr_8017BEBC.c b/src/ov_SC05_007/ov_SC05_007_jr_8017BEBC.c index 658d0f12b..f4e15ed8a 100644 --- a/src/ov_SC05_007/ov_SC05_007_jr_8017BEBC.c +++ b/src/ov_SC05_007/ov_SC05_007_jr_8017BEBC.c @@ -3388,7 +3388,23 @@ void func_8017D3BC(void *param_1) } -INCLUDE_ASM("asm/ov_SC05_007/nonmatchings/ov_SC05_007_jr_8017BEBC", func_8017D490); +void func_8017D490(void *a0) { + u16 sp10[4]; + u16 sp18[4]; + extern s32 D_801845DC; + extern s16 D_80126B62; + extern u8 D_80126B5C; + + func_80015978((s32)a0 + 4, (s32 *)sp10); + func_80015978((s32)&D_80126B5C, (s32 *)sp18); + sp18[1] = 0; + sp10[1] = 0; + if (func_80013294(sp10, sp18) < 0x80 && D_80126B62 < -0x1BF) { + func_80178B18((s32)a0, (s32)&D_801845DC); + func_8012AD50(a0); + } +} + INCLUDE_ASM("asm/ov_SC05_007/nonmatchings/ov_SC05_007_jr_8017BEBC", func_8017D52C); @@ -3418,7 +3434,12 @@ int func_8017D614(void) { } -INCLUDE_ASM("asm/ov_SC05_007/nonmatchings/ov_SC05_007_jr_8017BEBC", func_8017D638); +void func_8017D638(void *a0) { + *(u16 *)((s32)a0 + 0xFC) = *(u16 *)((s32)a0 + 6); + *(s32 *)((s32)a0 + 0xDC) = 0; + *(u16 *)((s32)a0 + 0xFE) = 0; +} + extern void func_80147324(s32 arg); void func_8017D64C(void) { @@ -3472,7 +3493,64 @@ void func_8017D764(void *a0) { } -INCLUDE_ASM("asm/ov_SC05_007/nonmatchings/ov_SC05_007_jr_8017BEBC", func_8017D7A0); +#include "common.h" + +extern s32 func_8012C1B8(void); +extern void func_8012CAE4(void *a0); +extern void func_8001C214(s32 a0, void *a1); +extern s32 func_80029178(s32 arg); +extern void MoveImage(void *a0, s32 a1, s32 a2); +extern void func_800233CC(void *, unsigned short); +extern void func_8001CD9C(int, void *); +extern s32 func_8012AD50(void *a0); + +extern u8 D_801908A4[]; +extern u8 D_80184624[]; +extern void func_8001D074(s32 a0, s32 a1); +extern u8 D_8019CD50[]; +extern u8 D_8019BA08[]; +extern u8 D_8019BA0C[]; + +typedef struct { u8 b[4]; } Blk4_8017D7A0; + +void func_8017D7A0(void *param_1) +{ + u8 *p_img; + u8 *p_buf; + s32 s1; + s32 v0; + + v0 = ((s32 (*)(void))func_8012C1B8)(); + *(s32 *)((s32)param_1 + 0x20) = v0; + if (v0 == 0) { + ((void (*)(void *))func_8012CAE4)(param_1); + return; + } + ((void (*)(s32, void *))func_8001C214)(v0, &D_801908A4); + if ((func_80029178(0xBA) & 0xFF) == 0) { + goto label; + } + p_img = (u8 *)&D_80184624; + MoveImage(p_img, 0x2D0, 0x180); + MoveImage(p_img + 8, 0x160, 0x155); + s1 = ((s32 (*)(s32, s32))func_8001D074)(0x7E, 0x100); + if (s1 == 0) { + goto label; + } + p_buf = (u8 *)&D_8019CD50; + ((void (*)(void *, unsigned short))func_800233CC)(p_buf, 0x28); + *(Blk4_8017D7A0 *)p_buf = *(Blk4_8017D7A0 *)&D_8019BA08; + *(Blk4_8017D7A0 *)(p_buf + 4) = *(Blk4_8017D7A0 *)&D_8019BA0C; + ((void (*)(int, void *))func_8001CD9C)(s1, p_buf); + *(u16 *)(s1 + 0x2C) = 0xC010; + *(u32 *)(s1 + 4) |= 0x50000000; + *(u16 *)(s1 + 8) = *(u16 *)((s32)param_1 + 6); + *(u16 *)(s1 + 0xA) = *(u16 *)((s32)param_1 + 0xA) - 0x10; + *(u16 *)(s1 + 0xC) = *(u16 *)((s32)param_1 + 0xE) - 0x10; +label: + ((void (*)(void *))func_8012AD50)(param_1); +} + void func_8017D8FC(void) { } @@ -3508,7 +3586,27 @@ void func_8017D948(s32 a0) { INCLUDE_ASM("asm/ov_SC05_007/nonmatchings/ov_SC05_007_jr_8017BEBC", func_8017D990); -INCLUDE_ASM("asm/ov_SC05_007/nonmatchings/ov_SC05_007_jr_8017BEBC", func_8017DAE4); +extern void func_8017DB58(s32 a0); +extern void func_80149020(s32 *a0); +extern void func_80159B3C(void *a0); +extern M2C_UNK D_800D5880; +extern void func_801542DC(s32 *a0, s32 a1); +extern u8 D_800D46E4[]; +extern void func_80165718(s32 a0); + +void func_8017DAE4(s32 arg0) +{ + func_80149020(arg0); + if (*(u16 *)((s32)arg0 + 0xB8) == 0x8000) { + func_8017DB58(arg0); + func_80159B3C(arg0); + if (*(s32 *)((s32)arg0 + 0xB4) == (s32)&D_800D5880) { + ((void (*)(s32, s32, s32))func_801542DC)(arg0, (s32)D_800D46E4, 0xE); + } + func_80165718(arg0); + } +} + extern void func_8014BC44(s32 a0, s32 a1); extern void func_80151664(void); @@ -3564,7 +3662,13 @@ void func_8017DBD4(s32 param_1) INCLUDE_ASM("asm/ov_SC05_007/nonmatchings/ov_SC05_007_jr_8017BEBC", func_8017DCAC); -INCLUDE_ASM("asm/ov_SC05_007/nonmatchings/ov_SC05_007_jr_8017BEBC", func_8017DD70); +s32 func_8017DD70(s32 param_1) { + func_80149374(*(s32 *)(param_1 + 0x34), param_1 + 4); + if (*(s32 *)(param_1 + 0x2C) == 0) { + func_800D1FC8(param_1, 5); + } +} + extern void func_80174684(void *); extern s32 func_8017DDE0; @@ -3584,14 +3688,50 @@ void aF8017DDE0(void *a0) } -INCLUDE_ASM("asm/ov_SC05_007/nonmatchings/ov_SC05_007_jr_8017BEBC", func_8017DE1C); +extern void (*D_8019099C[])(void); +extern void func_8017DE70(); + +void func_8017DE1C(s32 *a0) { + func_8014706C(a0); + func_80154274(a0, (s32)D_8019099C); + *(s16 *)((u8 *)(*(s32 **)((u8 *)a0 + 0x20)) + 0x12) = 0xC00; + func_80171A1C((u8 *)a0); + func_8017DE70(a0); +} + void func_8017DE70(void) { } -INCLUDE_ASM("asm/ov_SC05_007/nonmatchings/ov_SC05_007_jr_8017BEBC", func_8017DE78); +extern u8 D_801909C0; +void func_8017DE78(s32 *a0) { + func_80154274(a0, (s32)&D_801909C0); + func_801477E8(a0, 0xFFFE0000); + func_80146DE8(a0, 0, 0, 0xFFC00000); + func_80171A1C((u8 *)a0); +} + + +#include "common.h" + +extern void func_80147460(s32 a0); +extern void func_80147814(s32 a0, s32 a1); +extern void func_80147B18(s32); +extern void func_801473EC(s32 *a0); +extern void func_80171A1C(u8 *a0); + +void func_8017DED0(s32 arg0) +{ + func_80147814(arg0, 0x10000); + func_80147460(arg0); + ((void (*)(s32, s32, s32, s32))func_80147B18)(arg0, 0, 0, 0x10000); + func_801473EC((s32 *)arg0); + if (*(s16 *)((u8 *)arg0 + 0xA) >= -705) { + *(s16 *)((u8 *)arg0 + 0xA) = -706; + func_80171A1C((u8 *)arg0); + } +} -INCLUDE_ASM("asm/ov_SC05_007/nonmatchings/ov_SC05_007_jr_8017BEBC", func_8017DED0); INCLUDE_ASM("asm/ov_SC05_007/nonmatchings/ov_SC05_007_jr_8017BEBC", func_8017DF40); @@ -3641,7 +3781,26 @@ void func_8017DFEC(s32 a0) { } -INCLUDE_ASM("asm/ov_SC05_007/nonmatchings/ov_SC05_007_jr_8017BEBC", func_8017E078); +extern s32 D_801927F0; +extern s32 D_80192824[]; +extern s32 func_8012C354(s32 *a0, s32 a1); +extern s32 func_80143970(s32 a0); + +void func_8017E078(void *arg0) { + register s32 val __asm__("$3"); + if (func_8012C354(arg0, &D_801927F0) != 0) { + val = 0xFFFBDFD9; + *(u8 *)((char *)arg0 + 0xC0) = 1; + *(s32 **)((char *)arg0 + 0xBC) = &D_80192824; + *(s32 *)((char *)arg0 + 0xB4) = val; + *(s32 *)((char *)arg0 + 0xDC) = 0; + *(s16 *)((char *)arg0 + 0x100) = 0x1000; + *(s32 *)((char *)arg0 + 0xC4) |= 1; + func_80143970(arg0); + *(s16 *)((char *)arg0 + 0x2) = 1; + } +} + extern void func_8012A828(s32 *a0, s32 a1); @@ -3869,7 +4028,27 @@ void func_8017E688(void *a0) { } -INCLUDE_ASM("asm/ov_SC05_007/nonmatchings/ov_SC05_007_jr_8017BEBC", func_8017E740); +extern s32 func_8012B8E4(s32 a0, s32 a1); +extern s32 func_8012BEE8(s32 a0); + +void func_8017E740(s32 a0) { + s32 v; + + if ((*(s32 *)(a0 + 0xDC) & 0x8) != 0) { + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) += 0x44; + } else { + v = func_8012B8E4(a0, 0x8); + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) += v; + if (v == 0) { + *(s16 *)(a0 + 0x2) = 5; + return; + } + } + if (func_8012BEE8(a0) != 0) { + *(s16 *)(a0 + 0x2) = 5; + } +} + INCLUDE_ASM("asm/ov_SC05_007/nonmatchings/ov_SC05_007_jr_8017BEBC", func_8017E7D0); @@ -3893,7 +4072,14 @@ void func_8017E84C(void *a0) { } -INCLUDE_ASM("asm/ov_SC05_007/nonmatchings/ov_SC05_007_jr_8017BEBC", func_8017E874); +void func_8017E874(void *a0) { + if (*(s16 *)((s32)a0 + 0x76) <= 0) { + *(s32 *)((s32)a0 + 0xdc) |= 2; + } + *(s32 *)((s32)a0 + 0xe4) = 0; + *(s16 *)((s32)a0 + 0x52) = -0x30; +} + INCLUDE_ASM("asm/ov_SC05_007/nonmatchings/ov_SC05_007_jr_8017BEBC", func_8017E8A4); @@ -4160,7 +4346,42 @@ void func_8017EDB0(s32 param_1) { } -INCLUDE_ASM("asm/ov_SC05_007/nonmatchings/ov_SC05_007_jr_8017BEBC", func_8017EE80); +extern s32 func_8012BEE8(s32 a0); +extern void func_80130D48(s32 a0); +extern void func_8017F568(void *a0); +extern u16 D_800B99DA; + +void func_8017EE80(s32 a0) +{ + register s32 v0 __asm__("$2"); + register s32 v1 __asm__("$3"); + + v0 = *(s32 *)(a0 + 0xDC); + if ((v0 & 0x2) != 0) { + v0 = *(s32 *)(a0 + 0x1C); + if (v0 >= 0x15) { + v1 = *(s32 *)(a0 + 0x20); + v0 = *(u16 *)(v1 + 0x10); + *(s16 *)(v1 + 0x10) = v0 - 0x1E; + } + } + + v0 = *(s32 *)(a0 + 0x1C); + if (v0 < 0x11) { + v0 = *(s32 *)(a0 + 0x20); + v1 = *(s32 *)(v0 + 0x4); + v1 = v1 ^ 0x80000000; + *(s32 *)(v0 + 0x4) = v1; + } + + if (func_8012BEE8(a0) != 0) { + if ((D_800B99DA & 0x1F) == 0) { + func_80130D48(a0); + } + func_8017F568((void *)a0); + } +} + extern s32 rand(void); extern void func_8012B0B4(u32 *a0, s32 a1, s32 a2); diff --git a/src/ov_SC05_010/ov_SC05_010_jr_80181CDC.c b/src/ov_SC05_010/ov_SC05_010_jr_80181CDC.c index fe590c5a5..53f162140 100644 --- a/src/ov_SC05_010/ov_SC05_010_jr_80181CDC.c +++ b/src/ov_SC05_010/ov_SC05_010_jr_80181CDC.c @@ -3794,7 +3794,31 @@ void func_8018568C(s32 a0) { } -INCLUDE_ASM("asm/ov_SC05_010/nonmatchings/ov_SC05_010_jr_80181CDC", func_80185744); +void func_80185744(s32 a0) { + switch (*(s16 *)(a0 + 0x10A)) { + case 0: + break; + case 1: + *(s16 *)(a0 + 2) = 2; + *(s32 *)(a0 + 0x1C) = 0xF; + break; + case 2: + *(s16 *)(a0 + 2) = 3; + *(s16 *)(a0 + 0x34) = 0; + *(s32 *)(a0 + 0x1C) = 0; + *(s16 *)(a0 + 0xFC) = 3; + func_8002D4C8(0x903, 0); + break; + case 3: + *(s16 *)(a0 + 2) = 4; + *(s16 *)(a0 + 0x34) = 0; + *(s32 *)(a0 + 0x1C) = 0; + *(s16 *)(a0 + 0xFC) = 3; + break; + } + *(s16 *)(a0 + 0x10A) = 0; +} + void func_801857EC(s32 a0) { s32 v0; @@ -3821,7 +3845,24 @@ void func_801857EC(s32 a0) { } -INCLUDE_ASM("asm/ov_SC05_010/nonmatchings/ov_SC05_010_jr_80181CDC", func_80185894); +void func_80185894(s32 a0) { + extern s32 func_8012C354(s32 a0, s32 a1); + extern void func_8012A828(s32 a0, void *a1); + extern s32 func_8012C588(s32 a0, s32 a1); + extern u8 D_8019257C[]; + extern void (*D_80188CCC)(void); + + if (func_8012C354(a0, (s32)D_8019257C) != 0) { + *(u16 *)(a0 + 2) = 1; + *(u16 *)(a0 + 6) = *(u16 *)(a0 + 6) + 0x205; + *(u16 *)(a0 + 0xA) = *(u16 *)(a0 + 0xA) + 1; + func_8012A828(a0, &D_80188CCC); + *(u8 *)(a0 + 0xC0) = 1; + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x2C) = *(u16 *)(*(s32 *)(a0 + 0x20) + 0x2C) | 0x10; + *(s32 *)(a0 + 0x6C) = func_8012C588(0x2D4, a0); + } +} + void func_80185920(void *a0) { s16 x; @@ -4177,7 +4218,36 @@ extern void func_8012CBCC(s32 a0); INCLUDE_ASM("asm/ov_SC05_010/nonmatchings/ov_SC05_010_jr_80181CDC", func_80186624); -INCLUDE_ASM("asm/ov_SC05_010/nonmatchings/ov_SC05_010_jr_80181CDC", func_8018672C); +extern s32 func_8012C1B8(void); +extern void func_8012CAE4(void *a0); +extern void func_8012B23C(s32 a0); +extern void func_8001CA1C(void *a0, void *a1); +extern void func_8012A828(s32 a0, void *a1); + +extern u8 D_80192B70[]; +extern u8 D_80192C30[]; + +void func_8018672C(s32 param_1) +{ + s32 v0; + s32 v1; + + if ((*(s32 *)(param_1 + 0x20) = func_8012C1B8()) == 0) { + func_8012CAE4((void *)param_1); + } else { + func_8012B23C(param_1); + func_8001CA1C((void *)(*(s32 *)(param_1 + 0x20)), D_80192B70); + func_8012A828(param_1, D_80192C30); + v0 = *(s32 *)(param_1 + 0x20); + *(u16 *)(param_1 + 2) = 1; + *(u32 *)(v0 + 4) |= 0x50000000; + v1 = *(s32 *)(param_1 + 0x20); + *(u16 *)(v1 + 0x2C) |= 0x10; + *(s16 *)(*(s32 *)(param_1 + 0x20) + 0x18) = 0x2000; + *(s16 *)(*(s32 *)(param_1 + 0x20) + 0x1A) = 0x2000; + } +} + extern void func_8012CBCC(s32 a0); extern void func_8012C218(void *a0); diff --git a/src/ov_SC06_016/ov_SC06_016_jr_8017C8D0.c b/src/ov_SC06_016/ov_SC06_016_jr_8017C8D0.c index 99f7c39b3..83109ef6d 100644 --- a/src/ov_SC06_016/ov_SC06_016_jr_8017C8D0.c +++ b/src/ov_SC06_016/ov_SC06_016_jr_8017C8D0.c @@ -3338,7 +3338,32 @@ void func_8017DB34(void) { } -INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_8017DB5C); +void func_8017DB5C(void) { + extern s32 D_80126954; + extern s32 D_8012695C; + extern s16 D_80126968; + extern s16 D_8012696A; + extern s16 D_8012696C; + extern s16 D_80126976; + extern s16 D_80126978; + extern s16 D_8012697A; + extern u8 D_80126948[]; + extern void func_8012A018(s32 a0, s32 a1); + extern void func_8012A094(s32 a0); + extern void func_8017DBF8(void *a0); + D_80126954 = 0x190; + D_8012695C = 0x3E8; + D_80126968 = 0x1C7; + D_8012696A = 0x800; + D_8012696C = 0; + D_80126976 = 0; + D_80126978 = -0x20; + D_8012697A = 0; + func_8012A018((s32)func_8017DBF8, 0); + func_8012A094((s32)D_80126948); + func_8017DBF8(D_80126948); +} + extern void (*D_80188970[])(void); @@ -3553,7 +3578,20 @@ INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_8017E1D INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_8017E26C); -INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_8017E4AC); +#include "common.h" + +extern void func_8017EEFC(s32 arg0, s32 arg1, s32 arg2, s32 arg3); +extern void func_8002D4C8(s32 a0, s32 a1); +extern s32 D_801963EC; +extern s16 D_80188A18; + +void func_8017E4AC(s32 a0) +{ + func_8017EEFC(a0, 6, 0, &D_801963EC); + *(s32 *)(a0 + 0x1C) = D_80188A18; + func_8002D4C8(4, 0x97E); +} + INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_8017E4FC); @@ -3829,7 +3867,40 @@ INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_8017EE7 INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_8017EEB4); -INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_8017EEFC); +extern void func_8012E8E0(s32 a0, s32 a1); +extern void func_8012A828(s32 *a0, s32 a1); +extern void func_8012E88C(u8 *a0); +extern void func_8017F124(void *a0); +extern void func_8017F13C(void *a0); +extern u8 D_80188D38[]; + +void func_8017EEFC(s32 param_1, s32 param_2, s32 param_3, s32 param_4) { + register s32 s0 __asm__("$16") = param_1; + register s32 s2 __asm__("$18") = param_2; + register s32 s1 __asm__("$17") = param_4; + s32 v1; + + *(u16 *)(s0 + 2) = s2; + if (param_3 != 0) { + func_8012E8E0(param_1, param_3); + } + if (s1 != 0) { + func_8012A828((s32 *)s0, s1); + } + v1 = *(s32 *)(s0 + 0x20); + *(u16 *)(v1 + 0x2C) |= 0x10; + v1 = *(s32 *)(s0 + 0x20); + *(u16 *)(v1 + 0x1C) = 0x1000; + *(u16 *)(v1 + 0x1A) = 0x1000; + *(u16 *)(v1 + 0x18) = 0x1000; + func_8012E88C((u8 *)s0); + if (D_80188D38[s2] != 0) { + func_8017F124((void *)s0); + } else { + func_8017F13C((void *)s0); + } +} + #include "common.h" @@ -4879,7 +4950,57 @@ void func_80180E24(void *a0) } -INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_80180F68); +extern void func_8012B2CC(s32 a0); +extern void func_8012B200(u8 *a0); +extern void func_8002D4C8(s32 a0, s32 a1); + +void func_80180F68(s32 a0) +{ + { + register s32 *p __asm__("$2"); + register s32 two __asm__("$3"); + + p = (s32 *)(*(u32 *)((u8 *)a0 + 0x20)); + two = 2; + *(s16 *)((u8 *)a0 + 2) = two; + *(s16 *)((u8 *)a0 + 0x34) = 0; + *(s16 *)((u8 *)p + 0x14) = 0; + *(s16 *)((u8 *)p + 0x12) = 0; + *(s16 *)((u8 *)p + 0x10) = 0; + } + func_8012B2CC(a0); + func_8012B200((u8 *)a0); + + { + register s32 v __asm__("$2"); + + v = *(s16 *)((u8 *)a0 + 6); + if (v < 0) { + v = *(s16 *)((u8 *)a0 + 0x70); + if (v != 0) { + v = 0x40000; + } else { + v = 0x30000; + } + } else { + v = *(s16 *)((u8 *)a0 + 0x70); + if (v != 0) { + v = -0x40000; + } else { + v = -0x30000; + } + } + *(s32 *)((u8 *)a0 + 0x10) = v; + __asm__ __volatile__(""); + } + + *(s32 *)((u8 *)a0 + 0x14) = 0x200000; + *(s32 *)((u8 *)a0 + 0x18) = 0; + *(s32 *)((u8 *)a0 + 0x48) = 0x20000; + *(s32 *)((u8 *)a0 + 0x1C) = 0; + func_8002D4C8(0x980, 0); +} + extern s32 func_8012C658(s32 arg0, s32 arg1, s32 arg2); @@ -5298,7 +5419,27 @@ INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_80181B6 INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_80181C78); -INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_80181CD0); +extern s32 func_8012B8E4(s32 arg0, s32 arg1); +extern void func_8002D4C8(s32 a0, s32 a1); +extern s32 func_8012BEE8(s32 a0); +extern void func_8017E190(s32 a0); + +void func_80181CD0(int param_1) +{ + int v; + unsigned short *p; + + v = func_8012B8E4(param_1, 4); + p = (unsigned short *)(*(int *)(param_1 + 0x20) + 0x12); + *p = (unsigned short)(*p + v); + if (*(int *)(param_1 + 0x1C) == 7) { + func_8002D4C8(0xA91, 0); + } + if (func_8012BEE8(param_1) != 0) { + func_8017E190(param_1); + } +} + extern s32 func_8012BEE8(s32 arg); extern void func_8017E1D8(s32 *a0); @@ -5338,7 +5479,21 @@ void func_80181DFC(s32 a0) { } -INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_80181E3C); +extern void func_8002D4C8(s32 a0, s32 a1); +extern s32 func_8012BEE8(s32 a0); +extern void func_8017E910(s32 a0); + +void func_80181E3C(s32 arg0) { + s32 s0 = arg0; + + if (*(s32 *)(s0 + 0x1C) == 0xA) { + func_8002D4C8(0xA93, 0); + } + if (func_8012BEE8(s0) != 0) { + func_8017E910(s0); + } +} + INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_80181E90); @@ -5892,7 +6047,159 @@ s32 func_80183020(s32 s0) { } -INCLUDE_ASM("asm/ov_SC06_016/nonmatchings/ov_SC06_016_jr_8017C8D0", func_801830B4); +/* Declarations copied verbatim from src/ov_SC06_016/ov_SC06_016_jr_8017C8D0.c + (func_8004914C / func_800491AC / RotTransSV / short+s16 D_800B9A02) and from + this overlay's sibling TUs (ov_SC06_016_jr_80135A4C.c et al.) for the rest. + gte_Set{Rot,Trans}Matrix macro form already used banked in ov_SC03_028 + (func_80183E04). */ +extern s32 D_80126950; +extern s16 D_800B9A02; +extern void func_8004914C(void *a0); +extern void func_800491AC(void *a0); +extern void RotTransSV(void *a0, void *a1, void *a2); +extern s32 RotTransPers(s32 a0, s32 a1, s32 *a2, s32 *a3); +extern s32 D_800A651C; +extern u8 D_800AF648; +extern u8 D_8019A49C[]; +extern u32 D_8019A4A4[]; +extern u8 D_8019A4B0[]; +extern u8 D_8019A4B1[]; +extern u8 D_8019A4B2[]; +extern u8 D_8019A4B3[]; +extern u8 D_8019A4C0[]; +extern u8 D_8019A4C1[]; +extern u8 D_8019A4C2[]; +extern u8 D_8019A4C3[]; +extern u8 D_8019A4D0[]; +extern u8 D_8019A4D1[]; +extern u8 D_8019A4D2[]; +extern u8 D_8019A4D3[]; +extern void *func_80010A08(s32); +extern s32 func_8005A600(s32, s32, s32, s32, s32); +extern s32 GetTPage(s32, s32, s32, s32); +extern s32 AddPrim(s32, void *); + +#define gte_SetRotMatrix(r0) __asm__ volatile ( \ + "lw $12, 0( %0 );" \ + "lw $13, 4( %0 );" \ + "ctc2 $12, $0;" \ + "ctc2 $13, $1;" \ + "lw $12, 8( %0 );" \ + "lw $13, 12( %0 );" \ + "lw $14, 16( %0 );" \ + "ctc2 $12, $2;" \ + "ctc2 $13, $3;" \ + "ctc2 $14, $4" \ + : \ + : "r"( r0 ) \ + : "$12", "$13", "$14" ) +#define gte_SetTransMatrix(r0) __asm__ volatile ( \ + "lw $12, 20( %0 );" \ + "lw $13, 24( %0 );" \ + "ctc2 $12, $5;" \ + "lw $14, 28( %0 );" \ + "ctc2 $13, $6;" \ + "ctc2 $14, $7" \ + : \ + : "r"( r0 ) \ + : "$12", "$13", "$14" ) + +void func_801830B4(void *a0) +{ + s32 tags[4]; /* sp+0x18 */ + s16 sv[4]; /* sp+0x28 */ + s16 xs[8]; /* sp+0x30 */ + s16 ys[8]; /* sp+0x40 */ + struct { + s32 flag; /* sp+0x50 */ + u16 sxy[2]; /* sp+0x54 */ + s32 pz; /* sp+0x58 */ + } o; + + s32 m; + void *pv; + s32 *pflag; + s32 ret; + s32 d; + s32 e; + s32 x; + s32 y; + s32 ot; + u8 *prim; + u8 *pp; + u8 *base; + u32 *pal; + s32 i; + s32 k; + + m = *(s32 *)((s32)a0 + 0x20) + 0x34; + gte_SetRotMatrix(m); + gte_SetTransMatrix(m); + + pv = (void *)sv; + pflag = &o.flag; + RotTransSV(D_8019A49C, pv, pflag); + func_8004914C(&D_800AF648); + func_800491AC(&D_800AF648); + ret = RotTransPers((s32)pv, (s32)o.sxy, &o.pz, pflag); + if ((ret > 0) && (o.flag >= 0)) { + ret = ret * 4; + d = ((D_80126950 + 0x1F4) * 48) / ret; + x = o.sxy[0]; + y = o.sxy[1]; + ot = *(s32 *)((s8 *)&D_800A651C + ((u16)D_800B9A02 * 0x14)) + ret; + e = (d * 179) >> 8; + + xs[2] = x; + ys[2] = y; + xs[0] = x - d; + xs[1] = x - e; + xs[3] = x + e; + xs[4] = x + d; + ys[0] = y - d; + ys[1] = y - e; + ys[3] = y + e; + ys[4] = y + d; + + prim = (u8 *)func_80010A08(0x9C); + if (prim != 0) { + s32 tp; + tp = GetTPage(0, 1, 0, 0); + func_8005A600((s32)prim, 0, 0, (u16)tp, 0); + + tags[0] = (s32)(prim + 0xC); + pp = prim + 0xC; + pal = D_8019A4A4; + base = (u8 *)tags; + k = 0; + tags[1] = (s32)(prim + 0x30); + tags[2] = (s32)(prim + 0x54); + tags[3] = (s32)(prim + 0x78); + do { + i = k * 4; + *(u32 *)(pp + 0x04) = pal[D_8019A4D0[i]]; + *(u32 *)(pp + 0x0C) = pal[D_8019A4D1[i]]; + *(u32 *)(pp + 0x14) = pal[D_8019A4D2[i]]; + *(u32 *)(pp + 0x1C) = pal[D_8019A4D3[i]]; + *(u8 *)(pp + 0x03) = 8; + *(u8 *)(pp + 0x07) = 0x3A; + *(u16 *)(pp + 0x08) = *(u16 *)(base + 0x18 + D_8019A4B0[i] * 2); + *(u16 *)(pp + 0x10) = *(u16 *)(base + 0x18 + D_8019A4B1[i] * 2); + *(u16 *)(pp + 0x18) = *(u16 *)(base + 0x18 + D_8019A4B2[i] * 2); + *(u16 *)(pp + 0x20) = *(u16 *)(base + 0x18 + D_8019A4B3[i] * 2); + *(u16 *)(pp + 0x0A) = *(u16 *)(base + 0x28 + D_8019A4C0[i] * 2); + *(u16 *)(pp + 0x12) = *(u16 *)(base + 0x28 + D_8019A4C1[i] * 2); + *(u16 *)(pp + 0x1A) = *(u16 *)(base + 0x28 + D_8019A4C2[i] * 2); + *(u16 *)(pp + 0x22) = *(u16 *)(base + 0x28 + D_8019A4C3[i] * 2); + AddPrim(ot, pp); + k += 1; + pp += 0x24; + } while (k < 4); + AddPrim(ot, prim); + } + } +} + diff --git a/src/ov_SC06_022/ov_SC06_022_jr_8017BEBC.c b/src/ov_SC06_022/ov_SC06_022_jr_8017BEBC.c index e12561a57..baa99ea1e 100644 --- a/src/ov_SC06_022/ov_SC06_022_jr_8017BEBC.c +++ b/src/ov_SC06_022/ov_SC06_022_jr_8017BEBC.c @@ -3324,9 +3324,44 @@ INCLUDE_ASM("asm/ov_SC06_022/nonmatchings/ov_SC06_022_jr_8017BEBC", func_8017D29 INCLUDE_ASM("asm/ov_SC06_022/nonmatchings/ov_SC06_022_jr_8017BEBC", func_8017D348); -INCLUDE_ASM("asm/ov_SC06_022/nonmatchings/ov_SC06_022_jr_8017BEBC", func_8017D414); +extern void func_8014C6AC(void); +extern void func_8012A018(s32 a, s32 b); +extern void func_8017D59C(void *a0); +extern u8 D_80126948[]; + +void func_8017D414(void) { + func_8014C6AC(); + func_8012A018((s32)func_8017D59C, 2); + func_8017D59C(D_80126948); +} + + +extern void func_8014C6C0(void); +extern void func_8012A018(s32 a, s32 b); +extern s32 D_80126954; +extern s32 D_8012695C; +extern s16 D_80126968; +extern s16 D_8012696A; +extern s16 D_8012696C; +extern s16 D_80126976; +extern s16 D_80126978; +extern s16 D_8012697A; +extern void func_8017D59C(void *a0); + +void func_8017D454(void) +{ + func_8014C6C0(); + D_80126954 = 400; + D_8012695C = 1200; + D_80126968 = 0x238; + D_8012696A = 0x800; + D_8012696C = 0; + D_80126976 = 0; + D_80126978 = -0x20; + D_8012697A = 0; + func_8012A018(func_8017D59C, 0); +} -INCLUDE_ASM("asm/ov_SC06_022/nonmatchings/ov_SC06_022_jr_8017BEBC", func_8017D454); extern u8 D_80126948[]; extern void func_8017D59C(void *a0); @@ -3448,9 +3483,42 @@ void func_8017DB74(int param_1) } -INCLUDE_ASM("asm/ov_SC06_022/nonmatchings/ov_SC06_022_jr_8017BEBC", func_8017DBA4); +extern void (*D_80190F04[])(void); +extern s32 func_80128DB4(s32 a0, s32 *a1); +extern s32 D_801E1F98; + +void func_8017DBA4(void *a0) { + D_80190F04[*(u16 *)((s32)a0 + 0x2)](); + if (*(s32 *)((s32)a0 + 0xE0) != 0) { + func_80128DB4(0, &D_801E1F98); + } +} + + +void func_8017DC0C(s32 param_1) { + extern s32 func_8012C354(s32 a0, void *a1); + extern s32 func_8012E504(s32 a0, s32 a1); + extern void func_80128D60(s32 a0, s32 *a1, s32 *a2); + extern void func_8001C97C(s32 *a0); + extern void (*D_80190E58)(void *); + extern void (*D_80190E8C)(void *); + extern s32 D_801E1F98; + extern s32 D_801AAD00[]; + extern s32 D_801AAD08[]; + + if (func_8012C354(param_1, &D_80190E58) == 0) { + return; + } + if (func_8012E504(param_1, 0x2F0) == 0) { + *(s32 *)(param_1 + 0xE0) = 1; + func_80128D60(0, &D_801E1F98, &D_80190E8C); + func_8001C97C(D_801AAD00); + func_8001C97C(D_801AAD08); + } + *(s16 *)(param_1 + 0xAE) = 0x2000; + *(u16 *)(param_1 + 2) = *(u16 *)(param_1 + 2) + 1; +} -INCLUDE_ASM("asm/ov_SC06_022/nonmatchings/ov_SC06_022_jr_8017BEBC", func_8017DC0C); void func_8017DCA4(s32 arg0) { s32 sp10; @@ -4240,7 +4308,16 @@ void func_8017F704(s32 arg0) void func_8017F7FC(void) { } -INCLUDE_ASM("asm/ov_SC06_022/nonmatchings/ov_SC06_022_jr_8017BEBC", func_8017F804); +s32 func_8017F804(s16 *a0) { + extern s16 D_80126CB0; + s32 diff; + diff = D_80126CB0 - a0[2]; + if (diff < 0) { + diff = a0[2] - D_80126CB0; + } + return (u32)(diff - 0x3C1) < 0x3F; +} + extern s16 D_80126CB0; @@ -5196,7 +5273,15 @@ INCLUDE_ASM("asm/ov_SC06_022/nonmatchings/ov_SC06_022_jr_8017BEBC", func_8018166 INCLUDE_ASM("asm/ov_SC06_022/nonmatchings/ov_SC06_022_jr_8017BEBC", func_80181744); -INCLUDE_ASM("asm/ov_SC06_022/nonmatchings/ov_SC06_022_jr_8017BEBC", func_80181780); +void func_80181780(s32 param_1) +{ + if (*(s32 *)(*(s32 *)(*(s32 *)(param_1 + 0xCC) + 0x20) + 4) < 0) { + func_8012C218((void *)param_1); + } else { + func_80180EE0(param_1); + } +} + void func_801817D0(void) { } @@ -5237,7 +5322,39 @@ void func_801818E4(s32 param_1) { } -INCLUDE_ASM("asm/ov_SC06_022/nonmatchings/ov_SC06_022_jr_8017BEBC", func_8018199C); +extern void func_8012AD80(s32 a0); +extern void func_80181468(); +extern s32 rand(void); +extern void func_80181394(void *a0); + +void func_8018199C(s32 arg0) { + register s32 a0 __asm__("$4"); + register s32 a1 __asm__("$5"); + u16 val; + s16 h; + + a0 = *(s32 *)(arg0 + 0x20); + val = *(u16 *)(arg0 + 0x106); + *(u16 *)(a0 + 0x10) = *(u16 *)(a0 + 0x10) + val; + + a1 = *(s32 *)(arg0 + 0x20); + val = *(u16 *)(arg0 + 0x108); + *(u16 *)(a1 + 0x14) = *(u16 *)(a1 + 0x14) + val; + + func_8012AD80(arg0); + + h = *(s16 *)(arg0 + 0xE0); + if (*(s16 *)(arg0 + 0xA) >= h) { + *(s16 *)(arg0 + 0xA) = h; + *(u16 *)(*(s32 *)(arg0 + 0x20) + 0x10) = 0x400; + if ((rand() & 1) != 0) { + *(u16 *)(*(s32 *)(arg0 + 0x20) + 0x10) = 0xC00; + } + func_80181394((void *)arg0); + } + func_80181468(arg0, 0x4001); +} + INCLUDE_ASM("asm/ov_SC06_022/nonmatchings/ov_SC06_022_jr_8017BEBC", func_80181A4C); @@ -5708,7 +5825,18 @@ void func_80182404(s32 p) } -INCLUDE_ASM("asm/ov_SC06_022/nonmatchings/ov_SC06_022_jr_8017BEBC", func_80182554); +extern s32 D_801D4430; +extern void func_8012A828(s32 a0, void *a1); + +void func_80182554(void *arg0) { + extern void func_8012A828(s32, void*); + extern s32 D_801D4430; + + ((void (*)(void *, void *))func_8012A828)(arg0, &D_801D4430); + *(s16 *)((u8 *)arg0 + 0x2) = 0xD; + *(s32 *)((u8 *)arg0 + 0x1C) = 0x28; +} + INCLUDE_ASM("asm/ov_SC06_022/nonmatchings/ov_SC06_022_jr_8017BEBC", func_80182594); @@ -5979,4 +6107,20 @@ void func_80182B90(s32 p) } -INCLUDE_ASM("asm/ov_SC06_022/nonmatchings/ov_SC06_022_jr_8017BEBC", func_80182CA0); +extern void func_8012A828(s32 a0, void *a1); + +void func_80182CA0(s32 p) +{ + extern u8 D_801D4488[]; + + *(s16 *)(p + 2) = 0x16; + if ((*(u32 *)(p + 0xE0) & 0x400) == 0) { + func_8012A828(p, D_801D4488); + *(s16 *)(p + 0x34) = 4; + *(s32 *)(p + 0x1C) = 0xF; + } else { + *(s32 *)(p + 0x1C) = 0x1E; + *(s16 *)(p + 0x34) = 0; + } +} + diff --git a/src/ov_SC06_024/ov_SC06_024_jr_801851E0.c b/src/ov_SC06_024/ov_SC06_024_jr_801851E0.c index c3ded08a3..180ae9779 100644 --- a/src/ov_SC06_024/ov_SC06_024_jr_801851E0.c +++ b/src/ov_SC06_024/ov_SC06_024_jr_801851E0.c @@ -3423,7 +3423,7 @@ void func_80186198(s32 p) } -extern void func_801875A4(void); +extern void func_801875A4(); void func_80186314(void *a0) { if (*(s16 *)((s32)a0 + 0x98) == 0) { ((void (*)(void))func_801875A4)(); diff --git a/src/ov_SC06_024/ov_SC06_024_jr_801867DC.c b/src/ov_SC06_024/ov_SC06_024_jr_801867DC.c index a1aaf1c96..846283a07 100644 --- a/src/ov_SC06_024/ov_SC06_024_jr_801867DC.c +++ b/src/ov_SC06_024/ov_SC06_024_jr_801867DC.c @@ -2810,7 +2810,7 @@ extern void func_801898EC(s32, void*, void*, s32); extern void func_80189888(s32, void*, s32, s32, s32, s32); extern s32 func_80013478(s32 a0, s32 a1); extern void func_80185EF8(s32 param_1); -extern void func_801875A4(void); +extern void func_801875A4(); extern void func_80186314(void *a0); /* ==== end §8b carried decl layer ==== */ diff --git a/src/ov_SC06_024/ov_SC06_024_jr_80186F00.c b/src/ov_SC06_024/ov_SC06_024_jr_80186F00.c index 8d5cd6e5a..e9376a96c 100644 --- a/src/ov_SC06_024/ov_SC06_024_jr_80186F00.c +++ b/src/ov_SC06_024/ov_SC06_024_jr_80186F00.c @@ -2795,7 +2795,7 @@ extern void func_801898EC(s32, void*, void*, s32); extern void func_80189888(s32, void*, s32, s32, s32, s32); extern s32 func_80013478(s32 a0, s32 a1); extern void func_80185EF8(s32 param_1); -extern void func_801875A4(void); +extern void func_801875A4(); extern void func_80186314(void *a0); /* ==== end §8b carried decl layer ==== */ @@ -3004,10 +3004,31 @@ extern void func_8018A3CC(s32 arg0, s32 arg1); } -INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_80186F00", func_80187460); +void func_80187460(s32 a0) { + + extern void func_8002AC00(s32 arg0); + extern void func_8002A04C(s32 arg0); + extern void func_8012C098(void *a0); + + switch (*(u16 *)(a0 + 0x70) & 0xF) { + case 0: + func_8002AC00(0x1F); + break; + case 1: + func_8002AC00(0x20); + break; + case 2: + func_8002AC00(0x21); + break; + } + + func_8002A04C(a0); + func_8012C098((void *)a0); +} -extern void func_801875A4(void); + +extern void func_801875A4(); extern void func_80187A50(s32 a0, s32 a1); extern void func_8012A828(s32 a0, void *a1); @@ -3039,7 +3060,33 @@ void func_801874E4(s32 param_1) { } -INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_80186F00", func_801875A4); +void func_801875A4(s32 s0) { + extern void func_8012A828(s32 a0, void *a1); + extern u8 D_801D3F5C[]; + extern u8 D_801D3284[]; + extern u32 D_801BC298[]; + extern u32 D_801BC2A8[]; + + s32 f = *(s32 *)(s0 + 0xE0); + if (!(f & 4)) { + if (f & 0x800) { + *(u16 *)(s0 + 2) = 14; + func_8012A828(s0, D_801D3F5C); + } else if (!((f & 1) || *(s32 *)(s0 + 0xD0) == 0)) { + *(u16 *)(s0 + 2) = 14; + *(u16 *)(s0 + 0x34) = 2; + *(s32 *)(s0 + 0x1C) = 0x200; + func_8012A828(s0, D_801D3284); + } else { + *(u16 *)(s0 + 2) = D_801BC298[*(u16 *)(s0 + 0x70) & 0xF]; + } + } else { + *(u16 *)(s0 + 2) = D_801BC2A8[*(u16 *)(s0 + 0x70) & 0xF]; + func_8012A828(s0, D_801D3F5C); + *(s32 *)(s0 + 0x1C) = 0x200; + } +} + extern void func_8012EC04(s32 param_1, s32 param_2, s32 *param_3); extern void func_8012F568(s32 a0, s32 a1, s32 a2, s32 a3, s32 a4, s32 a5); @@ -3282,7 +3329,20 @@ void func_8018788C(s32 a0) { INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_80186F00", func_80187A50); -INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_80186F00", func_80187BC8); +s32 func_80187BC8(s32 a0) { + s32 flags; + s32 hi; + + flags = func_8012CBA4(a0); + func_80187C28(a0, flags); + if (flags & 0x2000) { + hi = flags & 0x8000; + return !hi; + } + func_8012ADE4((u8 *)a0); + return 0; +} + /* Family exemplar (S48 wave-4). Two compiler-shape levers used, both already @@ -3331,7 +3391,15 @@ void func_80187C28(s32 a0, s32 a1) { } -INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_80186F00", func_80187D50); +void func_80187D50(s32 a0) { + if (func_80187DB0(a0, 2) == 0) { + *(s32 *)(a0 + 0xE8) += 0x40; + } else { + *(s32 *)(a0 + 0xE8) -= 0x40; + } + *(s32 *)(a0 + 0xE0) |= 0x40; +} + /* func_80187DB0 — line-of-sight / collision probe. @@ -3822,7 +3890,17 @@ void func_80188630(s32 a0) { } -INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_80186F00", func_801887A0); +void func_801887A0(s32 param_1) +{ + *(s32 *)(param_1 + 0x1C) = 0x18; + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x10) = 0x80; + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x12) = + *(u16 *)(*(s32 *)(*(s32 *)(param_1 + 0x64) + 0x20) + 0x12); + func_8012B2CC(param_1); + func_8012B178(param_1, -0x100000); + *(s16 *)(param_1 + 2) = 2; +} + extern void func_8012C218(s32); @@ -3935,7 +4013,20 @@ LAB_80188494: } -INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_80186F00", func_80188A60); +extern void func_8012B2CC(s32 a0); +extern void func_8012B178(s32 a0, s32 a1); + +void func_80188A60(s32 param_1) { + *(s32 *)(param_1 + 0x48) = 0xC000; + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x12) = + *(u16 *)(*(s32 *)(*(s32 *)(param_1 + 0x64) + 0x20) + 0x12); + func_8012B2CC(param_1); + func_8012B178(param_1, 0x20000); + *(u16 *)(param_1 + 2) = 4; + *(s32 *)(param_1 + 0x1C) = 0; + *(u16 *)(param_1 + 0x34) = 0; +} + extern void func_8012C218(s32); @@ -3988,7 +4079,17 @@ LAB_tail: } -INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_80186F00", func_80188BF8); +void func_80188BF8(void *a0) { + s32 v1 = *(s32 *)((s32)a0 + 0x64); + *(s16 *)((s32)a0 + 2) = 6; + *(s16 *)((s32)a0 + 0x34) = 0; + { + s32 t = *(s32 *)(v1 + 0x20); + s32 u = *(s32 *)((s32)a0 + 0x20); + *(u16 *)(u + 0x12) = *(u16 *)(t + 0x12); + } +} + // @class: struct @@ -4253,7 +4354,24 @@ void func_801892C0(void *a0) } -INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_80186F00", func_801892FC); +extern s32 func_8012D624(void *a0, s32 a1, s32 a2); +extern s32 func_801899B8(s32 a0, s32 a1, s32 a2); +extern void func_8012C218(s32); + +void func_801892FC(s32 param_1) +{ + extern u16 D_80126B96; + + if (*(u16 *)(param_1 + 0x70) & 1) { + if (func_8012D624((void *)param_1, 0x60, *(s16 *)(param_1 + 0x104)) == 1) { + D_80126B96 = 0x4001; + } + } + if (func_801899B8(param_1, 0x60, *(s16 *)(param_1 + 0x104)) == 1) { + ((void (*)(void *))func_8012C218)((void *)param_1); + } +} + /* func_8018937C @ ov_SC06_018 (subseg ov_SC06_018_jr_8017C24C) — 124 ins. MATCH. @@ -6692,7 +6810,16 @@ void func_8018D230(s32 arg0) { } -INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_80186F00", func_8018D4B4); +void func_8018D4B4(void *a0) { + s32 v1; + v1 = *(s32 *)((s32)a0 + 0xCC); + *(s16 *)((s32)a0 + 0x5C) = 0; + *(s16 *)((s32)a0 + 0xFC) = 30; + *(s16 *)(v1 + 0x5C) = 0; + v1 = *(s32 *)((s32)a0 + 0xD0); + *(s16 *)(v1 + 0x5C) = 0; +} + extern void func_8012B1B4(s32 a0, s32 a1); @@ -7852,7 +7979,27 @@ void func_8018EDC4(void *a0) { } -INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_80186F00", func_8018EE00); +extern void func_80016714(void *a0, s32 a1); +extern void func_8002A04C(s32 a0); +extern void func_8012C218(s32 a0); + +void func_8018EE00(s32 a0) +{ + if (*(s16 *)(a0 + 0x70) != 0) { + *(s16 *)(a0 + 0x2) = 4; + *(s16 *)(a0 + 0x5C) = 0; + *(s16 *)(a0 + 0x5E) = 0; + *(u8 *)(a0 + 0xC1) = 0; + } else { + if (*(s32 *)(a0 + 0xCC) != 0) + func_80016714(*(void **)(a0 + 0xCC), 0x84); + if (*(s32 *)(a0 + 0xD0) != 0) + func_80016714(*(void **)(a0 + 0xD0), 0x84); + ((void (*)(void *))func_8002A04C)((void *)a0); + ((void (*)(void *))func_8012C218)((void *)a0); + } +} + extern void func_8002D4C8(s32 arg0, s32 arg1); extern void func_8018DEC0(void); @@ -7878,7 +8025,20 @@ extern void func_8018E094(void); } -INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_80186F00", func_8018EF1C); +extern void func_80131E00(); +extern void func_8018E094(void); + +void func_8018EF1C(void *a0) { + if (*(s16 *)((s32)a0 + 0x76) < 0) { + func_80131E00(a0, 6); + } else { + *(u16 *)((s32)a0 + 0x2) = 1; + *(u16 *)((s32)a0 + 0x100) = 0x3C; + *(u16 *)((s32)a0 + 0x34) = 0; + func_8018E094(); + } +} + extern int func_80143C74(short*, int); @@ -7922,7 +8082,28 @@ extern void func_8018DEC0(void); } -INCLUDE_ASM("asm/ov_SC06_024/nonmatchings/ov_SC06_024_jr_80186F00", func_8018F0B4); +extern void func_801319E0(void); +extern s32 func_8012BEE8(s32 a0); +extern void func_80131E00(s32 a0, s32 a1); +extern s32 func_8012CBF4(s32 a0); +extern void func_80131C78(s32 a0); +extern void func_8018DEC0(void); + +void func_8018F0B4(s32 a0) { + if (*(s16 *)(a0 + 0xA) >= 0x10) { + ((void (*)(void))func_801319E0)(); + } else { + if (func_8012BEE8(a0) != 0) { + func_80131E00(a0, 6); + } else { + if ((func_8012CBF4(a0) & 0x2000) != 0) { + func_80131C78(a0); + } + ((void (*)(s32))func_8018DEC0)(a0); + } + } +} + extern s32 func_8012C354(s32, void*); diff --git a/src/ov_SC06_032/ov_SC06_032_jr_80182890.c b/src/ov_SC06_032/ov_SC06_032_jr_80182890.c index fad6d6258..005aedcb3 100644 --- a/src/ov_SC06_032/ov_SC06_032_jr_80182890.c +++ b/src/ov_SC06_032/ov_SC06_032_jr_80182890.c @@ -4593,7 +4593,18 @@ INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_8018567 INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_801857B0); -INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_801857F4); +extern void (*D_801BEEF8[])(void); +extern void func_801875D0(void); +extern void func_80185D4C(void); + +void func_801857F4(void *a0) { + D_801BEEF8[*(u16 *)((s32)a0 + 0x2)](); + if (*(u16 *)((s32)a0 + 0x104) & 0x100) { + func_801875D0(); + func_80185D4C(); + } +} + extern void func_8016AA50(s32, s32); extern s32 rand(void); @@ -4798,7 +4809,54 @@ void func_80185EAC(s32 param_1) INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_80185F4C); -INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_8018603C); +extern void func_8012C1B8(void); +extern void func_8012CAE4(s32 a0); +extern void func_8001C214(s32 a0, s32 a1); +extern void func_8012B23C(); +extern void func_80186160(s32 a0); +extern void func_801863B0(s32 a0); +extern void func_801866B0(s32 *a0); +extern s32 rand(void); +extern s32 D_801BEF2C[]; +extern s32 D_801BEF30[]; + +void func_8018603C(s32 param_1) +{ + register s32 obj __asm__("$4"); + s16 v; + register s32 w __asm__("$2"); + s32 p48; + + obj = ((s32 (*)(void))func_8012C1B8)(); + *(s32 *)(param_1 + 0x20) = obj; + if (obj == 0) { + func_8012CAE4(param_1); + return; + } + v = *(s16 *)(param_1 + 0x70); + if (v < 0x10) { + func_8001C214(obj, D_801BEF2C[v]); + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x2C) |= 0x10; + func_8012B23C(param_1); + if (*(s16 *)(param_1 + 0x70) == 0) { + func_80186160(param_1); + } else { + func_801863B0(param_1); + } + return; + } else { + func_8001C214(*(s32 *)(param_1 + 0x20), D_801BEF30[rand() & 3]); + *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x2C) |= 0x10; + w = (rand() & 0x1F0) | 0x400; + p48 = *(s32 *)(param_1 + 0x20); + *(s16 *)(p48 + 0x1C) = w; + *(s16 *)(p48 + 0x1A) = w; + *(s16 *)(p48 + 0x18) = w; + func_8012B23C(param_1); + func_801866B0((s32 *)param_1); + } +} + // @class: struct @@ -5018,7 +5076,28 @@ void func_80186834(void *a0) { } -INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_80186870); +extern void func_801437D8(s32 a0, s32 a1, s32 a2, s32 a3); +extern u8 D_801BEF74[]; + +void func_80186870(s32 param_1) +{ + struct { + u16 f0; + u16 f2; + u16 f4; + u16 f6; + } local; + + local.f0 = *(u16 *)(param_1 + 0x6); + local.f2 = *(u16 *)(param_1 + 0xA) - 0x40; + local.f4 = *(u16 *)(param_1 + 0xE); + local.f6 = 0x3000; + func_801437D8(param_1 + 0xFE, (s32)&local, (s32)D_801BEF74, 0); + if ((*(u16 *)(param_1 + 0xFE) & 3) == 0) { + func_8002D4C8(0xA9F, 0); + } +} + extern s32 func_80132EF4(s32 a0, s32 a1); @@ -5226,7 +5305,56 @@ s32 func_80187180(s32 out, s32 from, s32 to) { } -INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_80187268); +#define gte_ldv0(r0) __asm__ volatile ( \ + "lwc2 $0, 0( %0 );" "lwc2 $1, 4( %0 )" : : "r"( r0 ) ) +#define gte_ldv3(r0, r1, r2) __asm__ volatile ( \ + "lwc2 $0, 0( %0 );" "lwc2 $1, 4( %0 );" "lwc2 $2, 0( %1 );" \ + "lwc2 $3, 4( %1 );" "lwc2 $4, 0( %2 );" "lwc2 $5, 4( %2 )" \ + : : "r"( r0 ), "r"( r1 ), "r"( r2 ) ) +#define gte_rtps() __asm__ volatile ("nop;nop;rtps") +#define gte_rtpt() __asm__ volatile ("nop;nop;rtpt") +#define gte_stsxy(r0) __asm__ volatile ( \ + "swc2 $14, 0( %0 )" : : "r"( r0 ) : "memory" ) +#define gte_stsxy3(r0, r1, r2) __asm__ volatile ( \ + "swc2 $12, 0( %0 );" "swc2 $13, 0( %1 );" "swc2 $14, 0( %2 )" \ + : : "r"( r0 ), "r"( r1 ), "r"( r2 ) : "memory" ) +#define gte_avsz4() __asm__ volatile ("nop;nop;avsz4") +#define gte_stotz(r0) __asm__ volatile ( \ + "swc2 $7, 0( %0 )" : : "r"( r0 ) : "memory" ) +#define gte_stflg(r0) __asm__ volatile ( \ + "cfc2 $12, $31;" "nop;" "sw $12, 0( %0 )" : : "r"( r0 ) : "$12", "memory" ) + +extern u8 D_800AF648; +void func_80187268(void *a0) +{ + register void *s1 __asm__("$17"); + register u8 *s0 __asm__("$16"); + s32 flag1, flag2; + u32 otz; + u8 *mb; + + s1 = a0; + mb = &D_800AF648; + s0 = mb; + func_8004914C(s0); + func_800491AC(s0); + + gte_ldv3(s1, (u8 *)s1 + 8, (u8 *)s1 + 0x10); + gte_rtpt(); + gte_stflg(&flag1); + gte_stsxy3(s1, (u8 *)s1 + 8, (u8 *)s1 + 0x10); + gte_ldv0((u8 *)s1 + 0x18); + gte_rtps(); + gte_stflg(&flag2); + flag1 |= flag2; + gte_stsxy((u8 *)s1 + 0x18); + gte_avsz4(); + gte_stotz(&otz); + *(s16 *)((u8 *)s1 + 4) = (s16)otz; + if (otz < 0x1000) + func_80017254(s1); +} + #include "common.h" @@ -8702,7 +8830,37 @@ void func_8018CD54(s32 a0) { INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_8018CDB4); -INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_8018CE74); +extern u8 D_801CA8D4[]; +extern u8 D_801CA8E0[]; +extern u8 D_800D3918[]; +extern void func_8012C218(void *a0); +extern void func_8012B14C(s32 a0, s32 a1); +extern void func_8012AD80(s32 a0); +extern s32 func_8012D5E4(s32 a0, s32 a1, s32 a2, s32 a3); +extern void func_8012B370(int a0); + +void func_8018CE74(s32 param_1) { + if ((*(s16 *)(param_1 + 6) == *(s16 *)(param_1 + 0xDE)) && + (*(s16 *)(param_1 + 0xE) == *(s16 *)(param_1 + 0xE2))) { + func_8012C218(param_1); + } else { + *(s32 *)(param_1 + 0xDC) = *(s32 *)(param_1 + 4); + *(s32 *)(param_1 + 0xE0) = *(s32 *)(param_1 + 0xC); + func_8012B14C(param_1, (s32)D_801CA8D4); + func_8012AD80(param_1); + if (func_8012D5E4(param_1, (s32)D_801CA8E0, (s32)D_800D3918, 0x30) != 0) { + func_8012C218(param_1); + } else { + *(s32 *)(param_1 + 0x1C) -= 1; + if (*(s32 *)(param_1 + 0x1C) == 0) { + func_8012C218(param_1); + } else { + func_8012B370(param_1); + } + } + } +} + extern void func_8012C1B8(void); diff --git a/src/ov_SC06_033/ov_SC06_033_jr_8017C24C.c b/src/ov_SC06_033/ov_SC06_033_jr_8017C24C.c index 64e04aedc..63ec0abee 100644 --- a/src/ov_SC06_033/ov_SC06_033_jr_8017C24C.c +++ b/src/ov_SC06_033/ov_SC06_033_jr_8017C24C.c @@ -3493,7 +3493,14 @@ void func_8017DC10(void *a0) { } -INCLUDE_ASM("asm/ov_SC06_033/nonmatchings/ov_SC06_033_jr_8017C24C", func_8017DC18); +extern s16 D_800B9AB8[]; +extern s16 D_800B9ABA[]; + +void func_8017DC18(void) { + D_800B9AB8[0] = 0; + D_800B9ABA[0] = 0; +} + INCLUDE_ASM("asm/ov_SC06_033/nonmatchings/ov_SC06_033_jr_8017C24C", func_8017DC30); @@ -6039,7 +6046,17 @@ void func_801824F8(s32 param_1) { } -INCLUDE_ASM("asm/ov_SC06_033/nonmatchings/ov_SC06_033_jr_8017C24C", func_80182714); +void func_80182714(s32 param_1) { + extern void func_80142414(s32 a0, s16 a1); + extern s32 func_8012BEE8(s32 a0); + if (*(s32 *)(param_1 + 0x1C) == 0xF) { + func_80142414(param_1, -0x90); + } + if (func_8012BEE8(param_1) != 0) { + *(s16 *)(param_1 + 2) = 2; + } +} + /* func_80182764 — a randomised state entry: seed the timer at 0x1C with @@ -6228,9 +6245,49 @@ void func_801829D8(s32 p) INCLUDE_ASM("asm/ov_SC06_033/nonmatchings/ov_SC06_033_jr_8017C24C", func_80182B60); -INCLUDE_ASM("asm/ov_SC06_033/nonmatchings/ov_SC06_033_jr_8017C24C", func_80182B94); +extern s32 func_8012BDBC(s32 a0, s32 a1); +extern s32 func_8012BCCC(s32 a0); +extern s32 func_8012BEE8(); + +void func_80182B94(s32 param_1) +{ + register s32 p __asm__("$16") = param_1; + + if (func_8012BDBC(p, 0x300) != 0) { + s32 r = func_8012BCCC(p); + if (r < 0x100000) { + *(s16 *)(p + 2) = (r < 0x6400) ? 8 : 4; + return; + } + } else { + s32 r = func_8012BCCC(p); + if (r < 0x4000) { + *(s16 *)(p + 2) = 0xF; + return; + } + } + + if (func_8012BEE8(p) != 0) { + *(s16 *)(p + 2) = 2; + } +} + + +#include "common.h" + +extern void func_8012A828(s32 a0, void *a1); + +void func_80182C1C(s32 p) +{ + extern u8 D_801C6AB4[]; + u32 f; + + func_8012A828(p, D_801C6AB4); + f = *(u32 *)(p + 0xE0); + *(u16 *)(p + 2) = 9; + *(u32 *)(p + 0xE0) = (f | 2) & ~0x10; +} -INCLUDE_ASM("asm/ov_SC06_033/nonmatchings/ov_SC06_033_jr_8017C24C", func_80182C1C); extern s32 func_80185BB8(s32 a0, s32 a1); diff --git a/src/ov_SC07_001/ov_SC07_001_jr_8017BEBC.c b/src/ov_SC07_001/ov_SC07_001_jr_8017BEBC.c index 947b9a5ce..148ea6568 100644 --- a/src/ov_SC07_001/ov_SC07_001_jr_8017BEBC.c +++ b/src/ov_SC07_001/ov_SC07_001_jr_8017BEBC.c @@ -3965,13 +3965,69 @@ void func_8017E3E8(s32 arg0, s16 *a1, s32 a2) { } -INCLUDE_ASM("asm/ov_SC07_001/nonmatchings/ov_SC07_001_jr_8017BEBC", func_8017E448); +void func_8017E448(s32 a0) { + extern void func_8017ED50(s32 a0); + extern void (*D_8018533C[])(void); + extern u16 D_80126B5E; + extern u16 D_80126B66; + extern u16 D_801AAD64; + extern u16 D_801AAD68; + + D_8018533C[*(u16 *)((s32)a0 + 2)](); + if (*(u16 *)((s32)a0 + 0) != 0) { + func_8017ED50(a0); + if ((*(s32 *)((s32)a0 + 0xE0) & 0x10) != 0) { + D_80126B5E = D_801AAD64; + D_80126B66 = D_801AAD68; + } + } +} + INCLUDE_ASM("asm/ov_SC07_001/nonmatchings/ov_SC07_001_jr_8017BEBC", func_8017E4DC); -INCLUDE_ASM("asm/ov_SC07_001/nonmatchings/ov_SC07_001_jr_8017BEBC", func_8017E64C); +extern s32 func_800132BC(s32 a0, s32 a1); +extern s32 func_8012E57C(s32 a0, s32 a1); +extern void func_8012C218(s32 a0); +extern void func_8017E2B0(); +extern u16 D_80126B5E; +extern u16 D_80126B66; +extern u16 D_801850B4; +extern u16 D_801850B8; + +void func_8017E64C(s32 arg0) { + u16 sp10[4]; + u16 sp18[3]; + + sp10[0] = D_80126B5E; + sp10[2] = D_80126B66; + sp18[0] = D_801850B4; + sp18[2] = D_801850B8; + sp10[1] = 0; + sp18[1] = 0; + if (func_800132BC((s32)sp10, (s32)sp18) < 0x9001) { + s32 ret = func_8012E57C(0x3C3, 4); + if (ret != 0) { + func_8012C218(ret); + } + func_8017E2B0(); + *(u16 *)(arg0 + 2) = 3; + } +} + + +extern int func_80178970(void); +extern void func_80178D18(void); +extern void func_8017E2B0(void); + +void func_8017E6EC(void *arg0) { + if (func_80178970() == 1) { + ((void (*)(void *))func_80178D18)(arg0); + *(u16 *)((s32)arg0 + 2) = 3; + func_8017E2B0(); + } +} -INCLUDE_ASM("asm/ov_SC07_001/nonmatchings/ov_SC07_001_jr_8017BEBC", func_8017E6EC); extern s32 func_8012E8A8(u8 *a0); diff --git a/src/ov_SC07_007/ov_SC07_007_jr_8017BEBC.c b/src/ov_SC07_007/ov_SC07_007_jr_8017BEBC.c index 77598c73d..c350244a2 100644 --- a/src/ov_SC07_007/ov_SC07_007_jr_8017BEBC.c +++ b/src/ov_SC07_007/ov_SC07_007_jr_8017BEBC.c @@ -3904,7 +3904,42 @@ INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_8017D35 INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_8017D41C); -INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_8017D4E4); +#include "common.h" + +extern void func_8012A018(s32 a0, s32 a1); +extern void func_8012A094(s32 a0); +extern void func_8017D648(void *a0); + +typedef struct { s16 x0, x1, x2, x3; } UnalignedShortBlock; + +void func_8017D4E4(void) { + extern u8 D_80126948[]; + extern u8 D_801869D8; + extern u8 D_801274E8[]; + extern s32 D_80126954; + extern s32 D_8012695C; + extern s16 D_80126968; + extern s16 D_8012696A; + extern s16 D_8012696C; + extern s16 D_80126976; + extern s16 D_80126978; + extern s16 D_8012697A; + + D_80126954 = 0x190; + D_8012695C = 0x15E; + D_80126968 = -0x38; + D_80126976 = -0x140; + D_8012696A = 0; + D_8012696C = 0; + D_80126978 = -0x60; + D_8012697A = 0; + + func_8012A018((s32)func_8017D648, 6); + *(UnalignedShortBlock *)&D_801274E8 = *(UnalignedShortBlock *)&D_801869D8; + func_8012A094((s32)D_80126948); + func_8017D648(D_80126948); +} + extern void func_8012A018(s32 a, s32 b); @@ -5182,7 +5217,26 @@ void func_8017F788(void *a0) } -INCLUDE_ASM("asm/ov_SC07_007/nonmatchings/ov_SC07_007_jr_8017BEBC", func_8017F814); +#include "common.h" + +extern s32 func_8012BEE8(s32 a0); +extern void func_80180F94(s32 a0); +extern void func_8018122C(s32 a0, void *a1); +extern s32 func_8012AD50(void *arg0); + +extern s16 D_80188B18; + +void func_8017F814(s32 a0) { + s32 s0; + + s0 = a0; + if (func_8012BEE8(a0) != 0) { + func_80180F94(8); + func_8018122C(s0, &D_80188B18); + func_8012AD50((void *)s0); + } +} + #include "common.h" diff --git a/src/ov_SC07_010/ov_SC07_010_jr_8017AE2C.c b/src/ov_SC07_010/ov_SC07_010_jr_8017AE2C.c index 9f151baa8..55766bf0e 100644 --- a/src/ov_SC07_010/ov_SC07_010_jr_8017AE2C.c +++ b/src/ov_SC07_010/ov_SC07_010_jr_8017AE2C.c @@ -4133,7 +4133,21 @@ void func_8017D85C(s32 *a0) { INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017D898); -INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017D91C); +extern s32 D_801151D4; +extern s32 D_80185AC8; +extern void func_801542A4(s32 *a0, s32 a1); +extern s32 func_80171990(u8 *a0); + +void func_8017D91C(u8 *a0) { + s32 ws = D_801151D4; + if (*(u16 *)(a0 + 0xB8) & 0x8000) { + *(s16 *)(ws + 0x22) = 0x200; + *(s16 *)(ws + 0x1A) = 0x200; + func_801542A4((s32 *)a0, (s32)&D_80185AC8); + func_80171990(a0); + } +} + INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017D974); @@ -4437,7 +4451,14 @@ void func_8017E170(void *a0) { INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017E1AC); -INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017E234); +void func_8017E234(void *a0) { + s32 *s0 = *(s32 **)((s32)a0 + 0x20); + if (func_8017DCC8() == 6) { + *(s32 *)((s32)s0 + 4) &= 0x7FFFFFFF; + func_8012AD50(a0); + } +} + void func_8017E290(void) { } @@ -4454,7 +4475,7 @@ void func_8017E298(void *a0) { INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017E2D4); extern u16 D_800B99DA; -extern void func_8017E70C(s32 a0); +extern void func_8017E70C(); void func_8017E374(s32 a0) { s32 v0; @@ -4558,7 +4579,39 @@ void func_8017E520(s32 a0) { INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017E5B8); -INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017E70C); +extern void func_80015954(s32 a0, s32 a1); +extern s32 func_8012C588(s32 a0, s32 a1); +extern s32 rand(void); + +struct S6C { u8 pad[8]; }; +struct S72 { s16 unk0; u8 pad[6]; }; +struct S9E { u16 unk0; u16 pad; }; +struct Ent { u8 pad[0xDC]; s32 unkDC; u8 pad2[0x1C]; u16 unkFC; }; + +extern struct S6C D_80185D6C[]; +extern struct S72 D_80185D72[]; +extern struct S9E D_80185D9E[]; + +void func_8017E70C(void) { + register s32 r __asm__("$19"); /* incoming $s3, never written */ + struct Ent *p; + s32 t; + + t = rand() % 6; + p = (struct Ent *)func_8012C588(0x3A6, 0); + if (p != 0) { + func_80015954((s32)&D_80185D6C[t], (s32)p + 4); + p->unkFC = D_80185D9E[D_80185D72[t].unk0].unk0 + (r * 170 - 341); + p->unkDC = 0; + } + p = (struct Ent *)func_8012C588(0x3A6, 0); + if (p != 0) { + func_80015954((s32)&D_80185D6C[t], (s32)p + 4); + p->unkFC = D_80185D9E[D_80185D72[t].unk0].unk0 + (r * 170 - 227); + p->unkDC = 1; + } +} + @@ -4880,7 +4933,13 @@ INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017F47 INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017F4A8); -INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_8017F51C); +extern u32 D_801A7D0C[]; +extern s32 func_8017F54C(void *a0, void *a1); + +s32 func_8017F51C(void *arg0, void *arg1) { + return func_8017F54C((void *)((u8 *)D_801A7D0C + (*(s16 *)((s32)arg0 + 0x70) << 6)), arg1); +} + extern void func_8017F5A4(void *a0, s32 a1); @@ -5488,7 +5547,23 @@ void func_80181224(void) { } -INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_80181270); +extern s32 func_8017DCC8(void); +extern void func_8002D4C8(s32 a0, s32 a1); +extern void func_801813F8(void *a0, void *a1, void *a2); +extern s32 func_8012AD50(void *a0); +extern void (*D_80185FC0[])(void *); +extern u32 D_80185F90[]; + +void func_80181270(void *a0) { + if (func_8017DCC8() == 0xA) { + func_8002D4C8(0xC16, 0); + func_801813F8(a0, &D_80185F90[0], &D_80185FC0[0]); + func_801813F8(a0, &D_80185F90[2], &D_80185FC0[1]); + func_801813F8(a0, &D_80185F90[4], &D_80185FC0[2]); + func_8012AD50(a0); + } +} + INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_80181304); @@ -5709,7 +5784,25 @@ void func_80181E20(void *a0) { } -INCLUDE_ASM("asm/ov_SC07_010/nonmatchings/ov_SC07_010_jr_8017AE2C", func_80181E5C); +extern s32 func_8001CC3C(s32, s32, s32, s32); +extern void func_80128EA8(s32 a0, s32 a1, s32 a2); +extern u8 D_800D387C[]; +extern u8 D_80186020[]; + +void func_80181E5C(s32 param_1) +{ + s32 work; + + work = *(s32 *)(param_1 + 0x20); + ((void (*)(s32, s32, s32, s32))func_8001CC3C)(work, D_800D387C, 0, 0); + *(u8 *)(work + 0x27) = 0x9C; + *(u16 *)(work + 0x1A) = 0x3000; + *(u16 *)(work + 0x18) = 0x3000; + *(u32 *)(work + 4) = *(u32 *)(work + 4) | 0x50000000; + func_80128EA8(work, param_1 + 0x24, D_80186020); + *(u16 *)(param_1 + 2) = *(u16 *)(param_1 + 2) + 1; +} + extern s32 func_80128ED8(s32 param_1, s32 *param_2); extern void func_801292C8(u8 *a0);