From 3a0c4cab45a862bfa795bc18e500400a01428f20 Mon Sep 17 00:00:00 2001 From: Drew T <50529377+Druthulu@users.noreply.github.com> Date: Mon, 24 Aug 2026 01:19:03 -0600 Subject: [PATCH] =?UTF-8?q?feat(decomp):=20ox=20wave=20aa=20overlays=20?= =?UTF-8?q?=E2=80=94=2025=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/ov_SC01_080/ov_SC01_080_jr_8017AE2C.c | 234 +++++++++++++++++++++- src/ov_SC02_016/ov_SC02_016_jr_8017DC70.c | 170 +++++++++++++++- src/ov_SC02_021/ov_SC02_021_jr_8017C294.c | 177 +++++++++++++++- src/ov_SC03_090/ov_SC03_090_jr_8017CA80.c | 9 +- src/ov_SC04_004/ov_SC04_004_jr_8017AE2C.c | 96 ++++++++- src/ov_SC04_005/ov_SC04_005_jr_8017BEBC.c | 50 ++++- src/ov_SC06_032/ov_SC06_032_jr_80182890.c | 47 ++++- src/ov_SC07_000/ov_SC07_000_jr_8017BEBC.c | 204 ++++++++++++++++++- src/ov_SC07_006/ov_SC07_006_jr_8017BEBC.c | 145 +++++++++++++- 9 files changed, 1099 insertions(+), 33 deletions(-) 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 a55ee7bd2..6bc71e096 100644 --- a/src/ov_SC01_080/ov_SC01_080_jr_8017AE2C.c +++ b/src/ov_SC01_080/ov_SC01_080_jr_8017AE2C.c @@ -4918,7 +4918,56 @@ void func_8017FF78(void *a0) { } -INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_8017FFB4); +void func_8017FFB4(s32 arg0) +{ + extern void func_8012C1B8(void); + extern void func_8012CAE4(void *a0); + extern void func_8001C214(s32 a0, s32 a1); + extern void func_8001D0E8(s32 a0, s32 a1, s32 a2); + extern void func_8012A828(s32 a0, void *a1); + extern void func_8001D074(s32, s32); + extern void func_800233CC(void *a0, u16 a1); + extern void func_8001CD9C(s32 a0, void *a1); + extern u8 D_801AE2D8; + extern u8 D_8018A02C; + extern u8 D_80189974; + extern s32 D_801C7EC0; + + register s32 s0 __asm__("$16"); + register s32 s1 __asm__("$17"); + register s32 s2 __asm__("$18") = arg0; + s32 v0; + + v0 = ((s32 (*)(void))func_8012C1B8)(); + *(s32 *)(s2 + 0x20) = v0; + s0 = v0; + if (v0 == 0) { + func_8012CAE4((void *)s2); + return; + } + func_8001C214(s0, &D_801AE2D8); + func_8001D0E8(s0, 0x800, 0x800); + func_8012A828((void *)s2, &D_8018A02C); + D_801C7EC0 = 0; + s1 = ((s32 (*)(s32, s32))func_8001D074)(0x3E, 0x7D); + *(s32 *)(s2 + 0xF4) = s1; + if (s1 != 0) { + func_800233CC(&D_80189974, 0x50); + func_8001CD9C(s1, &D_80189974); + } + s1 = ((s32 (*)(s32, s32))func_8001D074)(0x3E, 0x7D); + *(s32 *)(s2 + 0xF8) = s1; + if (s1 != 0) { + func_800233CC(&D_80189974, 0x40); + func_8001CD9C(s1, &D_80189974); + } + *(u16 *)(s2 + 0x34) = 0; + *(s32 *)(s2 + 4) = *(s32 *)(*(s32 *)(s2 + 0x64) + 4); + *(s32 *)(s2 + 8) = *(s32 *)(*(s32 *)(s2 + 0x64) + 8) - *(s32 *)(*(s32 *)(s2 + 0x64) + 0xF0); + *(s32 *)(s2 + 0xC) = *(s32 *)(*(s32 *)(s2 + 0x64) + 0xC); + *(u16 *)(s2 + 2) = *(u16 *)(s2 + 2) + 1; +} + INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_801800F4); @@ -4931,7 +4980,32 @@ void func_80180174(void) { } -INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_80180188); +extern void (*D_801899B4[])(void); +extern void (*D_801899BC[])(void); +extern s32 D_8018A200[]; + +void func_80180188(s32 param_1) +{ + u16 sp10[3]; + + func_8012B2CC(param_1); + func_8012F14C(*(s32 *)(param_1 + 0x20) + 0x34, (s32)D_801899B4, (s32)sp10); + *(u16 *)(*(s32 *)(param_1 + 0xF4) + 0x8) = sp10[0]; + *(u16 *)(*(s32 *)(param_1 + 0xF4) + 0xA) = sp10[1]; + *(u16 *)(*(s32 *)(param_1 + 0xF4) + 0xC) = sp10[2]; + *(u16 *)(*(s32 *)(param_1 + 0xF4) + 0x10) = *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x10); + *(u16 *)(*(s32 *)(param_1 + 0xF4) + 0x12) = *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x12); + *(u16 *)(*(s32 *)(param_1 + 0xF4) + 0x14) = *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x14); + func_8012F14C(*(s32 *)(param_1 + 0x20) + 0x34, (s32)D_801899BC, (s32)sp10); + *(u16 *)(*(s32 *)(param_1 + 0xF8) + 0x8) = sp10[0]; + *(u16 *)(*(s32 *)(param_1 + 0xF8) + 0xA) = sp10[1]; + *(u16 *)(*(s32 *)(param_1 + 0xF8) + 0xC) = sp10[2]; + *(u16 *)(*(s32 *)(param_1 + 0xF8) + 0x10) = *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x10); + *(u16 *)(*(s32 *)(param_1 + 0xF8) + 0x12) = *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x12); + *(u16 *)(*(s32 *)(param_1 + 0xF8) + 0x14) = *(u16 *)(*(s32 *)(param_1 + 0x20) + 0x14); + ((void (*)(s32))D_8018A200[*(u16 *)((s32)param_1 + 0x34)])(param_1); +} + void func_801802D8(void *a0) { s32 *p1, *q1; @@ -5205,7 +5279,41 @@ INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_8018191 INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_801819D0); -INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_80181A70); +void func_80181A70(void *a0) +{ + extern u8 D_801C5D00[]; + extern u8 D_8018A220[]; + extern void func_801465C0(void); + s32 s0; + + s0 = *(s32 *)((s32)a0 + 0x20); + *(s16 *)((s32)a0 + 0xA) = -0x680; + *(s16 *)((s32)a0 + 0xE) = 0xF0; + func_8001CD50((s32)s0, (s32)D_801C5D00); + if (*(s16 *)((s32)a0 + 0x2C) == 0) { + *(u16 *)((s32)a0 + 6) = 0; + *(s16 *)(s0 + 0x12) = -0x200; + } else { + *(s16 *)((s32)a0 + 6) = -0x60; + *(s16 *)(s0 + 0x12) = 0x1A0; + } + *(s16 *)(s0 + 0x10) = -0x100; + *(s32 *)(s0 + 4) |= 0x50000000; + s0 = ((s32 (*)(void))func_801465C0)(); + if (s0 != 0) { + func_8001CB6C((u8 *)s0, (s32)D_8018A220, 0x280, 0x180); + *(u8 *)(s0 + 0x27) = 0x4D; + *(u16 *)(s0 + 8) = *(u16 *)((s32)a0 + 6); + *(u16 *)(s0 + 0xA) = *(u16 *)((s32)a0 + 0xA); + *(u16 *)(s0 + 0xC) = *(u16 *)((s32)a0 + 0xE); + *(s32 *)(s0 + 4) |= 0x50000000; + *(s32 *)((s32)a0 + 0x34) = s0; + } + *(s32 *)((s32)a0 + 0x2C) = 0x4000; + *(u16 *)((s32)a0 + 2) = *(u16 *)((s32)a0 + 2) + 1; + *(s32 *)((s32)a0 + 0x30) = 0x70; +} + void func_80181B80(void *a0) { *(short *)((char *)a0 + 0x2) = 1; @@ -5229,7 +5337,47 @@ INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_80181D9 INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_80181F5C); -INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_80181FAC); +extern u16 D_800B99DA; +extern s32 D_801270D0; +extern void func_8002D59C(s32, s32, s32); + +void func_80181FAC(s32 arg0) { + register s32 id __asm__("$5"); + s32 dist; + s32 vol; + + if ((D_800B99DA & 1) == 0) { + dist = *(s16 *)(arg0 + 0xFC) - D_801270D0; + if (dist < 0) { + dist = -dist; + } + vol = ((700 - dist) * 127) / 700; + if (vol < 0) { + vol = 0; + } else if (vol > 127) { + vol = 127; + } + id = 0x4A4; + if (*(s16 *)(arg0 + 0x70) == 2) { + id = 0x4A5; + } + if (*(s32 *)(arg0 + 0xDC) == 0) { + if (dist < 700) { + func_8002D59C(id, (u16)(vol | 0x5000), *(u16 *)(arg0 + 0x36)); + *(s32 *)(arg0 + 0xDC) = 1; + } + } else { + if (dist < 700) { + func_8002D59C(id, (u16)(vol | 0x5000), *(u16 *)(arg0 + 0x36)); + *(s32 *)(arg0 + 0xDC) = 1; + } else { + func_8002D59C(4, id, *(u16 *)(arg0 + 0x36)); + *(s32 *)(arg0 + 0xDC) = 0; + } + } + } +} + INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_801820AC); @@ -5247,7 +5395,51 @@ INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_8018230 INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_801824D0); -INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_801824FC); +extern void func_8012C1B8(void); +extern void func_8012CAE4(void *); +extern void func_8001C214(s32, s32); +extern void func_8012A828(s32, void *); +extern void func_8002D4C8(s32, s32); +extern s32 rand(void); +extern s16 D_80126CB4; +extern s16 D_80126CB6; +extern s16 D_80126CB8; +extern u16 D_80126B5E; +extern s32 *D_80126B78; +extern s32 D_80126B68; +extern s32 D_80126B70; +extern s16 D_8018A300; +extern s32 D_801C0264; +extern s32 D_80183884; + +void func_801824FC(s32 arg0) { + s32 v0; + + v0 = ((s32 (*)(void))func_8012C1B8)(); + *(s32 *)(arg0 + 0x20) = v0; + if (v0 == 0) { + ((void (*)(s32))func_8012CAE4)(arg0); + } else { + ((void (*)(s32, s32))func_8001C214)(v0, (s32)&D_801C0264); + ((void (*)(s32, void *))func_8012A828)(arg0, &D_80183884); + *(s16 *)(arg0 + 2) = 1; + *(u16 *)(arg0 + 6) = D_80126CB4; + *(u16 *)(arg0 + 0xA) = D_80126CB6; + *(u16 *)(arg0 + 0xE) = D_80126CB8; + *(s32 *)(arg0 + 8) = 0xFDFE0000; + if (((D_80126B5E + 0x2C0) & 0xFFFF) >= 0x581U && *(s16 *)((s32)D_80126B78 + 0x12) == 0x800) { + *(s32 *)(arg0 + 4) += D_80126B68 * 40 + (rand() & 0x3F) - 0x20; + *(s32 *)(arg0 + 0xC) += D_80126B70 * 40; + if (*(s16 *)(arg0 + 0xE) >= 0x380) { + *(s16 *)(arg0 + 0xE) = 0x380; + } + } + *(s32 *)(*(s32 *)(arg0 + 0x20) + 4) |= 0x80000000; + *(s32 *)(arg0 + 0x1C) = D_8018A300; + func_8002D4C8(0x49F, 0); + } +} + extern void (*D_8018A32C[])(void); @@ -5295,7 +5487,37 @@ void func_801827B4(void *a0) { } -INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_8018287C); +typedef struct { u16 x, y, z, w; } V4_8018287C; + +extern s32 D_80126B58; +extern s32 D_8018A30C[][2]; +extern s32 D_8018A310[][2]; + +void func_8018287C(s32 arg0) { + V4_8018287C in; /* sp+0x10 */ + V4_8018287C out; /* sp+0x18 */ + u16 *base; + s32 i; + + base = (u16 *)&D_80126B58; + if (func_8012BEE8(arg0) != 0) { + for (i = 0; i < 4; i++) { + in.x = *(u16 *)(arg0 + 6) + D_8018A30C[i][0]; + in.y = *(u16 *)(arg0 + 0xA); + in.z = *(u16 *)(arg0 + 0xE) + D_8018A310[i][0]; + out = in; + out.y -= 0x18; + if (func_8012DF34(0, (s32)&in, (s32)&out) != 0) { + base[0x21] = i << 10; + base[0x20] = 0xA; + } + } + func_8002D4C8(0x4A7, 0); + func_8012C588(0x37, arg0); + func_8012C218((void *)arg0); + } +} + INCLUDE_ASM("asm/ov_SC01_080/nonmatchings/ov_SC01_080_jr_8017AE2C", func_80182990); diff --git a/src/ov_SC02_016/ov_SC02_016_jr_8017DC70.c b/src/ov_SC02_016/ov_SC02_016_jr_8017DC70.c index 06938e0a8..3fc2a136c 100644 --- a/src/ov_SC02_016/ov_SC02_016_jr_8017DC70.c +++ b/src/ov_SC02_016/ov_SC02_016_jr_8017DC70.c @@ -4052,9 +4052,175 @@ void func_801814A8(s32 a0) { INCLUDE_ASM("asm/ov_SC02_016/nonmatchings/ov_SC02_016_jr_8017DC70", func_801815DC); -INCLUDE_ASM("asm/ov_SC02_016/nonmatchings/ov_SC02_016_jr_8017DC70", func_80181714); +#include "common.h" + +extern s32 func_8012BEE8(s32 a0); +extern void func_8012B23C(s32 a0); +extern s32 func_8012CBCC(s32 a0); +extern s32 func_80143B6C(s32 a0, s32 a1); +extern void func_8012A828(s32, s32); +extern s16 D_801AFBBC; +extern s16 D_801AFC44; +extern s16 D_801B04DC; + +void func_80181714(s32 a0) { + register s32 v0; + register s32 v1; + register s32 obj; + + switch (*(u16 *)(a0 + 0x34)) { + case 0: + if (func_8012BEE8(a0) == 0) { + return; + } + *(u16 *)(a0 + 0x34) += 1; + func_8012B23C(a0); + *(s32 *)(*(s32 *)(a0 + 0x20) + 4) &= 0x7FFFFFFF; + *(u16 *)(a0 + 0x5C) = *(u16 *)(*(s32 *)(a0 + 0x78) + 2); + return; + case 1: + if ((func_8012CBCC(a0) & 0x2000) == 0) { + return; + } + func_80143B6C(a0, 1); + *(u16 *)(a0 + 0x34) += 1; + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x2C) |= 0x10; + *(s32 *)(a0 + 0x1C) = 0x10; + /* fallthrough */ + case 2: + v0 = func_8004787C((*(s32 *)(a0 + 0x1C) << 7) & 0x780); + v1 = ((v0 << 9) >> 12) + 0x1000; + __asm__ __volatile__(""); + obj = *(s32 *)(a0 + 0x20); + *(s16 *)(obj + 0x1C) = v1; + *(s16 *)(obj + 0x18) = v1; + *(s16 *)(*(s32 *)(a0 + 0x20) + 0x1A) = 0x1000 - ((v0 << 10) >> 12); + if (func_8012BEE8(a0) == 0) { + return; + } + *(s16 *)(a0 + 2) = 3; + if (*(u16 *)(a0 + 0x86) & 2) { + *(s16 *)(a0 + 0x34) = 1; + *(s32 *)(a0 + 0x1C) = 0x28; + if (*(u16 *)(a0 + 0x70) & 0x200) { + func_8012A828(a0, &D_801B04DC); + } else { + func_8012A828(a0, &D_801AFBBC); + } + *(u16 *)(a0 + 0xFE) = 0; + } else { + *(s16 *)(a0 + 0x34) = 0; + func_8012A828(a0, &D_801AFC44); + *(s32 *)(a0 + 0x1C) = 0x19; + *(u16 *)(a0 + 0x86) |= 2; + } + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x2C) &= ~0x10; + break; + } +} + + +extern s32 func_8012C354(s32 a0, s32 a1); +extern s32 func_80143970(s32 a0); +extern void func_8012E8A8(u8 *a0); +extern void func_8012A828(s32 a0, s32 a1); +extern s32 func_8012B744(void *a0, void *a1); +extern void Square0(s32 *a0, s32 *a1); +extern s32 rand(void); + +extern u8 D_8018852C[]; +extern void (*D_801885C8[])(void); +extern u8 D_80078EB1; +extern short D_801AF9CC; +extern u8 D_801AFB14[]; + +typedef struct { + s32 vx, vy, vz; +} Vec3_1818F8; + +void func_801818F8(s32 a0) { + s32 idx; + s32 sum; + Vec3_1818F8 d; + s32 r; + Vec3_1818F8 *p; + s32 dx, dz; + s32 x; + s32 v1; + s32 y; + register void *s1_ptr __asm__("$17"); + + idx = (*(u16 *)(a0 + 0x70) & 0xF00) >> 8; + + if (func_8012C354(a0, (s32)(D_8018852C + idx * 0x34)) == 0) { + return; + } + + *(u8 *)(a0 + 0xC0) = 1; + *(s32 *)(a0 + 0xB4) = -1; + *(u8 *)(a0 + 0xC1) = 0; + *(s32 *)(a0 + 0xBC) = (s32)D_801885C8; + func_80143970(a0); + + if ((*(u16 *)(a0 + 0x70) & 0x6000) != 0) { + *(s16 *)(a0 + 0x2) = 6; + func_8012A828(a0, (s32)&D_801AF9CC); + return; + } + + if ((*(u16 *)(a0 + 0x70) & 0x1) != 0) { + *(s16 *)(a0 + 0x2) = 0xF; + return; + } + + if ((*(u16 *)(a0 + 0x70) & 0x100) != 0) { + if ((*(u16 *)(a0 + 0x70) & 0x1000) != 0) { + y = (u32)(D_80078EB1 - 7) < 0xC; + *(u16 *)(a0 + 0x102) = y; + if (y == 0) { + func_8012E8A8((u8 *)a0); + *(s16 *)(a0 + 0x2) = 0x11; + return; + } + } + *(s16 *)(a0 + 0x2) = 9; + return; + } + + *(s16 *)(a0 + 0x2) = 1; + *(s16 *)(a0 + 0x34) = 0; + *(u16 *)(a0 + 0x5C) = 0xAA10; + r = rand(); + p = &d; + r = r & 0x1F; + dx = *(s16 *)(a0 + 0x6); + dz = *(s16 *)(a0 + 0x88); + *(s32 *)(a0 + 0x1C) = r + 0x28; + + p->vy = 0; + p->vx = dx - dz; + p->vz = *(s16 *)(a0 + 0xE) - *(s16 *)(a0 + 0x8C); + Square0(&p->vx, &p->vx); + + sum = d.vx + d.vz; + s1_ptr = (void *)(a0 + 0x88); + if (sum > 0x8FFFF) { + *(s16 *)(a0 + 0xFC) = (s16)func_8012B744((void *)(a0 + 4), s1_ptr); + } else { + x = rand() & 0x3FF; + v1 = x - 0x200; + if (v1 >= 0) { + v1 = x + 0x100; + } else { + v1 = x - 0x500; + } + y = (*(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + v1) & 0xFFF; + *(s16 *)(a0 + 0xFC) = y; + } + + func_8012A828(a0, (s32)D_801AFB14); +} -INCLUDE_ASM("asm/ov_SC02_016/nonmatchings/ov_SC02_016_jr_8017DC70", func_801818F8); INCLUDE_ASM("asm/ov_SC02_016/nonmatchings/ov_SC02_016_jr_8017DC70", func_80181AE8); diff --git a/src/ov_SC02_021/ov_SC02_021_jr_8017C294.c b/src/ov_SC02_021/ov_SC02_021_jr_8017C294.c index 67ada260e..93b201150 100644 --- a/src/ov_SC02_021/ov_SC02_021_jr_8017C294.c +++ b/src/ov_SC02_021/ov_SC02_021_jr_8017C294.c @@ -3364,7 +3364,86 @@ void func_8017D7E0(void *a0) { } -INCLUDE_ASM("asm/ov_SC02_021/nonmatchings/ov_SC02_021_jr_8017C294", func_8017D81C); +extern void func_8012CAE4(void *a0); +extern s32 func_8012C1B8(void); +extern void func_8001C2C4(s32 a0); +extern void func_800233CC(void *, unsigned short); + +void func_8017D81C(void *a0) +{ + extern u8 D_80192D28[]; + extern s16 D_80192CF0; + extern s16 D_80192CF2; + extern s16 D_80192CF4; + extern s16 D_80192CF6; + extern s32 D_80192D00; + extern s16 D_80192D14; + extern s16 D_80192D16; + extern s32 D_80192CE0; + extern s32 D_80192CE4; + extern s32 D_80192CE8; + extern s32 D_80192CEC; + extern s32 D_80192CFC; + extern s32 D_80192D04; + extern s32 D_80192D08; + extern s32 D_80192D0C; + extern s32 D_80192D10; + extern s16 D_80192D18; + extern s16 D_80192D1A; + extern s32 D_80192D20; + extern s32 D_80192D1C; + extern s32 D_80192D24; + s32 v; + s32 s1; + u8 *p; + register s32 x asm("v1"); + register s32 y asm("a1"); + register s32 z asm("a0"); + + v = func_8012C1B8(); + *(s32 *)((s32)a0 + 0x20) = v; + if (v == 0) { + func_8012CAE4((void *)a0); + return; + } + func_8001C2C4(v); + p = D_80192D28; + s1 = 0; + x = -0x680; + y = -0xE80; + z = -0x350; + __asm__ __volatile__("" : "=r"(x) : "0"(x)); + __asm__ __volatile__("" : "=r"(y), "=r"(z) : "0"(y), "1"(z)); + D_80192CF0 = 0x68; + D_80192CF2 = 0xB; + D_80192CF4 = 0x36A; + D_80192CF6 = 0x36A; + D_80192D00 = 1; + D_80192D14 = 0x1F4; + D_80192D16 = 0x291; + D_80192CE0 = x; + D_80192CE4 = y; + D_80192CE8 = z; + D_80192CEC = x; + D_80192CFC = 0; + D_80192D04 = x; + D_80192D08 = y; + D_80192D0C = z; + D_80192D10 = x; + D_80192D18 = 0x23D; + D_80192D1A = 0x23D; + D_80192D20 = 0; + D_80192D1C = 0; + D_80192D24 = 0; + do { + p[3] = 0; + func_800233CC(p, 0x40); + s1++; + p += 0x40; + } while (s1 < 0x20); + *(u16 *)((s32)a0 + 2) = *(u16 *)((s32)a0 + 2) + 1; +} + INCLUDE_ASM("asm/ov_SC02_021/nonmatchings/ov_SC02_021_jr_8017C294", func_8017D980); @@ -3374,7 +3453,51 @@ INCLUDE_ASM("asm/ov_SC02_021/nonmatchings/ov_SC02_021_jr_8017C294", func_8017E41 INCLUDE_ASM("asm/ov_SC02_021/nonmatchings/ov_SC02_021_jr_8017C294", func_8017E4DC); -INCLUDE_ASM("asm/ov_SC02_021/nonmatchings/ov_SC02_021_jr_8017C294", func_8017E608); +extern s32 func_8012DEB8(s32 a0, s32 a1, s32 a2); + +typedef struct { + u16 x; /* 0x0 */ + u16 y; /* 0x2 */ + u16 z; /* 0x4 */ + u16 w; /* 0x6 */ +} Vec4h_8017E608; + +s32 func_8017E608(s32 a0, s32 a1, s16 a2) { + Vec4h_8017E608 p1; + Vec4h_8017E608 p2; + register s32 p2addr __asm__("$17"); + + p2addr = (s32)&p2; + p1.x = p2.x = *(u16 *)(a1 + 0x4); + p1.z = p2.z = a2; + p1.y = *(u16 *)(a1 + 0x8); + p2.y = *(u16 *)(a1 + 0xA); + if (func_8012DEB8(a0, (s32)&p1, p2addr)) { + return 1; + } + + p1.x = p2.x = (*(s16 *)(a1 + 0x4) + *(s16 *)(a1 + 0x6)) >> 2; + if (func_8012DEB8(a0, (s32)&p1, p2addr)) { + return 1; + } + + p1.x = p2.x = (*(s16 *)(a1 + 0x4) + *(s16 *)(a1 + 0x6)) >> 1; + if (func_8012DEB8(a0, (s32)&p1, p2addr)) { + return 1; + } + + p1.x = p2.x = ((*(s16 *)(a1 + 0x4) + *(s16 *)(a1 + 0x6)) >> 2) * 3; + if (func_8012DEB8(a0, (s32)&p1, p2addr)) { + return 1; + } + + p1.x = p2.x = *(u16 *)(a1 + 0x6); + if (func_8012DEB8(a0, (s32)&p1, p2addr)) { + return 1; + } + return 0; +} + INCLUDE_ASM("asm/ov_SC02_021/nonmatchings/ov_SC02_021_jr_8017C294", func_8017E734); @@ -3502,7 +3625,55 @@ void func_8017F228(void *a0) { INCLUDE_ASM("asm/ov_SC02_021/nonmatchings/ov_SC02_021_jr_8017C294", func_8017F264); -INCLUDE_ASM("asm/ov_SC02_021/nonmatchings/ov_SC02_021_jr_8017C294", func_8017F2FC); +typedef struct { + u8 r; /* 0x00 */ + u8 g; /* 0x01 */ + u8 b; /* 0x02 */ + u8 cd; /* 0x03 */ +} Col4_8017F2FC; + +typedef struct { + s32 unk0; /* 0x00 */ + s16 unk4; /* 0x04 */ + s16 unk6; /* 0x06 */ +} Gte8_8017F2FC; + +extern void func_8012EFB8(s32 a0); +extern void func_80015954(s32 a0, s32 a1); + +void func_8017F2FC(s32 a0) { + Gte8_8017F2FC sp10; + Col4_8017F2FC col; + s32 *owner; + s32 t; + + extern u16 D_800B99DA; + extern Col4_8017F2FC D_801838BC; + extern Col4_8017F2FC D_801838D8; + extern Col4_8017F2FC D_801838F4; + extern Col4_8017F2FC D_80183910; + + owner = *(s32 **)(a0 + 0x20); + + if (((s32 (*)(s32, s32))func_8012EFB8)(a0 + 0xFC, (s32)&sp10) & ~0x1000) { + owner[1] |= 0x80000000; + } else { + owner[1] &= 0x7FFFFFFF; + } + + func_80015954((s32)&sp10, a0 + 4); + + t = (D_800B99DA & 1) << 2; + col.r = t + 0x40; + col.g = t + 0x40; + col.b = t + 0x60; + + D_801838BC = col; + D_801838D8 = col; + D_801838F4 = col; + D_80183910 = col; +} + extern void (*D_80183944[])(void); diff --git a/src/ov_SC03_090/ov_SC03_090_jr_8017CA80.c b/src/ov_SC03_090/ov_SC03_090_jr_8017CA80.c index 50abe923a..79d1b4b84 100644 --- a/src/ov_SC03_090/ov_SC03_090_jr_8017CA80.c +++ b/src/ov_SC03_090/ov_SC03_090_jr_8017CA80.c @@ -4184,14 +4184,7 @@ void func_80181380(s32 a0) { void func_801813C8(void) { } -extern s32 func_80146994(s32 a0, s32 a1, s32 a2, s32 a3); -extern s32 func_80171990(u8 *a0); - -void func_801813D0(s32 arg0) { - func_80146994(0x1A, arg0, 0xA030A04, 0); - func_80171990((u8 *)arg0); -} - +INCLUDE_ASM("asm/ov_SC03_090/nonmatchings/ov_SC03_090_jr_8017CA80", func_801813D0); extern s32 func_8014C050(s32 arg0, s32 arg1); extern void func_80171928(void *a0); diff --git a/src/ov_SC04_004/ov_SC04_004_jr_8017AE2C.c b/src/ov_SC04_004/ov_SC04_004_jr_8017AE2C.c index 006b97a3e..370058367 100644 --- a/src/ov_SC04_004/ov_SC04_004_jr_8017AE2C.c +++ b/src/ov_SC04_004/ov_SC04_004_jr_8017AE2C.c @@ -6118,7 +6118,52 @@ void func_8018056C(S_8018056C *s0) { } -INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_801805D0); +extern M2C_UNK D_80199824; +extern M2C_UNK D_8019972C; +extern s32 D_801997A4; + +void func_801805D0(void *arg0) { + void *s0 = arg0; + void *a1 = *(void **)((u8 *)s0 + 0x20); + + if (*(s16 *)((u8 *)s0 + 0xFE) == *(s16 *)((u8 *)a1 + 0x12)) { + s32 buf[2]; + + if (func_80180BA4(s0, buf) == 1) { + if ((*(u16 *)((u8 *)s0 + 0x86) & 1) != 0) { + goto L_C0; + } + if ((rand() & 1) == 0) { + goto L_FC; + } + if ((*(u16 *)((u8 *)s0 + 0x86) & 1) == 0) { + goto L_D0; + } +L_C0: + func_801804CC(s0); + goto tail; +L_D0: + func_8012A8B0((u8 *)s0, (s32)&D_80199824); + *(s32 *)((u8 *)s0 + 0x1C) = 0x60; + func_8012AD44((s32 *)s0, 3); + goto tail; +L_FC: + func_8012A8B0((u8 *)s0, (s32)&D_8019972C); + *(s32 *)((u8 *)s0 + 0x94) = 0xF; + *(s32 *)(*(u8 **)((u8 *)s0 + 0x20) + 0x20) = D_801997A4; + func_8012B23C((s32)s0); + func_8012AD44((s32 *)s0, 2); + } else { + *(u16 *)((u8 *)s0 + 0xFE) += 0x200; + } + +tail: + *(u16 *)((u8 *)s0 + 0x100) += 1; + } else { + func_80180F74(*(s16 *)((u8 *)s0 + 0xFE), (u16 *)((u8 *)a1 + 0x12), 0x20); + } +} + extern M2C_UNK D_80199644; extern void func_8012A8B0(u8 *a0, s32 a1); @@ -6133,7 +6178,54 @@ void func_8018070C(void *arg0) { } -INCLUDE_ASM("asm/ov_SC04_004/nonmatchings/ov_SC04_004_jr_8017AE2C", func_80180750); +typedef struct { s32 w[8]; } MTX8L_80180750; + +s32 func_80180750(s32 a0) +{ + extern MTX8L_80180750 aD800AE620 __asm__("D_800AE620"); + extern void RotMatrixY(s32 a0, void *a1); + extern void func_80020F34(s32 a0, s32 a1); + extern void func_8004914C(void *a0); + extern void func_800491AC(void *a0); + extern void RotTransSV(void *a0, void *a1, void *a2); + extern s32 func_8012C588(s32 a0, s32 a1); + + s16 *s1; + s16 rv[4]; + s16 vec[4]; + MTX8L_80180750 m; + s16 out[4]; + + s1 = (s16 *)func_8012C588(0x239, a0); + if (s1 != 0) { + m = aD800AE620; + + vec[2] = 0x1800; + vec[1] = 0x1800; + vec[0] = 0x1800; + + RotMatrixY(*(s16 *)(*(s32 *)(a0 + 0x20) + 0x12), &m); + + func_80020F34((s32)&m, (s32)vec); + + func_8004914C(&m); + + func_800491AC((void *)(*(s32 *)(a0 + 0x20) + 0x34)); + + rv[1] = -0x200; + rv[0] = 0; + rv[2] = -0x48; + RotTransSV(rv, rv, out); + + *(u16 *)((u8 *)s1 + 0x6) = *(u16 *)&rv[0]; + *(u16 *)((u8 *)s1 + 0xA) = *(u16 *)&rv[1]; + *(u16 *)((u8 *)s1 + 0xE) = *(u16 *)&rv[2]; + + *(s32 *)(a0 + 0xCC) = (s32)s1; + } + return (s32)s1; +} + extern void func_8012A8B0(u8 *a0, s32 a1); extern void func_8012AD44(s32 *a0, s16 a1); diff --git a/src/ov_SC04_005/ov_SC04_005_jr_8017BEBC.c b/src/ov_SC04_005/ov_SC04_005_jr_8017BEBC.c index 0d77bb7db..7cb20bbe0 100644 --- a/src/ov_SC04_005/ov_SC04_005_jr_8017BEBC.c +++ b/src/ov_SC04_005/ov_SC04_005_jr_8017BEBC.c @@ -6907,7 +6907,43 @@ void func_8018229C(s32 arg0) { } -INCLUDE_ASM("asm/ov_SC04_005/nonmatchings/ov_SC04_005_jr_8017BEBC", func_801822E4); +extern s32 D_80199BC0; +extern s32 D_80199C28; +extern s32 func_8012C354(s32 a0, s32 a1); +extern s32 func_80143970(s32 a0); +extern u8 D_80199B8C[]; +extern u8 D_801A4378[]; + extern void func_8012A828(s32, s32); +extern void func_8012B23C(s32 a0); + +void func_801822E4(s32 a0) { + extern u8 D_80199B8C[]; + extern s32 D_80199C28; + extern s32 D_80199BC0; + extern u8 D_801A4378[]; + extern s32 func_80143970(s32 a0); + extern s32 func_8012C354(s32 a0, s32 a1); + extern void func_8012A828(s32, s32); + extern void func_8012B23C(s32 a0); + + if (func_8012C354(a0, (s32)D_80199B8C) == 0) { + return; + } + + *(u8 *)(a0 + 0xC0) = 1; + *(s32 *)(a0 + 0xB4) = -1; + func_80143970(a0); + ((void (*)(s32, void *))func_8012A828)(a0, (void *)&D_801A4378); + *(u16 *)(a0 + 2) = *(u16 *)(a0 + 2) + 1; + func_8012B23C(a0); + + if (*(s16 *)(a0 + 0x70) == 3) { + *(s32 *)(a0 + 0xBC) = (s32)&D_80199C28; + } else { + *(s32 *)(a0 + 0xBC) = (s32)&D_80199BC0; + } +} + extern s32 func_8012BCCC(s32 a0); extern u8 D_801A4378[]; @@ -9557,7 +9593,17 @@ void func_801861A4(s32 a0) } -INCLUDE_ASM("asm/ov_SC04_005/nonmatchings/ov_SC04_005_jr_8017BEBC", func_801864DC); +extern u8 D_801B59D0[]; +extern void (*D_801B5BA8[])(void); +extern void func_8018676C(s32 a0, void *a1, s32 a2); + +void func_801864DC(void *a0) { + D_801B5BA8[*(u16 *)((s32)a0 + 0x2)](); + if (*(u16 *)a0 != 0) { + func_8018676C((s32)a0, (void *)&D_801B59D0, 0); + } +} + extern void D_801B811C; extern void func_8001C214(s32, s32); 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 aaa57c7be..4e5276339 100644 --- a/src/ov_SC06_032/ov_SC06_032_jr_80182890.c +++ b/src/ov_SC06_032/ov_SC06_032_jr_80182890.c @@ -4595,7 +4595,52 @@ INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_801857B INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_801857F4); -INCLUDE_ASM("asm/ov_SC06_032/nonmatchings/ov_SC06_032_jr_80182890", func_80185860); +extern void func_8016AA50(s32, s32); +extern s32 rand(void); +extern s32 func_8012C658(s32, s32, s32); +extern void func_8002D4C8(s32, s32); +extern s16 D_801BEE6C[]; + +void func_80185860(u8 *arg) { + s32 dec; + s32 cnt; + s32 i; + s32 cc; + s16 t; + + cc = *(s32 *)(arg + 0xCC); + if (*(s32 *)(arg + 0x78) != 0) { + dec = (*(s16 *)(arg + 0x60) * *(s16 *)(*(s32 *)(arg + 0x78) + 0x30)) >> 12; + if (dec < 1) { + dec = 1; + } + } + if (*(s16 *)(arg + 0x76) != 0) { + func_8016AA50((s32)arg, dec); + t = *(s16 *)(arg + 0x76) - dec; + *(s16 *)(arg + 0x76) = t; + if (t < 0) { + *(s16 *)(arg + 0x76) = 0; + } + *(u16 *)(arg + 0x10A) = rand() & 0x3F0; + cnt = (rand() & 3) + 1; + for (i = 0; i < cnt; i++) { + func_8012C658(0x304, i + 0x10, (s32)arg); + } + } + *(u8 *)(arg + 0xC1) = 1; + *(u16 *)(arg + 0x5C) &= 0xFFFE; + *(s32 *)(*(s32 *)(arg + 0x20) + 0x80) = (s32)D_801BEE6C; + if (cc != 0) { + *(s32 *)(*(s32 *)(cc + 0x20) + 0x80) = (s32)D_801BEE6C; + } + *(u16 *)(arg + 0xFE) = 8; + if (*(s16 *)(arg + 0x76) == 0) { + *(u16 *)(arg + 0x5C) = 0x800; + } + func_8002D4C8(0xAAC, 0); +} + extern u8 D_801BEE64[]; extern void func_8012AD44(s32 *a0, s16 a1); diff --git a/src/ov_SC07_000/ov_SC07_000_jr_8017BEBC.c b/src/ov_SC07_000/ov_SC07_000_jr_8017BEBC.c index 9ba2f5f48..3bc2b7738 100644 --- a/src/ov_SC07_000/ov_SC07_000_jr_8017BEBC.c +++ b/src/ov_SC07_000/ov_SC07_000_jr_8017BEBC.c @@ -3742,7 +3742,45 @@ void func_8017DC68(s32 param_1, s16 *param_2) { } -INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017DE00); +extern s32 D_801D0C5C; +extern s32 D_801D0C78[]; +extern s32 D_801D0540; +extern s32 D_801D0598; +extern s32 D_801860D8[]; +extern s32 *D_80186150[]; +extern s32 D_801861C8[]; +extern s32 D_801A3560; + +void func_8017DE00(void) +{ + s32 i; + + switch (D_801D0C5C) { + case 0: + for (i = 0; i < 30; i++) { + func_8013C0F8(D_801860D8[i]); + func_8017CD9C(D_80186150[i]); + D_801861C8[i] = 1; + } + D_801D0598 = 1; + func_8013C0F8((s32)&D_801A3560); + func_8017CD9C((s32)&D_801D0540); + D_801D0C5C = D_801D0C5C + 1; + break; + + case 1: + for (i = 0; i < 30; i++) { + if (D_801861C8[i] != 0) { + func_8017CDF0((s32)D_801D0C78, D_801860D8[i], D_80186150[i]); + } + } + if (D_801D0598 != 0) { + func_8017CDF0((s32)D_801D0C78, (s32)&D_801A3560, (s32)&D_801D0540); + } + break; + } +} + extern s32 D_801D0598; void func_8017DF84(s32 arg0) { @@ -3987,7 +4025,52 @@ void func_8017E804(s32 *a0, s32 a1, s32 a2) { INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017E830); -INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017E960); +typedef struct { u8 b[4]; } __attribute__((packed, aligned(1))) Blk4_E960; + +extern s16 D_801D05A0[]; +extern Blk4_E960 D_80186540[]; +extern Blk4_E960 D_801CE6E0; + +void func_8017E960(void *a0) { + s32 ret; + u8 *s0; + + ret = func_8012C1B8(); + *(s32 *)((u8 *)a0 + 0x20) = ret; + if (ret == 0) { + func_8012CAE4(a0); + return; + } + + s0 = (u8 *)&D_801D05A0 + (*(s16 *)((u8 *)a0 + 0x70) << 6); + func_8001CA88(ret, s0); + func_800233CC(s0, 0x100); + + *(Blk4_E960 *)s0 = D_80186540[*(s16 *)((u8 *)a0 + 0x70)]; + *(Blk4_E960 *)(s0 + 4) = D_801CE6E0; + + *(u16 *)(*(s32 *)((u8 *)a0 + 0x20) + 0x2E) = 0xC080; + + if (*(s16 *)((u8 *)a0 + 0x70) == 0) { + *(s32 *)(*(s32 *)((u8 *)a0 + 0x20) + 4) |= 0x50800000; + *(s16 *)(*(s32 *)((u8 *)a0 + 0x20) + 0x18) = 0x1400; + *(s16 *)(*(s32 *)((u8 *)a0 + 0x20) + 0x1A) = 0x1A00; + } else { + *(s32 *)(*(s32 *)((u8 *)a0 + 0x20) + 4) |= 0x50800000; + *(s16 *)(*(s32 *)((u8 *)a0 + 0x20) + 0x18) = 0x1200; + *(s16 *)(*(s32 *)((u8 *)a0 + 0x20) + 0x1A) = 0x1600; + } + + func_8001C1E4((void *)*(s32 *)((u8 *)a0 + 0x20), + *(void **)(*(s32 *)((u8 *)a0 + 0x64) + 0x20)); + + *(s16 *)((u8 *)a0 + 6) = 0; + *(s16 *)((u8 *)a0 + 0xA) = -0xA8; + *(s16 *)((u8 *)a0 + 0xE) = 0; + *(s32 *)(*(s32 *)((u8 *)a0 + 0x20) + 0x28) = 0x1000100; + func_8012AD50(a0); +} + extern s32 func_8004787C(s32 a0); extern void func_800234E4(void *a0, s32 a1, s32 a2); @@ -4107,7 +4190,56 @@ extern void func_8012B200(u8 *a0); INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017EEC0); -INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017EEE0); +extern void func_8012A828(s32, void*); +extern void func_8012AD80(s32 a0); +extern void func_8017F044(s32 a0); +extern void func_8017F3FC(s32 a0); +extern u8 D_801BD0D4[]; +extern s16 D_801D0B7C; + +void func_8017EEE0(s32 a0) { + u16 state = *(u16 *)(a0 + 0x34); + + switch (state) { + case 0: + if (*(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) != 0x800) { + *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) = *(u16 *)(*(s32 *)(a0 + 0x20) + 0x12) + 0x100; + if (*(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) >= 0x801) { + *(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) = 0x800; + } + if (*(s16 *)(*(s32 *)(a0 + 0x20) + 0x12) == 0x800) { + ((void (*)(s32, s32))func_8012A828)(a0, &D_801BD0D4[0]); + *(u32 *)(a0 + 0x18) = 0xC0000; + *(u16 *)(a0 + 0x34) = *(u16 *)(a0 + 0x34) + 1; + } + } + break; + case 1: { + u16 st; + func_8012AD80(a0); + if (*(s16 *)(a0 + 0xE) >= 0x4E1) { + st = *(u16 *)(a0 + 0x34); + D_801D0B7C = 3; + *(u16 *)(a0 + 0x34) = st + 1; + } + break; + } + case 2: + func_8012AD80(a0); + if (*(s16 *)(a0 + 0xE) >= 0x541) { + func_8017F044(a0); + } + break; + } + + if (*(u32 *)(a0 + 0x18) != 0) { + *(u32 *)(a0 + 0x1C) = *(u32 *)(a0 + 0x1C) + 1; + if ((*(u32 *)(a0 + 0x1C) & 7) == 0) { + func_8017F3FC(a0); + } + } +} + extern void func_8012A828(s32 a0, void *a1); extern void func_8012B200(u8 *a0); @@ -4147,7 +4279,33 @@ INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017F4F INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017F554); -INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017F59C); +extern s32 func_80132EF4(); +extern void func_8012A828(); +extern void func_8012AD44(); +extern void func_8002D4C8(s32 a0, s32 a1); + +void func_8017F59C(void *a0) { + register s32 s0 __asm__("$16") = (s32)a0; + extern u8 D_801CCFA8[]; + register s32 obj; + register s32 y; + + *(s32 *)(s0 + 0x10) = (*(s32 *)(*(s32 *)(s0 + 0x64) + 4) - *(s32 *)(s0 + 4)) >> 4; + y = *(s32 *)(s0 + 8) + 0x1400000; + *(s32 *)(s0 + 0x14) = (*(s32 *)(*(s32 *)(s0 + 0x64) + 8) - y) >> 4; + *(s32 *)(s0 + 0x18) = (*(s32 *)(*(s32 *)(s0 + 0x64) + 0xC) - *(s32 *)(s0 + 0xC) + 0x200000) >> 4; + *(s32 *)(s0 + 0x1C) = 0x10; + obj = func_80132EF4(s0, 0x77); + if (obj != 0) { + *(s32 *)(obj + 4) += *(s32 *)(s0 + 0x10) * 4; + *(s32 *)(obj + 8) += -0x300000 + (*(s32 *)(s0 + 0x14) * 4); + *(s32 *)(obj + 0xC) += *(s32 *)(s0 + 0x18) * 4; + } + func_8012A828(s0, D_801CCFA8); + func_8012AD44((s32 *)s0, 3); + func_8002D4C8(0xC1A, 0); +} + INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_8017F69C); @@ -4490,7 +4648,43 @@ void func_80180CEC(s32 a0) { } -INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_80180DB4); +extern s16 D_801D0B7C; + +void func_80180DB4(s32 ent) { + s16 t; + + switch (*(u16 *)(ent + 0x34)) { + case 0: + t = *(s16 *)(*(s32 *)(ent + 0x20) + 0x12); + if (t != 0) { + *(s16 *)(*(s32 *)(ent + 0x20) + 0x12) = t - 0x100; + if (*(s16 *)(*(s32 *)(ent + 0x20) + 0x12) < 0) { + *(u16 *)(*(s32 *)(ent + 0x20) + 0x12) = 0; + } + if (*(s16 *)(*(s32 *)(ent + 0x20) + 0x12) != 0) { + break; + } + } + *(u16 *)(ent + 0x34) = *(u16 *)(ent + 0x34) + 1; + break; + case 1: + func_80142414(ent, -0x80); + *(s32 *)(ent + 0x1C) = 0x10; + *(u16 *)(ent + 0x34) = *(u16 *)(ent + 0x34) + 1; + break; + case 2: + if (func_8012BEE8(ent) == 0) { + break; + } + func_8017FE5C(ent); + *(u16 *)(ent + 0x34) = *(u16 *)(ent + 0x34) + 1; + break; + } + if (*(u16 *)&D_801D0B7C == 5) { + func_8017F59C(ent); + } +} + INCLUDE_ASM("asm/ov_SC07_000/nonmatchings/ov_SC07_000_jr_8017BEBC", func_80180ED0); diff --git a/src/ov_SC07_006/ov_SC07_006_jr_8017BEBC.c b/src/ov_SC07_006/ov_SC07_006_jr_8017BEBC.c index c28d1ef03..efb55d9d3 100644 --- a/src/ov_SC07_006/ov_SC07_006_jr_8017BEBC.c +++ b/src/ov_SC07_006/ov_SC07_006_jr_8017BEBC.c @@ -3827,7 +3827,51 @@ void func_8017D130(s32 a0) { } -INCLUDE_ASM("asm/ov_SC07_006/nonmatchings/ov_SC07_006_jr_8017BEBC", func_8017D1D0); +extern s16 *D_801F6098; +typedef struct { s16 w[4]; } Blk8_80126940_8018008C; +extern Blk8_80126940_8018008C D_801274E8; +extern void func_8017D4E4(s32 param_1, s16 *param_2); + +void func_8017D1D0(s32 param_1) { + s16 sp10[3]; + s16 *ptr; + s32 v; + + ptr = D_801F6098; + switch (*(s16 *)(param_1 + 0xA0)) { + case 0: + sp10[0] = ptr[0] + (ptr[8] - ptr[0]) * *(s32 *)(param_1 + 0x9C) / ptr[3]; + sp10[1] = ptr[1] + (ptr[9] - ptr[1]) * *(s32 *)(param_1 + 0x9C) / ptr[3]; + sp10[2] = ptr[2] + (ptr[10] - ptr[2]) * *(s32 *)(param_1 + 0x9C) / ptr[3]; + *(s32 *)(param_1 + 0x9C) = *(s32 *)(param_1 + 0x9C) + 1; + if (ptr[3] < *(s32 *)(param_1 + 0x9C)) { + D_801274E8 = *(Blk8_80126940_8018008C *)&sp10[0]; + *(s32 *)(param_1 + 0x9C) = 0; + *(u16 *)(param_1 + 0xA0) += 1; + } + break; + case 1: + v = (ptr[8] - ptr[0]) * *(s32 *)(param_1 + 0x9C) / ptr[3]; + if (v < 0) { + v += 3; + } + sp10[0] = *(s16 *)&D_801274E8 + (v >> 2); + v = (ptr[9] - ptr[1]) * *(s32 *)(param_1 + 0x9C) / ptr[3]; + if (v < 0) { + v += 3; + } + sp10[1] = ((s16 *)&D_801274E8)[1] + (v >> 2); + v = (ptr[10] - ptr[2]) * *(s32 *)(param_1 + 0x9C) / ptr[3]; + if (v < 0) { + v += 3; + } + sp10[2] = ((s16 *)&D_801274E8)[2] + (v >> 2); + *(s32 *)(param_1 + 0x9C) += 1; + break; + } + func_8017D4E4(param_1, sp10); +} + @@ -4178,7 +4222,32 @@ void func_8017DC1C(s32 t) } -INCLUDE_ASM("asm/ov_SC07_006/nonmatchings/ov_SC07_006_jr_8017BEBC", func_8017F3D4); +void func_8017F3D4(s32 arg0, s32 arg1) { + extern u16 D_8018E33C; + extern void func_8017D8A4(s32 a0, void *a1, void *a2, s32 a3, s32 a4); + + func_8017D8A4(*(s32 *)(*(s32 *)(arg0 + 0x94) * 8 + *(s32 *)(arg0 + 0x90)), + (u8 *)&D_8018E33C, (u8 *)&D_8018E33C + 0x120, arg1, 1); + func_8017D8A4(*(s32 *)(*(s32 *)(arg0 + 0x94) * 8 + *(s32 *)(arg0 + 0x90)) + 0xCC, + (u8 *)&D_8018E33C + 0x60, (u8 *)&D_8018E33C + 0xCC, arg1, 1); + func_8017D8A4(*(s32 *)(*(s32 *)(arg0 + 0x94) * 8 + *(s32 *)(arg0 + 0x90)) + 0x3C, + (u8 *)&D_8018E33C - 0xC0, (u8 *)&D_8018E33C - 0x90, arg1, 1); + func_8017D8A4(*(s32 *)(*(s32 *)(arg0 + 0x94) * 8 + *(s32 *)(arg0 + 0x90)) + 0x48, + (u8 *)&D_8018E33C - 0xB4, (u8 *)&D_8018E33C - 0x84, arg1, 1); + func_8017D8A4(*(s32 *)(*(s32 *)(arg0 + 0x94) * 8 + *(s32 *)(arg0 + 0x90)) + 0x54, + (u8 *)&D_8018E33C - 0xA8, (u8 *)&D_8018E33C - 0x78, arg1, 1); + func_8017D8A4(*(s32 *)(*(s32 *)(arg0 + 0x94) * 8 + *(s32 *)(arg0 + 0x90)) + 0x60, + (u8 *)&D_8018E33C - 0x9C, (u8 *)&D_8018E33C - 0x6C, arg1, 1); + func_8017D8A4(*(s32 *)(*(s32 *)(arg0 + 0x94) * 8 + *(s32 *)(arg0 + 0x90)) + 0x90, + (u8 *)&D_8018E33C - 0x60, (u8 *)&D_8018E33C - 0x30, arg1, 1); + func_8017D8A4(*(s32 *)(*(s32 *)(arg0 + 0x94) * 8 + *(s32 *)(arg0 + 0x90)) + 0x9C, + (u8 *)&D_8018E33C - 0x54, (u8 *)&D_8018E33C - 0x24, arg1, 1); + func_8017D8A4(*(s32 *)(*(s32 *)(arg0 + 0x94) * 8 + *(s32 *)(arg0 + 0x90)) + 0xA8, + (u8 *)&D_8018E33C - 0x48, (u8 *)&D_8018E33C - 0x18, arg1, 1); + func_8017D8A4(*(s32 *)(*(s32 *)(arg0 + 0x94) * 8 + *(s32 *)(arg0 + 0x90)) + 0xB4, + (u8 *)&D_8018E33C - 0x3C, (u8 *)&D_8018E33C - 0xC, arg1, 1); +} + INCLUDE_ASM("asm/ov_SC07_006/nonmatchings/ov_SC07_006_jr_8017BEBC", func_8017F5D4); @@ -4461,9 +4530,77 @@ void func_80181C74(s32 a0, s32 a1) { INCLUDE_ASM("asm/ov_SC07_006/nonmatchings/ov_SC07_006_jr_8017BEBC", func_80181E64); -INCLUDE_ASM("asm/ov_SC07_006/nonmatchings/ov_SC07_006_jr_8017BEBC", func_80182000); +extern u8 D_801BFCCC; +extern u8 D_8018E3A8[]; +extern void func_8017D8A4(s32 a0, void *a1, void *a2, s32 a3, s32 a4); +extern void func_8017DA30(s32 a0, void *a1, void *a2, s32 a3, s32 a4, s32 a5); + +void func_80182000(s32 a0, s32 a1) +{ + func_8017D8A4(*(s32 *)&D_801BFCCC, D_8018E3A8, &D_8018E3A8[0xB4], a1, 1); + func_8017DA30(*(s32 *)&D_801BFCCC + 0x18, &D_8018E3A8[0x18], &D_8018E3A8[0xC0], a1, 1, + *(short *)((char *)a0 + 0x100)); + func_8017DA30(*(s32 *)&D_801BFCCC + 0x24, &D_8018E3A8[0x24], &D_8018E3A8[0xCC], a1, 1, + *(short *)((char *)a0 + 0x100)); + func_8017DA30(*(s32 *)&D_801BFCCC + 0x30, &D_8018E3A8[0x30], &D_8018E3A8[0xD8], a1, 1, + *(short *)((char *)a0 + 0x100)); + func_8017DA30(*(s32 *)&D_801BFCCC + 0x60, &D_8018E3A8[0x3C], &D_8018E3A8[0xE4], a1, 1, + *(short *)((char *)a0 + 0x100) + 0x200); + func_8017DA30(*(s32 *)&D_801BFCCC + 0x6C, &D_8018E3A8[0x48], &D_8018E3A8[0xF0], a1, 1, + *(short *)((char *)a0 + 0x100) + 0x200); + func_8017DA30(*(s32 *)&D_801BFCCC + 0x78, &D_8018E3A8[0x54], &D_8018E3A8[0xFC], a1, 1, + *(short *)((char *)a0 + 0x100) + 0x200); +} + + +extern void func_800599B8(u16 *); + +void func_80182158(s32 x) +{ + extern u16 D_801F60A0[]; + extern u16 D_801CAC48[]; + extern u16 D_801CAC28[]; + extern u8 D_8018DFB0[]; + u16 *dst; + u16 *b; + u16 *a; + s32 t; + s32 i; + s32 hi; + s32 r; + s32 g; + s32 bl; + s32 nr; + s32 ng; + s32 nb; + + dst = D_801F60A0; + b = D_801CAC48; + a = D_801CAC28; + t = (x - 0x800) * 2; + if (t < 0) { + t = 0; + } + for (i = 0; i < 16; i++) { + if (t >= 0x800) { + hi = *a & 0x8000; + } else { + hi = *b & 0x8000; + } + r = *b & 0x1F; + g = *b & 0x3E0; + bl = *b & 0x7C00; + nr = (r + ((((*a & 0x1F) - r) * t) >> 12)) & 0x1F; + ng = (g + ((((*a & 0x3E0) - g) * t) >> 12)) & 0x3E0; + nb = (bl + ((((*a & 0x7C00) - bl) * t) >> 12)) & 0x7C00; + *dst = hi | nr | ng | nb; + b++; + a++; + dst++; + } + ((void (*)(u8 *, u16 *))func_800599B8)(D_8018DFB0, &D_801F60A0[0]); +} -INCLUDE_ASM("asm/ov_SC07_006/nonmatchings/ov_SC07_006_jr_8017BEBC", func_80182158); INCLUDE_ASM("asm/ov_SC07_006/nonmatchings/ov_SC07_006_jr_8017BEBC", func_80182268);