From 876fd8df6da482e177d9eb9590859b00e1cead9d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mateusz=20K=C5=82ysz?= Date: Tue, 13 Oct 2026 10:30:44 +0000 Subject: [PATCH 01/12] overlay: decompile the pose packer FUN_L00_002092c8 pack_pose writes every listed scratchpad joint rotation, identity padding, the scales that are not 1.0 and the translations that differ from the model's bind pose as packed s16 vectors after a PackedPose header. --- src/overlays/shared/ui/help/00203b18.c | 148 +++++++++++++------------ 1 file changed, 78 insertions(+), 70 deletions(-) diff --git a/src/overlays/shared/ui/help/00203b18.c b/src/overlays/shared/ui/help/00203b18.c index ad82f0877..8246da6fc 100644 --- a/src/overlays/shared/ui/help/00203b18.c +++ b/src/overlays/shared/ui/help/00203b18.c @@ -2157,95 +2157,103 @@ void FUN_L00_00209240(s32 a) { t = D_L00_001E7C10; FUN_L00_0024f8f0(a, 9, &t, (((char *)&hero) + 0xac0)); } -#ifndef NON_MATCHING -INCLUDE_ASM("config/us/overlays/asm/FUN_L00_002092c8.s", FUN_L00_002092c8); -#else -extern u64 FUN_001ff768_002092c8(int, float) __asm__("FUN_L00_001ff768"); -extern void FUN_00254b58_002092c8(int) __asm__("FUN_L00_00254b58"); -extern volatile s32 D_001413D0_002092c8 __asm__("D_001413D0"); - -void FUN_L00_002092c8(s32 *indices, u16 *header, u8 *reference, s32 padding, s32 context) { - s32 *index; - s32 *first_index; - s32 *comparison_index; +/* A packed pose: after this header come three lists of 64-bit entries, four + saturated s16 each. Rotations (quaternions * 32768) start with the root at + 0x10; scales (4096 = 1.0) and translations follow, each entry tagged with + its joint index in the top s16 (scales also with 0x8000). */ +typedef struct { + u16 unk0; + u16 unk2; + u16 unk4; + u16 size; /* 0x6: quadwords from 0x10 to the end */ + u16 scale_offset; /* 0x8: bytes from 0x10 to the scale list */ + u16 scale_count; /* 0xA */ + u16 translation_offset; /* 0xC: bytes from 0x10 to the translation list */ + u16 translation_count; /* 0xE */ + u64 root_rotation; /* 0x10 */ +} PackedPose; + +/* The identity quaternion, packed: w = 0x7FFF. */ +#define PACKED_IDENTITY 0x7fff000000000000ULL +/* A packed scale of 1.0 (x = y = z = 0x1000), which the scale list leaves out. */ +#define PACKED_UNIT_SCALE 0x100010001000ULL +#define PACKED_XYZ_MASK 0xffffffffffffULL + +/* Scratchpad joint records, 0x40 bytes each: rotation, scale, translation. */ +#define SPR_JOINT_ROTATION 0x70000000 +#define SPR_JOINT_SCALE 0x70000010 +#define SPR_JOINT_TRANSLATION 0x70000020 + +extern u64 pack_vector_s16(s32 vector, f32 scale) __asm__("FUN_L00_001ff768"); +extern void FUN_00254b58_002092c8(s32) __asm__("FUN_L00_00254b58"); + +/* Packs the scratchpad joints listed in joints[1..] (ended by a negative + entry) into pose: every rotation, padding identity rotations, the scales + that are not 1.0 and the translations that differ from the bind pose. */ +void pack_pose(s32 *joints, PackedPose *pose, u8 *model, s32 padding, s32 context) __asm__("FUN_L00_002092c8"); +void pack_pose(s32 *joints, PackedPose *pose, u8 *model, s32 padding, s32 context) { u64 *out; - s32 first_count; - s32 second_count; - s32 third_count; + s32 rotation_count; + s32 scale_count; + s32 translation_count; s32 i; - s32 third_index; + s32 joint; + s32 rotation_size; u64 value; if (context == 0) - context = *(volatile s32 *)D_001413D0; - out = (u64 *)((u8 *)header + 0x18); + context = D_001413D0_00209240; + out = (u64 *)(pose + 1); FUN_00254b58_002092c8(context); - *(u64 *)(header + 8) = 0x7fff000000000000ULL; - first_count = 1; - if (indices[1] >= 0) { - s32 source_address = 0x70000000; - first_index = indices + 1; - do { - first_count++; - *out = FUN_001ff768_002092c8((*first_index++ << 6) + source_address, 32768.0f); - out++; - } while (*first_index >= 0); + pose->root_rotation = PACKED_IDENTITY; + rotation_count = 1; + for (i = 1; joints[i] >= 0; i++) { + *out++ = pack_vector_s16((joints[i] << 6) + SPR_JOINT_ROTATION, 32768.0f); + rotation_count++; } if (padding > 0) { s32 remaining = padding; do { - *out = 0x7fff000000000000ULL; + *out = PACKED_IDENTITY; remaining--; out++; - first_count++; + rotation_count++; } while (remaining != 0); } - second_count = 0; + scale_count = 0; i = 1; - if (indices[1] >= 0) { - index = indices + 1; - do { - value = FUN_001ff768_002092c8(0x70000010 + (*index << 6), 4096.0f); - if ((value & 0xffffffffffffULL) != 0x100010001000ULL) { - *out = value & 0xffffffffffffULL; - second_count++; - *(u16 *)((u8 *)out + 6) = i | 0x8000; - out++; - } - index++; - i++; - } while (*index >= 0); - } - third_count = 0; - third_index = 1; - if (indices[1] >= 0) { - comparison_index = indices + 1; - do { - value = FUN_001ff768_002092c8(0x70000020 + (*comparison_index << 6), 1.0f); - if ((value & 0xffffffffffffULL) != - (FUN_001ff768_002092c8(*(s32 *)(reference + 0x18) + (third_index << 4), 1.0f) & - 0xffffffffffffULL)) { - *out = value & 0xffffffffffffULL; - third_count++; - *(u16 *)((u8 *)out + 6) = third_index; - out++; - } - comparison_index++; - third_index++; - } while (*comparison_index >= 0); + rotation_size = rotation_count << 3; + for (; joints[i] >= 0; i++) { + value = pack_vector_s16(SPR_JOINT_SCALE + (joints[i] << 6), 4096.0f); + if ((value & PACKED_XYZ_MASK) != PACKED_UNIT_SCALE) { + *out = value & PACKED_XYZ_MASK; + scale_count++; + *(u16 *)((u8 *)out + 6) = i | 0x8000; + out++; + } + } + translation_count = 0; + for (joint = 1; joints[joint] >= 0; joint++) { + value = pack_vector_s16(SPR_JOINT_TRANSLATION + (joints[joint] << 6), 1.0f); + if ((value & PACKED_XYZ_MASK) != + (pack_vector_s16(*(s32 *)(model + 0x18) + (joint << 4), 1.0f) & PACKED_XYZ_MASK)) { + *out = value & PACKED_XYZ_MASK; + translation_count++; + *(u16 *)((u8 *)out + 6) = joint; + out++; + } } if ((u32)out & 0xf) *out++ = 0; - header[7] = third_count; - header[4] = first_count << 3; - header[3] = ((u8 *)out - ((u8 *)header + 0x10)) >> 4; - header[5] = second_count; - header[6] = (first_count + second_count) << 3; - header[1] = 0; - header[2] = 0; - header[0] = 0; + pose->translation_count = translation_count; + pose->scale_offset = rotation_size; + pose->size = ((u8 *)out - (u8 *)&pose->root_rotation) >> 4; + pose->scale_count = scale_count; + pose->translation_offset = (rotation_count + scale_count) << 3; + pose->unk2 = 0; + pose->unk4 = 0; + pose->unk0 = 0; } -#endif typedef struct { float x, y, z, w_00209540; } V4_00209540; From 02c6926cca4baed5ac5e1a31b5c0b2625ee0f83d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mateusz=20K=C5=82ysz?= Date: Tue, 13 Oct 2026 10:45:21 +0000 Subject: [PATCH 02/12] overlay: decompile FUN_L00_002599e8 (returns the callee's value) --- src/overlays/shared/gameplay/entities/00259710.c | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/src/overlays/shared/gameplay/entities/00259710.c b/src/overlays/shared/gameplay/entities/00259710.c index 978939e29..3ce5ad3fe 100644 --- a/src/overlays/shared/gameplay/entities/00259710.c +++ b/src/overlays/shared/gameplay/entities/00259710.c @@ -67,17 +67,14 @@ void make_hit_descriptor(char *a, int b, int c, float d, void *q) { qcopy(a, q); } INCLUDE_ASM("config/us/overlays/asm/FUN_L00_002598b0.s", FUN_L00_002598b0); -#ifndef NON_MATCHING -INCLUDE_ASM("config/us/overlays/asm/FUN_L00_002599e8.s", FUN_L00_002599e8); -#else extern void moby_point_position(void *, int, void *) __asm__("FUN_L00_0024f7c8"); -extern void FUN_L00_002598b0(void *, void *, int, float, float, float, int, int, int); -void FUN_L00_002599e8(void *a, int b, int c, float d, float e, float f, int g, int h, int i) { +extern int FUN_L00_002598b0(void *, void *, int, float, float, float, int, int, int); +/* Calls FUN_L00_002598b0 at a moby point; the f13 argument is ignored and c is passed again as a float. */ +int FUN_L00_002599e8(void *moby, int point, int c, float d, float unused, float f, int g, int h, int i) { float position[4] __attribute__((aligned(16))); - moby_point_position(a, b, position); - FUN_L00_002598b0(a, position, c, d, (float)c, f, g, h, i); + moby_point_position(moby, point, position); + return FUN_L00_002598b0(moby, position, c, d, (float)c, f, g, h, i); } -#endif typedef unsigned int u128_259a88 __attribute__((mode(TI), aligned(16))); typedef struct { u128_259a88 v; From 7982a9da5326e381f7e50b3aef0bcab54636bfc4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mateusz=20K=C5=82ysz?= Date: Tue, 13 Oct 2026 12:23:41 +0000 Subject: [PATCH 03/12] overlay: port FUN_L07_002f5ba0 from rac1-decomp --- src/overlays/l07/gameplay/entities/002cd2b0.c | 287 +++++++++--------- 1 file changed, 140 insertions(+), 147 deletions(-) diff --git a/src/overlays/l07/gameplay/entities/002cd2b0.c b/src/overlays/l07/gameplay/entities/002cd2b0.c index 84f66cac1..fcbd20aa5 100644 --- a/src/overlays/l07/gameplay/entities/002cd2b0.c +++ b/src/overlays/l07/gameplay/entities/002cd2b0.c @@ -728,68 +728,86 @@ void FUN_L07_002cdb28(struct Moby *moby) { } } } -#ifndef NON_MATCHING -INCLUDE_ASM("config/us/overlays/asm/FUN_L07_002f5ba0.s", FUN_L07_002f5ba0); -#else -extern u8 D_0013D388[]; -extern s32 D_L07_0015F5C4; -extern char *D_L07_0015FFD8; -extern char *D_L07_001600EC __attribute__((section(".data"))); -extern char D_0013F3D0[]; -extern int is_point_inside_clip_volume(void *, int) __asm__("FUN_00214720"); -extern void FUN_L00_00298840(int); -extern void FUN_L00_002607d0(int); +/* Update for moby class 436 on level 07: steps through its scenes as the hero enters its clip volumes. */ +/* Ported from rac1-decomp (src/overlays/l07_umbris/vendor_002CE470.c: func_L07_002F6F20), where it is exact; names translated to the US level program. */ + +typedef struct { + int open_volume; + int finish_volume; + int removed_moby; + int moby_0c; + int moby_10; + int moby_14; + int points_18; + int points_1c; +} Class436Vars; + +typedef struct { + char pad0[0x30]; + float unk30[4]; + char pad40[0x30]; + float unk70[4]; +} ScenePoints; + +extern u8 D_0013D3B1[]; +extern u8 alternate_item_available[128] __asm__("D_0013D388"); +extern struct Moby *level_mobys __asm__("D_L07_0015FFD8"); +extern int scene_state __asm__("D_L07_0015F5C4"); +extern ScenePoints *scene_points __asm__("D_L07_001600EC"); +extern void delete_moby_m(void *) __asm__("FUN_0020c828"); +extern void start_scene(int) __asm__("FUN_L00_00298840"); +extern int is_point_inside_clip_volume_i(void *, int) __asm__("FUN_00214720"); extern void FUN_L00_00216f90(void *, void *, int, int); extern void FUN_L01_0027a248(int, int); -extern void FUN_L07_00270248(int, int, int, int); extern void FUN_L00_00299460(int); -extern void FUN_0022e188(int); -extern void FUN_0020b178(int, int); extern void FUN_001f9c90(void *, void *, float); +extern void FUN_L07_00270248(int x, int y, int w, int h); +extern void unlock_planet(int) __asm__("FUN_L00_002607d0"); +extern int memcard_save_data(int, int) __asm__("FUN_0020b178"); +extern void FUN_0022e188(int); + +void FUN_L07_002f5ba0(struct Moby *moby) +{ + Class436Vars *data = (Class436Vars *)moby->pvars; + float v[4]; -void FUN_L07_002f5ba0(struct Moby *moby) { - int *data = (int *)moby->pvars; - char *other; - char *entry; - float delta[4]; switch (moby->state) { case 0: - if (D_0013D388[0x29] && data[2] != -1) - delete_moby((struct Moby *)(D_L07_0015FFD8 + data[2] * 0x100)); - if (D_L07_0015F5C4 == 0) moby->state = 1; + if (D_0013D3B1[0] != 0 && data->removed_moby != -1) { + delete_moby_m(&level_mobys[data->removed_moby]); + } + if (scene_state == 0) moby->state = 1; break; case 1: - if (!D_0013D388[0x28]) { - D_0013D388[0x28] = 1; + if (alternate_item_available[0x28] == 0) { + alternate_item_available[0x28] = 1; moby->state = 2; - FUN_L00_00298840(0); - return; + start_scene(0); + } else { + moby->state = 3; } - moby->state = 3; break; case 2: - if (D_L07_0015F5C4 != 2) moby->state = 3; + if (scene_state != 2) moby->state = 3; break; case 3: moby->state = 4; break; case 4: - if (!D_0013D388[0x29]) { - if (data[0] != -1) { - if (is_point_inside_clip_volume(D_0013F3D0, data[0])) { - D_0013D388[0x29] = 1; - if (data[3] != -1) { - other = D_L07_0015FFD8 + data[3] * 0x100; - *(u16 *)(other + 0x34) |= 0x41; + if (alternate_item_available[0x29] == 0) { + if (data->open_volume != -1) { + if (is_point_inside_clip_volume_i(&hero.motion.pos, data->open_volume) != 0) { + alternate_item_available[0x29] = 1; + if (data->moby_0c != -1) { + struct Moby *e = &level_mobys[data->moby_0c]; + e->flags |= 0x41; } - if (data[5] != -1) { - { - char *other = D_L07_0015FFD8 + data[5] * 0x100; - *(u16 *)(other + 0x34) |= 0x41; - } + if (data->moby_14 != -1) { + struct Moby *e = &level_mobys[data->moby_14]; + e->flags |= 0x41; } moby->state = 5; - FUN_L00_00298840(1); + start_scene(1); } } else { moby->state = 8; @@ -797,127 +815,102 @@ void FUN_L07_002f5ba0(struct Moby *moby) { } else { moby->state = 7; } - if (moby->state != 4 && data[2] != -1) - delete_moby((struct Moby *)(D_L07_0015FFD8 + data[2] * 0x100)); + if (moby->state != 4 && data->removed_moby != -1) { + delete_moby_m(&level_mobys[data->removed_moby]); + } break; case 5: - if (D_L07_0015F5C4 != 2) { - if (data[3] != -1) { - { - char *other = D_L07_0015FFD8 + data[3] * 0x100; - *(u16 *)(other + 0x34) |= 0x41; - } - } - moby->state = 6; - FUN_L00_00298840(2); + if (scene_state == 2) break; + if (data->moby_0c != -1) { + struct Moby *e = &level_mobys[data->moby_0c]; + e->flags |= 0x41; } + moby->state = 6; + start_scene(2); break; case 6: - if (D_L07_0015F5C4 != 2) { - if (data[6] != -1) { - char *entry = (char *)((u32)data[6] * 0x80 + (u32)D_L07_001600EC); - FUN_L00_00216f90(entry + 0x30, entry + 0x70, 0, 1); - } - moby->state = 7; + if (scene_state == 2) break; + if (data->points_18 != -1) { + FUN_L00_00216f90(scene_points[data->points_18].unk30, scene_points[data->points_18].unk70, 0, 1); } + moby->state = 7; break; case 7: - if (data[3] != -1) { - { - char *other = D_L07_0015FFD8 + data[3] * 0x100; - *(u16 *)(other + 0x34) &= ~0x41; - } + if (data->moby_0c != -1) { + struct Moby *e = &level_mobys[data->moby_0c]; + e->flags &= 0xFFBE; } - if (data[5] != -1) { - { - char *other = D_L07_0015FFD8 + data[5] * 0x100; - *(u16 *)(other + 0x34) &= ~0x41; - } + if (data->moby_14 != -1) { + struct Moby *e = &level_mobys[data->moby_14]; + e->flags &= 0xFFBE; } FUN_L01_0027a248(2, 4); moby->state = 8; break; - case 8: { - char *other; - u8 next_state; - if (D_0013D388[0x2a]) { - next_state = 12; - goto store_state; - } - if (data[3] != -1) { - char *other = D_L07_0015FFD8 + data[3] * 0x100; - if (other && ((u8 *)other)[0x20] != 0xfe && ((u8 *)other)[0x20] != 0xfd) - goto check_state; - } - if (data[1] == -1) { - next_state = 13; - goto store_state; - } - if (is_point_inside_clip_volume(D_0013F3D0, data[1])) { - char *entry = (char *)((u32)data[7] * 0x80 + (u32)D_L07_001600EC); - FUN_L00_00216f90(entry + 0x30, entry + 0x70, 0x72, 1); - D_0013D388[0x2a] = 1; - moby->state = 9; - FUN_L00_00298840(3); - } - goto check_state; -store_state: - moby->state = next_state; -check_state: - if (moby->state != 8 && data[4] != -1) { - char *other = D_L07_0015FFD8 + data[4] * 0x100; - *(u16 *)(other + 0x34) |= 0x41; + case 8: + if (alternate_item_available[0x2A] == 0) { + struct Moby *e; + if (data->moby_0c == -1 || (e = &level_mobys[data->moby_0c]) == 0 || e->state == 0xFE || e->state == 0xFD) { + if (data->finish_volume != -1) { + if (is_point_inside_clip_volume_i(&hero.motion.pos, data->finish_volume) != 0) { + FUN_L00_00216f90(scene_points[data->points_1c].unk30, scene_points[data->points_1c].unk70, 0x72, 1); + alternate_item_available[0x2A] = 1; + moby->state = 9; + start_scene(3); + } + } else { + moby->state = 13; + } + } + } else { + moby->state = 12; + } + if (moby->state != 8 && data->moby_10 != -1) { + struct Moby *e = &level_mobys[data->moby_10]; + e->flags |= 0x41; } break; - } case 9: - if (D_L07_0015F5C4 != 2) { - moby->state = 10; - FUN_L00_00299460(8); - } + if (scene_state == 2) break; + moby->state = 10; + FUN_L00_00299460(8); break; case 10: - if (D_L07_0015F5C4 == 2) return; + if (scene_state == 2) break; moby->state = 11; - FUN_L00_00298840(4); - case 11: { - char *other; - if (D_L07_0015F5C4 != 2) { - if (data[7] != -1) { - char *entry = (char *)((u32)data[7] * 0x80 + (u32)D_L07_001600EC); - FUN_L00_00216f90(entry + 0x30, entry + 0x70, 0, 1); - } - if (data[4] != -1) { - other = D_L07_0015FFD8 + data[4] * 0x100; - subtract_vector_xyz(delta, D_0013F3D0, other + 0x10); - FUN_001f9c90(delta, delta, 0.9f); - add_vector_xyz(other + 0x10, D_0013F3D0, delta); - delete_moby((struct Moby *)other); - } - FUN_L07_00270248(0x87, 0xc, 0x56, 0x3c); - FUN_L00_002607d0(8); - FUN_0020b178(0, 8); - FUN_0022e188(8); - moby->state = 12; - } + start_scene(4); + case 11: + if (scene_state == 2) break; + if (data->points_1c != -1) { + FUN_L00_00216f90(scene_points[data->points_1c].unk30, scene_points[data->points_1c].unk70, 0, 1); + } + if (data->moby_10 != -1) { + struct Moby *e = &level_mobys[data->moby_10]; + subtract_vector_xyz(v, &hero.motion.pos, &e->pos); + FUN_001f9c90(v, v, 0.9f); + add_vector_xyz(&e->pos, &hero.motion.pos, v); + delete_moby_m(e); + } + FUN_L07_00270248(0x87, 0xC, 0x56, 0x3C); + unlock_planet(8); + memcard_save_data(0, 8); + FUN_0022e188(8); + moby->state = 12; break; - } - case 12: { - char *other; - if (data[4] != -1) { - other = D_L07_0015FFD8 + data[4] * 0x100; - if (other && ((u8 *)other)[0x20] != 0xfe && ((u8 *)other)[0x20] != 0xfd) - delete_moby((struct Moby *)other); + case 12: + if (data->moby_10 != -1) { + struct Moby *e = &level_mobys[data->moby_10]; + if (e != 0 && e->state != 0xFE && e->state != 0xFD) { + delete_moby_m(e); + } } moby->state = 13; break; - } case 13: - delete_moby(moby); + delete_moby_m(moby); break; } } -#endif #include "rnc/gameplay/entities/moby.h" struct SpawnClassView { @@ -975,20 +968,20 @@ INCLUDE_ASM("config/us/overlays/asm/FUN_L07_0030b000.s", FUN_L07_0030b000); #else extern char *D_L07_001B0530[] __asm__("D_L07_001B0530"); extern char *FUN_L00_0025a420(void *, int, int); -extern s32 FUN_00213928(struct Moby *, char *, f32 *, s32, s32 *, s32, s32, s32) __asm__("FUN_00213928"); -extern void FUN_L01_0026e0e0(s32, s32) __asm__("FUN_L01_0026e0e0"); -extern void FUN_001f99f8(void *) __asm__("FUN_001f99f8"); +extern s32 FUN_00213928(struct Moby *, char *, f32 *, s32, s32 *, s32, s32, s32); +extern void FUN_L01_0026e0e0(s32, s32); +extern void FUN_001f99f8(void *); extern void FUN_L00_0025e450_l07(f32, f32, f32, f32, f32, f32, f32, struct Moby *, void *, s32, s32, s32, s32, s32, s32, s32, s32, s32) __asm__("FUN_L00_0025e450"); -extern f32 FUN_001f9b48(void *, void *) __asm__("FUN_001f9b48"); -extern s32 FUN_L00_002591d0(s32 *, s32, s32, s32) __asm__("FUN_L00_002591d0"); -extern s32 FUN_L00_002592b8(s32 *, s32, s32, s32) __asm__("FUN_L00_002592b8"); -extern void FUN_001e93b0(char *, ...) __asm__("FUN_001e93b0"); -extern s32 FUN_L01_0028b510(f32, void *, void *) __asm__("FUN_L01_0028b510"); +extern f32 FUN_001f9b48(void *, void *); +extern s32 FUN_L00_002591d0(s32 *, s32, s32, s32); +extern s32 FUN_L00_002592b8(s32 *, s32, s32, s32); +extern void FUN_001e93b0(char *, ...); +extern s32 FUN_L01_0028b510(f32, void *, void *); extern void FUN_L00_0025d458(void *, short *); -extern void FUN_L00_0025d538(struct Moby *, void *) __asm__("FUN_L00_0025d538"); -extern void FUN_L00_0025d808(f32, void *, void *, void *, void *, s32) __asm__("FUN_L00_0025d808"); -extern void FUN_001f9a28(void *, void *, void *) __asm__("FUN_001f9a28"); -extern void FUN_L00_00259fe8(struct Moby *, f32) __asm__("FUN_L00_00259fe8"); +extern void FUN_L00_0025d538(struct Moby *, void *); +extern void FUN_L00_0025d808(f32, void *, void *, void *, void *, s32); +extern void FUN_001f9a28(void *, void *, void *); +extern void FUN_L00_00259fe8(struct Moby *, f32); extern char D_L07_00211550[] __asm__("D_L07_00211550"); extern char D_L07_00211580[] __asm__("D_L07_00211580"); extern char D_L07_002115D0[] __asm__("D_L07_002115D0"); From 6aac0665e1ebf696b01d43dbaac9384ce5a9230e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mateusz=20K=C5=82ysz?= Date: Tue, 13 Oct 2026 12:58:43 +0000 Subject: [PATCH 04/12] overlay: port FUN_L00_002c6158 from rac1-decomp --- .../shared/gameplay/entities/002bffa8.c | 317 +++++++++++++++++- 1 file changed, 316 insertions(+), 1 deletion(-) diff --git a/src/overlays/shared/gameplay/entities/002bffa8.c b/src/overlays/shared/gameplay/entities/002bffa8.c index 3be212798..67f7a723f 100644 --- a/src/overlays/shared/gameplay/entities/002bffa8.c +++ b/src/overlays/shared/gameplay/entities/002bffa8.c @@ -1936,7 +1936,322 @@ void FUN_L00_002c53c0(struct Moby *m) { } } #ifndef NON_MATCHING -INCLUDE_ASM("config/us/overlays/asm/FUN_L00_002c6158.s", FUN_L00_002c6158); +#include "rnc/input/pad_state.h" +#include "rnc/math/vector.h" +#include "rnc/gameplay/hero.h" +#include "rnc/gameplay/entities/moby.h" + + + +#include "qcopy.h" + +/* Swingshot (class 208) update: keeps the hook at the glove, shows the targets, fires the hook to the swing target + or the grind target, swings the hero, and reels the hook back. */ +/* Ported from rac1-decomp (src/overlays/shared/vendor_002C12B0.c: func_L00_002C74B8), where it is exact; names translated to the US level program. */ + + +typedef struct Moby Moby; + + +typedef int OvlQuad_6158 __attribute__((mode(TI))); + +typedef unsigned int Q_2C74B8 __attribute__((mode(TI))); + +typedef union { struct { float x, y, z, w; } f; Q_2C74B8 q; } V_2C74B8 __attribute__((aligned(16))); + +typedef struct { V_2C74B8 row[3]; } M3_2C74B8; + +typedef struct HookData_2C74B8 { char pad0[4]; float speed; } HookData_2C74B8; + +typedef struct Data_2C74B8 { + char pad0[0x14]; + Moby *hook; + float spin; + float scale; + float size; +} Data_2C74B8; + +extern char D_0013F350[]; +extern f32 distance_xyz(void *, void *) __asm__("func_001F9B48"); +extern f32 vector_length_xyz(void *) __asm__("FUN_001f9af0"); +extern float D_0015ED60; +extern float D_0015ED6C; +extern int D_0013C940; /* no foreign declaration */ +extern int FUN_001efa68(void *,void *,int,int,int); +extern int FUN_L00_00205000(); +extern int FUN_L00_002223f8(); +extern int FUN_L00_002323b8(); +extern int scale_game_frames_alt(int) __asm__("FUN_001f96f8"); +extern s32 allocate_voice_for_target_entry() __asm__("func_0022DA68"); +extern void FUN_L00_0024f7c8(void *, int, void *); +extern void add_vector_xyz(void *, void *, void *) __asm__("FUN_001f9a10"); +extern void enqueue_callback_list_1(void *, void *) __asm__("FUN_001f4600"); +extern void normalize_vector_xyz(void *, void *, f32) __asm__("FUN_001f9bf8"); +extern void subtract_vector_xyz(void *, void *, void *) __asm__("FUN_001f9a28"); +unsigned char *FUN_L00_002c6f88(unsigned char *src, float f); +void FUN_L00_001edf60(int a, int b, void *pos, int kind, int mode, float x, float y, float z); +extern int func_L00_00222B80_2C74B8(int, int) __asm__("FUN_L00_002223f8"); +extern Moby *func_L00_002C82E8_2C74B8(void *, float) __asm__("FUN_L00_002c6f88"); +extern void func_L00_001EE2E0_2C74B8(int, int, float, void *, int, float, int, float, int) __asm__("FUN_L00_001edf60"); +extern int func_001F9850_2C74B8(int) __asm__("FUN_001f96f8"); +extern void func_00213DE0_2C74B8(void *, int, int, int) __asm__("FUN_00212f90"); +extern void func_L00_00250800_2C74B8(void *, int, void *) __asm__("FUN_L00_0024f7c8"); +extern int func_0022ED80_2C74B8(int, int, void *) __asm__("FUN_0022da68"); +extern float func_001F9D10_2C74B8(void *, void *) __asm__("FUN_001f9b48"); +extern void func_001F49B0_2C74B8(void (*)(char *), void *) __asm__("FUN_001f4600"); +extern void func_001F9BF0_2C74B8(void *, void *, void *) __asm__("FUN_001f9a28"); +extern void func_L00_001FF4B0_2C74B8(void *, void *, float) __asm__("FUN_001f9bf8"); +extern void func_001F9BD8_2C74B8(void *, void *, void *) __asm__("FUN_001f9a10"); +extern float func_001F9CB8_2C74B8(void *) __asm__("FUN_001f9af0"); +extern int func_L00_001EFFF0_2C74B8(void *, void *, int, int, int) __asm__("FUN_001efa68"); +extern int func_L00_00205618_2C74B8(int) __asm__("FUN_L00_00205000"); +extern void func_L00_00232C10_2C74B8(int, int, float) __asm__("FUN_L00_002323b8"); +extern void func_L00_002C7128_2C74B8(char *) __asm__("FUN_L00_002c5dc8"); + +void FUN_L00_002c6158(Moby *m) { + V_2C74B8 v0; + V_2C74B8 v10; + Data_2C74B8 *d; + HookData_2C74B8 *hd; + float speed; + int n; + + if (m == 0) return; + if (hero.state.current == 1) func_L00_00222B80_2C74B8(30, 1); + d = (void *)m->pvars; + if (d == 0) return; + hd = 0; + if (!d->hook) d->hook = func_L00_002C82E8_2C74B8(m, frame_time * 24.0f); + if (d->hook) hd = (void *)d->hook->pvars; + if ((hero.state.current == 1 || hero.state.current == 30) && + hero.state_timer >= 2) { + func_L00_001EE2E0_2C74B8((int)m, 0xFF0000FF, 1.0f, 0, 0x24, 0.0f, -1, 90.0f, 4); + if (hero.unk968 && hero.unk964) + func_L00_001EE2E0_2C74B8((int)m, 0xFF00FF00, 0.5f, &hero.unk964->pos, 0x24, 0.0f, -1, 90.0f, 4); + else if (hero.unk990) + func_L00_001EE2E0_2C74B8((int)m, 0xFF00FF00, 0.5f, &hero.unk990->pos, 0x24, 0.0f, -1, 90.0f, 4); + } + switch (m->state) { + case 0: + case 1: + if (m->anim_flags & 2) { + if (m->prev_seq != 1) func_00213DE0_2C74B8(m, 1, 0, func_001F9850_2C74B8(10)); + m->state = 1; + } + if (d->hook) { + func_L00_00250800_2C74B8(m, 0, &d->hook->pos); + { + Moby *h = d->hook; + *(u128 *)&h->rot_row0 = *(u128 *)&m->rot_row0; + *(u128 *)&h->rot_row1 = *(u128 *)&m->rot_row1; + *(u128 *)&h->rot_row2 = *(u128 *)&m->rot_row2; + } + } + if (hero.state.current == 0x24 || + (hero.state.control_mode == 0xF && hero.unk5B4)) { + if (hd) { + d->size = 0.280000001f; + d->scale = 1.0f; + d->spin = 0.0f; + hd->speed = frame_time * 24.0f; + if (m->prev_seq != 3) func_00213DE0_2C74B8(m, 3, 0, func_001F9850_2C74B8(10)); + func_0022ED80_2C74B8(0, 0, m); + m->state = 2; + } + } + if (hero.state.current == 0x2C && hd) { + speed = func_001F9D10_2C74B8(&hero.unk994->pos, &d->hook->pos); + n = func_001F9850_2C74B8(7); + if (hero.items[0].unk20 < func_001F9850_2C74B8(30)) n = func_001F9850_2C74B8(5); + hd->speed = speed / (float)n; + d->size = 0.280000001f; + d->scale = 1.0f; + d->spin = 0.0f; + if (m->prev_seq != 3) func_00213DE0_2C74B8(m, 3, 0, func_001F9850_2C74B8(10)); + func_0022ED80_2C74B8(0, 0, m); + m->state = 9; + } + break; + case 2: + func_001F49B0_2C74B8(func_L00_002C7128_2C74B8, m); + if (m->anim_flags & 2) { + if (m->prev_seq != 4) func_00213DE0_2C74B8(m, 4, 0, func_001F9850_2C74B8(10)); + } + func_001F9BF0_2C74B8(&v0, &hero.unk964->pos, &d->hook->pos); + speed = hd->speed; + if (hero.state.control_mode == 0xF) { + speed = speed + hero.unk574; + } else if (hero.state.prev_control_mode == 4 || hero.state.prev_control_mode == 2) { + if (2.0f < hero.ground_distance) speed = frame_time * 48.0f; + } + qcopy(&v10, &hero.motion.pos); + v10.f.z += 0.5f; + if (func_L00_001EFFF0_2C74B8(&v10, &hero.unk964->pos, 2, 0, 0)) { + if (0.5f < hero.ground_distance) { + func_L00_00222B80_2C74B8(6, 1); + } else { + func_L00_00222B80_2C74B8(0, 0); + func_L00_00232C10_2C74B8(func_L00_00205618_2C74B8(0), 0, (float)func_001F9850_2C74B8(14)); + } + m->state = 6; + } else if (speed < func_001F9D10_2C74B8(&d->hook->pos, &hero.unk964->pos)) { + func_L00_001FF4B0_2C74B8(&v0, &v0, speed); + func_001F9BD8_2C74B8(&d->hook->pos, &d->hook->pos, &v0); + } else { + qcopy(&d->hook->pos, &hero.unk964->pos); + m->state = 3; + } + break; + case 3: + func_0022ED80_2C74B8(1, 0, m); + func_001F49B0_2C74B8(func_L00_002C7128_2C74B8, m); + qcopy(&d->hook->pos, &hero.unk964->pos); + m->state = 4; + break; + case 4: + func_L00_00250800_2C74B8(m, 0, &v0); + qcopy(&v0, &hero.motion.pos); + v0.f.z += 0.5f; + if (func_L00_001EFFF0_2C74B8(&v0, &hero.unk964->pos, 2, 0, 0)) { + if (hero.air_frames.s) func_L00_00222B80_2C74B8(6, 1); + else func_L00_00222B80_2C74B8(0, 1); + m->state = 6; + break; + } + if (m->anim_flags & 2) { + if (m->prev_seq != 4) func_00213DE0_2C74B8(m, 4, 0, func_001F9850_2C74B8(10)); + } + func_001F49B0_2C74B8(func_L00_002C7128_2C74B8, m); + d->spin = d->spin + 0.69813168f; + d->size = d->size * (frame_scale * -0.100000024f + 1.0f); + if (d->size < 0.168000013f) { + hero.unk5B4 = 0; + if (d->hook && 3.5f < func_001F9D10_2C74B8(&d->hook->pos, &hero.motion.pos)) { + if (!(controller_state.held & hero.items[0].button_mask)) { + hero.unk988 = 1; + func_L00_00222B80_2C74B8(0, 0); + func_L00_00232C10_2C74B8(func_L00_00205618_2C74B8(0), 0, (float)func_001F9850_2C74B8(14)); + m->state = 6; + } else { + func_0022ED80_2C74B8(2, 0, m); + if (hero.unk978) func_L00_00222B80_2C74B8(0x26, 1); + else func_L00_00222B80_2C74B8(0x25, 1); + m->state = 5; + } + } else { + func_L00_00222B80_2C74B8(0, 1); + m->state = 6; + } + } + break; + case 5: + qcopy(&d->hook->pos, &hero.unk964->pos); + if (m->anim_flags & 2) { + if (m->prev_seq != 4) func_00213DE0_2C74B8(m, 4, 0, func_001F9850_2C74B8(10)); + } + d->size = d->size * (frame_scale * -0.100000024f + 1.0f); + d->spin = d->spin + 0.69813168f; + func_001F49B0_2C74B8(func_L00_002C7128_2C74B8, m); + if ((unsigned int)(hero.state.current - 0x25) >= 2) m->state = 6; + break; + case 6: + func_001F49B0_2C74B8(func_L00_002C7128_2C74B8, m); + hd->speed = frame_time * 80.0f; + m->state = 7; + break; + case 7: + func_L00_00250800_2C74B8(m, 0, &v10); + func_001F9BF0_2C74B8(&v0, &v10, &d->hook->pos); + if (hd->speed < func_001F9D10_2C74B8(&d->hook->pos, &v10)) { + func_L00_001FF4B0_2C74B8(&v0, &v0, hd->speed); + func_001F9BD8_2C74B8(&d->hook->pos, &d->hook->pos, &v0); + func_001F49B0_2C74B8(func_L00_002C7128_2C74B8, m); + } else { + qcopy(&d->hook->pos, &v10); + if (m->prev_seq != 1) func_00213DE0_2C74B8(m, 1, 0, func_001F9850_2C74B8(10)); + m->state = 1; + } + break; + case 8: + break; + case 9: + func_001F49B0_2C74B8(func_L00_002C7128_2C74B8, m); + if (m->anim_flags & 2) { + if (m->prev_seq != 4) func_00213DE0_2C74B8(m, 4, 0, func_001F9850_2C74B8(10)); + } + func_001F9BF0_2C74B8(&v0, &hero.unk994->pos, &d->hook->pos); + if (hd->speed < func_001F9CB8_2C74B8(&v0)) { + func_L00_001FF4B0_2C74B8(&v0, &v0, hd->speed); + func_001F9BD8_2C74B8(&d->hook->pos, &d->hook->pos, &v0); + } else { + qcopy(&d->hook->pos, &hero.unk994->pos); + m->state = 11; + func_0022ED80_2C74B8(1, 0, m); + } + break; + case 10: + func_001F49B0_2C74B8(func_L00_002C7128_2C74B8, m); + m->state = 11; + break; + case 11: + if (m->anim_flags & 2) { + if (m->prev_seq != 4) func_00213DE0_2C74B8(m, 4, 0, func_001F9850_2C74B8(10)); + } + func_001F49B0_2C74B8(func_L00_002C7128_2C74B8, m); + d->spin = d->spin + 0.69813168f; + d->size = d->size * (frame_scale * -0.600000024f + 1.0f); + if (d->size < 0.168000013f) { + hero.unk99C = 1; + m->state = 12; + } + break; + case 12: + if (hero.unk994) + qcopy(&d->hook->pos, &hero.unk994->pos); + if (m->anim_flags & 2) { + if (m->prev_seq != 4) func_00213DE0_2C74B8(m, 4, 0, func_001F9850_2C74B8(10)); + } + d->size = d->size * (frame_scale * -0.600000024f + 1.0f); + d->spin = d->spin + 0.69813168f; + func_001F49B0_2C74B8(func_L00_002C7128_2C74B8, m); + if (hero.state.current != 0x2C) m->state = 13; + break; + case 13: + if (m->anim_flags & 2) { + if (m->prev_seq != 4) func_00213DE0_2C74B8(m, 4, 0, func_001F9850_2C74B8(10)); + } + func_001F49B0_2C74B8(func_L00_002C7128_2C74B8, m); + hd->speed = frame_time * 80.0f; + m->state = 14; + break; + case 14: + if (m->anim_flags & 2) { + if (m->prev_seq != 4) func_00213DE0_2C74B8(m, 4, 0, func_001F9850_2C74B8(10)); + } + func_L00_00250800_2C74B8(m, 0, &v10); + func_001F9BF0_2C74B8(&v0, &v10, &d->hook->pos); + if (hd->speed < func_001F9D10_2C74B8(&d->hook->pos, &v10)) { + func_L00_001FF4B0_2C74B8(&v0, &v0, hd->speed); + func_001F9BD8_2C74B8(&d->hook->pos, &d->hook->pos, &v0); + func_001F49B0_2C74B8(func_L00_002C7128_2C74B8, m); + } else { + qcopy(&d->hook->pos, &v10); + if (m->prev_seq != 1) func_00213DE0_2C74B8(m, 1, 0, func_001F9850_2C74B8(10)); + m->state = 1; + } + if (hero.state.current == 0x2C && hd) { + hd->speed = func_001F9D10_2C74B8(&hero.unk994->pos, &d->hook->pos) / 10.0f; + d->scale = 1.0f; + d->size = 0.0f; + d->spin = 0.0f; + if (m->prev_seq != 3) func_00213DE0_2C74B8(m, 3, 0, func_001F9850_2C74B8(10)); + m->state = 9; + } + break; + case 15: + break; + } +} #else extern s32 D_001413D4_2c6158 __asm__("D_001413D4"); extern s32 D_001413DC_2c6158 __asm__("D_001413DC"); From d669cf8877e15ad8d868e9a01f9f3f583f90fca8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mateusz=20K=C5=82ysz?= Date: Tue, 13 Oct 2026 13:09:26 +0000 Subject: [PATCH 05/12] overlay: port FUN_L00_002b87e0 from rac1-decomp --- include/rnc/gameplay/hero.h | 3 +- .../shared/gameplay/entities/002b2100.c | 371 +++++++++++++++++- 2 files changed, 370 insertions(+), 4 deletions(-) diff --git a/include/rnc/gameplay/hero.h b/include/rnc/gameplay/hero.h index 288b1f8bc..cae289960 100644 --- a/include/rnc/gameplay/hero.h +++ b/include/rnc/gameplay/hero.h @@ -758,7 +758,8 @@ struct Hero { u8 unk20B2; /* 0x20B2 */ u8 unk20B3; /* 0x20B3 */ u8 unk20B4; /* 0x20B4 */ - u8 pad_20B5[0x3]; + u8 unk20B5; /* 0x20B5 */ + u8 pad_20B6[0x2]; s32 pending_item[7]; /* 0x20B8: per slot: item to switch to */ s32 selected_item[7]; /* 0x20D4: per slot: item after a switch */ s32 saved_item[7]; /* 0x20F0: per slot: item kept while another is forced in */ diff --git a/src/overlays/shared/gameplay/entities/002b2100.c b/src/overlays/shared/gameplay/entities/002b2100.c index de2ab24e3..233d4170c 100644 --- a/src/overlays/shared/gameplay/entities/002b2100.c +++ b/src/overlays/shared/gameplay/entities/002b2100.c @@ -1873,7 +1873,7 @@ typedef struct { u32 flags; } Ring; -extern s32 FUN_L00_0028d8c0(Moby *, s32); +extern s32 FUN_L00_0028d8c0_u(Moby *, s32) __asm__("FUN_L00_0028d8c0"); extern s32 FUN_L00_00257b90_c(s32, s32) __asm__("FUN_L00_00257b90"); extern s32 FUN_001f96f8_c(s32) __asm__("FUN_001f96f8"); extern void blend_moby_animation(Moby *, s32, s32, s32) __asm__("FUN_00212f90"); @@ -2038,7 +2038,7 @@ void FUN_L00_002b6f10(Moby *m) { } else { o->cnt18 = 0; } - if (FUN_L00_0028d8c0(m, o->anim) == 0) { + if (FUN_L00_0028d8c0_u(m, o->anim) == 0) { b = D_0013C940[0x1A4 / 4] & hero.items[0].button_mask; if ((b != 0 || ((D_0013C940[0x1A0 / 4] & hero.items[0].button_mask) != 0 && o->retry >= 0x11)) && hero.unk20AC == 0) { @@ -2731,7 +2731,372 @@ void FUN_L00_002b8798(ListSlots8 *list, s32 val) { i++; } } -INCLUDE_ASM("config/us/overlays/asm/FUN_L00_002b87e0.s", FUN_L00_002b87e0); +#include "rnc/input/pad_state.h" + + + +#include "qcopy.h" + +#include "qzero.h" + +/* Tesla claw (class 177) update: tracks up to two targets while fire is held, extends the claw tip, runs its + firing states and statistics, and moves its light. */ +/* Ported from rac1-decomp (src/overlays/shared/vendor_002B33E8.c: func_L00_002B9AD8), where it is exact; names translated to the US level program. */ + + + + +typedef struct { u8 p0[0x2084]; s32 i2084; } G_B4F40; + +typedef unsigned int Q_2B9AD8 __attribute__((mode(TI))); + +typedef union { struct { float x, y, z, w; } f; Q_2B9AD8 q; } V_2B9AD8 __attribute__((aligned(16))); + +typedef struct Data_2B9AD8 { + V_2B9AD8 pos; + V_2B9AD8 tip; + struct Moby *target; + float reach; + short hold; + short hold2; + int timer; + int light; + int glow; + struct Moby *target2; + short tick; + short f3E; + short lock; + short lock2; + short f44; + short f46; + int sound; +} Data_2B9AD8; + +typedef struct Stats_2B9AD8 { char pad0[0x98]; unsigned short uses; unsigned short longest; int levels; } Stats_2B9AD8; + +typedef struct Stats2_2B9AD8 { char pad0[0xD0]; unsigned short uses; unsigned short longest; int levels; } Stats2_2B9AD8; + +typedef struct Voice_2B9AD8 { char pad0[4]; unsigned char active; char pad5[0x13]; struct Moby *owner; char pad1C[0x54]; } Voice_2B9AD8; + +typedef struct Aim_2B9AD8 { char pad0[4]; short kind; } Aim_2B9AD8; + +typedef struct Light_2B9AD8 { float x, y, z, b; V_2B9AD8 pos; } Light_2B9AD8; + +extern G_B4F40 D_0013F350; +extern char D_0013E533[]; +extern f32 convert_integer_to_float(s32) __asm__("func_001FA6C0"); +extern f32 distance_xyz(void *, void *) __asm__("func_001F9B48"); +extern float D_0015ED60; +extern float FUN_001f9e90(float, float); +extern float fast_difference_between_rotations(float, float) __asm__("func_001FA688"); +extern int D_00141918; /* no foreign declaration */ +extern int D_00141D70; /* no foreign declaration */ +extern int D_0015ED84; +extern int D_0015EEA4; +extern int FUN_001f9770(void *); +extern int FUN_L00_00233db8(int, int); +extern int FUN_L00_00233e98(); +extern int FUN_L00_002b94d0(); +extern int allocate_voice_for_target_entry_alt(int, int, int) __asm__("FUN_0022da68"); +extern void FUN_L00_002ba970(char *); +extern int scale_game_frames_alt(int) __asm__("FUN_001f96f8"); +extern int tick_countdown_32_alt(int *arg0) __asm__("FUN_001f9740"); +extern s32 FUN_L00_0028d8c0(struct Moby *, s32); +extern short D_L00_00161590; +extern u32 D_0013C940[]; +extern u8 D_0013E550[]; +extern unsigned char *FUN_002141f8(void *); +extern void FUN_L00_0024f7c8(void *, int, void *); +extern void add_vector_xyz(void *, void *, void *) __asm__("FUN_001f9a10"); +extern void enqueue_callback_list_1_alt(void (*)(void), void *) __asm__("FUN_001f4600"); +extern void normalize_vector_xyz(void *, void *, f32) __asm__("FUN_001f9bf8"); +extern void release_voice_slot(s32) __asm__("FUN_0022d798"); +extern void transform_vector_by_basis(void *, void *, void *) __asm__("func_001F9CF8"); +int FUN_L00_0023e5e0(u128 *v, float a, float b, int col); +void FUN_L00_00203908(int, int); +void FUN_L00_0020e4c8(void); +void FUN_L00_0020e698(void); +void FUN_L00_0023e838(int); +void FUN_L00_002b9310(char *moby); +extern unsigned char D_0014171B_2B33E8[] __asm__("D_0014161B"); +extern int D_0015EFA4_2B33E8 __asm__("D_0015EEA4"); +extern int D_0015EE84_2B33E8 __asm__("D_0015ED84"); +extern char D_0013CA40_2B5C98[] __asm__("D_0013C940"); +extern char D_0013F450_2B7430[] __asm__("D_0013F350"); +extern float D_0015EE60_2B7430 __asm__("D_0015ED60"); +extern Voice_2B9AD8 D_0013E650_2B9AD8[] __asm__("D_0013E550"); +extern unsigned char D_0013E633_2B9AD8[] __asm__("D_0013E533"); +extern unsigned short D_00141E70_2B9AD8[] __asm__("D_00141D70"); +extern unsigned short D_00141A18_2B9AD8[] __asm__("D_00141918"); +extern float D_L00_0017AEBC __attribute__((section(".data"))); +extern int D_L00_00161660_2B9AD8 __asm__("D_L00_00161590"); +extern char D_L00_001670D0_2B9AD8[] __asm__("D_L00_00166FD0"); +extern Light_2B9AD8 D_L00_001803C0_2B9AD8[] __asm__("D_L00_001802C0"); +extern int func_L00_00234718_2B9AD8(int) __asm__("FUN_L00_00233e98"); +extern void func_L00_00203F20_2B9AD8(int, int) __asm__("FUN_L00_00203908"); +extern int func_001F9938_2B9AD8(short *) __asm__("FUN_001f9770"); +extern int func_001F9908_2B9AD8(int *) __asm__("FUN_001f9740"); +extern int func_L00_00234638_2B9AD8(int, int) __asm__("FUN_L00_00233db8"); +extern int func_001F9850_2B9AD8(int) __asm__("FUN_001f96f8"); +extern int func_L00_0023EF78_2B9AD8(void *, float, float, int) __asm__("FUN_L00_0023e5e0"); +extern float func_L00_001FF860_2B9AD8(float, float) __asm__("FUN_001f9e90"); +extern float func_001FA850_2B9AD8(float, float) __asm__("FUN_001fa688"); +extern float func_001F9D10_2B9AD8(void *, void *) __asm__("FUN_001f9b48"); +extern Aim_2B9AD8 *func_L00_0025D390_2B9AD8(void *) __asm__("FUN_002141f8"); +extern float func_001FA888_2B9AD8(int) __asm__("FUN_001fa6c0"); +extern void func_001F9EC0_2B9AD8(void *, void *, void *) __asm__("FUN_001f9cf8"); +extern void func_001F9BD8_2B9AD8(void *, void *, void *) __asm__("FUN_001f9a10"); +extern void func_L00_00250800_2B9AD8(void *, int, void *) __asm__("FUN_L00_0024f7c8"); +extern void func_L00_001FF4B0_2B9AD8(void *, void *, float) __asm__("FUN_001f9bf8"); +extern void func_L00_002BA608_2B9AD8(void *) __asm__("FUN_L00_002b9310"); +extern void func_L00_002BA7C8_2B9AD8(void *) __asm__("FUN_L00_002b94d0"); +extern void func_001F49B0_2B9AD8(void (*)(void), void *) __asm__("FUN_001f4600"); +extern void func_L00_0028EBF0_2B9AD8(int) __asm__("FUN_0022d798"); +extern int func_L00_0028EB98_2B9AD8(void *, int) __asm__("FUN_L00_0028d8c0"); +extern int func_0022ED80_2B9AD8(int, int, void *) __asm__("FUN_0022da68"); +extern void func_L00_0020EB60_2B9AD8(void) __asm__("FUN_L00_0020e4c8"); +extern void func_L00_0020ED30_2B9AD8(void) __asm__("FUN_L00_0020e698"); +extern void func_L00_0023F1D0_2B9AD8(int) __asm__("FUN_L00_0023e838"); + +void FUN_L00_002b87e0(struct Moby *m) { + V_2B9AD8 t; + Data_2B9AD8 *s = (Data_2B9AD8 *)m->pvars; + int active; + int done = ((struct Hero *)D_0013F450_2B7430)->items[0].state == 3; + int ready; + struct Hero *h; + + if ((controller_state.pressed & ((struct Hero *)D_0013F450_2B7430)->items[0].button_mask) && + !((struct Hero *)D_0013F450_2B7430)->unk20AC) { + s->reach = 0.8f; + } + D_L00_0017AEBC = 0.9f; + active = 0; + ready = func_L00_00234718_2B9AD8(-1); + if (D_00141E70_2B9AD8[0] == 0 && D_00141A18_2B9AD8[0] == 0 && + ((struct Hero *)D_0013F450_2B7430)->unk20B5 >= 3) { + if ((unsigned int)((struct Hero *)D_0013F450_2B7430)->state.control_mode < 2 || ((struct Hero *)D_0013F450_2B7430)->state.control_mode == 9) + func_L00_00203F20_2B9AD8(0x4E30, 0x81); + } + if ((controller_state.held & ((struct Hero *)D_0013F450_2B7430)->items[0].button_mask) && m->state != 4 && + m->state != 0 && !((struct Hero *)D_0013F450_2B7430)->unk20AC && ((struct Hero *)D_0013F450_2B7430)->state.current != 0x72) { + if (s->timer == 0) { + if (ready > 0) { + if (func_001F9938_2B9AD8(&s->tick)) { + func_001F9938_2B9AD8(&s->f44); + func_001F9938_2B9AD8(&s->f46); + func_L00_00234638_2B9AD8(-1, 1); + s->tick = func_001F9850_2B9AD8(10); + } + if (s->light == -1) { + s->light = func_L00_0023EF78_2B9AD8(&m->pos, 7.5f, 0.0f, 0); + } else if (s->glow < func_001F9850_2B9AD8(10)) { + s->glow++; + } + active = 1; + if (s->target) { + if (2.0943f < func_001FA850_2B9AD8(((struct Hero *)D_0013F450_2B7430)->motion.rot.f[2], + func_L00_001FF860_2B9AD8(s->target->pos.x - ((struct Hero *)D_0013F450_2B7430)->motion.pos.f[0], + s->target->pos.y - ((struct Hero *)D_0013F450_2B7430)->motion.pos.f[1])) || + !s->target->visible || + 20.0f < func_001F9D10_2B9AD8(&s->target->pos, &((struct Hero *)D_0013F450_2B7430)->motion.pos)) { + s->target = 0; + s->lock = 0; + } + } + if (s->target2) { + if (2.0943f < func_001FA850_2B9AD8(((struct Hero *)D_0013F450_2B7430)->motion.rot.f[2], + func_L00_001FF860_2B9AD8(s->target2->pos.x - ((struct Hero *)D_0013F450_2B7430)->motion.pos.f[0], + s->target2->pos.y - ((struct Hero *)D_0013F450_2B7430)->motion.pos.f[1])) || + !s->target2->visible || + 20.0f < func_001F9D10_2B9AD8(&s->target2->pos, &((struct Hero *)D_0013F450_2B7430)->motion.pos)) { + s->target2 = 0; + s->lock2 = 0; + } + } + qcopy(&s->pos, &m->pos); + s->pos.f.z += 0.7f; + qcopy(&s->tip, &s->pos); + if (s->target && s->lock) { + int lim = 50; + Aim_2B9AD8 *a; + short n; + s->hold++; + a = func_L00_0025D390_2B9AD8(s->target); + if (a && a->kind == 1) lim = 5; + n = s->hold; + if (!(n < func_001F9850_2B9AD8(lim))) { + s->target = 0; + s->lock = 0; + } + } else { + s->hold = 0; + } + if (s->target2 && s->lock2) { + int lim = 50; + Aim_2B9AD8 *a; + short n; + s->hold2++; + a = func_L00_0025D390_2B9AD8(s->target2); + if (a && a->kind == 1) lim = 5; + n = s->hold2; + if (!(n < func_001F9850_2B9AD8(lim))) { + s->target2 = 0; + s->lock2 = 0; + } + } else { + s->hold2 = 0; + } + s->reach += (func_001FA888_2B9AD8(D_0013E633_2B9AD8[0]) * 6.0f + 12.0f - s->reach) * (D_0015EE60_2B7430 * 0.07f); + if (((struct Hero *)D_0013F450_2B7430)->state.current == 1) { + t.f.x = 1.2f; + t.f.y = 0.0f; + t.f.z = 0.0f; + func_001F9EC0_2B9AD8(&t, &t, D_L00_001670D0_2B9AD8); + s->pos.f.z = t.f.z + m->pos.z; + s->pos.f.x = t.f.x + ((struct Hero *)D_0013F450_2B7430)->motion.pos.f[0]; + s->pos.f.y = t.f.y + ((struct Hero *)D_0013F450_2B7430)->motion.pos.f[1]; + t.f.x = s->reach; + t.f.y = 0.0f; + t.f.z = 0.0f; + func_001F9EC0_2B9AD8(&t, &t, D_L00_001670D0_2B9AD8); + func_001F9BD8_2B9AD8(&s->tip, &s->pos, &t); + } else if (((struct Hero *)D_0013F450_2B7430)->unk22C8 == 1) { + func_L00_00250800_2B9AD8(m, 0, &s->pos); + t.f.x = 0.0f; + t.f.y = -s->reach; + t.f.z = 0.0f; + func_001F9EC0_2B9AD8(&t, &t, &m->rot_row0); + func_001F9BD8_2B9AD8(&s->tip, &s->pos, &t); + } else { + func_L00_00250800_2B9AD8(m, 0, &s->pos); + func_L00_001FF4B0_2B9AD8(&s->tip, D_0013F450_2B7430 + 0x640, s->reach); + func_001F9BD8_2B9AD8(&s->tip, &s->pos, &s->tip); + } + func_L00_002BA608_2B9AD8(m); + func_L00_002BA7C8_2B9AD8(m); + func_001F49B0_2B9AD8(FUN_L00_002ba970, m); + } else { + s->target = 0; + s->target2 = 0; + s->lock = 0; + s->lock2 = 0; + s->f44 = 0; + s->f46 = 0; + } + } + } else { + s->target = 0; + s->target2 = 0; + s->lock = 0; + s->lock2 = 0; + } + if (!active) { + D_L00_00161660_2B9AD8 = 1; + if (s->glow > 0) s->glow--; + if (s->sound != -1) { + Voice_2B9AD8 *v = &D_0013E650_2B9AD8[s->sound]; + if (v[1].owner == m && v[1].active) func_L00_0028EBF0_2B9AD8(s->sound); + } + s->sound = -1; + } else if (!func_L00_0028EB98_2B9AD8(m, s->sound)) { + s->sound = func_0022ED80_2B9AD8(4, 4, m); + } + if (!s->target || s->target->state == 0xFE || s->target->state == 0xFD || !(s->target->flags & 0x1000)) s->lock = 1; + if (!s->target2 || s->target2->state == 0xFE || s->target2->state == 0xFD || !(s->target2->flags & 0x1000)) s->lock2 = 1; + switch (m->state) { + case 0: + s->timer = func_001F9850_2B9AD8(16); + s->light = func_L00_0023EF78_2B9AD8(&s->pos, 0.0f, 0.0f, 0); + D_L00_00161660_2B9AD8 = 1; + m->state = 1; + s->f3E = 20; + s->sound = -1; + s->target2 = 0; + s->target = 0; + s->lock = 0; + s->lock2 = 0; + s->f46 = 0; + s->f44 = 0; + break; + case 1: + func_001F9908_2B9AD8(&s->timer); + if (active) { + func_L00_0020EB60_2B9AD8(); + m->state = 3; + } + if ((controller_state.pressed & (h = (struct Hero *)D_0013F450_2B7430)->items[0].button_mask) && !h->unk20AC) { + if (active) { + Stats_2B9AD8 *st = (Stats_2B9AD8 *)(D_0014171B_2B33E8 + 0x65); + if (st->uses < 65535) st->uses++; + if (func_001F9850_2B9AD8(D_0015EFA4_2B33E8) / 600 > st->longest) + st->longest = func_001F9850_2B9AD8(D_0015EFA4_2B33E8) / 600; + st->levels = (st->levels | (1 << D_0015EE84_2B33E8)) | 0x80000000; + func_L00_0020EB60_2B9AD8(); + m->state = 3; + } else { + s->target = 0; + s->target2 = 0; + s->lock = 0; + s->lock2 = 0; + m->state = 1; + func_0022ED80_2B9AD8(0, 0, m); + func_L00_0020ED30_2B9AD8(); + } + } + break; + case 2: + break; + case 3: + if ((controller_state.released & ((struct Hero *)D_0013F450_2B7430)->items[0].button_mask) || !active || + ((struct Hero *)D_0013F450_2B7430)->unk20AC) { + h = (struct Hero *)D_0013F450_2B7430; + if (func_001F9850_2B9AD8(70) < h->unk1BC) { + if (((Stats2_2B9AD8 *)(D_0014171B_2B33E8 + 0x22D))->uses < 65535) ((Stats2_2B9AD8 *)(D_0014171B_2B33E8 + 0x22D))->uses++; + } + if (func_001F9850_2B9AD8(D_0015EFA4_2B33E8) / 600 > ((Stats2_2B9AD8 *)(D_0014171B_2B33E8 + 0x22D))->longest) + ((Stats2_2B9AD8 *)(D_0014171B_2B33E8 + 0x22D))->longest = func_001F9850_2B9AD8(D_0015EFA4_2B33E8) / 600; + ((Stats2_2B9AD8 *)(D_0014171B_2B33E8 + 0x22D))->levels = (((Stats2_2B9AD8 *)(D_0014171B_2B33E8 + 0x22D))->levels | (1 << D_0015EE84_2B33E8)) | 0x80000000; + if (((struct Hero *)D_0013F450_2B7430)->unk1BC < func_001F9850_2B9AD8(30)) + ((struct Hero *)D_0013F450_2B7430)->unk20B5++; + else + ((struct Hero *)D_0013F450_2B7430)->unk20B5 = 0; + s->target = 0; + s->target2 = 0; + s->lock = 0; + s->lock2 = 0; + s->reach = 0.0f; + func_L00_0020ED30_2B9AD8(); + m->state = 1; + } + break; + case 4: + break; + case 5: + break; + } + if (s->light != -1) { + float k; + qzero(&t); + t.f.x = 2.0f; + t.f.z = 2.0f; + func_001F9EC0_2B9AD8(&t, &t, D_0013F450_2B7430 + 0x640); + D_L00_001803C0_2B9AD8[s->light].pos.f.x = ((struct Hero *)D_0013F450_2B7430)->motion.pos.f[0] + t.f.x; + D_L00_001803C0_2B9AD8[s->light].pos.f.y = ((struct Hero *)D_0013F450_2B7430)->motion.pos.f[1] + t.f.y; + D_L00_001803C0_2B9AD8[s->light].pos.f.z = ((struct Hero *)D_0013F450_2B7430)->motion.pos.f[2] + t.f.z; + D_L00_001803C0_2B9AD8[s->light].pos.f.w = 7.5f; + k = func_001FA888_2B9AD8(s->glow) / (float)func_001F9850_2B9AD8(10); + D_L00_001803C0_2B9AD8[s->light].z = k; + k = k * 0.7f; + D_L00_001803C0_2B9AD8[s->light].y = k; + D_L00_001803C0_2B9AD8[s->light].x = D_L00_001803C0_2B9AD8[s->light].y; + if (done && s->light != -1) { + func_L00_0023F1D0_2B9AD8(s->light); + s->light = -1; + } + } + if (done && s->light == -1) m->state = 4; +} typedef struct { float f[4]; From db7c1ae19d64b0a8bbde28327958cf998148d613 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mateusz=20K=C5=82ysz?= Date: Tue, 13 Oct 2026 13:30:20 +0000 Subject: [PATCH 06/12] overlay: port FUN_L00_002b03a0 from rac1-decomp --- .../shared/gameplay/entities/002aa670.c | 795 ++++++++++-------- 1 file changed, 446 insertions(+), 349 deletions(-) diff --git a/src/overlays/shared/gameplay/entities/002aa670.c b/src/overlays/shared/gameplay/entities/002aa670.c index 95fa99080..728545dde 100644 --- a/src/overlays/shared/gameplay/entities/002aa670.c +++ b/src/overlays/shared/gameplay/entities/002aa670.c @@ -2496,381 +2496,478 @@ void FUN_L00_002affa8(char *self, O *out, char *skip) { o = active_mobies[i]; } } -#ifndef NON_MATCHING -INCLUDE_ASM("config/us/overlays/asm/FUN_L00_002b03a0.s", FUN_L00_002b03a0); -#else -typedef struct { unsigned int color[6]; } ProjectileColors; +/* Ported from rac1-decomp (src/overlays/shared/vendor_002AB910.c: func_L00_002B1688), where it is exact; names translated to the US level program. */ + +typedef u32 VQ1688 __attribute__((mode(TI), aligned(16))); + typedef union { - struct { U910 distance, velocity, target_sample, intercept; } vectors; - Qry910 query; -} ProjectileScratch; -extern B910 D_L00_001E9950; -extern B910 D_L00_001E99A0; -extern ProjectileColors D_L00_001E99F0; -extern ProjectileColors D_L00_001E9A08; -extern float D_0015F5D0 __asm__("D_L00_0015F5D0"); -extern float D_0015F5D4 __asm__("D_L00_0015F5D4"); -extern U910 D_L00_00160660, D_L00_00160680; -extern unsigned char *D_L00_001B20DC; -/* Retail adds into the second argument and ignores the destination. */ -extern void FUN_L00_001ff290(void *, void *, void *); -extern void FUN_L00_001ff2c0(void *, void *, void *); -extern float FUN_L00_001ff430(void *); -extern void FUN_L00_001ffd48(void *, void *, float); -extern void FUN_L00_001ffe20(void *, void *, void *); -extern float spring_turn(float *, float, float, float, float, float) __asm__("FUN_L00_00258110"); -extern void FUN_001f9fc8(void *); -extern void FUN_001f9d20(void *, void *, void *); -extern void FUN_001f9cf8(void *, void *, void *); -extern void FUN_L00_0026a4c8(void *, void *, int, int, int, float); -extern void build_look_at_matrix(void *, void *, void *, float) __asm__("FUN_00214890"); -extern unsigned char *FUN_L00_002712b8(void *, void *, int, int, int, int, float, float, float, float, float) __asm__("FUN_L00_002712b8"); -extern void spawn_burst(void *, void *, int, int, int, int, float) __asm__("FUN_L00_0026cbb0"); -extern float vector_length_xy(void *) __asm__("FUN_001f9b20"); + VQ1688 q; + f32 f[4]; + s32 i[4]; +} V1688; -void FUN_L00_002b03a0(unsigned char *m) { - B910 a = D_L00_001E9950; - B910 b = D_L00_001E99A0; - U910 camera_distance, previous, recoil, up, random, offset, target_position, target_motion; - ProjectileScratch scratch; - U910 matrix[4], matrix_squared[4], product[4], scaled[4], rotation[4]; - O *v; - char *target; - void * volatile hit_owner = 0; - void *pos = m + 0x10; - volatile int i, count; - volatile int reduced = 0; - int mode, j, low, high, life, color1, color2; - float ratio, factor, yaw, pitch, time, speed, coefficient, discriminant, root1, root2, angle, length, bias; +typedef int Q1688 __attribute__((mode(TI))); - up.q = 0; - up.f[2] = frame_time * 8.0f; - recoil.q = up.q; - up.q = 0; - up.f[2] = 1.0f; - v = *(O **)(m + 0x78); - target = v->owner; - if (0.9f < D_0015F5D0 || 0.9f < D_0015F5D4) - reduced = 1; - *(float *)&v->w20 += ((*(float *)&v->w34 - *(float *)&v->w20) / 10.0f) * frame_scale_sq; - FUN_001f9770((char *)v + 0x3C); - ratio = convert_integer_to_float(*(short *)((char *)v + 0x3C)); - ratio /= convert_integer_to_float(*(short *)((char *)v + 0x3E)); - add_vector_xyz(&scratch.vectors.distance, D_0013F490_2afc70, (char *)D_0013F490_2afc70 - 0x40); - target_motion.q = scratch.vectors.distance.q; - scale_vector_xyz(&target_motion, &target_motion, ratio); - factor = convert_integer_to_float(D_0013E520.bB) + 1.0f; - if (target != 0) { - low = scale_game_frames(300); - high = scale_game_frames(5); - if (v->w14 < low - high && *(signed char *)(target + 0x20) >= 0) { - time = 0.0f; - qcopy(&scratch.vectors.target_sample, target + 0x10); - scratch.vectors.target_sample.f[2] += v->f1C; - subtract_vector_xyz(&scratch.vectors.distance, &scratch.vectors.target_sample, pos); - if (v->w38 != 0) { - subtract_vector_xyz(&scratch.vectors.velocity, &scratch.vectors.target_sample, v); - FUN_L00_001ff2c0(&scratch.vectors.intercept, &scratch.vectors.velocity, &target_motion); - qcopy(v, &scratch.vectors.target_sample); - speed = FUN_L00_001ff430(&scratch.vectors.velocity); - length = *(float *)&v->w20; - speed = length * length - speed; - coefficient = (scratch.vectors.velocity.f[0] * scratch.vectors.distance.f[0] + scratch.vectors.velocity.f[1] * scratch.vectors.distance.f[1] + - scratch.vectors.velocity.f[2] * scratch.vectors.distance.f[2]) * -2.0f; - length = FUN_L00_001ff430(&scratch.vectors.distance); - discriminant = FUN_001f9988(coefficient * coefficient - speed * 4.0f * -length); - root1 = (-coefficient + discriminant) / (speed + speed); - root2 = (-coefficient - discriminant) / (speed + speed); - if (0.0f < root1 && 0.0f < root2) { - if (root2 < root1) time = root1; - else time = root2; - } else { - time = root1; - if (!(0.0f < root1)) { - time = -1.0f; - if (0.0f < root2) time = root2; - } - } - } - if (0.0f < time && time < (float)scale_game_frames(300)) { - scale_vector_xyz(&scratch.vectors.intercept, &scratch.vectors.velocity, time); - add_vector_xyz(&scratch.vectors.intercept, &scratch.vectors.intercept, &scratch.vectors.distance); - yaw = FUN_001f9e90(scratch.vectors.intercept.f[0], scratch.vectors.intercept.f[1]); - pitch = -FUN_001f9e90(vector_length_xy(&scratch.vectors.intercept), scratch.vectors.intercept.f[2]); +typedef struct { + V1688 previous_target; + M910 *owner; + int life; + M910 *target; + float target_height; + float speed; + float yaw_velocity; + float pitch_velocity; + float yaw; + float pitch; + float desired_speed; + int track_velocity; + short turn_time; + short turn_period; + int bounce_count; + int bounce_timer; + float limit; +} Missile1688; + +typedef struct { int colors[6]; } Colors1688; + +typedef union { + Qry910 collision; + struct { V1688 direction; V1688 relative; V1688 target; } vectors; +} MissilePhase1688; + +typedef struct { char pad0[0x100]; V1688 previous; char pad110[0x30]; V1688 current; } HeroMotion1688; + +typedef struct { char pad0[0x18]; M910 *moby; int kind; V1688 position; char pad30[0x10]; V1688 normal, velocity_end, velocity_start; } Impact1688; + +extern B910 D_L00_001E9950; +extern B910 D_L00_001E99A0; +extern Cam910 D_L00_00166C80; +extern Colors1688 D_L00_001E99F0; +extern Colors1688 D_L00_001E9A08; +extern E D_0013E520; +extern P D_0013F350; +extern V1688 D_L00_00160660 __attribute__((section(".sdata"))); +extern V1688 D_L00_00160680 __attribute__((section(".sdata"))); +extern char *FUN_L00_002af450(char *, char *, int, int, int); +extern char *FUN_L00_002d3838(char *a, char *b, int c, char *d); +extern f32 FUN_001f9b80(void *, void *); +extern f32 convert_integer_to_float(s32) __asm__("func_001FA6C0"); +extern f32 fast_cos(f32) __asm__("func_001F9DC8"); +extern f32 fast_sin(f32) __asm__("func_001F9DE0"); +extern f32 random_angle_radians(void) __asm__("func_00213308"); +extern f32 random_float_between(f32, f32) __asm__("func_002132A8"); +extern f32 square_root_scalar(f32) __asm__("func_001F9988"); +extern f32 vector_length_xy(void *) __asm__("FUN_001f9b20"); +extern f32 vector_length_xyz(void *) __asm__("FUN_001f9af0"); +extern float D_0015ED64; +extern float D_0015ED6C; +extern float D_0015ED70; +extern float D_L00_0015F5D0; +extern float D_L00_0015F5D4; +extern float FUN_001f9e90(float, float); +extern int *D_L00_00177F00[]; +extern int D_L00_0015F5CC; +extern int FUN_001efa68(void *, void *, int, int, int); +extern int FUN_001f9770(void *); +extern int FUN_001f9fc8(); +extern int FUN_L00_001f2868(void *, int, void *, void *, float); +extern int FUN_L00_001ff290(); +extern int FUN_L00_001ff2c0(); +extern int FUN_L00_001ff430(); +extern int FUN_L00_001ffd48(); +extern int FUN_L00_001ffe20(); +extern int FUN_L00_00257b90(int, int); +extern int FUN_L00_00258110(); +unsigned char *spawn_glow_particle_u8(void *owner, void *pos, void *vel, float scale, int lifetime, unsigned char red, unsigned char green, unsigned char blue, unsigned char alpha) __asm__("FUN_L00_002ac910"); +extern int allocate_voice_for_target_entry_alt(int, int, int) __asm__("FUN_0022da68"); +extern int scale_game_frames_alt(int) __asm__("FUN_001f96f8"); +extern int tick_countdown_32_alt(int *) __asm__("FUN_001f9740"); +extern s32 D_L00_00166DC0[]; +extern s32 D_L00_00173E40[0x1C]; +extern s32 random_integer_below(s32) __asm__("func_00213260"); +extern s32 truncate_float_to_s32(f32) __asm__("func_001FA6D0"); +extern short D_L00_001B0770[]; +extern unsigned FUN_L00_0025c0e8(unsigned c, int mask); +extern unsigned char *D_L00_001B20DC __attribute__((section(".data"))); +extern void *FUN_L00_0026bb70(void *, void *, int, int, float, int, int, int, int); +extern void FUN_001f9c48(void *, void *, float); +extern void FUN_001f9c90(void *, void *, float); +extern void FUN_001fa378(void *, void *, void *); +extern void FUN_L00_001ff660(void *, void *, void *); +extern void FUN_L00_0025a9f8(void *, void *, void *, int, int, int, int, int, float, float, float); +extern void FUN_L00_0025f800(void *, void *); +extern void FUN_L00_0026a9f0(void *, void *, int, int, float, int, int, int, int, float); +extern void add_vector_xyz(void *, void *, void *) __asm__("FUN_001f9a10"); +extern void build_look_at_matrix(void *out, void *dir, void *axis, f32 ang) __asm__("FUN_00214890"); +extern void build_spherical_offset_c(void *, f32, f32, f32) __asm__("FUN_00214db0"); +extern void normalize_vector_xyz(void *, void *, f32) __asm__("FUN_001f9bf8"); +extern void scale_vector_xyz(void *, void *, float) __asm__("FUN_001f9a68"); +extern void subtract_vector_xyz(void *, void *, void *) __asm__("FUN_001f9a28"); +extern void transform_vector(void *, void *, void *) __asm__("func_001F9D20"); +extern void transform_vector_by_basis(void *, void *, void *) __asm__("func_001F9CF8"); +void FUN_L00_0026a4c8(Q1688 *a, Q1688 *b, int c, int d, int n, float f); +void FUN_L00_0026cbb0(void *, void *, int, int, int, int, float); +void FUN_L00_002712b8(void *, void *, int, int, int, int, float, float, float, float, float); +void FUN_L00_002affa8(char *self, O *out, char *skip); +extern Impact1688 impact1688 __asm__("D_L00_00173E40"); +extern HeroMotion1688 hero_motion1688 __asm__("D_0013F350"); +extern float dot1688(void *) __asm__("FUN_L00_001ff430"); +extern void cross1688(void *,void *,void *) __asm__("FUN_L00_001ff2c0"); +extern float horizontal1688(void *) __asm__("FUN_001f9b20"); +extern float chase1688(void *,float,float,float,float,float) __asm__("FUN_L00_00258110"); +extern unsigned char *smoke1688(void *,void *,int,int,int,int,float,float,float,float,float) __asm__("FUN_L00_002712b8"); +extern void rotate1688(void *,void *,void *) __asm__("FUN_001f9cf8"); +extern float random_angle1688(void) __asm__("FUN_00213308"); +extern void axis_rotate1688(void *,void *,void *,float) __asm__("FUN_00214890"); +extern void spark1688(void *,void *,int,int,int,int,float) __asm__("FUN_L00_0026cbb0"); +extern void combine_velocity1688(void *,void *,void *) __asm__("FUN_L00_001ff290"); +extern int collision1688(void *,void *,int,void *,void *) __asm__("FUN_001efa68"); +extern void reflect1688(void *,void *,void *) __asm__("FUN_L00_001ff660"); +extern void matrix_scale1688(void *,void *,float) __asm__("FUN_L00_001ffd48"); +extern void matrix_add1688(void *,void *,void *) __asm__("FUN_L00_001ffe20"); +extern void identity1688(void *) __asm__("FUN_001f9fc8"); +extern void transform1688(void *,void *,void *) __asm__("FUN_001f9d20"); +extern void rings1688(void *,void *,int,int,float,int,int,int,int,float) __asm__("FUN_L00_0026a9f0"); +extern void debris1688(void *,void *,int,int,float,int) __asm__("FUN_L00_0026a4c8"); + +void FUN_L00_002b03a0(M910 *m) { + B910 effect=D_L00_001E9950; + B910 gold_effect=D_L00_001E99A0; + V1688 camera_delta; + V1688 previous; + V1688 blast_velocity; + V1688 normal; + V1688 smoke_position; + V1688 motion; + V1688 surface_motion; + V1688 hero_velocity; + MissilePhase1688 phase; + V1688 predicted; + float basis[4][4]; + float basis_squared[4][4]; + float rotation[4][4]; + float diagonal[4][4]; + float rotation_part[4][4]; + M910 *skip=0; + int reduced=0; + Missile1688 *d; + M910 *target; + float size, yaw, pitch; + normal.q=0; + normal.f[2]=D_0015ED6C*8.0f; + blast_velocity.q=normal.q; + normal.q=0; + normal.f[2]=1.0f; + d=(Missile1688 *)m->v; + target=d->target; + if(D_L00_0015F5D0>0.9f || D_L00_0015F5D4>0.9f) reduced=1; + d->speed=d->speed+(d->desired_speed-d->speed)/10.0f*D_0015ED64; + FUN_001f9770(&d->turn_time); + { + float turn=convert_integer_to_float(d->turn_time); + turn=turn/convert_integer_to_float(d->turn_period); + add_vector_xyz(phase.collision.dir,&hero_motion1688.current,&hero_motion1688.previous); + hero_velocity.q=phase.vectors.direction.q; + scale_vector_xyz(&hero_velocity,&hero_velocity,turn); + } + size=convert_integer_to_float(D_0013E520.bB)+1.0f; + if(target && d->lifestate>=0) { + float time=0.0f; + qcopy(&phase.vectors.target,&target->pos); + phase.vectors.target.f[2]+=d->target_height; + subtract_vector_xyz(phase.collision.dir,&phase.vectors.target,(&m->pos)); + if(d->track_velocity) { + float b,a,root,t1,t2,denominator,negative_b; + subtract_vector_xyz(&phase.vectors.relative,&phase.vectors.target,&d->previous_target); + cross1688(&predicted,&phase.vectors.relative,&hero_velocity); + qcopy(&d->previous_target,&phase.vectors.target); + a=dot1688(&phase.vectors.relative); + b=(phase.vectors.relative.f[0]*phase.collision.dir[0]+phase.vectors.relative.f[1]*phase.collision.dir[1]+phase.vectors.relative.f[2]*phase.collision.dir[2])*-2.0f; + a=d->speed*d->speed-a; + root=square_root_scalar(b*b-a*4.0f*-dot1688(phase.collision.dir)); + negative_b=-b; + denominator=a+a; + t1=(negative_b+root)/denominator; + t2=(negative_b-root)/denominator; + if(t1>0.0f && t2>0.0f) { + if(t20.0f) time=t1; + else { + time=-1.0f; + if(t2>0.0f) time=t2; + } } - goto turn; } - } - low = scale_game_frames(300); - high = scale_game_frames(5); - if (v->w14 < low - high) { - yaw = v->f2C; - pitch = v->f30; + if(time>0.0f && time<(float)scale_game_frames_alt(300)) { + scale_vector_xyz(&predicted,&phase.vectors.relative,time); + add_vector_xyz(&predicted,&predicted,phase.collision.dir); + yaw=FUN_001f9e90(predicted.f[0],predicted.f[1]); + pitch=-FUN_001f9e90(horizontal1688(&predicted),predicted.f[2]); + } else { + yaw=FUN_001f9e90(phase.collision.dir[0],phase.collision.dir[1]); + pitch=-FUN_001f9e90(horizontal1688(phase.collision.dir),phase.collision.dir[2]); + } } else { - yaw = *(float *)(m + 0x48); - pitch = *(float *)(m + 0x44); + if(d->lifeyaw; + pitch=d->pitch; + } else { + yaw=m->rz; + pitch=m->ry; + } } -turn: - if (target != 0) { - *(float *)(m + 0x48) = spring_turn((float *)&v->w24, *(float *)(m + 0x48), yaw, - frame_time_sq * 6.2831855f, frame_time_sq * 3.1415927f, frame_time * 6.2831855f); - *(float *)(m + 0x44) = spring_turn((float *)&v->w28, *(float *)(m + 0x44), pitch, - frame_time_sq * 6.2831855f, frame_time_sq * 3.1415927f, frame_time * 6.2831855f); + if(target) { + m->rz=chase1688(&d->yaw_velocity,m->rz,yaw,D_0015ED70*6.2831855f,D_0015ED70*3.1415927f,D_0015ED6C*6.2831855f); + m->ry=chase1688(&d->pitch_velocity,m->ry,pitch,D_0015ED70*6.2831855f,D_0015ED70*3.1415927f,D_0015ED6C*6.2831855f); } else { - *(float *)(m + 0x48) = spring_turn((float *)&v->w24, *(float *)(m + 0x48), yaw, - frame_time_sq * 6.2831855f, frame_time_sq * 3.1415927f, frame_time * 4.712389f); - *(float *)(m + 0x44) = spring_turn((float *)&v->w28, *(float *)(m + 0x44), pitch, - frame_time_sq * 6.2831855f, frame_time_sq * 3.1415927f, frame_time * 4.712389f); + m->rz=chase1688(&d->yaw_velocity,m->rz,yaw,D_0015ED70*6.2831855f,D_0015ED70*3.1415927f,D_0015ED6C*4.71238899f); + m->ry=chase1688(&d->pitch_velocity,m->ry,pitch,D_0015ED70*6.2831855f,D_0015ED70*3.1415927f,D_0015ED6C*4.71238899f); } - build_spherical_offset(offset.f, *(float *)&v->w20, *(float *)(m + 0x48), -*(float *)(m + 0x44)); - normalize_vector_xyz(coll_hit_normal, &offset, 1.0f); - scale_vector_xyz(coll_hit_normal, coll_hit_normal, -1.0f); - if (!reduced || !(D_L00_0015F5CC & 1)) { - unsigned char *particle; - scratch.vectors.velocity.q = 0; - scratch.vectors.velocity.f[0] = random_float_between(-1.0f, 1.0f); - scratch.vectors.velocity.f[1] = random_float_between(-1.0f, 1.0f); - scratch.vectors.velocity.f[2] = random_float_between(-1.0f, 1.0f); - scratch.vectors.distance.q = scratch.vectors.velocity.q; - normalize_vector_xyz(&scratch.vectors.distance, &scratch.vectors.distance, random_float_between(0.1f, 0.2f) * frame_time); - normalize_vector_xyz(&random, &offset, -random_float_between(frame_time * 0.1f, frame_time)); - add_vector_xyz(&scratch.vectors.distance, &scratch.vectors.distance, &random); - normalize_vector_xyz(&random, &offset, random_float_between(0.0f, 1.0f) * *(float *)&v->w20); - add_vector_xyz(&random, &random, pos); - life = scale_game_frames(40); - particle = FUN_L00_002712b8(&random, &scratch.vectors.distance, life, 50, 0x505050, 3, - 40000.0f, 1000.0f, 1.0f, -0.0002f, 0.0f); - if (particle != 0) { - unsigned char color = *D_L00_001B20DC; - particle[3] = 0x44; - particle[2] = color; + build_spherical_offset_c(&motion,d->speed,m->rz,-m->ry); + normalize_vector_xyz(&impact1688.normal,&motion,1.0f); + scale_vector_xyz(&impact1688.normal,&impact1688.normal,-1.0f); + if(!reduced || !(D_L00_0015F5CC&1)) { + unsigned char *p; + phase.vectors.relative.q=0; + phase.vectors.relative.f[0]=random_float_between(-1.0f,1.0f); + phase.vectors.relative.f[1]=random_float_between(-1.0f,1.0f); + phase.vectors.relative.f[2]=random_float_between(-1.0f,1.0f); + phase.vectors.direction.q=phase.vectors.relative.q; + normalize_vector_xyz(phase.collision.dir,phase.collision.dir,random_float_between(0.1f,0.2f)*D_0015ED6C); + normalize_vector_xyz(&smoke_position,&motion,-random_float_between(D_0015ED6C*0.1f,D_0015ED6C)); + add_vector_xyz(phase.collision.dir,phase.collision.dir,&smoke_position); + normalize_vector_xyz(&smoke_position,&motion,random_float_between(0.0f,1.0f)*d->speed); + add_vector_xyz(&smoke_position,&smoke_position,(&m->pos)); + p=smoke1688(&smoke_position,phase.collision.dir,scale_game_frames_alt(40),50,0x505050,3,40000.0f,1000.0f,1.0f,-0.0002f,0.0f); + if(p) { unsigned char texture=*D_L00_001B20DC; p[3]=0x44; p[2]=texture; } + smoke1688((&m->pos),phase.collision.dir,scale_game_frames_alt(7),127,0xB0B0B0,3,40000.0f,1000.0f,1.0f,-0.0004f,0.0f); + phase.vectors.relative.q=0; + phase.vectors.relative.f[2]=0.02f; + rotate1688(&phase.vectors.relative,&phase.vectors.relative,m->mtx); + axis_rotate1688(&phase.vectors.relative,&phase.vectors.relative,m->mtx,random_angle1688()); + { + int color=FUN_L00_0025c0e8(0x4F007FFF,D_0013E520.bB); + spark1688(&smoke_position,&phase.vectors.relative,color,0x1FFFFFFF,scale_game_frames_alt(15),1,25000.0f); } - life = scale_game_frames(7); - FUN_L00_002712b8(pos, &scratch.vectors.distance, life, 0x7F, 0xB0B0B0, 3, - 40000.0f, 1000.0f, 1.0f, -0.0004f, 0.0f); - scratch.vectors.velocity.q = 0; - scratch.vectors.velocity.f[2] = 0.02f; - FUN_001f9cf8(&scratch.vectors.velocity, &scratch.vectors.velocity, m + 0xC0); - angle = random_angle_radians(); - build_look_at_matrix(&scratch.vectors.velocity, &scratch.vectors.velocity, m + 0xC0, angle); - color1 = FUN_L00_0025c0e8(0x4F007FFF, D_0013E520.bB); - life = scale_game_frames(15); - spawn_burst(&random, &scratch.vectors.velocity, color1, 0x1FFFFFFF, life, 1, 25000.0f); } - qcopy(&previous, pos); - FUN_L00_001ff290(&scratch.vectors.distance, &offset, &target_motion); - add_vector_xyz(pos, pos, &offset); - if (*(float *)(m + 0x10) < 0.0f || *(float *)(m + 0x14) < 0.0f || *(float *)(m + 0x18) < 0.0f) - goto remove; - scratch.query.flags = 0x830000; - scratch.query.fC = 3.0f; - scratch.query.moby = (M910 *)m; - scratch.query.i10 = 1; - qcopy(&scratch.query, &offset); - FUN_001f9c48(&scratch.query, &scratch.query, 1.0f); - scratch.query.dir[3] = 5627.925f; - scratch.query.b8 = 3; - scratch.query.cls = *(unsigned short *)(m + 0xA6); - scratch.query.dir[2] = 1.0f; - scratch.query.b9 = 1; - if (FUN_001efa68(&previous, pos, 0, (int)D_001413D0_2afc70, (int)&scratch.query)) { - if (coll_hit.moby != 0) { - if (coll_hit.moby == (M910 *)D_001413D0_2afc70) goto hit_ready; - if (coll_hit.moby == (M910 *)v->w10) goto hit_ready; - m[0xBC] = 2; - qcopy(pos, &coll_hit.pos); - subtract_vector_xyz(&target_position, (char *)&coll_hit + 0x50, (char *)&coll_hit + 0x60); - hit_owner = m; - } else { - if (coll_hit.i1C < 1) goto hit_ready; - m[0xBC] = 1; - qcopy(pos, &coll_hit.pos); - subtract_vector_xyz(&target_position, (char *)&coll_hit + 0x50, (char *)&coll_hit + 0x60); + qcopy(&previous,(&m->pos)); + combine_velocity1688(phase.collision.dir,&motion,&hero_velocity); + add_vector_xyz((&m->pos),(&m->pos),&motion); + if(m->pos.f[0]<0.0f || m->pos.f[1]<0.0f || m->pos.f[2]<0.0f) { + FUN_L00_0025f800(m,D_L00_001B0770); + mark_moby_for_removal(m); + return; + } + phase.collision.moby=m; + phase.collision.flags=0x830000; + phase.collision.fC=3.0f; + phase.collision.i10=1; + qcopy(phase.collision.dir,&motion); + FUN_001f9c48(phase.collision.dir,phase.collision.dir,1.0f); + phase.collision.dir[2]=1.0f; + phase.collision.dir[3]=5627.925f; + phase.collision.b8=3; + phase.collision.cls=m->cls; + phase.collision.b9=1; + if(collision1688(&previous,(&m->pos),0,D_0013F350.cam,&phase.collision)) { + Impact1688 *hit=&impact1688; + V1688 *hit_normal; + if(hit->moby) { + if(hit->moby!=(M910 *)D_0013F350.cam && hit->moby!=d->owner) { + m->bBC=2; + qcopy((&m->pos),&hit->position); + subtract_vector_xyz(&surface_motion,&hit->velocity_end,&hit->velocity_start); + hit_normal=&hit->normal; + skip=m; + normalize_vector_xyz(&surface_motion,&surface_motion,1.0f); + reflect1688(&blast_velocity,&motion,hit_normal); + normalize_vector_xyz(&blast_velocity,&blast_velocity,D_0015ED6C+D_0015ED6C); + normalize_vector_xyz(&normal,hit_normal,1.0f); + } + } else if(hit->kind>0) { + m->bBC=1; + qcopy((&m->pos),&hit->position); + subtract_vector_xyz(&surface_motion,&hit->velocity_end,&hit->velocity_start); + hit_normal=&hit->normal; + normalize_vector_xyz(&surface_motion,&surface_motion,1.0f); + reflect1688(&blast_velocity,&motion,hit_normal); + normalize_vector_xyz(&blast_velocity,&blast_velocity,D_0015ED6C+D_0015ED6C); + normalize_vector_xyz(&normal,hit_normal,1.0f); + } + } else if(tick_countdown_32_alt(&d->life) || d->limitpos),&D_0013F350.x80)) { + qcopy(&normal,&D_L00_00160680); + qcopy(&surface_motion,&D_L00_00160660); + rotate1688(&surface_motion,&surface_motion,m->mtx); + rotate1688(&normal,&normal,m->mtx); + if(!D_0013E520.bB) { + FUN_L00_0025f800(m,D_L00_001B0770); + mark_moby_for_removal(m); + return; } - normalize_vector_xyz(&target_position, &target_position, 1.0f); - FUN_L00_001ff660(&recoil, &offset, coll_hit_normal); - normalize_vector_xyz(&recoil, &recoil, frame_time + frame_time); - normalize_vector_xyz(&up, coll_hit_normal, 1.0f); - } else if (tick_countdown_32_alt(&v->w14) || *(float *)((char *)v + 0x48) < FUN_001f9b80(pos, &hero_pos)) { - up.q = D_L00_00160680.q; - target_position.q = D_L00_00160660.q; - FUN_001f9cf8(&target_position, &target_position, m + 0xC0); - FUN_001f9cf8(&up, &up, m + 0xC0); - if (D_0013E520.bB == 0) goto remove; - m[0xBC] = 1; - add_vector_xyz(&recoil, &recoil, &offset); + m->bBC=1; + add_vector_xyz(&blast_velocity,&blast_velocity,&motion); } -hit_ready: - if (m[0xBC] != 0) { - int hit_count; - U910 random; - ProjectileColors colors1, colors2; - float blast = factor + factor; - hit_count = collect_mobies_in_sphere(pos, 0x10, m, 0, blast); - count = 10; - qcopy(&scratch.vectors.intercept, m + 0x10); - send_blast_hits(m, &scratch.vectors.intercept, D_L00_00177F00, hit_count, (int)hit_owner, - 0x830000, 3, 1, 3.0f, 1.0f, 1.0f); - matrix[0].f[0] = 0; - matrix[0].f[1] = up.f[2]; - matrix[0].f[2] = -up.f[1]; - matrix[0].f[3] = 0; - matrix[1].f[0] = -up.f[2]; - matrix[1].f[1] = 0; - matrix[1].f[2] = up.f[0]; - matrix[1].f[3] = 0; - matrix[2].f[0] = up.f[1]; - matrix[2].f[1] = -up.f[0]; - matrix[2].f[2] = 0; - matrix[2].f[3] = 0; - matrix[3].f[0] = 0.0f; - matrix[3].f[1] = 0.0f; - matrix[3].f[2] = 0.0f; - matrix[3].f[3] = 0.0f; - FUN_001fa378(matrix_squared, matrix, matrix); - mode = 0; - if (reduced) { count /= 3; mode = 1; } - for (i = count; i != 0; ) { - if (m[0xBC] == 1) { - angle = random_angle_radians(); - FUN_L00_001ffd48(rotation, matrix_squared, 1.0f - fast_cos(angle)); - FUN_L00_001ffd48(scaled, matrix, fast_sin(angle)); - FUN_L00_001ffe20(scaled, scaled, rotation); - FUN_001f9fc8(rotation); - FUN_L00_001ffe20(product, scaled, rotation); - FUN_001f9d20(&scratch.vectors.intercept, &target_position, product); - normalize_vector_xyz(&scratch.vectors.intercept, &scratch.vectors.intercept, random_float_between(8.5f, 16.5f) * frame_time * factor); + if(m->bBC) { + float distance, near_adjust; + int particles; + int particle_reduction; + int i,j; + int hit=FUN_L00_001f2868((&m->pos),16,m,0,(size+size)); + particles=10; + predicted.q=m->pos.q; + FUN_L00_0025a9f8(m,&predicted,D_L00_00177F00,hit,(int)skip,0x830000,3,1,3.0f,1.0f,1.0f); + particle_reduction=0; + basis[0][0]=0.0f; + basis[1][0]=-normal.f[2]; + basis[2][0]=normal.f[1]; + basis[3][0]=0.0f; + basis[0][1]=normal.f[2]; + basis[1][1]=0.0f; + basis[2][1]=-normal.f[0]; + basis[3][1]=0.0f; + basis[0][2]=-normal.f[1]; + basis[1][2]=normal.f[0]; + basis[2][2]=0.0f; + basis[3][2]=0.0f; + basis[0][3]=0.0f; + basis[1][3]=0.0f; + basis[2][3]=0.0f; + basis[3][3]=0.0f; + FUN_001fa378(basis_squared,basis,basis); + if(reduced) { particle_reduction=1; particles/=3; } + { int remaining; + for(remaining=0;remainingbBC==1) { + float a=random_angle1688(); + matrix_scale1688(rotation_part,basis_squared,1.0f-fast_cos(a)); + matrix_scale1688(diagonal,basis,fast_sin(a)); + matrix_add1688(diagonal,diagonal,rotation_part); + identity1688(rotation_part); + matrix_add1688(rotation,diagonal,rotation_part); + transform1688(&predicted,&surface_motion,rotation); + normalize_vector_xyz(&predicted,&predicted,random_float_between(8.5f,16.5f)*D_0015ED6C*size); } else { - speed = random_float_between(8.5f, 16.5f) * frame_time * factor; - yaw = random_angle_radians(); - pitch = random_angle_radians(); - build_spherical_offset(scratch.vectors.intercept.f, speed, yaw, pitch); + float speed=random_float_between(8.5f,16.5f)*D_0015ED6C*size; + float a=random_angle1688(); + build_spherical_offset_c(&predicted,speed,a,random_angle1688()); + } + predicted.f[2]+=D_0015ED6C*5.0f; + add_vector_xyz(&predicted,&predicted,&blast_velocity); + { + int color=FUN_L00_0025c0e8(0x4F007FFF,D_0013E520.bB); + int fade=FUN_L00_0025c0e8(0x1F00007F,D_0013E520.bB); + int life; + float particle_scale; + if(vector_length_xyz(&predicted)>1.0f) normalize_vector_xyz(&predicted,&predicted,D_0015ED6C*8.0f); + particle_scale=size*40000.0f; + life=FUN_L00_00257b90(scale_game_frames_alt(60),scale_game_frames_alt(120))-particle_reduction*35; + FUN_L00_0026bb70((&m->pos),&predicted,color,fade,particle_scale,life,1,-1,-1); } - scratch.vectors.intercept.f[2] += frame_time * 5.0f; - add_vector_xyz(&scratch.vectors.intercept, &scratch.vectors.intercept, &recoil); - color1 = FUN_L00_0025c0e8(0x4F007FFF, D_0013E520.bB); - color2 = FUN_L00_0025c0e8(0x1F00007F, D_0013E520.bB); - if (1.0f < vector_length_xyz(&scratch.vectors.intercept)) - normalize_vector_xyz(&scratch.vectors.intercept, &scratch.vectors.intercept, frame_time * 8.0f); - i--; - low = scale_game_frames(60); - high = scale_game_frames(120); - life = FUN_L00_00257b90(low, high); - FUN_L00_0026bb70(pos, &scratch.vectors.intercept, color1, color2, factor * 40000.0f, - life - mode * 35, 1, -1, -1); } - random.q = 0; - random.f[0] = random_float_between(-1.0f, 1.0f); - random.f[1] = random_float_between(-1.0f, 1.0f); - random.f[2] = random_float_between(-1.0f, 1.0f); - scratch.vectors.intercept.q = random.q; - subtract_vector_xyz(&camera_distance, D_L00_00166DC0, pos); - length = vector_length_xyz(&camera_distance); - camera_distance.f[2] += length * 0.5f; - normalize_vector_xyz(&scratch.vectors.intercept, &scratch.vectors.intercept, (length / 5.0f) * frame_time * factor); - normalize_vector_xyz(&camera_distance, &camera_distance, (length + length) * frame_time); - add_vector_xyz(&scratch.vectors.intercept, &scratch.vectors.intercept, &camera_distance); - FUN_001f9c90_2adb30(&scratch.vectors.intercept, &scratch.vectors.intercept, frame_time * 10.0f); - low = scale_game_frames(60); - high = scale_game_frames(90); - spawn_debris(pos, &scratch.vectors.intercept, FUN_L00_00257b90(low, high), 0, 0); - j = 3; - if (length < 6.0f) j = truncate_float_to_s32(length) / 2; - bias = 0.0f; - if (length < 7.0f) bias = 7.0f - length; - if (reduced) j /= 2; - if (j > 0) do { - speed = random_float_between(8.0f, 10.0f); - j--; - colors1 = D_L00_001E99F0; - colors2 = D_L00_001E9A08; - speed = speed * factor * frame_time - bias * frame_time; - color1 = FUN_L00_0025c0e8(colors1.color[random_integer_below(6)], D_0013E520.bB); - color2 = FUN_L00_0025c0e8(colors2.color[random_integer_below(6)], D_0013E520.bB); - low = scale_game_frames(15); high = scale_game_frames(20); - i = FUN_L00_00257b90(low, high) - mode * 7; - low = scale_game_frames(25); high = scale_game_frames(30); - life = FUN_L00_00257b90(low, high) - mode * 10; - FUN_L00_0026a9f0_2adb30(pos, &recoil, color1, color2, 400000.0f, i, life, 0, 0, speed); - low = scale_game_frames(5); high = scale_game_frames(10); - i = FUN_L00_00257b90(low, high) - mode * 5; - low = scale_game_frames(15); high = scale_game_frames(20); - life = FUN_L00_00257b90(low, high) - mode * 7; - FUN_L00_0026a9f0_2adb30(pos, &recoil, 0x7FFFFFFF, 0xFFFFFF, 400000.0f, i, life, 0, 0, speed * 0.5f); - } while (j != 0); - for (i = count; i != 0; ) { - U910 velocity, random; - colors1 = D_L00_001E99F0; - colors2 = D_L00_001E9A08; - random.q = 0; - random.f[0] = random_float_between(-1.0f, 1.0f); - i--; - random.f[1] = random_float_between(-1.0f, 1.0f); - random.f[2] = random_float_between(-1.0f, 1.0f); - velocity.q = random.q; - normalize_vector_xyz(&velocity, &velocity, random_float_between(0.0f, 3.0f) * frame_time * factor); - color1 = FUN_L00_0025c0e8(colors1.color[random_integer_below(6)], D_0013E520.bB); - color2 = FUN_L00_0025c0e8(colors2.color[random_integer_below(6)], D_0013E520.bB); - low = scale_game_frames(20); high = scale_game_frames(35); - life = FUN_L00_00257b90(low, high) - mode * 10; - FUN_L00_0026a4c8(pos, &velocity, color1, color2, life, factor * 200000.0f); } - if (D_0015F5D0 < 0.95f && 9.0f < length) { - unsigned char red = 0x7F, blue = 0x7F; - if (D_0013E520.bB != 0) { red = 0x3C; blue = 0x3C; } - life = scale_game_frames(15); - spawn_glow_particle(m, pos, &recoil, life, red, 0x7F, blue, 0x20, factor * 4.0f); - life = scale_game_frames(24); - spawn_glow_particle(m, pos, &recoil, life, red, 0x7F, blue, 0x20, factor * 4.0f); + { V1688 random; + random.q=0; + random.f[0]=random_float_between(-1.0f,1.0f); + random.f[1]=random_float_between(-1.0f,1.0f); + random.f[2]=random_float_between(-1.0f,1.0f); + predicted.q=random.q; } - color1 = 0x7F; - if (D_0013E520.bB != 0) color1 = 0x20; - life = scale_game_frames(20); - spawn_glow_particle(m, pos, &recoil, life, color1, 0x7F, 0, 0x30, factor * 4.0f); - if (!reduced) { - life = scale_game_frames(19); - spawn_glow_particle(m, pos, &recoil, life, 0xFF, 0xFF, 0xFF, 0x20, blast); + subtract_vector_xyz(&camera_delta,D_L00_00166DC0,(&m->pos)); + distance=vector_length_xyz(&camera_delta); + camera_delta.f[2]+=distance*0.5f; + normalize_vector_xyz(&predicted,&predicted,distance/5.0f*D_0015ED6C*size); + normalize_vector_xyz(&camera_delta,&camera_delta,(distance+distance)*D_0015ED6C); + add_vector_xyz(&predicted,&predicted,&camera_delta); + FUN_001f9c90(&predicted,&predicted,D_0015ED6C*10.0f); + FUN_L00_002af450((char *)(&m->pos),(char *)&predicted,FUN_L00_00257b90(scale_game_frames_alt(60),scale_game_frames_alt(90)),0,0); + if(distance<6.0f) j=truncate_float_to_s32(distance)/2; + else j=3; + near_adjust=0.0f; + if(distance<7.0f) near_adjust=7.0f-distance; + if(reduced) j/=2; + for(i=0;ipos),&blast_velocity,c,f,400000.0f,life,end,0,0,speed); + white_life=FUN_L00_00257b90(scale_game_frames_alt(5),scale_game_frames_alt(10))-particle_reduction*5; + white_end=FUN_L00_00257b90(scale_game_frames_alt(15),scale_game_frames_alt(20))-particle_reduction*7; + rings1688((&m->pos),&blast_velocity,0x7FFFFFFF,0xFFFFFF,400000.0f,white_life,white_end,0,0,speed*0.5f); + } + for(i=0;ipos),&v,c,f,debris_scale,life); } - offset.f[0] = 0; - m[0xBC] = 0; - if (length < 20.0f) player_camera.f160 = 0.4f - length * 0.0175f; - else player_camera.f160 = 0.050000012f; - player_camera.i168 = scale_game_frames(25); - allocate_voice_for_target_entry(0, 0, m); - if (!reduced) { - if (D_0013E520.bB == 0) FUN_L00_002d3838((char *)&a, pos, 0, 0); - else FUN_L00_002d3838((char *)&b, pos, 0, 0); + if(D_L00_0015F5D0<0.95f && distance>9.0f) { + int c=127,f=127; + if(D_0013E520.bB) { c=60; f=60; } + spawn_glow_particle_u8(m,(&m->pos),&blast_velocity,size*4.0f,scale_game_frames_alt(15),c,127,f,32); + spawn_glow_particle_u8(m,(&m->pos),&blast_velocity,size*4.0f,scale_game_frames_alt(24),c,127,f,32); } - j = *(int *)((char *)v + 0x40) + 1; - *(int *)((char *)v + 0x40) = j; - if (D_0013E520.bB == 0 || j == 3) { -remove: - FUN_L00_0025f800(m, D_L00_001B0770_2afc70); + { unsigned char color=127; + int life; + float flash_scale=size*4.0f; + if(D_0013E520.bB) color=32; + life=scale_game_frames_alt(20); + spawn_glow_particle_u8(m,(&m->pos),&blast_velocity,flash_scale,life,color,127,0,48); + } + if(!reduced) spawn_glow_particle_u8(m,(&m->pos),&blast_velocity,(size+size),scale_game_frames_alt(19),255,255,255,32); + motion.f[0]=0.0f; + m->bBC=0; + D_L00_00166C80.f160=distance<20.0f ? 0.4f-distance*0.0175f : 0.4f-20.0f*0.0175f; + D_L00_00166C80.i168=scale_game_frames_alt(25); + allocate_voice_for_target_entry_alt(0,0,(int)m); + if(!reduced) { + if(D_0013E520.bB) FUN_L00_002d3838((char *)&gold_effect,(char *)(&m->pos),0,0); + else FUN_L00_002d3838((char *)&effect,(char *)(&m->pos),0,0); + } + d->bounce_count++; + if(!D_0013E520.bB || d->bounce_count==3) { + FUN_L00_0025f800(m,D_L00_001B0770); mark_moby_for_removal(m); return; } - v->owner = 0; - m[0xBC] = 0; - normalize_vector_xyz(coll_hit_normal, coll_hit_normal, 1.0f); - FUN_L00_001ff660(&random, &offset, coll_hit_normal); - *(float *)(m + 0x48) = FUN_001f9e90(random.f[0], random.f[1]); - *(float *)(m + 0x44) = -FUN_001f9e90(vector_length_xy(&random), random.f[2]); - v->w24 = 0; v->w28 = 0; - normalize_vector_xyz(&scratch.vectors.velocity, coll_hit_normal, 0.05f); - add_vector_xyz(pos, pos, &scratch.vectors.velocity); - if (coll_hit.moby != 0) v->w10 = (int)coll_hit.moby; - if (*(int *)((char *)v + 0x44) == 0) - *(int *)((char *)v + 0x44) = scale_game_frames(90); - FUN_L00_002affa8((char *)m, v, (char *)coll_hit.moby); - allocate_voice_for_target_entry(1, 0, m); + { V1688 bounce[2]; + d->target=0; + m->bBC=0; + normalize_vector_xyz(&impact1688.normal,&impact1688.normal,1.0f); + reflect1688(&bounce[0],&motion,&impact1688.normal); + m->rz=FUN_001f9e90(bounce[0].f[0],bounce[0].f[1]); + m->ry=-FUN_001f9e90(horizontal1688(&bounce[0]),bounce[0].f[2]); + d->yaw_velocity=0.0f; d->pitch_velocity=0.0f; + normalize_vector_xyz(&bounce[1],&impact1688.normal,0.05f); + add_vector_xyz((&m->pos),(&m->pos),&bounce[1]); + if(impact1688.moby) d->owner=impact1688.moby; + if(!d->bounce_timer) d->bounce_timer=scale_game_frames_alt(90); + FUN_L00_002affa8((char *)m,(O *)d,(char *)impact1688.moby); + allocate_voice_for_target_entry_alt(1,0,(int)m); + } } - if (tick_countdown_32_alt((int *)((char *)v + 0x44))) *(int *)((char *)v + 0x40) = 0; - return; + if(tick_countdown_32_alt(&d->bounce_timer)) d->bounce_count=0; } -#endif typedef struct { float f[4]; } __attribute__((aligned(16))) V_2b1af0; From d30258ae5f81d993332d6828afae28a3139d3b67 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mateusz=20K=C5=82ysz?= Date: Tue, 13 Oct 2026 13:29:24 +0000 Subject: [PATCH 07/12] overlay: port FUN_L11_0030b358 from rac1-decomp --- .../shared/gameplay/entities/002c8830.c | 174 ++++++++++-------- 1 file changed, 99 insertions(+), 75 deletions(-) diff --git a/src/overlays/shared/gameplay/entities/002c8830.c b/src/overlays/shared/gameplay/entities/002c8830.c index e08a60220..35dd9fa3d 100644 --- a/src/overlays/shared/gameplay/entities/002c8830.c +++ b/src/overlays/shared/gameplay/entities/002c8830.c @@ -716,85 +716,109 @@ void FUN_L11_0030a908(struct Moby *moby) { ((Fog_30a908 *)D_L11_0016D440_30a908)->f22C = s22C; FUN_00233980_30a908(0x47, 0x5360B); } -#ifndef NON_MATCHING -INCLUDE_ASM("config/us/overlays/asm/FUN_L11_0030b358.s", FUN_L11_0030b358); -#else -extern float D_L11_001677C0[]; -extern float D_L11_00161E08[]; -extern float D_L11_00161E18; -extern float D_L11_00161E1C; -extern float D_L11_001D9AF0[]; -extern int D_L11_0015F5CC; -extern float D_0015ED7C; -#define D_L11_00167800 ((float *)((char *)D_L11_001677C0 + 0x40)) -#define D_L11_00166DB8 ((float *)((char *)D_L11_001677C0 - 0xa08)) -#define D_L11_00166DDC (*(float *)((char *)D_L11_001677C0 - 0x9e4)) -extern void subtract_vector_xyz_b358(void *, void *, void *) __asm__("FUN_001f9a28"); -extern void scale_vector_xyz_b358(float, float *, void *) __asm__("FUN_001f9a68"); -extern int random_int_b358(void) __asm__("FUN_001fa6d0"); -extern float convert_integer_to_float_b358(int) __asm__("FUN_001fa6c0"); +/* Ocean update: scrolls the two wave layers with the camera and the time, keeps their offsets in -1..1 and sets the level's tide values. */ +/* Ported from rac1-decomp (src/overlays/shared/vendor_002C99E0.c: func_L11_0030C728), where it is exact; names translated to the US level program. */ +typedef struct { float u, v; } UV_30b358; +typedef float V4_30b358[4] __attribute__((aligned(16))); + +typedef struct { + char pad00[0x14]; + float level; /* 0x14 */ + float scale; /* 0x18 */ + char pad1C[0x4]; + float limit; /* 0x20 */ +} OceanVars_30b358; + +typedef struct { + char pad00[0x20]; + unsigned char state; /* 0x20 */ + char pad21[0xF]; + unsigned char f30; /* 0x30 */ + char pad31[0x47]; + OceanVars_30b358 *vars; /* 0x78 */ +} OceanMoby_30b358; + +extern void subtract_vector_b358(void *, void *, void *) __asm__("FUN_001f9a28"); +extern void scale_vector_b358(void *, void *, float) __asm__("FUN_001f9a68"); +extern int float_to_int_b358(float) __asm__("FUN_001fa6d0"); +extern float int_to_float_b358(int) __asm__("FUN_001fa6c0"); extern float fast_sin_b358(float) __asm__("FUN_001f9de0"); -extern void enqueue_callback_list_1_b358(void *, void *) __asm__("FUN_001f4600"); -extern void FUN_L11_0030a908(struct Moby *); +extern void enqueue_callback_b358(void *, void *) __asm__("FUN_001f4600"); +extern void FUN_L11_0030a908_b358(void) __asm__("FUN_L11_0030a908"); +extern UV_30b358 wave_offset[] __asm__("D_L11_00161E08") __attribute__((section(".sdata"))); +extern float camera_pos_b358[] __asm__("D_L11_001677C0"); +extern char last_camera_pos[4] __asm__("D_L11_00162840") __attribute__((sda)); /* a 16-byte vector; declared small so it is reached through $gp */ +extern float wave_speed[2] __asm__("D_L11_00161DF8") __attribute__((sda)); +extern float ocean_level __asm__("D_L11_00161E1C"); +extern UV_30b358 wave_drift[] __asm__("D_L11_001D9AF0"); +extern float tide_level __asm__("D_L11_00161E18"); +extern int level_frame_b358 __asm__("D_L11_0015F5CC"); +extern float frame_time_b358 __asm__("D_0015ED7C"); -void FUN_L11_0030b358(unsigned char *moby) { - char *data = *(char **)(moby + 0x78); - int i; - if (moby[0x20] == 0) { - moby[0x30] = 0xff; - moby[0x20] = 1; - { - float *a = D_L11_00161E08; - float *b = &D_L11_00161E08[1]; - for (i = 1; i >= 0; i--) { - *a = 0.0f; - *b = 0.0f; - a += 2; - b += 2; - } +void FUN_L11_0030b358(OceanMoby_30b358 *moby) +{ + OceanVars_30b358 *d = moby->vars; + float src[4]; + float out[4]; + int k; + + if (moby->state == 0) { + moby->state = 1; + moby->f30 = 0xFF; + for (k = 0; k < 2; k++) { + wave_offset[k].u = 0.0f; + wave_offset[k].v = 0.0f; } - qcopy(D_L11_00167800, D_L11_001677C0); - D_L11_00166DDC = *(float *)(data + 0x14); - } else { - float difference[4]; - subtract_vector_xyz_b358(difference, D_L11_001677C0, D_L11_00167800); - qcopy(D_L11_00167800, D_L11_001677C0); - { - float current_z = D_L11_001677C0[2]; - if (*(float *)(data + 0x20) < current_z) { - float scaled[2]; - float *phase_x = D_L11_00161E08; - float *phase_y = D_L11_00161E08 + 1; - float *velocity = D_L11_00166DB8; - i = 0; - do { - scale_vector_xyz_b358((*velocity + *velocity) / (*(float *)(data + 0x18) * 5.0f), scaled, difference); - if (1.0f < scaled[0] || scaled[0] < 1.0f) scaled[0] -= convert_integer_to_float_b358(random_int_b358()); - if (1.0f < scaled[1] || scaled[1] < 1.0f) scaled[1] -= convert_integer_to_float_b358(random_int_b358()); - *phase_x += scaled[0]; - *phase_y += scaled[1]; - if (*phase_x > 1.0f) *phase_x -= 1.0f; - if (*phase_x < -1.0f) *phase_x += 1.0f; - if (*phase_y > 1.0f) *phase_y -= 1.0f; - if (*phase_y < -1.0f) *phase_y += 1.0f; - phase_y += 2; - phase_x += 2; - velocity++; - i++; - } while (i < 2); - D_L11_00161E18 = D_L11_00161E1C + fast_sin_b358(convert_integer_to_float_b358(D_L11_0015F5CC % 0x168) * 0.017444445f - 3.14f) * 0.25f; - for (i = 0; i < 2; i++) { - float *phase = &D_L11_00161E08[i * 2]; - phase[0] += D_L11_001D9AF0[i * 2] * D_0015ED7C; - if (phase[0] > 1.0f) phase[0] -= 1.0f; - if (phase[0] < -1.0f) phase[0] += 1.0f; - phase[1] += D_L11_001D9AF0[i * 2 + 1] * D_0015ED7C; - if (phase[1] > 1.0f) phase[1] -= 1.0f; - if (phase[1] < -1.0f) phase[1] += 1.0f; - } - enqueue_callback_list_1_b358((void *)FUN_L11_0030a908, moby); + qcopy(last_camera_pos, camera_pos_b358); + ocean_level = d->level; + return; + } + subtract_vector_b358(src, camera_pos_b358, last_camera_pos); + qcopy(last_camera_pos, camera_pos_b358); + if (!(d->limit < camera_pos_b358[2])) { + return; + } + for (k = 0; k < 2; k++) { + scale_vector_b358(out, src, (wave_speed[k] + wave_speed[k]) / (d->scale * 5.0f)); + if (1.0f < out[0] || out[0] < 1.0f) { + out[0] = out[0] - int_to_float_b358(float_to_int_b358(out[0])); + } + if (1.0f < out[1] || out[1] < 1.0f) { + out[1] = out[1] - int_to_float_b358(float_to_int_b358(out[1])); + } + wave_offset[k].u = wave_offset[k].u + out[0]; + wave_offset[k].v = wave_offset[k].v + out[1]; + if (1.0f < wave_offset[k].u) { + wave_offset[k].u = wave_offset[k].u - 1.0f; + } + if (wave_offset[k].u < -1.0f) { + wave_offset[k].u = wave_offset[k].u + 1.0f; } + if (1.0f < wave_offset[k].v) { + wave_offset[k].v = wave_offset[k].v - 1.0f; + } + if (wave_offset[k].v < -1.0f) { + wave_offset[k].v = wave_offset[k].v + 1.0f; } } + tide_level = ocean_level + fast_sin_b358(int_to_float_b358(level_frame_b358 % 360) * 0.017444445f - 3.14f) * 0.25f; + for (k = 0; k < 2; k++) { + float sum = wave_offset[k].u + wave_drift[k].u * frame_time_b358; + wave_offset[k].u = sum; + if (1.0f < sum) { + wave_offset[k].u = sum - 1.0f; + } + if (wave_offset[k].u < -1.0f) { + wave_offset[k].u = wave_offset[k].u + 1.0f; + } + sum = wave_offset[k].v + wave_drift[k].v * frame_time_b358; + wave_offset[k].v = sum; + if (1.0f < sum) { + wave_offset[k].v = sum - 1.0f; + } + if (wave_offset[k].v < -1.0f) { + wave_offset[k].v = wave_offset[k].v + 1.0f; + } + } + enqueue_callback_b358((void *)FUN_L11_0030a908_b358, moby); } -#endif From b2b17a9c912fe9781ec0fa762da5168a25653563 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mateusz=20K=C5=82ysz?= Date: Tue, 13 Oct 2026 13:37:45 +0000 Subject: [PATCH 08/12] overlay: port FUN_L00_00245c28 from rac1-decomp --- configure.py | 1 + .../rnc/gameplay/state/overlay_game_state.h | 3 +- src/overlays/shared/rendering/00245c28.c | 737 ++++++------------ 3 files changed, 256 insertions(+), 485 deletions(-) diff --git a/configure.py b/configure.py index d84482492..ca9e261f7 100755 --- a/configure.py +++ b/configure.py @@ -350,6 +350,7 @@ "shared/math/rotations/0025d238.c", "shared/math/rotations/002899f8.c", "shared/math/vectors/0025c230.c", + "shared/rendering/00245c28.c", "shared/rendering/00269290.c", "shared/rendering/002712b8.c", "shared/rendering/0027f660.c", diff --git a/include/rnc/gameplay/state/overlay_game_state.h b/include/rnc/gameplay/state/overlay_game_state.h index 39bd92638..2c0a4e16a 100644 --- a/include/rnc/gameplay/state/overlay_game_state.h +++ b/include/rnc/gameplay/state/overlay_game_state.h @@ -45,7 +45,8 @@ struct GameState { s32 unk124; u8 pad128[0x130 - 0x128]; s32 unk130; - u8 pad134[0x140 - 0x134]; + u8 pad134[0x13C - 0x134]; + s32 unk13C; s32 unk140; s32 unk144; s32 stash_handles[20]; /* 0x148: FUN_L00_00276078 */ diff --git a/src/overlays/shared/rendering/00245c28.c b/src/overlays/shared/rendering/00245c28.c index 2d7d2b924..190c0d8ac 100644 --- a/src/overlays/shared/rendering/00245c28.c +++ b/src/overlays/shared/rendering/00245c28.c @@ -2,536 +2,305 @@ #include "types.h" #include "rnc/gameplay/state/overlay_game_state.h" #include "rnc/globals.h" -#include "asm.h" - -#ifndef NON_MATCHING -INCLUDE_ASM("config/us/overlays/asm/FUN_L00_00245c28.s", FUN_L00_00245c28); -#else -#include "rnc/gameplay/state/usage_stats.h" #include "sda.h" +#include "rnc/gameplay/state/usage_stats.h" #include "rnc/audio/music/music_stream_state.h" #include "rnc/rendering/debug/debug_menu.h" #include "rnc/storage/memory_card/memory_card_state.h" #include "rnc/gameplay/hero.h" #include "rnc/gameplay/state/level_state.h" -#include "rnc/overlay/level_globals.h" -extern s32 D_L00_0015F5C8 __asm__("D_L00_0015F5C8") MACRO_ADDR; -extern s32 D_L00_0015F5C4 MACRO_ADDR; -extern s32 D_L00_0015F570 __asm__("D_L00_0015F570"); -extern s32 D_L00_0015F3F8 __asm__("D_L00_0015F3F8"); -extern s32 D_L00_0015F5AC __asm__("D_L00_0015F5AC"); -extern s32 D_0015F5AC __asm__("D_L00_0015F5AC") __attribute__((sda)); -extern f32 D_L00_0015F5D0 __asm__("D_L00_0015F5D0"); -#define D_L00_0016C060 (g_debug_menu.update_flags) -#define D_L00_0016C070 (g_debug_menu.profiler_mode) -#define D_L00_0016C088 (g_debug_menu.television_mode) -#define D_L00_0016C090 (g_debug_menu.scene_index) -#define D_L00_0016C14C (g_debug_menu.actuator_enabled) -#define D_L00_0016C064 (g_debug_menu.selected_column) -extern s16 D_L00_0016C8B0 __asm__("D_L00_0016C8B0"); -#define D_00151708 (music_stream_state.primary.track) -extern s32 D_0015EEA4; -extern u8 D_00141680[] NOT_SDA; -#define D_0013DD43 (*(u8 *)0x13dd43) -#define D_0013D390 (*(u8 *)0x13d390) -#define D_0013D364 (memory_card_state.state) -#define D_0013D36C (memory_card_state.pending_state) -#define D_00141401 (hero.unk20B1) -#define D_L00_001B9E2C (*(s32 *)((u8 *)&D_L00_001B9CF0 + 0x13c)) -extern u64 frm_clock_time __asm__("D_0015ED40") NOT_SDA; -extern s32 D_0015F3F8; -extern s32 D_0015F570; -extern s32 D_0015F5D8; +/* Level main loop (shared by every level): clears the level's work area, sets up the level and counts the visit + and play time of the planet, then runs one frame per pass, dispatching on the game mode, until the level asks to + quit. */ +/* Ported from rac1-decomp (src/overlays/shared/map_002465F8.c: func_L00_002465F8), where it is exact; names translated to the US level program. */ -void FUN_001ff068(void *, s32) __asm__("FUN_001f9810"); -void FUN_001eb078(void *) __asm__("FUN_L00_001eb078"); -void FUN_00293b18(void) __asm__("FUN_L00_00293b18"); -void FUN_0023d028(void) __asm__("FUN_L00_0023d028"); -void FUN_00244110(s32, s32) __asm__("FUN_L00_00244110"); -void FUN_001f3638(void) __asm__("FUN_L00_001f3638"); -void FUN_00234e98(void) __asm__("FUN_L00_00234e98"); -void FUN_00276078(void) __asm__("FUN_L00_00276078"); -void FUN_0028eed0(void) __asm__("FUN_L00_0028eed0"); -void FUN_00122298(s32) __asm__("FUN_00122298"); -void FUN_00200f18(void) __asm__("FUN_L00_00200f18"); -void FUN_00265418(s32,s32,s32) __asm__("FUN_00215c40"); -void FUN_00265860(void) __asm__("FUN_00216088"); -void FUN_00265828(s32) __asm__("FUN_00216050"); -s32 FUN_001fef20(s32) __asm__("FUN_001f96f8"); -void FUN_0012eaf0(void) __asm__("FUN_0012eaf0"); -void FUN_001f6d70(void) __asm__("FUN_L00_001f6d70"); -void FUN_002a08c8(void) __asm__("FUN_L00_002a08c8"); -void FUN_002a0858(void) __asm__("FUN_L00_002a0858"); -void FUN_00201040(void) __asm__("FUN_L00_00201040"); -void FUN_00201350(void) __asm__("FUN_L00_00201350"); -void FUN_00200f40(void) __asm__("FUN_L00_00200f40"); -void FUN_0012dc80(void) __asm__("FUN_0012dc80"); -void FUN_00267898(void) __asm__("FUN_L00_00267898"); -void FUN_00297f78(void) __asm__("FUN_L00_00297f78"); -void FUN_001f8e30(void) __asm__("FUN_L00_001f8e30"); -void FUN_002999a8(void) __asm__("FUN_L00_002999a8"); -void FUN_00298f90(void) __asm__("FUN_L00_00298f90"); -void FUN_001f8e90(void) __asm__("FUN_L00_001f8e90"); -void FUN_00276bd0(void) __asm__("FUN_L00_00276bd0"); -void FUN_001f8f50(void) __asm__("FUN_L00_001f8f50"); -void FUN_00202aa0(void) __asm__("FUN_L00_00202aa0"); -void FUN_001f8ec8(void) __asm__("FUN_L00_001f8ec8"); -void FUN_0029c648(void) __asm__("FUN_L00_0029c648"); -void FUN_002a02b0(void) __asm__("FUN_L00_002a02b0"); -void FUN_00290590(void) __asm__("FUN_L00_00290590"); -void FUN_00291d00(void) __asm__("FUN_L00_00291d00"); -void FUN_00299c48(void) __asm__("FUN_L00_00299c48"); -void FUN_001f8f78(void) __asm__("FUN_L00_001f8f78"); -void FUN_001f4598(void) __asm__("FUN_L00_001f4598"); -void FUN_001f58e0(void) __asm__("FUN_L00_001f58e0"); -void FUN_002a09d8(s32) __asm__("FUN_L00_002a09d8"); -void FUN_002a07f8(void) __asm__("FUN_L00_002a07f8"); -void FUN_0024b690(void) __asm__("FUN_L00_0024b690"); -void FUN_0024ac20(void) __asm__("FUN_L00_0024ac20"); -void FUN_001f9060(s32) __asm__("FUN_L00_001f9060"); -void FUN_002a0ba8(s32,s32) __asm__("FUN_L00_002a0ba8"); -s64 FUN_0023b208(s32,s32) __asm__("FUN_001ff960"); -void FUN_0023b4d8(s64,s32,s32,s32,s32,s32) __asm__("FUN_001ffc30"); -s64 FUN_0023b2b8(s64) __asm__("FUN_001ffa10"); -void FUN_0023c2a0(f32,f32,f32,f32,f32,s32,s32,s64) __asm__("FUN_00200600"); -void FUN_001f9178(void) __asm__("FUN_L00_001f9178"); -void FUN_001f36f8(void) __asm__("FUN_L00_001f36f8"); -void FUN_001f6d98(void *,s32) __asm__("FUN_L00_001f6d98"); -void FUN_001f6da0(void *,s32) __asm__("FUN_L00_001f6da0"); -f32 FUN_00200240(u32) __asm__("FUN_001fa6c0"); -void FUN_001f6d90(void) __asm__("FUN_L00_001f6d90"); -void FUN_00284c50(void) __asm__("FUN_L00_00284c50"); -void FUN_001f8540(void) __asm__("FUN_L00_001f8540"); -void FUN_0012eb00(void) __asm__("FUN_0012eb00"); -void FUN_0028e048(void) __asm__("FUN_L00_0028e048"); -void FUN_002656c0(void) __asm__("FUN_L00_002656c0"); -void FUN_00292e08(void) __asm__("FUN_L00_00292e08"); +extern char level_bss_end[] __asm__("D_L00_00165FB0"); +extern char level_bss_start[] __asm__("D_L00_00161E00"); +extern char level_bss_clear_args[] __asm__("D_L00_0015FCB0"); +extern char level_frame_callback_args[] __asm__("D_L00_0015FCB8"); +extern unsigned char D_0013D390 NOT_SDA; +extern struct UsageStat level_usage[] __asm__("D_00141680"); +extern short D_L00_0016C8B0 NOT_SDA; +extern int D_0015EEA4; +extern u64 frm_clock_time __asm__("D_0015ED40"); +extern int D_L00_0015F3F8; +extern int D_L00_0015F570; +extern int D_L00_0015F5AC; +/* lower alias of D_L00_0015F5AC: retail stores the float view with lui, the int view through $gp */ +extern float D_L00_0015F5A8_e[] __asm__("D_L00_0015F5A8") MACRO_ADDR; +extern int D_L00_0015F5C4_m __asm__("D_L00_0015F5C4"); +extern int D_L00_0015F5C8; +extern float D_L00_0015F5D0; +extern int D_L00_0015F5D8_m __asm__("D_L00_0015F5D8"); + +extern void clear_blocks_16(void *, int) __asm__("FUN_001f9810"); +extern int FUN_001e93b0(void *); +extern void FUN_00232d00(void); +extern void FUN_L00_0023d028(void); +extern int FUN_L00_00244110(int, int); +extern void FUN_001f0b88(void); +extern void FUN_L00_002464a8(void); +extern void init_hud(void) __asm__("FUN_001fee88"); +extern void FUN_L00_00276078(void); +extern void FUN_L00_0028eed0(void); +extern int FUN_00122298(int); +extern void put_disp_buffer(void) __asm__("FUN_001fb2a8"); +extern void music_start_track(int, int, int) __asm__("FUN_00215c40"); +extern void FUN_001e93e8(); +extern void register_audio_stream_callback(void) __asm__("FUN_00215420"); +extern void FUN_L00_001f4598(void); +extern void FUN_L00_001f58e0(void); +extern void FUN_L00_00297f78(void); +extern void FUN_L00_001f8e30(void); +extern void FUN_L00_002999a8(void); +extern void FUN_L00_00298f90(void); +extern void prepare_debug_profiler_render(void) __asm__("FUN_001f4248"); +extern void FUN_L00_00276bd0(void); +extern void FUN_L00_001f8f50(void); +extern void update_mode_freeze(void) __asm__("FUN_001fce28"); +extern void FUN_L00_001f8ec8(void); +extern void FUN_L00_0029c648(void); +extern void FUN_L00_002a02b0(void); +extern void update_resident_gameplay_state(void) __asm__("FUN_0022f778"); +extern void dispatch_game_state_update(void) __asm__("FUN_00230ee8"); +extern void FUN_L00_00299c48(void); +extern void FUN_L00_001f8f78(void); +extern void FUN_L00_001f6d70(void); +extern void swap_render_buffer_chain(void) __asm__("FUN_00233630"); +extern void put_draw_buffer_small(void) __asm__("FUN_001fb3d0"); +extern void append_palette_transfer_packet(void) __asm__("FUN_001fb6e0"); +extern void put_draw_buffer_large(void) __asm__("FUN_001fb2d0"); +extern int snd_flush_sound_commands(void) __asm__("FUN_0012dc80"); +extern void vu1_init_chain(void) __asm__("FUN_002335d0"); +extern void FUN_0012eaf0(void); +extern void snd_reset_state_and_flush_commands(void) __asm__("FUN_0012eb00"); +extern void sound_stop_all_sounds(void) __asm__("FUN_0022dcd0"); +extern void music_stop(void) __asm__("FUN_00215ee8"); +extern void memcard_update_state(void) __asm__("FUN_002093d8"); +extern void run_state_handler(void) __asm__("FUN_00208840"); +extern void setup_gif_paging(int) __asm__("FUN_001f4280"); +extern void vu1_add_gs_register(int, long) __asm__("FUN_00233980"); +extern int find_hud_sprite(int, int) __asm__("FUN_001ff960"); +extern void draw_hud_sprite(int, int, int, int, int, int) __asm__("FUN_001ffc30"); +extern long get_frame_texture(int) __asm__("FUN_001ffa10"); +extern void draw_rotated_sprite(float, float, int, int, long, float, float, float) __asm__("FUN_00200600"); +extern void do_gif_paging(void) __asm__("FUN_001f4398"); +extern void FUN_L00_001f36f8(void); +extern float convert_integer_to_float(int) __asm__("FUN_001fa6c0"); +extern int scale_game_frames(int) __asm__("FUN_001f96f8"); +extern void reset_gs_registers_pr(void) __asm__("FUN_001f3958"); +extern void do_space_transition(void) __asm__("FUN_00231ff0"); +extern void FUN_00216088(void); +extern void FUN_00216050(int); +extern void vu1_send_chain(void) __asm__("FUN_L00_002a08c8"); +extern void vu1_sync_chain(int) __asm__("FUN_L00_002a09d8"); +extern void FUN_00226e08(void); void FUN_L00_00245c28(void) { - s32 old_mode, mode, frames, value, index, i; - s32 restart; - s32 restart_arg; - s32 rotation_period; - struct UsageStat *stat; - f32 frame_ratio; - volatile u32 *timer = (volatile u32 *)0x10000800; - u8 *bss_base = (u8 *)&D_L00_0015F5C4 + 0xa3c; - u8 *bss_limit = (u8 *)&pal_mode + 0x1280; - u8 *bss_start = bss_base + 0x1e00; - u8 *bss_end = bss_limit + 0x5fb0; - s32 bss_size = bss_end - bss_start; + int i; + int v; + int quit; + int full; + int one; + int per; - if (((bss_size & 15) == 0) && (((u32)bss_start & 15) == 0)) { - FUN_001ff068(bss_start, bss_size); + if (((level_bss_end - level_bss_start) & 0xF) == 0 && ((unsigned int)level_bss_start & 0xF) == 0) { + clear_blocks_16(level_bss_start, level_bss_end - level_bss_start); } else { - FUN_001eb078((u8 *)&pal_mode + 0xf30); - bss_start = bss_base + 0x1e00; - bss_end = bss_limit + 0x5fb0; - bss_size = bss_end - bss_start; - i = 0; - while (i < bss_size) { - *(bss_start + i) = 0; - i++; + FUN_001e93b0(level_bss_clear_args); + for (i = 0; i < level_bss_end - level_bss_start; i++) { + level_bss_start[i] = 0; } } - FUN_00293b18(); + FUN_00232d00(); D_L00_0015F5C8 = 0; - D_L00_0015F5C4 = 6; - FUN_0023d028(); - D_00151708 = 0; - FUN_00244110(1, 0); - D_L00_0016C060 = 15; - D_L00_0016C088 = pal_mode; - D_L00_0016C090 = -1; - D_L00_0016C064 = 1; - D_L00_0016C14C = 1; - FUN_001f3638(); + D_L00_0015F5C4_m = 6; + one = 1; + FUN_L00_0023d028(); + music_stream_state.primary.track = 0; + FUN_L00_00244110(1, 0); + g_debug_menu.update_flags = 15; + g_debug_menu.television_mode = pal_mode; + g_debug_menu.scene_index = -1; + g_debug_menu.selected_column = one; + g_debug_menu.actuator_enabled = one; + FUN_001f0b88(); FUN_L00_002464a8(); - FUN_00234e98(); - FUN_00276078(); - FUN_0028eed0(); + init_hud(); + FUN_L00_00276078(); + FUN_L00_0028eed0(); D_L00_0015F3F8 = 0; FUN_00122298(0); - FUN_00200f18(); - FUN_00265418(D_00151708, 1, 0x400); - if ((current_level_index == 1 && D_0013DD43 == 0) || + put_disp_buffer(); + music_start_track(music_stream_state.primary.track, 1, 0x400); + if ((current_level_index == one && level_available[3] == 0) || (current_level_index == 0 && D_0013D390 != 0)) { - FUN_00265860(); - index = current_level_index; + FUN_00216088(); } else { - FUN_00265828(0); - index = current_level_index; + FUN_00216050(0); } - if (level_visit_state[index] == 0) { - level_visit_state[index] = 1; + if (level_visit_state[current_level_index] == 0) { + level_visit_state[current_level_index] = 1; } - stat = (struct UsageStat *)(D_00141680 + current_level_index * 8); - if (stat->count <= 0xfffe) { - stat->count++; + if (level_usage[current_level_index].count < 0xFFFF) { + level_usage[current_level_index].count++; } - frames = FUN_001fef20(D_0015EEA4) / 600; - stat = (struct UsageStat *)(D_00141680 + current_level_index * 8); - if (stat->unk2 < frames) { - frames = FUN_001fef20(D_0015EEA4) / 600; - stat = (struct UsageStat *)(D_00141680 + current_level_index * 8); - stat->unk2 = frames; + per = 600; + if (scale_game_frames(D_0015EEA4) / per > level_usage[current_level_index].unk2) { + level_usage[current_level_index].unk2 = scale_game_frames(D_0015EEA4) / 600; } - *(s32 *)(D_00141680 + 4 + current_level_index * 8) = - (*(s32 *)(D_00141680 + 4 + current_level_index * 8) | (1 << current_level_index)) | 0x80000000; + level_usage[current_level_index].level_mask = + level_usage[current_level_index].level_mask | (1 << current_level_index) | 0x80000000; FUN_0012eaf0(); while (D_L00_0015F570 == 0) { - restart = 0; - restart_arg = 0; - frm_clock_time += *timer; - *timer = 0; - FUN_001f6d70(); - D_L00_0015F5D8 = 0; - FUN_002a08c8(); - FUN_002a0858(); - FUN_00201040(); - FUN_00201350(); - FUN_00200f40(); - FUN_0012dc80(); - old_mode = D_L00_0015F5C4; - switch (old_mode) { - case -1: FUN_00267898(); FUN_001f4598(); FUN_001f58e0(); break; - case 0: FUN_00267898(); FUN_00297f78(); FUN_001f8e30(); break; - case 1: FUN_002999a8(); break; - case 2: FUN_00267898(); FUN_00298f90(); FUN_001f8e90(); break; - case 3: FUN_00267898(); FUN_00276bd0(); FUN_001f8f50(); break; - case 4: FUN_00267898(); FUN_00202aa0(); FUN_001f8ec8(); break; - case 5: FUN_00267898(); FUN_0029c648(); FUN_002a02b0(); break; - case 6: FUN_00267898(); FUN_00290590(); FUN_00291d00(); break; - case 7: FUN_00267898(); FUN_00299c48(); FUN_001f8f78(); break; + quit = 0; + full = 0; + frm_clock_time += (unsigned int)*(volatile int *)0x10000800; + *(volatile int *)0x10000800 = 0; + FUN_L00_001f6d70(); + D_L00_0015F5D8_m = 0; + vu1_send_chain(); + swap_render_buffer_chain(); + put_draw_buffer_small(); + append_palette_transfer_packet(); + put_draw_buffer_large(); + snd_flush_sound_commands(); + v = D_L00_0015F5C4_m; + switch (v) { + case -1: + register_audio_stream_callback(); + FUN_L00_001f4598(); + FUN_L00_001f58e0(); + break; + case 0: + register_audio_stream_callback(); + FUN_L00_00297f78(); + FUN_L00_001f8e30(); + break; + case 1: + FUN_L00_002999a8(); + break; + case 2: + register_audio_stream_callback(); + FUN_L00_00298f90(); + prepare_debug_profiler_render(); + break; + case 3: + register_audio_stream_callback(); + FUN_L00_00276bd0(); + FUN_L00_001f8f50(); + break; + case 4: + register_audio_stream_callback(); + update_mode_freeze(); + FUN_L00_001f8ec8(); + break; + case 5: + register_audio_stream_callback(); + FUN_L00_0029c648(); + FUN_L00_002a02b0(); + break; + case 6: + register_audio_stream_callback(); + update_resident_gameplay_state(); + dispatch_game_state_update(); + break; + case 7: + register_audio_stream_callback(); + FUN_L00_00299c48(); + FUN_L00_001f8f78(); + break; } - mode = D_L00_0015F5C4; - if (mode != old_mode) { + if (D_L00_0015F5C4_m != v) { D_L00_0015F5C8 = 0; } else { D_L00_0015F5C8 = D_L00_0015F5C8 + 1; } - if (D_L00_0015F5D8 != 0) { - FUN_002a09d8(1); - FUN_002a07f8(); + if (D_L00_0015F5D8_m != 0) { + vu1_sync_chain(1); + vu1_init_chain(); continue; } - FUN_0024b690(); - FUN_0024ac20(); - if ((D_0013D364 > 2 || D_0013D36C >= 0) && D_L00_001B9E2C == 0) { - rotation_period = 55; - FUN_001f9060(0); - FUN_002a0ba8(0x47, 0x3004b); - FUN_0023b4d8(FUN_0023b208(0x755d, 0), 0x32, 300, 0x40, 0x40, 0x80); - frames = D_L00_0015F3F8 % rotation_period; - FUN_0023c2a0(1312.0f, 5312.0f, 272.0f, 272.0f, - ((f32)frames * -6.2831855f) / (f32)rotation_period, 0x40, 0x40, - FUN_0023b2b8(FUN_0023b208(0x755d, 1))); - FUN_001f9178(); + memcard_update_state(); + run_state_handler(); + if (memory_card_state.state >= 3 || memory_card_state.pending_state >= 0) { + if (D_L00_001B9CF0.unk13C == 0) { + int n = 55; + float size; + float ang; + int t; + + setup_gif_paging(0); + size = 272.0f; + vu1_add_gs_register(0x47, 0x3004B); + t = find_hud_sprite(0x755D, 0); + draw_hud_sprite(t, 0x32, 0x12C, 0x40, 0x40, 0x80); + ang = (float)(D_L00_0015F3F8 % n) * -6.2831855f / (float)n; + draw_rotated_sprite(1312.0f, 5312.0f, 0x40, 0x40, get_frame_texture(find_hud_sprite(0x755D, 1)), + size, size, ang); + do_gif_paging(); + } + } + D_L00_001B9CF0.unk13C = 0; + FUN_L00_001f36f8(); + FUN_001e93e8(level_frame_callback_args, 0x10); + FUN_001e93e8(level_frame_callback_args, 0x10); + vu1_sync_chain(1); + D_L00_0015F5D0 = convert_integer_to_float(*(volatile int *)0x10000800) / (pal_mode != 0 ? 11520.0f : 9600.0f); + if (D_L00_0015F5C4_m == 0 && g_debug_menu.profiler_mode != 0) { + FUN_001e93e8(); } - D_L00_001B9E2C = 0; - FUN_001f36f8(); - bss_start = (u8 *)&pal_mode + 0xf38; - FUN_001f6d98(bss_start, 0x10); - FUN_001f6da0(bss_start, 0x10); - FUN_002a09d8(1); - frame_ratio = FUN_00200240(*timer); - frame_ratio = frame_ratio / (pal_mode ? 11520.0f : 9600.0f); - D_L00_0015F5D0 = frame_ratio; - if (D_L00_0015F5C4 == 0 && D_L00_0016C070 != 0) FUN_001f6d90(); - if (D_00141401 == 0) { - if (D_L00_0015F5C4 == 0 || D_L00_0015F5C4 == 2) { - frames = (s32)*timer; - value = pal_mode ? 0x2d00 : 0x2580; - if (value < frames) { - if (D_L00_0015F5C4 == 0) { - FUN_00267898(); FUN_00297f78(); - } else if (D_L00_0015F5C4 == 2 && D_L00_0016C8B0 == 0) { - FUN_00267898(); FUN_00298f90(); + if (hero.unk20B1 == 0) { + int mode = D_L00_0015F5C4_m; + + if (mode == 0 || mode == 2) { + int lim = 9600; + + if (pal_mode != 0) { + lim = 11520; + } + if (lim < *(volatile int *)0x10000800) { + if (mode == 0) { + register_audio_stream_callback(); + FUN_L00_00297f78(); + } else if (mode == 2 && D_L00_0016C8B0 == 0) { + register_audio_stream_callback(); + FUN_L00_00298f90(); } } FUN_00122298(0); D_L00_0015F3F8 = D_L00_0015F3F8 + 1; - FUN_00284c50(); - D_0015F5AC = 0; + FUN_00226e08(); + D_L00_0015F5AC = 0; } else { FUN_00122298(0); D_L00_0015F3F8 = D_L00_0015F3F8 + 1; - FUN_00284c50(); - D_L00_0015F5AC = 0; + FUN_00226e08(); + D_L00_0015F5A8_e[1] = 0.0f; } } - FUN_001f8540(); - if (D_L00_0015F5C4 == 0 && D_00141401 != 0) { - restart = 1; - restart_arg = 1; - } - if (restart) { - FUN_002a07f8(); - FUN_0012eb00(); - FUN_0012dc80(); - FUN_0028e048(); - FUN_002656c0(); - FUN_00244110(0, restart_arg); - D_L00_0015F5C4 = 0; - FUN_00265418(D_00151708, 1, 0x400); - FUN_00234e98(); + reset_gs_registers_pr(); + if (D_L00_0015F5C4_m == 0 && hero.unk20B1 != 0) { + quit = 1; + full = 1; } - frames = FUN_001fef20(D_0015EEA4) / 600; - stat = (struct UsageStat *)(D_00141680 + current_level_index * 8); - if (stat->unk2 < frames) { - frames = FUN_001fef20(D_0015EEA4) / 600; - stat = (struct UsageStat *)(D_00141680 + current_level_index * 8); - stat->unk2 = frames; + if (quit != 0) { + vu1_init_chain(); + snd_reset_state_and_flush_commands(); + snd_flush_sound_commands(); + sound_stop_all_sounds(); + music_stop(); + FUN_L00_00244110(0, full); + D_L00_0015F5C4_m = 0; + music_start_track(music_stream_state.primary.track, 1, 0x400); + init_hud(); } - } - FUN_00292e08(); -} -#endif -#ifndef NON_MATCHING -INCLUDE_ASM("config/us/overlays/asm/FUN_L00_002464a8.s", FUN_L00_002464a8); -#else -#endif -#include "rnc/storage/disc_table.h" - -typedef struct { - u8 pad0[0x24]; - s32 active; - u8 pad28[0x1fc]; - s32 archive_index; - s32 load_state; - s32 file_handle; - s32 loaded; - s32 transfer_bytes; - u8 pad238[4]; - s32 old_base; - u8 pad240[0x38]; - s32 start; - s32 buffer; - s32 old_end; - s32 zero_284; - s32 zero_288; - s32 slot_28c; - s32 level_slot; - s32 slot_294; - s32 slot_298; - s32 slot_29c; - s32 slot_2a0; - u8 pad2a4[4]; - s32 last_transfer_bytes; -} RenderArchiveState; - -extern RenderArchiveState D_L00_001841F0 __asm__("D_L00_001841F0"); -extern u8 D_0013D4E1 __attribute__((section(".data"))); -extern struct DiscFile D_00138438[]; - -void FUN_001e93e8(void); -void FUN_0020bf90(s32, s32); -void FUN_00216788(s32, s32, s32); -void FUN_002168a8(s32); -void FUN_L00_00293d38(s32, s32, s32, s32); -void FUN_00232f20(s32, s32, s32, s32, s32); - -void FUN_L00_002468b8(void) { - s32 first_base; - s32 second_base; - s32 buffer; - s32 bytes; - s32 archive_index; - RenderArchiveState *state = &D_L00_001841F0; - - FUN_001e93e8(); - FUN_0020bf90(state->archive_index, 1); - first_base = D_L00_001B9CF0.first_base; - second_base = D_L00_001B9CF0.second_base; - buffer = first_base + 0x9a800; - D_L00_001B9CF0.first_base = buffer + 0x48000; - D_L00_001841F0.old_base = first_base; - D_L00_001841F0.start = 0; - D_L00_001841F0.buffer = buffer; - D_L00_001841F0.old_end = second_base; - D_L00_001B9CF0.second_base = second_base + 0x48000; - state->zero_284 = 0; - state->zero_288 = 0; - state->slot_28c = -1; - state->level_slot = -1; - state->slot_294 = -1; - state->slot_298 = -1; - state->slot_29c = -1; - state->slot_2a0 = -1; - if (state->file_handle != -1) { - if (state->loaded == 0 && D_0013D4E1 != 0) { - archive_index = state->archive_index; - bytes = disc_table.render_archives[archive_index].size << 7; - FUN_00216788(buffer, disc_table.render_archives[archive_index].sector, - disc_table.render_archives[archive_index].size); - FUN_002168a8(1); - state->loaded = 1; - state->transfer_bytes = bytes; - FUN_L00_00293d38(state->buffer, state->file_handle, 0, bytes); - state->level_slot = current_level_index + 0x100; - state->last_transfer_bytes = bytes; - state->active = 1; - state->load_state = -2; - return; + per = 600; + if (scale_game_frames(D_0015EEA4) / per > level_usage[current_level_index].unk2) { + level_usage[current_level_index].unk2 = scale_game_frames(D_0015EEA4) / 600; } - if (D_L00_001841F0.file_handle != -1) { - D_L00_001841F0.last_transfer_bytes = D_L00_001841F0.transfer_bytes; - FUN_00232f20(D_L00_001841F0.buffer, D_L00_001841F0.file_handle, 0, D_L00_001841F0.transfer_bytes, 0); - D_L00_001841F0.level_slot = D_0013D4E1 != 0 ? current_level_index + 0x100 : current_level_index; - D_L00_001841F0.active = 1; - D_L00_001841F0.load_state = -2; - return; - } - } - D_L00_001841F0.active = 0; -} -#ifdef NON_MATCHING -#include "rnc/storage/disc_table.h" -extern u8 D_0013D4E1; -extern s32 D_L00_00173E08 __attribute__((section(".data"))); - -typedef struct { - s32 first_data; - s32 second_data; - s32 scratch_data; - s32 mask_data; - s32 initialized; - s32 second_raw; - u8 pad18[0x20c]; - s32 archive_index; - u8 pad228[4]; - s32 file_handle; - s32 loaded; - s32 transfer_bytes; -} RenderArchiveLoad; -extern RenderArchiveLoad D_L00_001841F0_load __asm__("D_L00_001841F0"); - -void FUN_00266040(void *, s32, s32) __asm__("FUN_L00_00266040"); -s32 FUN_00293c58(void *, s32, s32, s32) __asm__("FUN_L00_00293c58"); -void FUN_L00_0024d8d0(void *, s32 *) __asm__("FUN_L00_0024d8d0"); -s32 FUN_002355f0(s32, s32, s32, s32) __asm__("FUN_L00_002355f0"); -void hud_send_resident_bank(s32, s32, s32) __asm__("FUN_001ff128"); -void FUN_L00_00248278(s32, s32, s32) __asm__("FUN_L00_00248278"); -void FUN_L00_00249f48(s32, void *, s32) __asm__("FUN_L00_00249f48"); - -extern u8 D_L00_00184394[]; -extern s32 D_L00_00183EF0[]; -extern char render_archive_source_file[] __asm__("D_L00_0015FE00"); - -void FUN_L00_002464a8(void) { - s32 i, x, y; - s32 *source; - s32 *destination; - s32 *archive; - s32 first_size, second_size; - s32 scratch; - s32 word0, word1; - s32 heap_tag; - s32 *archive_base; - f32 *points; - f32 *coefficients; - f32 x_slope, y_slope; - f32 x0, y0, x1, y1, x2, y2, x3, y3; - struct DiscFile *file; - u8 *level_data; - u8 *mask; - RenderArchiveLoad *state = &D_L00_001841F0_load; - - D_L00_001841F0_load.initialized = 1; - source = D_L00_00183EF0; - destination = (s32 *)((u8 *)state + 0x154); - for (i = 0x13; i >= 0; i--) { - word0 = source[0]; - word1 = source[1]; - *(s32 *)((u8 *)destination - 0x50) = word0; - destination[0] = word1; - *(f32 *)((u8 *)destination - 0xa0) = 0.65f; - source += 2; - destination++; - } - i = current_level_index; - D_L00_001841F0_load.file_handle = -1; - i = 0x12 < i ? 0 : i; - D_L00_001841F0_load.archive_index = i; - points = (f32 *)0x182810; - coefficients = (f32 *)0x182a70; - for (i = 0x12; i >= 0; i--) { - x0 = points[0]; - y0 = points[1]; - x1 = points[2]; - y1 = points[3]; - x2 = points[4]; - y2 = points[5]; - x3 = points[6]; - y3 = points[7]; - x_slope = (x2 - x3) / (x0 - x1); - y_slope = (y2 - y3) / (y0 - y1); - coefficients[1] = x_slope; - coefficients[3] = y_slope; - coefficients[0] = x2 - x_slope * x0; - coefficients[2] = y2 - y_slope * y0; - points += 8; - coefficients += 4; - } - if (D_0013D4E1 != 0) { - file = (struct DiscFile *)0x138438; - D_L00_001841F0_load.loaded = 1; - } else { - file = (struct DiscFile *)0x1383a0; - D_L00_001841F0_load.loaded = 0; - } - file += D_L00_001841F0_load.archive_index; - if (file->size != 0) { - *(s32 *)0x184218 = 1; - heap_tag = (s32)render_archive_source_file; - archive_base = (s32 *)D_L00_00173E08; - archive = (s32 *)((s32)archive_base + 0x9a800); - scratch = file->size << 7; - FUN_00266040(archive, file->sector, file->size); - state->file_handle = FUN_00293c58(archive, scratch, 0x4800, 0x1e8b00); - state->transfer_bytes = scratch; - FUN_L00_0024d8d0(archive, archive_base); - archive = archive_base; - first_size = archive[1] - archive[0]; - D_L00_001841F0_load.first_data = FUN_002355f0(first_size, 0, heap_tag, 0x2db); - hud_send_resident_bank(D_L00_001841F0_load.first_data, (s32)archive + archive[0], first_size); - D_L00_001841F0_load.first_data += 8; - state->second_data = D_L00_001841F0_load.first_data; - second_size = archive[2] - archive[1]; - state->second_raw = FUN_002355f0(second_size, 0, heap_tag, 0x2ec); - hud_send_resident_bank(state->second_raw, (s32)archive + archive[1], second_size); - state->scratch_data = FUN_002355f0(0x1000, 0, heap_tag, 0x2f3); - destination = (s32 *)0x184228; - for (i = 0; i < 8; i++) { - *(s32 *)((u8 *)destination - 8) = -1; - *(s32 *)((u8 *)destination - 4) = -1; - destination[0] = state->scratch_data + i * 0x200; - destination += 4; - } - state->mask_data = FUN_002355f0(0x8000, 0, (s32)render_archive_source_file, 0x2fc); - level_data = (u8 *)(0x141ec0 + state->archive_index * 0x800); - if (level_data[0] == 0) { - FUN_L00_00248278(state->mask_data, D_L00_001841F0_load.first_data, state->second_data); - } else { - FUN_L00_00249f48(state->mask_data, level_data, state->second_raw); - } - mask = D_L00_00184394; - for (y = 0; y < 32; y++) { - for (x = 0; x < 32; x++) { - if ((15.5f - (f32)x) * (15.5f - (f32)x) + - (15.5f - (f32)y) * (15.5f - (f32)y) > 256.0f) { - mask[x / 8 + y * 4] |= 1 << (x % 8); - } - } - } - } else { - D_L00_001841F0_load.first_data = 0; - *(s32 *)0x184218 = 0; - state->scratch_data = 0; - state->mask_data = 0; - state->second_data = 0; } + do_space_transition(); } -#endif From 69c7e9118b24fef8c748a4beff2032893be8afe6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mateusz=20K=C5=82ysz?= Date: Tue, 13 Oct 2026 13:41:04 +0000 Subject: [PATCH 09/12] overlay: port FUN_L13_002b50d8 from rac1-decomp --- src/overlays/l13/gameplay/entities/002b0e80.c | 1013 ++++++++++++++++- 1 file changed, 1012 insertions(+), 1 deletion(-) diff --git a/src/overlays/l13/gameplay/entities/002b0e80.c b/src/overlays/l13/gameplay/entities/002b0e80.c index 26f89f28f..1bdbeb91e 100644 --- a/src/overlays/l13/gameplay/entities/002b0e80.c +++ b/src/overlays/l13/gameplay/entities/002b0e80.c @@ -907,7 +907,1018 @@ void FUN_L13_002b4ff0(struct Moby *m, char *d) { qzero(d + 0x120); } } -INCLUDE_ASM("config/us/overlays/asm/FUN_L13_002b50d8.s", FUN_L13_002b50d8); + +/* Robosquawker update: tracks a target, walks its path, flies to a random point, hops and pecks after the hero, and dies with a burst of parts. */ +/* Ported from rac1-decomp (src/overlays/l13_gemlik/vendor_002B2020.c: func_L13_002B6288), where it is exact; names translated to the US level program. */ + +typedef struct { + float f[4]; +} RsVec __attribute__((aligned(16))); + +typedef struct { + char pad0[0x20]; + unsigned char state; + char pad21[0x85]; + short hA6; +} RsTargetMoby; + +typedef struct { + RsVec pos; + RsVec v10; + RsVec v20; + RsVec v30; + RsTargetMoby *moby; + int kind; +} RsTarget; + +typedef struct { + char pad0[0x20]; + float f20; + short h24; + short h26; + unsigned char b28; + unsigned char b29; + char pad2A[0xE]; + int w38; + char pad3C[4]; + RsVec v40; + char pad50[8]; + unsigned char b58; + char pad59; + unsigned char b5A; + char pad5B[0x6D]; + short hC8; + char padCA[6]; + void *pD0; + char padD4[0x3C]; + char x110[0x10]; + char x120[0x10]; + float f130; + float f134; + float f138; + float f13C; + int w140; + int w144; + float f148; + char pad14C[0x11]; + unsigned char b15D; + char pad15E[0x12]; + float f170; + float f174; + char pad178[8]; + int w180; + int w184; + float f188; + float f18C; + char pad190[8]; + float f198; + char pad19C[8]; + float f1A4; + char pad1A8[0x10]; + int w1B8; + char pad1BC[0x14]; + RsVec v1D0; + RsVec v1E0; + float f1F0; + float f1F4; + float f1F8; + float f1FC; + float f200; + float f204; + short h208; + short h20A; + int w20C; + int w210; + short h214; + short h216; + char *p218; + int w21C; + int w220; + int w224; + void *p228; + int w22C; + unsigned char x230[1]; +} RsVars; + +typedef struct { + char pad0[0x10]; + RsVec pos; + unsigned char state; + unsigned char b21; + char pad22[2]; + char *w24; + char pad28[9]; + unsigned char b31; + char pad32[2]; + unsigned short h34; + char pad36[0xA]; + RsVec rot; + char pad50[2]; + unsigned char b52; + unsigned char b53; + char pad54[4]; + float f58; + char pad5C[0x14]; + unsigned char b70; + char pad71[7]; + RsVars *vars; + char pad7C[3]; + unsigned char b7F; + char pad80[0x14]; + int w94; + char pad98[0xC]; + unsigned char bA4; + char padA5; + unsigned short hA6; + char padA8[0x14]; + unsigned char bBC; +} RsMoby; + +typedef struct RsOther { + char pad0[0x10]; + RsVec pos; + signed char state; + char pad21[7]; + struct RsOther *next; + char pad2C[0x7A]; + short hA6; +} RsOther; + +typedef struct { + char pad0[0x10]; + RsVec pos; + RsMoby *src; + char pad24[8]; + float f2C; +} RsHit; + +extern char *D_L13_001B07B0[]; +extern char *D_L13_0015FFE4; +extern char *FUN_L00_0025a420(void *, int, int); +extern f32 convert_integer_to_float(s32) __asm__("func_001FA6C0"); +extern f32 distance_xyz(void *, void *) __asm__("func_001F9B48"); +extern f32 fast_add_rotations(f32, f32) __asm__("func_001FA580"); +extern f32 fast_cos(f32) __asm__("func_001F9DC8"); +extern f32 fast_sin(f32) __asm__("func_001F9DE0"); +extern f32 fast_subtract_rotations(f32, f32) __asm__("func_001FA5C8"); +extern f32 random_angle_radians(void) __asm__("func_00213308"); +extern f32 random_float_between(f32, f32) __asm__("func_002132A8"); +extern f32 vector_length_xy(void *) __asm__("FUN_001f9b20"); +extern f32 vector_length_xyz(void *) __asm__("FUN_001f9af0"); +extern float D_L13_0015F62C; +extern float D_L13_0015F630; +extern float D_L13_00161390 __attribute__((sda)); +extern float D_L13_00161394 __attribute__((sda)); +extern float D_L13_00161398 __attribute__((sda)); +extern float D_L13_0016139C __attribute__((sda)); +extern float D_L13_001670C0[]; +extern float FUN_001f96b0(float); +extern float FUN_001f9b80(void *, void *); +extern float FUN_001f9e90(float, float); +extern float FUN_L00_0025abf0(void *, void *, void *, float, float); +extern float approach_value(float *, float, float); +extern float fast_difference_between_rotations(float, float) __asm__("func_001FA688"); +extern float probe_ground_height(void *, int, float) __asm__("func_00213508"); +extern int D_L13_0015F5C4; +extern int D_L13_001613B0[] __attribute__((section(".sdata"))); +extern int FUN_001f9770(void *); +extern int FUN_00213928(void *, void *, void *, int, int *, float *, int, int); +extern int FUN_L00_001f0d60(float, void *, int, void *); +extern int FUN_L00_00257b90(int, int); +extern int FUN_L00_00258830(void *, void *, float, float, float, int); +extern int FUN_L00_00258b50(void *, void *, void *, void *, float); +extern int FUN_L00_0025c698(void *, void *); +extern int FUN_L00_002dc9f0(void *, void *); +extern int FUN_L01_0026e008(int, int); +extern int FUN_L01_0028b510(void *, void *, float); +extern int FUN_L01_0028b5e0(void *, void *, void *, void *); +extern int FUN_L01_002efbf8(int *, int, int); +extern int FUN_L13_0026bd00(void *, void *, float); +extern int is_point_inside_clip_volume(void *arg0, int arg1) __asm__("func_00214720"); +extern int scale_game_frames_alt(int) __asm__("FUN_001f96f8"); +extern s32 rand(void); +extern s32 random_integer_below(s32) __asm__("func_00213260"); +extern short D_L13_001613A0 __attribute__((sda)); +extern void FUN_L00_00257470(void *, int, int); +extern void FUN_L00_00258278(char *moby, float *vel, float target, float k, float d, float max); +extern void FUN_L00_00259bc8(void *, int, int, void *, void *, float); +extern void FUN_L00_0025a120(void *); +extern void FUN_L00_0025ab48(void *, float *, void *, void *); +extern void FUN_L00_0025c558(void *, void *, int, int, int, float); +extern void FUN_L00_0025d458(void *m, short *p); +extern void FUN_L00_0025d538(void *, void *); +extern void FUN_L00_0025f090(void *, void *, int, float, float); +extern void FUN_L00_0025f730(void *, float); +extern void FUN_L00_00263ac8(float, int, int, unsigned char *); +extern void FUN_L01_0026d930(char *p); +extern void FUN_L01_0026e090(int, int); +extern void add_vector_xyz(void *, void *, void *) __asm__("FUN_001f9a10"); +extern void blend_moby_animation_c(void *, s32, s32, s32) __asm__("FUN_00212f90"); +extern void clear_u64_value(void *) __asm__("func_001F99F8"); +extern void mark_moby_for_removal_c(void *) __asm__("func_0020C828"); +extern void normalize_vector_xyz(void *, void *, f32) __asm__("FUN_001f9bf8"); +extern void subtract_vector_xyz(void *, void *, void *) __asm__("FUN_001f9a28"); +extern void tick_countdown_32(s32 *) __asm__("func_001F9740"); +f32 compute_interpolated_record_value(void *anim) __asm__("FUN_0020c9e0"); +float absolute_float(float input) __asm__("func_001F99C0"); +void FUN_L13_002b4f28(struct Moby *moby, char *data); +void FUN_L13_002b4ff0(struct Moby *m, char *d); +extern int func_001F9908_i(void *) __asm__("FUN_001f9740"); + +void FUN_L13_002b50d8(RsMoby *m) { + RsVars *v; + RsVec old; + RsTarget tgt; + RsVec va; + RsVec vb; + RsVec vc; + int hits; + float dmg; + float ang; + float h; + float out; + RsHit *hit; + RsTargetMoby *tm; + + v = m->vars; + FUN_L00_00263ac8(2.5f, (int)m, 0, v->x230); + if (m->b31 != 0) { + if (distance_xyz(&m->pos, D_L13_001670C0) < 28.0f) { + FUN_L00_0025a120(m); + m->b7F = 0x16; + } + } + if (D_L13_0015F5C4 == 2) { + m->w94 = 0; + m->h34 |= 0x41; + return; + } + m->w94 = *(int *)(m->w24 + 0x10); + m->h34 &= 0xFFBE; + FUN_L13_0026bd00(m, &tgt, v->f1FC + 4.0f); + tm = tgt.moby; + if (tm == 0 || (v->h214 == 0 && v->w22C != -1 && is_point_inside_clip_volume(&tgt, v->w22C) == 0)) { + tgt.moby = 0; + tm = 0; + qzero(&tgt); + } + qcopy(&old, &m->pos); + if (v->w38 != 0) { + v->h214 = scale_game_frames_alt(0xF0); + } + v->w38 = 0; + FUN_001f9770(&v->h208); + if (m->state != 0) { + if (FUN_001f9770(&v->h214) != 0) { + v->f1FC = v->v1D0.f[3]; + } else { + v->f1FC = v->f200; + } + } + dmg = 0.0f; + hit = FUN_L00_0025a420(m, 0x330000, 0); + FUN_00213928(m, hit, &v->f20, 0, &hits, &dmg, 0, 4); + FUN_001f9770(&v->h26); + if (v->h26 < scale_game_frames_alt(0x2D) && hit != 0 && m->state != 0x63) { + if (hit->src->hA6 >= 0xB0 && hit->src->hA6 <= 0xB1 && v->h26 != 0) { + hit->f2C = 0.0f; + } + if (m->b21 != 0xFF) { + FUN_L01_0026e090(m->b21, 1); + } + if (hit->f2C != 0.0f) { + ang = FUN_001f9e90(m->pos.f[0] - tgt.pos.f[0], m->pos.f[1] - tgt.pos.f[1]); + v->f148 = 0.5f; + v->w140 = 0x202; + v->f20 -= hit->f2C; + v->f130 = 0.0055f; + v->f134 = 0.0011f; + v->f138 = D_L13_00161394 * frame_time; + v->f13C = D_L13_00161390 * frame_time; + v->w144 = 9; + v->b15D = 0; + if (v->f20 <= 0.0f) { + m->h34 &= 0xEFFF; + v->f138 = frame_time * 10.0f; + v->f13C = frame_time * 5.5f; + *(u128 *)&va = *(u128 *)&hit->pos; + FUN_L00_0025ab48(&va, &ang, &v->f138, &v->f13C); + /* Fakematch: ang is read into a copy before the call so it is loaded ahead of rand(), like retail. */ + { float yaw = ang; FUN_L00_0025c558(m, v->x120, (rand() & 1) + 9, 1, 0, yaw); } + v->f170 = 11.0f; + v->f174 = 18.0f; + m->state = 0x63; + FUN_L13_002b4fb8((Level13VendorMoby *)v); + v->x110[7] = 0x78; + FUN_L00_0025d458(m, (short *)v->x110); + FUN_L00_00257470(m, 0, -1); + } else { + *(u128 *)&va = *(u128 *)&hit->pos; + FUN_L00_0025ab48(&va, &ang, &v->f138, &v->f13C); + { float yaw = ang; FUN_L00_0025c558(m, v->x120, (rand() & 1) + 9, 1, 0, yaw); } + v->f170 = 5.0f; + v->f174 = 10.0f; + m->state = 6; + FUN_L13_002b4fb8((Level13VendorMoby *)v); + *(unsigned char *)&v->x110[7] = 0xFA; + v->h26 = scale_game_frames_alt(0x3C); + FUN_L00_0025d458(m, (short *)v->x110); + } + } + } + m->bA4 = 0xFF; + switch (m->state) { + case 0: + qcopy(&v->v1D0, &m->pos); + v->v1D0.f[3] = v->f1FC; + if (v->h20A != 0) { + m->state = 1; + if (m->b53 != 3) { + blend_moby_animation_c(m, 3, 0, 0); + } + } else { + m->state = 0xE; + m->pos.f[2] += 6.0f; + if (m->b53 != 0) { + blend_moby_animation_c(m, 0, 0, 0); + } + } + v->h214 = 0; + v->h208 = 0; + v->b29 = 0; + v->f20 = 1.0f; + v->h24 = 1; + v->b58 = 8; + v->b5A = 4; + FUN_L01_0026d930((char *)&v->w180); + v->w180 = 0x38D; + v->f18C = 2.0f; + v->f188 = 2.0f; + v->f1A4 = v->f204 * frame_time; + v->w1B8 |= 0x30; + if (rand() & 1) { + m->h34 |= 0x8000; + } + v->pD0 = &D_L13_001613A0; + if (v->w220 != -1) { + v->w224 = FUN_L01_0028b510(&m->pos, D_L13_001B07B0[v->w220], 0.0f); + } + break; + case 0xE: { + float d; + + FUN_L13_002b4f28((unsigned char *)m, (char *)v); + subtract_vector_xyz(&va, &tgt, &m->pos); + d = probe_ground_height(&m->pos, 0x120, 0.5f); + if (d > 1.0f + && vector_length_xy(&va) < v->f1FC + 4.0f + && absolute_float(m->pos.f[2] - tgt.pos.f[2]) < 10.0f + && random_integer_below(0x13) == 0) { + if (m->b53 != 0) { + blend_moby_animation_c(m, 0, 0, scale_game_frames_alt(3)); + } + m->state = 0x11; + FUN_L13_002b4fb8((Level13VendorMoby *)v); + } else if (d > 1.0f && m->bBC == 1 && random_integer_below(4) == 0) { + if (random_integer_below(0x100) & 1) { + v->f1F8 = -v->f1F8; + } + v->f1F4 = v->f1F8 * 0.017453292f; + v->w210 = scale_game_frames_alt((int)random_float_between(30.0f, 90.0f)); + if (m->b53 != 0) { + blend_moby_animation_c(m, 0, 0, scale_game_frames_alt(3)); + } + FUN_L13_002b4fb8((Level13VendorMoby *)v); + m->state = 0x11; + clear_u64_value(&v->v40); + m->bBC = 0; + } else if (v->w220 != -1) { + char *path; + + path = D_L13_001B07B0[v->w220]; + if (distance_xyz(&m->pos, path + (v->w224 * 16 + 16)) < 0.25f) { + v->w224 += 1; + if (v->w224 >= *(int *)path) { + v->w224 = 0; + } + } + qcopy(&v->v1E0, path + v->w224 * 16 + 16); + m->state = 0x12; + } else if (func_001F9908_i(&v->w20C) != 0) { + int i; + + v->w20C = scale_game_frames_alt(FUN_L00_00257b90(0x28, 0x78)); + for (i = 0; i < 10; i++) { + float r; + float a; + + r = random_float_between(0.0f, 4.0f); + a = random_angle_radians(); + vb.f[0] = fast_cos(a) * r; + vb.f[1] = fast_sin(a) * r; + vb.f[2] = 0.0f; + vb.f[2] = random_float_between(5.0f, 7.0f); + add_vector_xyz(&v->v1E0, &vb, &v->v1D0); + if (probe_ground_height(&v->v1E0, 0x120, 0.5f) > 1.0f) { + break; + } + } + if (m->b53 != 0) { + blend_moby_animation_c(m, 0, 0, scale_game_frames_alt(3)); + } + m->state = 0xF; + } + break; + } + case 0xF: { + float a; + + a = FUN_001f9e90(v->v1E0.f[0] - m->pos.f[0], v->v1E0.f[1] - m->pos.f[1]); + FUN_L00_00258278((char *)m, &v->f1F0, a, 0.03f, 0.6f, 0.09f); + h = vector_length_xyz(&v->v40); + m->f58 = h * 20.0f + 1.0f; + subtract_vector_xyz(&v->v40, &v->v1E0, &m->pos); + if (vector_length_xyz(&v->v40) > 1.0f) { + approach_value(&h, frame_time * 4.0f, frame_time_sq * 6.0f); + } else { + approach_value(&h, frame_time, frame_time_sq * 8.0f); + } + FUN_L00_0025f730(&v->v40, h); + add_vector_xyz(&va, &v->v40, &m->pos); + if (FUN_L00_001f0d60(1.2f, &va, 0, m) != 0) { + clear_u64_value(&v->v40); + if (m->b53 != 0) { + blend_moby_animation_c(m, 0, 0, scale_game_frames_alt(3)); + } + m->state = 0xE; + } else { + qcopy(&m->pos, &va); + } + if (distance_xyz(&m->pos, &v->v1E0) < h || h == 0.0f) { + if (m->b53 != 0) { + blend_moby_animation_c(m, 0, 0, scale_game_frames_alt(3)); + } + m->state = 0xE; + } + FUN_L13_002b4f28((unsigned char *)m, (char *)v); + break; + } + case 0x12: { + char *path; + float a; + float d; + + path = D_L13_001B07B0[v->w220]; + a = FUN_001f9e90(v->v1E0.f[0] - m->pos.f[0], v->v1E0.f[1] - m->pos.f[1]); + FUN_L00_00258278((char *)m, &v->f1F0, a, 0.018f, 0.8f, 0.09f); + subtract_vector_xyz(&v->v40, &v->v1E0, &m->pos); + FUN_L00_0025f730(&v->v40, frame_time * 4.0f); + add_vector_xyz(&va, &v->v40, &m->pos); + m->f58 = vector_length_xyz(&v->v40) * 20.0f + 1.0f; + if (FUN_L00_001f0d60(1.2f, &va, 0, m) != 0) { + int i; + + v->w20C = scale_game_frames_alt(0x78); + for (i = 0; i < 10; i++) { + float r; + float an; + + r = random_float_between(0.0f, 3.0f); + an = random_angle_radians(); + vb.f[0] = fast_cos(an) * r; + vb.f[1] = fast_sin(an) * r; + vb.f[2] = 0.0f; + vb.f[2] = random_float_between(5.0f, 7.0f); + add_vector_xyz(&v->v1E0, &vb, &v->v1D0); + if (probe_ground_height(&v->v1E0, 0x120, 0.5f) > 1.0f) { + break; + } + } + if (m->b53 != 0) { + blend_moby_animation_c(m, 0, 0, scale_game_frames_alt(3)); + } + m->state = 0xF; + } else { + qcopy(&m->pos, &va); + } + d = distance_xyz(&m->pos, &v->v1E0); + if (d < vector_length_xyz(&v->v40)) { + float g; + + v->w224 += 1; + if (v->w224 >= *(int *)path) { + v->w224 = 0; + } + qcopy(&v->v1E0, path + v->w224 * 16 + 16); + v->v1E0.f[2] = v->v1E0.f[2] + random_float_between(-0.2f, 0.2f); + g = probe_ground_height(&m->pos, 0x120, 0.5f); + if (g > 1.0f + && vector_length_xy(&vb) < v->f1FC + 4.0f + && absolute_float(m->pos.f[2] - tgt.pos.f[2]) < 10.0f + && random_integer_below(0x13) == 0) { + if (m->b53 != 0) { + blend_moby_animation_c(m, 0, 0, scale_game_frames_alt(3)); + } + qzero(&v->v40); + m->state = 0x11; + FUN_L13_002b4fb8((Level13VendorMoby *)v); + } else if (g > 1.0f && m->bBC == 1 && random_integer_below(4) == 0) { + if (random_integer_below(0x100) & 1) { + v->f1F8 = -v->f1F8; + } + v->f1F4 = v->f1F8 * 0.017453292f; + v->w210 = scale_game_frames_alt((int)random_float_between(30.0f, 90.0f)); + if (m->b53 != 0) { + blend_moby_animation_c(m, 0, 0, scale_game_frames_alt(3)); + } + FUN_L13_002b4fb8((Level13VendorMoby *)v); + qzero(&v->v40); + m->state = 0x11; + clear_u64_value(&v->v40); + m->bBC = 0; + } + } + FUN_L13_002b4f28((unsigned char *)m, (char *)v); + break; + } + case 0x11: { + float g; + + g = probe_ground_height(&m->pos, 0x120, 0.5f); + approach_value(&v->v40.f[2], -(frame_time * 8.0f), frame_time_sq * 10.8f); + FUN_L00_00258830(m, &v->v40, 0.6f, 0.5f, 0.0f, 0); + if (m->b53 != 2 + && m->pos.f[2] - g <= frame_time * 8.0f * FUN_001f96b0(45.0f) + && m->b53 != 2) { + blend_moby_animation_c(m, 2, 0, scale_game_frames_alt(5)); + } + if (m->pos.f[2] <= g) { + m->pos.f[2] = g; + if (random_integer_below(0x100) & 1) { + v->f1F8 = -v->f1F8; + } + v->f1F4 = v->f1F8 * 0.017453292f; + v->w210 = scale_game_frames_alt((int)random_float_between(30.0f, 90.0f)); + m->state = 3; + clear_u64_value(&v->v40); + if (m->b53 != 5) { + blend_moby_animation_c(m, 5, 0, scale_game_frames_alt(3)); + } + } + break; + } + case 0x10: { + float g; + + g = probe_ground_height(&m->pos, 0x120, 0.5f); + if (m->pos.f[2] - g < 3.0f) { + approach_value(&v->v40.f[2], frame_time * 8.0f, frame_time_sq * 10.8f); + } else { + approach_value(&v->v40.f[2], frame_time, frame_time_sq * 10.8f); + } + FUN_L00_00258830(m, &v->v40, 0.6f, 0.5f, 0.0f, 0); + m->f58 = 6.0f - (m->pos.f[2] - g) / 6.0f * 5.0f; + if (g + 6.0f <= m->pos.f[2]) { + m->pos.f[2] = g + 6.0f; + if (m->b53 != 0) { + blend_moby_animation_c(m, 0, 0, scale_game_frames_alt(3)); + } + m->state = 0xE; + clear_u64_value(&v->v40); + } + FUN_L13_002b4f28((unsigned char *)m, (char *)v); + break; + } + case 1: + subtract_vector_xyz(&va, &tgt, &m->pos); + if (vector_length_xyz(&va) < v->f1FC + 4.0f + && absolute_float(m->pos.f[2] - tgt.pos.f[2]) < 8.0f + && random_integer_below(0x13) == 0) { + m->state = 2; + if (m->b53 != 4) { + blend_moby_animation_c(m, 4, 0, scale_game_frames_alt(3)); + } + } else if (m->bBC == 1 && random_integer_below(0x13) == 0) { + if (random_integer_below(0x100) & 1) { + v->f1F8 = -v->f1F8; + } + v->f1F4 = v->f1F8 * 0.017453292f; + v->w210 = scale_game_frames_alt((int)random_float_between(30.0f, 90.0f)); + m->state = 3; + if (m->b53 != 5) { + blend_moby_animation_c(m, 5, 0, scale_game_frames_alt(3)); + } + m->bBC = 0; + } else if (vector_length_xyz(&va) > v->f1FC + 6.0f && v->h20A == 0) { + qzero(&v->v40); + m->state = 0x10; + if (m->b53 != 0) { + blend_moby_animation_c(m, 0, 0, scale_game_frames_alt(3)); + } + } + FUN_L13_002b4ff0((char *)m, (char *)v); + break; + case 8: + subtract_vector_xyz(&va, &tgt, &m->pos); + if (vector_length_xyz(&va) < v->f1FC - 4.0f + && absolute_float(m->pos.f[2] - tgt.pos.f[2]) < 8.0f + && random_integer_below(0x13) == 0) { + m->state = 2; + m->pos.f[2] += 1.0f; + if (m->b53 != 4) { + blend_moby_animation_c(m, 4, 0, scale_game_frames_alt(3)); + } + } + break; + case 0xA: { + float a; + + a = FUN_001f9e90(v->v1D0.f[0] - m->pos.f[0], v->v1D0.f[1] - m->pos.f[1]); + FUN_L00_00258278((char *)m, &v->f1F0, a, 0.05f, 0.3f, 0.2f); + subtract_vector_xyz(&va, &tgt, &v->v1D0); + if ((vector_length_xyz(&va) < v->f1FC && absolute_float(v->v1D0.f[2] - tgt.pos.f[2]) < 8.0f) || m->bBC == 2) { + if (m->b21 != 0xFF) { + FUN_L01_0026e090(m->b21, 2); + } + if (m->b53 != (rand() & 1) + 9) { + blend_moby_animation_c(m, (rand() & 1) + 9, 0, scale_game_frames_alt(3)); + } + v->f134 = 0.0f; + v->f130 = D_L13_0016139C; + v->f138 = D_L13_00161398 * frame_time; + v->f13C = FUN_L00_0025abf0(&m->pos, &v->v1D0, &out, D_L13_00161398 * frame_time, -D_L13_0016139C); + v->w144 = 0xD; + v->b15D = 0; + FUN_L00_0025c558(m, v->x120, (rand() & 1) + 9, 1, 0, m->rot.f[2]); + v->f170 = 5.0f; + v->f174 = 10.0f; + FUN_L13_002b4f28((unsigned char *)m, (char *)v); + m->state = 0xB; + } + break; + } + case 0xB: + if (FUN_L00_0025c698(m, v->x120) & 1) { + FUN_L13_002b4fb8((Level13VendorMoby *)v); + qzero(v->x120); + m->state = 3; + if (random_integer_below(0x100) & 1) { + v->f1F8 = -v->f1F8; + } + v->f1F4 = v->f1F8 * 0.017453292f; + v->w210 = scale_game_frames_alt((int)random_float_between(30.0f, 90.0f)); + if (m->b53 != 5) { + blend_moby_animation_c(m, 5, 8, scale_game_frames_alt(3)); + } + return; + } else if (m->pos.f[2] < 5.0f) { + FUN_L00_00257470(m, 0, -1); + mark_moby_for_removal_c(m); + return; + } + break; + case 2: { + float a; + + a = FUN_001f9e90(m->pos.f[0] - tgt.pos.f[0], m->pos.f[1] - tgt.pos.f[1]); + FUN_L00_00258278((char *)m, &v->f1F0, a, 0.02f, 0.3f, 0.1f); + subtract_vector_xyz(&va, &tgt, &m->pos); + if (vector_length_xyz(&va) < v->f1FC + && absolute_float(m->pos.f[2] - tgt.pos.f[2]) < 8.0f + && random_integer_below(0x13) == 0) { + if (m->b21 != 0xFF) { + FUN_L01_0026e090(m->b21, 1); + } + if (random_integer_below(0x100) & 1) { + v->f1F8 = -v->f1F8; + } + v->f1F4 = v->f1F8 * 0.017453292f; + v->w210 = scale_game_frames_alt((int)random_float_between(30.0f, 90.0f)); + m->state = 3; + if (m->b53 != 5) { + blend_moby_animation_c(m, 5, 0, scale_game_frames_alt(3)); + } + m->bBC = 0; + } else if (m->bBC == 1 && random_integer_below(0x13) == 0) { + if (random_integer_below(0x100) & 1) { + v->f1F8 = -v->f1F8; + } + v->f1F4 = v->f1F8 * 0.017453292f; + v->w210 = scale_game_frames_alt((int)random_float_between(30.0f, 90.0f)); + m->state = 3; + if (m->b53 != 5) { + blend_moby_animation_c(m, 5, 0, scale_game_frames_alt(3)); + } + m->bBC = 0; + } + if (m->b53 == 4 && (m->b70 & 2)) { + blend_moby_animation_c(m, 3, 0, scale_game_frames_alt(3)); + } + FUN_L13_002b4ff0((char *)m, (char *)v); + break; + } + case 3: { + float r; + int res; + float a; + float d; + + r = absolute_float(m->pos.f[2] - tgt.pos.f[2]); + r = r / FUN_001f9b80(&m->pos, &tgt); + if (v->w21C != -1) { + FUN_L01_0028b5e0(m, D_L13_001B07B0[v->w21C], &tgt, &vb); + } else { + qcopy(&vb, &tgt); + } + a = FUN_001f9e90(vb.f[0] - m->pos.f[0], vb.f[1] - m->pos.f[1]) + v->f1F4; + FUN_L00_00258278((char *)m, &v->f1F0, a, 0.05f, 0.3f, 0.2f); + va.f[0] = fast_cos(m->rot.f[2]) * 2.0f; + va.f[1] = fast_sin(m->rot.f[2]) * 2.0f; + va.f[2] = 0.0f; + res = FUN_L00_00258b50(m, &v->w180, &va, &vb, 1.0f); + if (func_001F9908_i(&v->w210) != 0) { + v->w210 = scale_game_frames_alt((int)random_float_between(30.0f, 90.0f)); + v->f1F4 = -v->f1F4; + } + subtract_vector_xyz(&vc, &tgt, &v->v1D0); + d = FUN_001f9b80(&m->pos, &tgt); + if ((d < 1.5f + || (tgt.moby != 0 && tgt.moby->hA6 == 0x10E && tgt.moby->state != 0xFE && tgt.moby->state != 0xFD && d < 2.3f)) + && !(res & 2)) { + m->state = 4; + if (m->b53 != 6) { + blend_moby_animation_c(m, 6, 0, scale_game_frames_alt(3)); + } + } else { + if (r > 1.0f || (res & 2)) { + m->pos.f[0] = old.f[0]; + m->pos.f[1] = old.f[1]; + } + if (vector_length_xyz(&vc) < v->f1FC + 4.0f && absolute_float(m->pos.f[2] - tgt.pos.f[2]) < 8.0f) { + if (m->b21 != 0xFF) { + FUN_L01_0026e090(m->b21, 1); + } + } else if (m->bBC != 1) { + m->state = 5; + } + } + m->bBC = 0; + FUN_L13_002b4ff0((char *)m, (char *)v); + break; + } + case 4: { + float a; + int same; + float hh; + float dz; + float d; + float da; + float g; + + a = FUN_001f9e90(tgt.pos.f[0] - m->pos.f[0], tgt.pos.f[1] - m->pos.f[1]); + FUN_L00_00258278((char *)m, &v->f1F0, a, 0.05f, 0.3f, 0.2f); + same = m->b52 == m->b53; + hh = compute_interpolated_record_value(m); + dz = absolute_float(m->pos.f[2] - tgt.pos.f[2]); + d = FUN_001f9b80(&m->pos, &tgt); + da = fast_difference_between_rotations(FUN_001f9e90(tgt.pos.f[0] - m->pos.f[0], tgt.pos.f[1] - m->pos.f[1]), m->rot.f[2]); + if (same + && absolute_float(hh - 13.0f) < 0.2f + && dz < 1.5f + && (d < 2.0f + || (tgt.moby != 0 && tgt.moby->hA6 == 0x10E && tgt.moby->state != 0xFE && tgt.moby->state != 0xFD && d < 2.6f)) + && da < 0.2617994f) { + va.f[0] = fast_cos(m->rot.f[2]) * 0.2f; + va.f[1] = fast_sin(m->rot.f[2]) * 0.2f; + va.f[2] = 0.0f; + qcopy(&vb, &tgt); + vb.f[2] += 0.75f; + if (tm != 0) { + FUN_L00_00259bc8(tm, (int)m, 1, &vb, &va, 1.0f); + } + } + if ((m->b70 & 2) && FUN_001f9b80(&m->pos, &tgt) > 1.5f) { + m->state = 3; + if (m->b53 != 5) { + blend_moby_animation_c(m, 5, 0, scale_game_frames_alt(3)); + } + } + g = probe_ground_height(&m->pos, 0x120, 0.5f); + v->f198 -= frame_time_sq * 9.8f; + m->pos.f[2] += v->f198; + if (m->pos.f[2] < g) { + v->f198 = 0.0f; + m->pos.f[2] = g; + } + FUN_L13_002b4ff0((char *)m, (char *)v); + break; + } + case 5: { + int res; + float a; + + if (v->w21C != -1) { + FUN_L01_0028b5e0(m, D_L13_001B07B0[v->w21C], &v->v1D0, &vb); + } else { + qcopy(&vb, &v->v1D0); + } + a = FUN_001f9e90(vb.f[0] - m->pos.f[0], vb.f[1] - m->pos.f[1]); + FUN_L00_00258278((char *)m, &v->f1F0, a, 0.02f, 0.3f, 0.1f); + va.f[0] = fast_cos(m->rot.f[2]) * 2.0f; + va.f[1] = fast_sin(m->rot.f[2]) * 2.0f; + va.f[2] = 0.0f; + res = FUN_L00_00258b50(m, &v->w180, &va, &vb, 1.0f); + if (FUN_001f9b80(&m->pos, &v->v1D0) < 2.0f) { + m->state = 1; + if (m->b53 != 3) { + blend_moby_animation_c(m, 3, 0, scale_game_frames_alt(3)); + } + } + subtract_vector_xyz(&vc, &tgt, &v->v1D0); + if (vector_length_xyz(&vc) < v->f1FC) { + if (m->b21 != 0xFF) { + FUN_L01_0026e090(m->b21, 1); + } + m->state = 3; + if (m->b53 != 5) { + blend_moby_animation_c(m, 5, 0, scale_game_frames_alt(3)); + } + } else if (m->bBC == 1) { + m->state = 3; + if (m->b53 != 5) { + blend_moby_animation_c(m, 5, 0, scale_game_frames_alt(3)); + } + } else if (res & 2) { + m->pos.f[0] = old.f[0]; + m->pos.f[1] = old.f[1]; + m->state = 0xC; + if (m->b53 != 4) { + blend_moby_animation_c(m, 4, 0, scale_game_frames_alt(3)); + } + } + FUN_L13_002b4ff0((char *)m, (char *)v); + m->bBC = 0; + break; + } + case 6: + if (FUN_L00_0025c698(m, v->x120) & 1) { + qzero(v->x120); + m->state = 3; + if (m->b53 != 5) { + blend_moby_animation_c(m, 5, 0, scale_game_frames_alt(3)); + } + return; + } else if (m->pos.f[2] < 5.0f) { + FUN_L00_00257470(m, 0, -1); + mark_moby_for_removal_c(m); + return; + } + break; + case 7: + FUN_L13_002b4fb8((Level13VendorMoby *)v); + if (FUN_L00_002dc9f0(m, v->x120) != 0) { + m->state = 0xE; + if (m->b53 != 0) { + blend_moby_animation_c(m, 0, 0, 0); + } + v->hC8 = 0; + } + break; + case 0x63: { + int t; + + m->h34 &= 0xEFFF; + if (FUN_L00_0025c698(m, v->x120) & 0x140) { + clear_u64_value(&va); + t = (int)((float)scale_game_frames_alt(1) * 60.0f); + if (FUN_L01_002efbf8(D_L13_001613B0, 3, t) >= 0) { + FUN_L00_0025f090(m, &m->pos, 4, 0.5f, 13.0f); + } + mark_moby_for_removal_c(m); + return; + } else if (m->pos.f[2] < 0.0f) { + mark_moby_for_removal_c(m); + return; + } + break; + } + case 0xC: { + float r; + int res; + float a; + + r = absolute_float(m->pos.f[2] - tgt.pos.f[2]); + r = r / FUN_001f9b80(&m->pos, &tgt); + if (v->w21C != -1) { + FUN_L01_0028b5e0(m, D_L13_001B07B0[v->w21C], &v->v1D0, &vb); + } else { + qcopy(&vb, &v->v1D0); + } + a = FUN_001f9e90(vb.f[0] - m->pos.f[0], vb.f[1] - m->pos.f[1]); + FUN_L00_00258278((char *)m, &v->f1F0, a, 0.05f, 0.3f, 0.2f); + va.f[0] = fast_cos(m->rot.f[2]) * 2.0f; + va.f[1] = fast_sin(m->rot.f[2]) * 2.0f; + va.f[2] = 0.0f; + res = FUN_L00_00258b50(m, &v->w180, &va, &vb, 1.0f); + subtract_vector_xyz(&vc, &tgt, &v->v1D0); + if (FUN_001f9b80(&m->pos, &tgt) < 1.5f && r <= 1.0f) { + m->state = 4; + if (m->b53 != 6) { + blend_moby_animation_c(m, 6, 0, scale_game_frames_alt(3)); + } + } else if (r <= 1.0f && !(res & 2)) { + m->state = 5; + if (m->b53 != 5) { + blend_moby_animation_c(m, 5, 0, scale_game_frames_alt(3)); + } + } else { + if (m->b70 & 2) { + int anim; + + anim = 4; + random_integer_below(4); + if (random_integer_below(4) != 0) { + anim = 3; + } + blend_moby_animation_c(m, anim, 0, scale_game_frames_alt(3)); + } + if (random_integer_below(0x63) == 0) { + qzero(&v->v40); + m->state = 0x10; + if (m->b53 != 0) { + blend_moby_animation_c(m, 0, 0, scale_game_frames_alt(3)); + } + } + } + m->bBC = 0; + break; + } + case 0xD: { + RsOther *o; + float g; + + if (m->b52 != 5 && m->b53 != 5) { + blend_moby_animation_c(m, 5, 0, scale_game_frames_alt(3)); + } + va.f[0] = fast_cos(m->rot.f[2]) * (v->f204 * frame_time); + va.f[1] = fast_sin(m->rot.f[2]) * (v->f204 * frame_time); + va.f[2] = 0.0f; + add_vector_xyz(&vb, &m->pos, &va); + for (o = (RsOther *)D_L13_0015FFE4; o != 0; o = o->next) { + if (o == (RsOther *)m) { + continue; + } + if (o->state < 0) { + continue; + } + if (o->hA6 != 0 && o->hA6 != 0x3F) { + continue; + } + if (FUN_001f9b80(&vb, &o->pos) < 2.0f) { + float z; + float a; + float d; + + z = m->pos.f[2]; + a = FUN_001f9e90(o->pos.f[0] - m->pos.f[0], o->pos.f[1] - m->pos.f[1]); + a = fast_subtract_rotations(m->rot.f[2], a); + d = frame_time * 1.5707964f; + if (!(a > 0.0f)) { + d = -d; + } + m->rot.f[2] = fast_add_rotations(m->rot.f[2], d); + subtract_vector_xyz(&vb, &m->pos, &o->pos); + normalize_vector_xyz(&vb, &vb, 2.0f); + add_vector_xyz(&vb, &vb, &o->pos); + vb.f[2] = z; + } + } + qcopy(&m->pos, &vb); + g = probe_ground_height(&m->pos, 0x120, 0.5f); + v->f198 -= frame_time_sq * 9.8f; + m->pos.f[2] += v->f198; + if (m->pos.f[2] < g) { + v->f198 = 0.0f; + m->pos.f[2] = g; + } + if (v->p218 == 0 || FUN_001f9b80(&m->pos, v->p218 + 0x10) > convert_integer_to_float(v->h216)) { + m->state = 5; + if (m->b53 != 5) { + blend_moby_animation_c(m, 5, 0, scale_game_frames_alt(3)); + } + } + m->bBC = 0; + break; + } + } + FUN_L00_0025d538(m, v->x110); + if (m->pos.f[0] < 2.0f || m->pos.f[0] > 1021.0f + || m->pos.f[1] < 2.0f || m->pos.f[1] > 1021.0f + || m->pos.f[2] < 2.0f || m->pos.f[2] > 1021.0f) { + mark_moby_for_removal_c(m); + return; + } +} #include "qcopy.h" #include "rnc/overlay/quad.h" From edb68e518d1a3f0acf7a36d55b871b135d1bdebb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mateusz=20K=C5=82ysz?= Date: Tue, 13 Oct 2026 13:54:00 +0000 Subject: [PATCH 10/12] overlay: name ported aliases after their us labels --- src/overlays/l07/gameplay/entities/002cd2b0.c | 172 ++++++------ src/overlays/l13/gameplay/entities/002b0e80.c | 46 ++-- .../shared/gameplay/entities/002b2100.c | 250 +++++++++--------- .../shared/gameplay/entities/002bffa8.c | 182 ++++++------- 4 files changed, 325 insertions(+), 325 deletions(-) diff --git a/src/overlays/l07/gameplay/entities/002cd2b0.c b/src/overlays/l07/gameplay/entities/002cd2b0.c index fcbd20aa5..a7f0c846f 100644 --- a/src/overlays/l07/gameplay/entities/002cd2b0.c +++ b/src/overlays/l07/gameplay/entities/002cd2b0.c @@ -1388,21 +1388,21 @@ void FUN_L01_002b7fe0(char *p, int n); void FUN_L01_002b8288(void *a, int b); void FUN_L07_0030cd20(void); void FUN_L07_0030cd48_c(int arg) __asm__("FUN_L07_0030cd48"); -extern Rec_30D8E8 D_L07_001DD100_30D8E8[] __asm__("D_L07_001DCE40"); -extern void func_L01_002B8C00_30D8E8(void *, int) __asm__("FUN_L01_002b7a48"); -extern void func_L01_002B90A8_30D8E8(float) __asm__("FUN_L01_002b7ef0"); -extern void func_L01_002B8E20_30D8E8(void *, void *) __asm__("FUN_L01_002b7c68"); -extern void func_L01_002B9440_30D8E8(void *, int, float, float, float, float) __asm__("FUN_L01_002b8288"); -extern void func_L07_0030E128_30D8E8(int) __asm__("FUN_L07_0030cd48"); -extern void func_L01_0026F090_30D8E8(int, int) __asm__("FUN_L01_0026e0e0"); -extern int func_L07_00282EB0_30D8E8(void *, int, int, int) __asm__("FUN_L07_00281ef8"); -extern float func_00214D28_30D8E8(float *, float, float) __asm__("FUN_00213ed8"); -extern void func_L01_0026F040_30D8E8(int, int) __asm__("FUN_L01_0026e090"); -extern void func_L00_002A5158_30D8E8(void *, int, int, float, float, float, float) __asm__("FUN_L00_002a3ec8"); -extern int func_00215570_30D8E8(void *, int) __asm__("FUN_00214720"); -extern int func_L01_00276680_30D8E8(void *, float) __asm__("FUN_L01_00275690"); -extern void func_L01_002B9198_30D8E8(void *, int) __asm__("FUN_L01_002b7fe0"); -extern void func_L07_0030E100_30D8E8(void) __asm__("FUN_L07_0030cd20"); +extern Rec_30D8E8 D_L07_001DCE40_2cd2b0[] __asm__("D_L07_001DCE40"); +extern void FUN_L01_002b7a48_2cd2b0(void *, int) __asm__("FUN_L01_002b7a48"); +extern void FUN_L01_002b7ef0_2cd2b0(float) __asm__("FUN_L01_002b7ef0"); +extern void FUN_L01_002b7c68_2cd2b0(void *, void *) __asm__("FUN_L01_002b7c68"); +extern void FUN_L01_002b8288_2cd2b0(void *, int, float, float, float, float) __asm__("FUN_L01_002b8288"); +extern void FUN_L07_0030cd48_2cd2b0(int) __asm__("FUN_L07_0030cd48"); +extern void FUN_L01_0026e0e0_2cd2b0(int, int) __asm__("FUN_L01_0026e0e0"); +extern int FUN_L07_00281ef8_2cd2b0(void *, int, int, int) __asm__("FUN_L07_00281ef8"); +extern float FUN_00213ed8_2cd2b0(float *, float, float) __asm__("FUN_00213ed8"); +extern void FUN_L01_0026e090_2cd2b0(int, int) __asm__("FUN_L01_0026e090"); +extern void FUN_L00_002a3ec8_2cd2b0(void *, int, int, float, float, float, float) __asm__("FUN_L00_002a3ec8"); +extern int FUN_00214720_2cd2b0(void *, int) __asm__("FUN_00214720"); +extern int FUN_L01_00275690_2cd2b0(void *, float) __asm__("FUN_L01_00275690"); +extern void FUN_L01_002b7fe0_2cd2b0(void *, int) __asm__("FUN_L01_002b7fe0"); +extern void FUN_L07_0030cd20_2cd2b0(void) __asm__("FUN_L07_0030cd20"); void FUN_L07_0030c508(Moby_30D8E8 *m) { Data_30D8E8 *d = m->data; @@ -1427,8 +1427,8 @@ void FUN_L07_0030c508(Moby_30D8E8 *m) { Cab_30D8E8 *cab; Dir_30D8E8 *dir; int (*p)[4]; - func_L01_002B8C00_30D8E8(D_L07_001DD100_30D8E8, 0x24); - func_L01_002B90A8_30D8E8(1.0f); + FUN_L01_002b7a48_2cd2b0(D_L07_001DCE40_2cd2b0, 0x24); + FUN_L01_002b7ef0_2cd2b0(1.0f); cab = &D_L07_001CA900; dir = &D_L07_0017FF40; cab->f0 = 16.0f; @@ -1452,31 +1452,31 @@ void FUN_L07_0030c508(Moby_30D8E8 *m) { D_L07_00161214 = 48.0f; cab->b3C = 0x40; cab->b3D = 0x40; - D_L07_001612D0 = D_L07_001DD100_30D8E8; + D_L07_001612D0 = D_L07_001DCE40_2cd2b0; D_L07_001612D4 = p; D_L07_00161208 = 0; for (i = 0; i < 0x24; i++) { - func_L01_002B8E20_30D8E8(&D_L07_001DD100_30D8E8[i], p[i]); - D_L07_001DD100_30D8E8[d->idx].h1E = D_L07_00204680[d->idx]; + FUN_L01_002b7c68_2cd2b0(&D_L07_001DCE40_2cd2b0[i], p[i]); + D_L07_001DCE40_2cd2b0[d->idx].h1E = D_L07_00204680[d->idx]; } for (k = 0; k < 0x24; k++) { - Rec_30D8E8 *t = D_L07_001DD100_30D8E8; + Rec_30D8E8 *t = D_L07_001DCE40_2cd2b0; Rec_30D8E8 *r = &t[k]; for (j = 0; j < 2; j++) { float x = r->x + random_float_between(-6.0f, 6.0f); float y = r->y + random_float_between(-6.0f, 6.0f); - func_L01_002B9440_30D8E8(t, 0x24, x, y, 2.0f, 0.2f); + FUN_L01_002b8288_2cd2b0(t, 0x24, x, y, 2.0f, 0.2f); } } for (n = 0; n < 0x24; n++) { - func_L07_0030E128_30D8E8(n); + FUN_L07_0030cd48_2cd2b0(n); } } if (d->fC != 0) { m->state = 3; d->timer = scale_game_frames_alt(0x3C); if (m->pos[2] < d->lo) { - D_L07_001DD100_30D8E8[d->idx].h1E = 0; + D_L07_001DCE40_2cd2b0[d->idx].h1E = 0; } } else if (d->f8 != 0) { m->state = 1; @@ -1486,40 +1486,40 @@ void FUN_L07_0030c508(Moby_30D8E8 *m) { break; case 2: if (m->sub & 4) { - func_L01_0026F090_30D8E8(m->f21, 1); - } else if (func_L07_00282EB0_30D8E8(m, m->f21, 1, 0) && m->sub != 1) { - func_00214D28_30D8E8(&m->pos[2], d->lo, D_0015ED6C * 4.0f); - func_L01_0026F040_30D8E8(m->f21, 1); + FUN_L01_0026e0e0_2cd2b0(m->f21, 1); + } else if (FUN_L07_00281ef8_2cd2b0(m, m->f21, 1, 0) && m->sub != 1) { + FUN_00213ed8_2cd2b0(&m->pos[2], d->lo, D_0015ED6C * 4.0f); + FUN_L01_0026e090_2cd2b0(m->f21, 1); } else if (m->sub == 1) { - func_00214D28_30D8E8(&m->pos[2], d->lo, D_0015ED6C * 4.0f); + FUN_00213ed8_2cd2b0(&m->pos[2], d->lo, D_0015ED6C * 4.0f); } if (random_integer_below(200) == 0) { - float x = D_L07_001DD100_30D8E8[d->idx].x + random_float_between(-4.0f, 4.0f); + float x = D_L07_001DCE40_2cd2b0[d->idx].x + random_float_between(-4.0f, 4.0f); float y = random_float_between(-4.0f, 4.0f); - Rec_30D8E8 *r = &D_L07_001DD100_30D8E8[d->idx]; - func_L00_002A5158_30D8E8(r, 1, 1, x, r->y + y, 1.0f, -0.05f); + Rec_30D8E8 *r = &D_L07_001DCE40_2cd2b0[d->idx]; + FUN_L00_002a3ec8_2cd2b0(r, 1, 1, x, r->y + y, 1.0f, -0.05f); } break; case 1: if (m->sub & 8) { - func_L01_0026F090_30D8E8(m->f21, 2); - } else if (func_L07_00282EB0_30D8E8(m, m->f21, 1, 0) && m->sub != 2) { - func_00214D28_30D8E8(&m->pos[2], d->hi, D_0015ED6C * 4.0f); - func_L01_0026F040_30D8E8(m->f21, 2); + FUN_L01_0026e0e0_2cd2b0(m->f21, 2); + } else if (FUN_L07_00281ef8_2cd2b0(m, m->f21, 1, 0) && m->sub != 2) { + FUN_00213ed8_2cd2b0(&m->pos[2], d->hi, D_0015ED6C * 4.0f); + FUN_L01_0026e090_2cd2b0(m->f21, 2); } else if (m->sub == 2) { - func_00214D28_30D8E8(&m->pos[2], d->hi, D_0015ED6C * 4.0f); + FUN_00213ed8_2cd2b0(&m->pos[2], d->hi, D_0015ED6C * 4.0f); } if (random_integer_below(200) == 0) { - float x = D_L07_001DD100_30D8E8[d->idx].x + random_float_between(-4.0f, 4.0f); + float x = D_L07_001DCE40_2cd2b0[d->idx].x + random_float_between(-4.0f, 4.0f); float y = random_float_between(-4.0f, 4.0f); - Rec_30D8E8 *r = &D_L07_001DD100_30D8E8[d->idx]; - func_L00_002A5158_30D8E8(r, 1, 1, x, r->y + y, 1.0f, -0.05f); + Rec_30D8E8 *r = &D_L07_001DCE40_2cd2b0[d->idx]; + FUN_L00_002a3ec8_2cd2b0(r, 1, 1, x, r->y + y, 1.0f, -0.05f); } break; case 3: - if (d->volume >= 0 && func_00215570_30D8E8(&hero.motion.pos, d->volume)) { + if (d->volume >= 0 && FUN_00214720_2cd2b0(&hero.motion.pos, d->volume)) { d->f1C = 0; - func_L01_0026F090_30D8E8(m->f21, 4); + FUN_L01_0026e0e0_2cd2b0(m->f21, 4); } break; case 4: @@ -1542,7 +1542,7 @@ void FUN_L07_0030c508(Moby_30D8E8 *m) { break; case 7: if (d->hi < m->pos[2]) { - D_L07_001DD100_30D8E8[d->idx].h1E = 0; + D_L07_001DCE40_2cd2b0[d->idx].h1E = 0; mark_moby_for_removal_c2(m); return; } @@ -1553,27 +1553,27 @@ void FUN_L07_0030c508(Moby_30D8E8 *m) { } { Cab_30D8E8 *cab = &D_L07_001CA900; - D_L07_001DD100_30D8E8[d->idx].b1C = cab->b3C; - D_L07_001DD100_30D8E8[d->idx].b1D = cab->b3D; + D_L07_001DCE40_2cd2b0[d->idx].b1C = cab->b3C; + D_L07_001DCE40_2cd2b0[d->idx].b1D = cab->b3D; } - D_L07_001DD100_30D8E8[d->idx].z = m->pos[2]; + D_L07_001DCE40_2cd2b0[d->idx].z = m->pos[2]; on = 0.0f; - if (m->f94 != 0 && func_L01_00276680_30D8E8(m, 48.0f) != -1) { + if (m->f94 != 0 && FUN_L01_00275690_2cd2b0(m, 48.0f) != -1) { if (!(m->state >= 3 && m->state <= 7) || (m->pos[2] > d->lo && m->pos[2] < d->hi)) { on = 1.0f; } } if (on == 0.0f) { - D_L07_001DD100_30D8E8[d->idx].h1E = 0; + D_L07_001DCE40_2cd2b0[d->idx].h1E = 0; } else { - D_L07_001DD100_30D8E8[d->idx].h1E = D_L07_00204680[d->idx]; + D_L07_001DCE40_2cd2b0[d->idx].h1E = D_L07_00204680[d->idx]; } if (d->idx == 0) { - func_L01_002B9198_30D8E8(D_L07_001DD100_30D8E8, 0x24); - enqueue_callback_list_1_c(func_L07_0030E100_30D8E8, m); + FUN_L01_002b7fe0_2cd2b0(D_L07_001DCE40_2cd2b0, 0x24); + enqueue_callback_list_1_c(FUN_L07_0030cd20_2cd2b0, m); } if (d->idx == D_L07_00161B30) { - D_L07_001DD100_30D8E8[d->idx].h1E = D_L07_00161B34; + D_L07_001DCE40_2cd2b0[d->idx].h1E = D_L07_00161B34; D_L07_00204680[d->idx] = D_L07_00161B34; } } @@ -2864,19 +2864,19 @@ extern s64 get_effect_texture(s32) __asm__("func_001F44B8"); extern void cross_vectors_xyz(void *, void *, void *) __asm__("func_001F9AD8"); extern void draw_geometry_quad(void *, int, int) __asm__("func_001F7D30"); unsigned char *FUN_L00_002729c8(void *pos, unsigned char a, unsigned char b, unsigned char c, unsigned char d, unsigned char e, int g, float x, float y); -extern float func_001FA888_313800(int) __asm__("FUN_001fa6c0"); -extern float func_L00_0025F368_313800(float) __asm__("FUN_L00_0025e310"); -extern float func_001F9F90_313800(float) __asm__("FUN_001f9dc8"); -extern float func_001F9FA8_313800(float) __asm__("FUN_001f9de0"); +extern float FUN_001fa6c0_2cd2b0(int) __asm__("FUN_001fa6c0"); +extern float FUN_L00_0025e310_2cd2b0(float) __asm__("FUN_L00_0025e310"); +extern float FUN_001f9dc8_2cd2b0(float) __asm__("FUN_001f9dc8"); +extern float FUN_001f9de0_2cd2b0(float) __asm__("FUN_001f9de0"); extern void add_vector_xyz_cf(void *, int, void *) __asm__("FUN_L00_0024f7c8"); -extern void func_L00_001FF4B0_313800(void *, void *, float) __asm__("FUN_001f9bf8"); -extern int func_L00_001EFFF0_313800(void *, void *, int, void *, int) __asm__("FUN_001efa68"); -extern int func_001F9850_313800(int) __asm__("FUN_001f96f8"); -extern void *func_L00_00273868_313800(float *pos, unsigned char a1, unsigned char a2, unsigned char a3, +extern void FUN_001f9bf8_2cd2b0(void *, void *, float) __asm__("FUN_001f9bf8"); +extern int FUN_001efa68_2cd2b0(void *, void *, int, void *, int) __asm__("FUN_001efa68"); +extern int FUN_001f96f8_2cd2b0(int) __asm__("FUN_001f96f8"); +extern void *FUN_L00_002729c8_2cd2b0(float *pos, unsigned char a1, unsigned char a2, unsigned char a3, unsigned char a4, unsigned char a5, void *a6, float f0, float f1) __asm__("FUN_L00_002729c8"); -extern long func_001F4868_313800(int) __asm__("FUN_001f44b8"); -extern char D_L07_001670D0_313800[] __asm__("D_L07_00167050"); -extern char D_L07_00173F60_313800[] __asm__("D_L07_00173EE0"); +extern long FUN_001f44b8_2cd2b0(int) __asm__("FUN_001f44b8"); +extern char D_L07_00167050_2cd2b0[] __asm__("D_L07_00167050"); +extern char D_L07_00173EE0_2cd2b0[] __asm__("D_L07_00173EE0"); void FUN_L07_00312420(struct Moby *arg) { @@ -2887,50 +2887,50 @@ void FUN_L07_00312420(struct Moby *arg) int k; Packet_313800 pkt; - f20 = func_001FA888_313800(D_L07_0015F5CC_c); + f20 = FUN_001fa6c0_2cd2b0(D_L07_0015F5CC_c); qcopy(v50, p->f140); - t = func_001F9F90_313800(func_L00_0025F368_313800(f20 / 11.0f)); + t = FUN_001f9dc8_2cd2b0(FUN_L00_0025e310_2cd2b0(f20 / 11.0f)); f20 = f20 / 10.0f; - t = func_L00_0025F368_313800(f20 + t * 1.5707964f); - v50[0] = v50[0] + func_001F9FA8_313800(t); + t = FUN_L00_0025e310_2cd2b0(f20 + t * 1.5707964f); + v50[0] = v50[0] + FUN_001f9de0_2cd2b0(t); add_vector_xyz_cf(arg, 2, v30); subtract_vector_xyz(v10, v50, v30); - func_L00_001FF4B0_313800(v10, v10, 30.0f); + FUN_001f9bf8_2cd2b0(v10, v10, 30.0f); add_vector_xyz(v0, v50, v10); - if (func_L00_001EFFF0_313800(v30, v0, 2, arg, 0)) { - qcopy(v0, D_L07_00173F60_313800); + if (FUN_001efa68_2cd2b0(v30, v0, 2, arg, 0)) { + qcopy(v0, D_L07_00173EE0_2cd2b0); } else { flag = 0; } subtract_vector_xyz(v40, v30, v0); - cross_vectors_xyz(v20, D_L07_001670D0_313800, v40); - func_L00_001FF4B0_313800(v20, v20, 0.25f); + cross_vectors_xyz(v20, D_L07_00167050_2cd2b0, v40); + FUN_001f9bf8_2cd2b0(v20, v20, 0.25f); add_vector_xyz(v10, v20, v0); if (flag) { - func_L00_00273868_313800(v0, 0, func_001F9850_313800((rand_e50() & 1) + 0x2D), - func_001F9850_313800((rand_e50() & 7) + 0x37), 1, - func_001F9850_313800((rand_e50() & 3) + 0xD), arg, 1.0f, 1.0f); + FUN_L00_002729c8_2cd2b0(v0, 0, FUN_001f96f8_2cd2b0((rand_e50() & 1) + 0x2D), + FUN_001f96f8_2cd2b0((rand_e50() & 7) + 0x37), 1, + FUN_001f96f8_2cd2b0((rand_e50() & 3) + 0xD), arg, 1.0f, 1.0f); if (p->f15C != 0.0f) { subtract_vector_xyz(c2, v0, p->f150); - func_L00_001FF4B0_313800(c2, c2, 0.2f); + FUN_001f9bf8_2cd2b0(c2, c2, 0.2f); qcopy(m, p->f150); for (k = 0; k < 4; k++) { add_vector_xyz(m, m, c2); subtract_vector_xyz(h, m, v30); - func_L00_001FF4B0_313800(h, h, 5.0f); + FUN_001f9bf8_2cd2b0(h, h, 5.0f); subtract_vector_xyz(ii, m, h); add_vector_xyz(jj, m, h); - if (func_L00_001EFFF0_313800(ii, jj, 2, arg, 0)) { - qcopy(m, D_L07_00173F60_313800); + if (FUN_001efa68_2cd2b0(ii, jj, 2, arg, 0)) { + qcopy(m, D_L07_00173EE0_2cd2b0); } if (k == 2) { - func_L00_00273868_313800(m, 0, func_001F9850_313800((rand_e50() & 1) + 0x2D), - func_001F9850_313800((rand_e50() & 7) + 0x37), 1, - func_001F9850_313800((rand_e50() & 3) + 0xD), arg, 1.0f, 1.0f); + FUN_L00_002729c8_2cd2b0(m, 0, FUN_001f96f8_2cd2b0((rand_e50() & 1) + 0x2D), + FUN_001f96f8_2cd2b0((rand_e50() & 7) + 0x37), 1, + FUN_001f96f8_2cd2b0((rand_e50() & 3) + 0xD), arg, 1.0f, 1.0f); } else { - func_L00_00273868_313800(m, 1, func_001F9850_313800(0x2D), - func_001F9850_313800(0x37), 1, - func_001F9850_313800(0xD), arg, 1.0f, 1.0f); + FUN_L00_002729c8_2cd2b0(m, 1, FUN_001f96f8_2cd2b0(0x2D), + FUN_001f96f8_2cd2b0(0x37), 1, + FUN_001f96f8_2cd2b0(0xD), arg, 1.0f, 1.0f); } } } @@ -2939,7 +2939,7 @@ void FUN_L07_00312420(struct Moby *arg) } else { p->f15C = 0.0f; } - pkt.x128 = func_001F4868_313800(0x3B); + pkt.x128 = FUN_001f44b8_2cd2b0(0x3B); pkt.col[0] = pkt.col[1] = pkt.col[2] = pkt.col[3] = 0x80808080; pkt.x130 = 0xFF9000000260; pkt.x120 = 4; diff --git a/src/overlays/l13/gameplay/entities/002b0e80.c b/src/overlays/l13/gameplay/entities/002b0e80.c index 1bdbeb91e..ad93a9b9a 100644 --- a/src/overlays/l13/gameplay/entities/002b0e80.c +++ b/src/overlays/l13/gameplay/entities/002b0e80.c @@ -460,22 +460,22 @@ struct Moby *FUN_L13_002b4958_c(struct Moby *parent) __asm__("FUN_L13_002b4958") void FUN_L00_00257d78(float *out, float lo, float hi); void FUN_L13_002b47a0_c(struct Moby *moby) __asm__("FUN_L13_002b47a0"); void FUN_L13_002b48d8_c(struct Moby *moby) __asm__("FUN_L13_002b48d8"); -extern void func_L13_002B5A88_2B5368(void *) __asm__("FUN_L13_002b48d8"); -extern void *func_L13_002B5B08_2B5368(void *) __asm__("FUN_L13_002b4958"); -extern void func_L00_00264B40_2B5368(float, void *, int, void *) __asm__("FUN_L00_00263ac8"); -extern void func_00213DE0_2B5368(void *, int, int, int) __asm__("FUN_00212f90"); +extern void FUN_L13_002b48d8_2b0e80(void *) __asm__("FUN_L13_002b48d8"); +extern void *FUN_L13_002b4958_2b0e80(void *) __asm__("FUN_L13_002b4958"); +extern void FUN_L00_00263ac8_2b0e80(float, void *, int, void *) __asm__("FUN_L00_00263ac8"); +extern void FUN_00212f90_2b0e80(void *, int, int, int) __asm__("FUN_00212f90"); extern float angle_atan2(float, float) __asm__("FUN_001f9e90"); extern float fast_difference_between_rotations(float, float) __asm__("FUN_001fa688"); extern float vector_distance(void *, void *) __asm__("FUN_001f9b80"); extern int random_int_between(int, int) __asm__("FUN_L00_00257b90"); extern float approach_angle(void *, float, void *, float, float, float) __asm__("FUN_L00_0025be00"); -extern float func_001FA790_2B5368(float, float) __asm__("FUN_001fa5c8"); -extern float func_001FA748_2B5368(float, float) __asm__("FUN_001fa580"); -extern void func_L13_002B5950_2B5368(void *) __asm__("FUN_L13_002b47a0"); +extern float FUN_001fa5c8_2b0e80(float, float) __asm__("FUN_001fa5c8"); +extern float FUN_001fa580_2b0e80(float, float) __asm__("FUN_001fa580"); +extern void FUN_L13_002b47a0_2b0e80(void *) __asm__("FUN_L13_002b47a0"); extern void mark_moby_for_removal_cf(void *, int, int) __asm__("FUN_L00_00257470"); -extern void func_L00_0025F4A8_2B5368(void *, void *, void *, float, float, int, int, int, float, float, float, int, float, float, int, int, int, int) __asm__("FUN_L00_0025e450"); +extern void FUN_L00_0025e450_2b0e80(void *, void *, void *, float, float, int, int, int, float, float, float, int, float, float, int, int, int, int) __asm__("FUN_L00_0025e450"); extern void random_vector(float *, float, float) __asm__("FUN_L00_00257d78"); -extern unsigned char D_0013E633_2B5368[] __asm__("D_0013F420"); +extern unsigned char D_0013F420_2b0e80[] __asm__("D_0013F420"); void FUN_L13_002b41b8(Moby_2B5368 *m) { Data_2B5368 *data = m->data; @@ -483,29 +483,29 @@ void FUN_L13_002b41b8(Moby_2B5368 *m) { Moby_2B5368 *gun; float r; - func_L13_002B5A88_2B5368(m); + FUN_L13_002b48d8_2b0e80(m); t = data->target; if (data->gun != 0 && data->gun->cls_id == 0x24 && data->gun->state >= 0) { - func_L00_00264B40_2B5368(2.7f, data->gun, 1, data->fx); + FUN_L00_00263ac8_2b0e80(2.7f, data->gun, 1, data->fx); } switch ((unsigned char)m->state) { case 0: m->scale = m->cls->scale * 1.5f; - data->gun = func_L13_002B5B08_2B5368(m); + data->gun = FUN_L13_002b4958_2b0e80(m); data->f54 = m->rot.z; if (m->b53 != 0) { - func_00213DE0_2B5368(m, 0, 0, 10); + FUN_00212f90_2b0e80(m, 0, 0, 10); } m->state = 1; break; case 1: r = fast_difference_between_rotations(angle_atan2(t->pos.x - m->pos.x, t->pos.y - m->pos.y), data->f54); if (r < 1.5707964f && vector_distance(&m->pos, &t->pos) < 20.0f - && (data->volume == -1 || is_point_inside_clip_volume(D_0013E633_2B5368, data->volume) != 0)) { + && (data->volume == -1 || is_point_inside_clip_volume(D_0013F420_2b0e80, data->volume) != 0)) { data->f68 = 8.0f; if (m->b53 != 1) { int a = random_int_between(0, 3); - func_00213DE0_2B5368(m, 1, a, random_int_between(7, 13)); + FUN_00212f90_2b0e80(m, 1, a, random_int_between(7, 13)); } m->state = 3; } @@ -513,7 +513,7 @@ void FUN_L13_002b41b8(Moby_2B5368 *m) { if (data->gun == 0 || data->gun->cls_id != 0x24 || (unsigned char)data->gun->state == 0xFE || (unsigned char)data->gun->state == 0xFD || (unsigned char)data->gun->state == 2) { if (m->b53 != 0) { - func_00213DE0_2B5368(m, 0, 0, random_int_between(7, 13)); + FUN_00212f90_2b0e80(m, 0, 0, random_int_between(7, 13)); } data->f64 = 1.0f; m->state = 5; @@ -522,28 +522,28 @@ void FUN_L13_002b41b8(Moby_2B5368 *m) { case 3: r = fast_difference_between_rotations(angle_atan2(t->pos.x - m->pos.x, t->pos.y - m->pos.y), data->f54); if (r >= 1.5707964f || vector_distance(&m->pos, &t->pos) > 22.0f - || (data->volume != -1 && is_point_inside_clip_volume(D_0013E633_2B5368, data->volume) == 0)) { + || (data->volume != -1 && is_point_inside_clip_volume(D_0013F420_2b0e80, data->volume) == 0)) { if (m->b53 != 0) { - func_00213DE0_2B5368(m, 0, 0, random_int_between(7, 13)); + FUN_00212f90_2b0e80(m, 0, 0, random_int_between(7, 13)); } m->state = 1; } else { float lim; approach_value(&data->f68, 20.0f, D_0015ED6C * 6.0f); - r = func_001FA790_2B5368(angle_atan2(t->pos.x - m->pos.x, t->pos.y - m->pos.y), data->f54); + r = FUN_001fa5c8_2b0e80(angle_atan2(t->pos.x - m->pos.x, t->pos.y - m->pos.y), data->f54); lim = data->f6C * 0.017453292f; if (lim < r) { r = lim; } else if (r < -lim) { r = -lim; } - r = func_001FA748_2B5368(r, data->f54); + r = FUN_001fa580_2b0e80(r, data->f54); approach_angle(&m->rot.z, r, &data->f60, D_0015ED70_c * 12.566371f, D_0015ED70_c * 12.566371f, D_0015ED6C * 12.566371f); - func_L13_002B5950_2B5368(m); + FUN_L13_002b47a0_2b0e80(m); if (data->gun == 0 || data->gun->cls_id != 0x24 || (unsigned char)data->gun->state == 0xFE || (unsigned char)data->gun->state == 0xFD || (unsigned char)data->gun->state == 2) { if (m->b53 != 0) { - func_00213DE0_2B5368(m, 0, 0, random_int_between(7, 13)); + FUN_00212f90_2b0e80(m, 0, 0, random_int_between(7, 13)); } data->f64 = 1.0f; m->state = 5; @@ -554,7 +554,7 @@ void FUN_L13_002b41b8(Moby_2B5368 *m) { V4_2B5368 v; random_vector(&v.x, 0.5f, 1.0f); mark_moby_for_removal_cf(m, 0, -1); - func_L00_0025F4A8_2B5368(m, &v, &m->pos, 0.0f, 0.0f, 5, 2, 4, 2.0f, 1.0f, 9.0f, -1, 1.0f, 15.0f, 1, 1, -1, 0); + FUN_L00_0025e450_2b0e80(m, &v, &m->pos, 0.0f, 0.0f, 5, 2, 4, 2.0f, 1.0f, 9.0f, -1, 1.0f, 15.0f, 1, 1, -1, 0); delete_moby(m); return; } diff --git a/src/overlays/shared/gameplay/entities/002b2100.c b/src/overlays/shared/gameplay/entities/002b2100.c index 233d4170c..da06e0dd7 100644 --- a/src/overlays/shared/gameplay/entities/002b2100.c +++ b/src/overlays/shared/gameplay/entities/002b2100.c @@ -2818,98 +2818,98 @@ void FUN_L00_0020e4c8(void); void FUN_L00_0020e698(void); void FUN_L00_0023e838(int); void FUN_L00_002b9310(char *moby); -extern unsigned char D_0014171B_2B33E8[] __asm__("D_0014161B"); -extern int D_0015EFA4_2B33E8 __asm__("D_0015EEA4"); -extern int D_0015EE84_2B33E8 __asm__("D_0015ED84"); -extern char D_0013CA40_2B5C98[] __asm__("D_0013C940"); -extern char D_0013F450_2B7430[] __asm__("D_0013F350"); -extern float D_0015EE60_2B7430 __asm__("D_0015ED60"); -extern Voice_2B9AD8 D_0013E650_2B9AD8[] __asm__("D_0013E550"); -extern unsigned char D_0013E633_2B9AD8[] __asm__("D_0013E533"); -extern unsigned short D_00141E70_2B9AD8[] __asm__("D_00141D70"); -extern unsigned short D_00141A18_2B9AD8[] __asm__("D_00141918"); +extern unsigned char D_0014161B_2b2100[] __asm__("D_0014161B"); +extern int D_0015EEA4_2b2100a __asm__("D_0015EEA4"); +extern int D_0015ED84_2b2100 __asm__("D_0015ED84"); +extern char D_0013C940_2b2100[] __asm__("D_0013C940"); +extern char D_0013F350_2b2100[] __asm__("D_0013F350"); +extern float D_0015ED60_2b2100 __asm__("D_0015ED60"); +extern Voice_2B9AD8 D_0013E550_2b2100[] __asm__("D_0013E550"); +extern unsigned char D_0013E533_2b2100[] __asm__("D_0013E533"); +extern unsigned short D_00141D70_2b2100[] __asm__("D_00141D70"); +extern unsigned short D_00141918_2b2100[] __asm__("D_00141918"); extern float D_L00_0017AEBC __attribute__((section(".data"))); -extern int D_L00_00161660_2B9AD8 __asm__("D_L00_00161590"); -extern char D_L00_001670D0_2B9AD8[] __asm__("D_L00_00166FD0"); -extern Light_2B9AD8 D_L00_001803C0_2B9AD8[] __asm__("D_L00_001802C0"); -extern int func_L00_00234718_2B9AD8(int) __asm__("FUN_L00_00233e98"); -extern void func_L00_00203F20_2B9AD8(int, int) __asm__("FUN_L00_00203908"); -extern int func_001F9938_2B9AD8(short *) __asm__("FUN_001f9770"); -extern int func_001F9908_2B9AD8(int *) __asm__("FUN_001f9740"); -extern int func_L00_00234638_2B9AD8(int, int) __asm__("FUN_L00_00233db8"); -extern int func_001F9850_2B9AD8(int) __asm__("FUN_001f96f8"); -extern int func_L00_0023EF78_2B9AD8(void *, float, float, int) __asm__("FUN_L00_0023e5e0"); -extern float func_L00_001FF860_2B9AD8(float, float) __asm__("FUN_001f9e90"); -extern float func_001FA850_2B9AD8(float, float) __asm__("FUN_001fa688"); -extern float func_001F9D10_2B9AD8(void *, void *) __asm__("FUN_001f9b48"); -extern Aim_2B9AD8 *func_L00_0025D390_2B9AD8(void *) __asm__("FUN_002141f8"); -extern float func_001FA888_2B9AD8(int) __asm__("FUN_001fa6c0"); -extern void func_001F9EC0_2B9AD8(void *, void *, void *) __asm__("FUN_001f9cf8"); -extern void func_001F9BD8_2B9AD8(void *, void *, void *) __asm__("FUN_001f9a10"); -extern void func_L00_00250800_2B9AD8(void *, int, void *) __asm__("FUN_L00_0024f7c8"); -extern void func_L00_001FF4B0_2B9AD8(void *, void *, float) __asm__("FUN_001f9bf8"); -extern void func_L00_002BA608_2B9AD8(void *) __asm__("FUN_L00_002b9310"); -extern void func_L00_002BA7C8_2B9AD8(void *) __asm__("FUN_L00_002b94d0"); -extern void func_001F49B0_2B9AD8(void (*)(void), void *) __asm__("FUN_001f4600"); -extern void func_L00_0028EBF0_2B9AD8(int) __asm__("FUN_0022d798"); -extern int func_L00_0028EB98_2B9AD8(void *, int) __asm__("FUN_L00_0028d8c0"); -extern int func_0022ED80_2B9AD8(int, int, void *) __asm__("FUN_0022da68"); -extern void func_L00_0020EB60_2B9AD8(void) __asm__("FUN_L00_0020e4c8"); -extern void func_L00_0020ED30_2B9AD8(void) __asm__("FUN_L00_0020e698"); -extern void func_L00_0023F1D0_2B9AD8(int) __asm__("FUN_L00_0023e838"); +extern int D_L00_00161590_2b2100 __asm__("D_L00_00161590"); +extern char D_L00_00166FD0_2b2100[] __asm__("D_L00_00166FD0"); +extern Light_2B9AD8 D_L00_001802C0_2b2100[] __asm__("D_L00_001802C0"); +extern int FUN_L00_00233e98_2b2100a(int) __asm__("FUN_L00_00233e98"); +extern void FUN_L00_00203908_2b2100(int, int) __asm__("FUN_L00_00203908"); +extern int FUN_001f9770_2b2100a(short *) __asm__("FUN_001f9770"); +extern int FUN_001f9740_2b2100(int *) __asm__("FUN_001f9740"); +extern int FUN_L00_00233db8_2b2100a(int, int) __asm__("FUN_L00_00233db8"); +extern int FUN_001f96f8_2b2100(int) __asm__("FUN_001f96f8"); +extern int FUN_L00_0023e5e0_2b2100(void *, float, float, int) __asm__("FUN_L00_0023e5e0"); +extern float FUN_001f9e90_2b2100(float, float) __asm__("FUN_001f9e90"); +extern float FUN_001fa688_2b2100(float, float) __asm__("FUN_001fa688"); +extern float FUN_001f9b48_2b2100(void *, void *) __asm__("FUN_001f9b48"); +extern Aim_2B9AD8 *FUN_002141f8_2b2100(void *) __asm__("FUN_002141f8"); +extern float FUN_001fa6c0_2b2100(int) __asm__("FUN_001fa6c0"); +extern void FUN_001f9cf8_2b2100(void *, void *, void *) __asm__("FUN_001f9cf8"); +extern void FUN_001f9a10_2b2100(void *, void *, void *) __asm__("FUN_001f9a10"); +extern void FUN_L00_0024f7c8_2b2100a(void *, int, void *) __asm__("FUN_L00_0024f7c8"); +extern void FUN_001f9bf8_2b2100(void *, void *, float) __asm__("FUN_001f9bf8"); +extern void FUN_L00_002b9310_2b2100(void *) __asm__("FUN_L00_002b9310"); +extern void FUN_L00_002b94d0_2b2100(void *) __asm__("FUN_L00_002b94d0"); +extern void FUN_001f4600_2b2100(void (*)(void), void *) __asm__("FUN_001f4600"); +extern void FUN_0022d798_2b2100(int) __asm__("FUN_0022d798"); +extern int FUN_L00_0028d8c0_2b2100(void *, int) __asm__("FUN_L00_0028d8c0"); +extern int FUN_0022da68_2b2100(int, int, void *) __asm__("FUN_0022da68"); +extern void FUN_L00_0020e4c8_2b2100a(void) __asm__("FUN_L00_0020e4c8"); +extern void FUN_L00_0020e698_2b2100(void) __asm__("FUN_L00_0020e698"); +extern void FUN_L00_0023e838_2b2100a(int) __asm__("FUN_L00_0023e838"); void FUN_L00_002b87e0(struct Moby *m) { V_2B9AD8 t; Data_2B9AD8 *s = (Data_2B9AD8 *)m->pvars; int active; - int done = ((struct Hero *)D_0013F450_2B7430)->items[0].state == 3; + int done = ((struct Hero *)D_0013F350_2b2100)->items[0].state == 3; int ready; struct Hero *h; - if ((controller_state.pressed & ((struct Hero *)D_0013F450_2B7430)->items[0].button_mask) && - !((struct Hero *)D_0013F450_2B7430)->unk20AC) { + if ((controller_state.pressed & ((struct Hero *)D_0013F350_2b2100)->items[0].button_mask) && + !((struct Hero *)D_0013F350_2b2100)->unk20AC) { s->reach = 0.8f; } D_L00_0017AEBC = 0.9f; active = 0; - ready = func_L00_00234718_2B9AD8(-1); - if (D_00141E70_2B9AD8[0] == 0 && D_00141A18_2B9AD8[0] == 0 && - ((struct Hero *)D_0013F450_2B7430)->unk20B5 >= 3) { - if ((unsigned int)((struct Hero *)D_0013F450_2B7430)->state.control_mode < 2 || ((struct Hero *)D_0013F450_2B7430)->state.control_mode == 9) - func_L00_00203F20_2B9AD8(0x4E30, 0x81); - } - if ((controller_state.held & ((struct Hero *)D_0013F450_2B7430)->items[0].button_mask) && m->state != 4 && - m->state != 0 && !((struct Hero *)D_0013F450_2B7430)->unk20AC && ((struct Hero *)D_0013F450_2B7430)->state.current != 0x72) { + ready = FUN_L00_00233e98_2b2100a(-1); + if (D_00141D70_2b2100[0] == 0 && D_00141918_2b2100[0] == 0 && + ((struct Hero *)D_0013F350_2b2100)->unk20B5 >= 3) { + if ((unsigned int)((struct Hero *)D_0013F350_2b2100)->state.control_mode < 2 || ((struct Hero *)D_0013F350_2b2100)->state.control_mode == 9) + FUN_L00_00203908_2b2100(0x4E30, 0x81); + } + if ((controller_state.held & ((struct Hero *)D_0013F350_2b2100)->items[0].button_mask) && m->state != 4 && + m->state != 0 && !((struct Hero *)D_0013F350_2b2100)->unk20AC && ((struct Hero *)D_0013F350_2b2100)->state.current != 0x72) { if (s->timer == 0) { if (ready > 0) { - if (func_001F9938_2B9AD8(&s->tick)) { - func_001F9938_2B9AD8(&s->f44); - func_001F9938_2B9AD8(&s->f46); - func_L00_00234638_2B9AD8(-1, 1); - s->tick = func_001F9850_2B9AD8(10); + if (FUN_001f9770_2b2100a(&s->tick)) { + FUN_001f9770_2b2100a(&s->f44); + FUN_001f9770_2b2100a(&s->f46); + FUN_L00_00233db8_2b2100a(-1, 1); + s->tick = FUN_001f96f8_2b2100(10); } if (s->light == -1) { - s->light = func_L00_0023EF78_2B9AD8(&m->pos, 7.5f, 0.0f, 0); - } else if (s->glow < func_001F9850_2B9AD8(10)) { + s->light = FUN_L00_0023e5e0_2b2100(&m->pos, 7.5f, 0.0f, 0); + } else if (s->glow < FUN_001f96f8_2b2100(10)) { s->glow++; } active = 1; if (s->target) { - if (2.0943f < func_001FA850_2B9AD8(((struct Hero *)D_0013F450_2B7430)->motion.rot.f[2], - func_L00_001FF860_2B9AD8(s->target->pos.x - ((struct Hero *)D_0013F450_2B7430)->motion.pos.f[0], - s->target->pos.y - ((struct Hero *)D_0013F450_2B7430)->motion.pos.f[1])) || + if (2.0943f < FUN_001fa688_2b2100(((struct Hero *)D_0013F350_2b2100)->motion.rot.f[2], + FUN_001f9e90_2b2100(s->target->pos.x - ((struct Hero *)D_0013F350_2b2100)->motion.pos.f[0], + s->target->pos.y - ((struct Hero *)D_0013F350_2b2100)->motion.pos.f[1])) || !s->target->visible || - 20.0f < func_001F9D10_2B9AD8(&s->target->pos, &((struct Hero *)D_0013F450_2B7430)->motion.pos)) { + 20.0f < FUN_001f9b48_2b2100(&s->target->pos, &((struct Hero *)D_0013F350_2b2100)->motion.pos)) { s->target = 0; s->lock = 0; } } if (s->target2) { - if (2.0943f < func_001FA850_2B9AD8(((struct Hero *)D_0013F450_2B7430)->motion.rot.f[2], - func_L00_001FF860_2B9AD8(s->target2->pos.x - ((struct Hero *)D_0013F450_2B7430)->motion.pos.f[0], - s->target2->pos.y - ((struct Hero *)D_0013F450_2B7430)->motion.pos.f[1])) || + if (2.0943f < FUN_001fa688_2b2100(((struct Hero *)D_0013F350_2b2100)->motion.rot.f[2], + FUN_001f9e90_2b2100(s->target2->pos.x - ((struct Hero *)D_0013F350_2b2100)->motion.pos.f[0], + s->target2->pos.y - ((struct Hero *)D_0013F350_2b2100)->motion.pos.f[1])) || !s->target2->visible || - 20.0f < func_001F9D10_2B9AD8(&s->target2->pos, &((struct Hero *)D_0013F450_2B7430)->motion.pos)) { + 20.0f < FUN_001f9b48_2b2100(&s->target2->pos, &((struct Hero *)D_0013F350_2b2100)->motion.pos)) { s->target2 = 0; s->lock2 = 0; } @@ -2922,10 +2922,10 @@ void FUN_L00_002b87e0(struct Moby *m) { Aim_2B9AD8 *a; short n; s->hold++; - a = func_L00_0025D390_2B9AD8(s->target); + a = FUN_002141f8_2b2100(s->target); if (a && a->kind == 1) lim = 5; n = s->hold; - if (!(n < func_001F9850_2B9AD8(lim))) { + if (!(n < FUN_001f96f8_2b2100(lim))) { s->target = 0; s->lock = 0; } @@ -2937,45 +2937,45 @@ void FUN_L00_002b87e0(struct Moby *m) { Aim_2B9AD8 *a; short n; s->hold2++; - a = func_L00_0025D390_2B9AD8(s->target2); + a = FUN_002141f8_2b2100(s->target2); if (a && a->kind == 1) lim = 5; n = s->hold2; - if (!(n < func_001F9850_2B9AD8(lim))) { + if (!(n < FUN_001f96f8_2b2100(lim))) { s->target2 = 0; s->lock2 = 0; } } else { s->hold2 = 0; } - s->reach += (func_001FA888_2B9AD8(D_0013E633_2B9AD8[0]) * 6.0f + 12.0f - s->reach) * (D_0015EE60_2B7430 * 0.07f); - if (((struct Hero *)D_0013F450_2B7430)->state.current == 1) { + s->reach += (FUN_001fa6c0_2b2100(D_0013E533_2b2100[0]) * 6.0f + 12.0f - s->reach) * (D_0015ED60_2b2100 * 0.07f); + if (((struct Hero *)D_0013F350_2b2100)->state.current == 1) { t.f.x = 1.2f; t.f.y = 0.0f; t.f.z = 0.0f; - func_001F9EC0_2B9AD8(&t, &t, D_L00_001670D0_2B9AD8); + FUN_001f9cf8_2b2100(&t, &t, D_L00_00166FD0_2b2100); s->pos.f.z = t.f.z + m->pos.z; - s->pos.f.x = t.f.x + ((struct Hero *)D_0013F450_2B7430)->motion.pos.f[0]; - s->pos.f.y = t.f.y + ((struct Hero *)D_0013F450_2B7430)->motion.pos.f[1]; + s->pos.f.x = t.f.x + ((struct Hero *)D_0013F350_2b2100)->motion.pos.f[0]; + s->pos.f.y = t.f.y + ((struct Hero *)D_0013F350_2b2100)->motion.pos.f[1]; t.f.x = s->reach; t.f.y = 0.0f; t.f.z = 0.0f; - func_001F9EC0_2B9AD8(&t, &t, D_L00_001670D0_2B9AD8); - func_001F9BD8_2B9AD8(&s->tip, &s->pos, &t); - } else if (((struct Hero *)D_0013F450_2B7430)->unk22C8 == 1) { - func_L00_00250800_2B9AD8(m, 0, &s->pos); + FUN_001f9cf8_2b2100(&t, &t, D_L00_00166FD0_2b2100); + FUN_001f9a10_2b2100(&s->tip, &s->pos, &t); + } else if (((struct Hero *)D_0013F350_2b2100)->unk22C8 == 1) { + FUN_L00_0024f7c8_2b2100a(m, 0, &s->pos); t.f.x = 0.0f; t.f.y = -s->reach; t.f.z = 0.0f; - func_001F9EC0_2B9AD8(&t, &t, &m->rot_row0); - func_001F9BD8_2B9AD8(&s->tip, &s->pos, &t); + FUN_001f9cf8_2b2100(&t, &t, &m->rot_row0); + FUN_001f9a10_2b2100(&s->tip, &s->pos, &t); } else { - func_L00_00250800_2B9AD8(m, 0, &s->pos); - func_L00_001FF4B0_2B9AD8(&s->tip, D_0013F450_2B7430 + 0x640, s->reach); - func_001F9BD8_2B9AD8(&s->tip, &s->pos, &s->tip); + FUN_L00_0024f7c8_2b2100a(m, 0, &s->pos); + FUN_001f9bf8_2b2100(&s->tip, D_0013F350_2b2100 + 0x640, s->reach); + FUN_001f9a10_2b2100(&s->tip, &s->pos, &s->tip); } - func_L00_002BA608_2B9AD8(m); - func_L00_002BA7C8_2B9AD8(m); - func_001F49B0_2B9AD8(FUN_L00_002ba970, m); + FUN_L00_002b9310_2b2100(m); + FUN_L00_002b94d0_2b2100(m); + FUN_001f4600_2b2100(FUN_L00_002ba970, m); } else { s->target = 0; s->target2 = 0; @@ -2992,23 +2992,23 @@ void FUN_L00_002b87e0(struct Moby *m) { s->lock2 = 0; } if (!active) { - D_L00_00161660_2B9AD8 = 1; + D_L00_00161590_2b2100 = 1; if (s->glow > 0) s->glow--; if (s->sound != -1) { - Voice_2B9AD8 *v = &D_0013E650_2B9AD8[s->sound]; - if (v[1].owner == m && v[1].active) func_L00_0028EBF0_2B9AD8(s->sound); + Voice_2B9AD8 *v = &D_0013E550_2b2100[s->sound]; + if (v[1].owner == m && v[1].active) FUN_0022d798_2b2100(s->sound); } s->sound = -1; - } else if (!func_L00_0028EB98_2B9AD8(m, s->sound)) { - s->sound = func_0022ED80_2B9AD8(4, 4, m); + } else if (!FUN_L00_0028d8c0_2b2100(m, s->sound)) { + s->sound = FUN_0022da68_2b2100(4, 4, m); } if (!s->target || s->target->state == 0xFE || s->target->state == 0xFD || !(s->target->flags & 0x1000)) s->lock = 1; if (!s->target2 || s->target2->state == 0xFE || s->target2->state == 0xFD || !(s->target2->flags & 0x1000)) s->lock2 = 1; switch (m->state) { case 0: - s->timer = func_001F9850_2B9AD8(16); - s->light = func_L00_0023EF78_2B9AD8(&s->pos, 0.0f, 0.0f, 0); - D_L00_00161660_2B9AD8 = 1; + s->timer = FUN_001f96f8_2b2100(16); + s->light = FUN_L00_0023e5e0_2b2100(&s->pos, 0.0f, 0.0f, 0); + D_L00_00161590_2b2100 = 1; m->state = 1; s->f3E = 20; s->sound = -1; @@ -3020,19 +3020,19 @@ void FUN_L00_002b87e0(struct Moby *m) { s->f44 = 0; break; case 1: - func_001F9908_2B9AD8(&s->timer); + FUN_001f9740_2b2100(&s->timer); if (active) { - func_L00_0020EB60_2B9AD8(); + FUN_L00_0020e4c8_2b2100a(); m->state = 3; } - if ((controller_state.pressed & (h = (struct Hero *)D_0013F450_2B7430)->items[0].button_mask) && !h->unk20AC) { + if ((controller_state.pressed & (h = (struct Hero *)D_0013F350_2b2100)->items[0].button_mask) && !h->unk20AC) { if (active) { - Stats_2B9AD8 *st = (Stats_2B9AD8 *)(D_0014171B_2B33E8 + 0x65); + Stats_2B9AD8 *st = (Stats_2B9AD8 *)(D_0014161B_2b2100 + 0x65); if (st->uses < 65535) st->uses++; - if (func_001F9850_2B9AD8(D_0015EFA4_2B33E8) / 600 > st->longest) - st->longest = func_001F9850_2B9AD8(D_0015EFA4_2B33E8) / 600; - st->levels = (st->levels | (1 << D_0015EE84_2B33E8)) | 0x80000000; - func_L00_0020EB60_2B9AD8(); + if (FUN_001f96f8_2b2100(D_0015EEA4_2b2100a) / 600 > st->longest) + st->longest = FUN_001f96f8_2b2100(D_0015EEA4_2b2100a) / 600; + st->levels = (st->levels | (1 << D_0015ED84_2b2100)) | 0x80000000; + FUN_L00_0020e4c8_2b2100a(); m->state = 3; } else { s->target = 0; @@ -3040,33 +3040,33 @@ void FUN_L00_002b87e0(struct Moby *m) { s->lock = 0; s->lock2 = 0; m->state = 1; - func_0022ED80_2B9AD8(0, 0, m); - func_L00_0020ED30_2B9AD8(); + FUN_0022da68_2b2100(0, 0, m); + FUN_L00_0020e698_2b2100(); } } break; case 2: break; case 3: - if ((controller_state.released & ((struct Hero *)D_0013F450_2B7430)->items[0].button_mask) || !active || - ((struct Hero *)D_0013F450_2B7430)->unk20AC) { - h = (struct Hero *)D_0013F450_2B7430; - if (func_001F9850_2B9AD8(70) < h->unk1BC) { - if (((Stats2_2B9AD8 *)(D_0014171B_2B33E8 + 0x22D))->uses < 65535) ((Stats2_2B9AD8 *)(D_0014171B_2B33E8 + 0x22D))->uses++; + if ((controller_state.released & ((struct Hero *)D_0013F350_2b2100)->items[0].button_mask) || !active || + ((struct Hero *)D_0013F350_2b2100)->unk20AC) { + h = (struct Hero *)D_0013F350_2b2100; + if (FUN_001f96f8_2b2100(70) < h->unk1BC) { + if (((Stats2_2B9AD8 *)(D_0014161B_2b2100 + 0x22D))->uses < 65535) ((Stats2_2B9AD8 *)(D_0014161B_2b2100 + 0x22D))->uses++; } - if (func_001F9850_2B9AD8(D_0015EFA4_2B33E8) / 600 > ((Stats2_2B9AD8 *)(D_0014171B_2B33E8 + 0x22D))->longest) - ((Stats2_2B9AD8 *)(D_0014171B_2B33E8 + 0x22D))->longest = func_001F9850_2B9AD8(D_0015EFA4_2B33E8) / 600; - ((Stats2_2B9AD8 *)(D_0014171B_2B33E8 + 0x22D))->levels = (((Stats2_2B9AD8 *)(D_0014171B_2B33E8 + 0x22D))->levels | (1 << D_0015EE84_2B33E8)) | 0x80000000; - if (((struct Hero *)D_0013F450_2B7430)->unk1BC < func_001F9850_2B9AD8(30)) - ((struct Hero *)D_0013F450_2B7430)->unk20B5++; + if (FUN_001f96f8_2b2100(D_0015EEA4_2b2100a) / 600 > ((Stats2_2B9AD8 *)(D_0014161B_2b2100 + 0x22D))->longest) + ((Stats2_2B9AD8 *)(D_0014161B_2b2100 + 0x22D))->longest = FUN_001f96f8_2b2100(D_0015EEA4_2b2100a) / 600; + ((Stats2_2B9AD8 *)(D_0014161B_2b2100 + 0x22D))->levels = (((Stats2_2B9AD8 *)(D_0014161B_2b2100 + 0x22D))->levels | (1 << D_0015ED84_2b2100)) | 0x80000000; + if (((struct Hero *)D_0013F350_2b2100)->unk1BC < FUN_001f96f8_2b2100(30)) + ((struct Hero *)D_0013F350_2b2100)->unk20B5++; else - ((struct Hero *)D_0013F450_2B7430)->unk20B5 = 0; + ((struct Hero *)D_0013F350_2b2100)->unk20B5 = 0; s->target = 0; s->target2 = 0; s->lock = 0; s->lock2 = 0; s->reach = 0.0f; - func_L00_0020ED30_2B9AD8(); + FUN_L00_0020e698_2b2100(); m->state = 1; } break; @@ -3080,18 +3080,18 @@ void FUN_L00_002b87e0(struct Moby *m) { qzero(&t); t.f.x = 2.0f; t.f.z = 2.0f; - func_001F9EC0_2B9AD8(&t, &t, D_0013F450_2B7430 + 0x640); - D_L00_001803C0_2B9AD8[s->light].pos.f.x = ((struct Hero *)D_0013F450_2B7430)->motion.pos.f[0] + t.f.x; - D_L00_001803C0_2B9AD8[s->light].pos.f.y = ((struct Hero *)D_0013F450_2B7430)->motion.pos.f[1] + t.f.y; - D_L00_001803C0_2B9AD8[s->light].pos.f.z = ((struct Hero *)D_0013F450_2B7430)->motion.pos.f[2] + t.f.z; - D_L00_001803C0_2B9AD8[s->light].pos.f.w = 7.5f; - k = func_001FA888_2B9AD8(s->glow) / (float)func_001F9850_2B9AD8(10); - D_L00_001803C0_2B9AD8[s->light].z = k; + FUN_001f9cf8_2b2100(&t, &t, D_0013F350_2b2100 + 0x640); + D_L00_001802C0_2b2100[s->light].pos.f.x = ((struct Hero *)D_0013F350_2b2100)->motion.pos.f[0] + t.f.x; + D_L00_001802C0_2b2100[s->light].pos.f.y = ((struct Hero *)D_0013F350_2b2100)->motion.pos.f[1] + t.f.y; + D_L00_001802C0_2b2100[s->light].pos.f.z = ((struct Hero *)D_0013F350_2b2100)->motion.pos.f[2] + t.f.z; + D_L00_001802C0_2b2100[s->light].pos.f.w = 7.5f; + k = FUN_001fa6c0_2b2100(s->glow) / (float)FUN_001f96f8_2b2100(10); + D_L00_001802C0_2b2100[s->light].z = k; k = k * 0.7f; - D_L00_001803C0_2B9AD8[s->light].y = k; - D_L00_001803C0_2B9AD8[s->light].x = D_L00_001803C0_2B9AD8[s->light].y; + D_L00_001802C0_2b2100[s->light].y = k; + D_L00_001802C0_2b2100[s->light].x = D_L00_001802C0_2b2100[s->light].y; if (done && s->light != -1) { - func_L00_0023F1D0_2B9AD8(s->light); + FUN_L00_0023e838_2b2100a(s->light); s->light = -1; } } diff --git a/src/overlays/shared/gameplay/entities/002bffa8.c b/src/overlays/shared/gameplay/entities/002bffa8.c index 67f7a723f..69f9b15e6 100644 --- a/src/overlays/shared/gameplay/entities/002bffa8.c +++ b/src/overlays/shared/gameplay/entities/002bffa8.c @@ -1990,23 +1990,23 @@ extern void normalize_vector_xyz(void *, void *, f32) __asm__("FUN_001f9bf8"); extern void subtract_vector_xyz(void *, void *, void *) __asm__("FUN_001f9a28"); unsigned char *FUN_L00_002c6f88(unsigned char *src, float f); void FUN_L00_001edf60(int a, int b, void *pos, int kind, int mode, float x, float y, float z); -extern int func_L00_00222B80_2C74B8(int, int) __asm__("FUN_L00_002223f8"); -extern Moby *func_L00_002C82E8_2C74B8(void *, float) __asm__("FUN_L00_002c6f88"); -extern void func_L00_001EE2E0_2C74B8(int, int, float, void *, int, float, int, float, int) __asm__("FUN_L00_001edf60"); -extern int func_001F9850_2C74B8(int) __asm__("FUN_001f96f8"); -extern void func_00213DE0_2C74B8(void *, int, int, int) __asm__("FUN_00212f90"); -extern void func_L00_00250800_2C74B8(void *, int, void *) __asm__("FUN_L00_0024f7c8"); -extern int func_0022ED80_2C74B8(int, int, void *) __asm__("FUN_0022da68"); -extern float func_001F9D10_2C74B8(void *, void *) __asm__("FUN_001f9b48"); -extern void func_001F49B0_2C74B8(void (*)(char *), void *) __asm__("FUN_001f4600"); -extern void func_001F9BF0_2C74B8(void *, void *, void *) __asm__("FUN_001f9a28"); -extern void func_L00_001FF4B0_2C74B8(void *, void *, float) __asm__("FUN_001f9bf8"); -extern void func_001F9BD8_2C74B8(void *, void *, void *) __asm__("FUN_001f9a10"); -extern float func_001F9CB8_2C74B8(void *) __asm__("FUN_001f9af0"); -extern int func_L00_001EFFF0_2C74B8(void *, void *, int, int, int) __asm__("FUN_001efa68"); -extern int func_L00_00205618_2C74B8(int) __asm__("FUN_L00_00205000"); -extern void func_L00_00232C10_2C74B8(int, int, float) __asm__("FUN_L00_002323b8"); -extern void func_L00_002C7128_2C74B8(char *) __asm__("FUN_L00_002c5dc8"); +extern int FUN_L00_002223f8_2bffa8(int, int) __asm__("FUN_L00_002223f8"); +extern Moby *FUN_L00_002c6f88_2bffa8(void *, float) __asm__("FUN_L00_002c6f88"); +extern void FUN_L00_001edf60_2bffa8(int, int, float, void *, int, float, int, float, int) __asm__("FUN_L00_001edf60"); +extern int FUN_001f96f8_2bffa8(int) __asm__("FUN_001f96f8"); +extern void FUN_00212f90_2bffa8(void *, int, int, int) __asm__("FUN_00212f90"); +extern void FUN_L00_0024f7c8_2bffa8(void *, int, void *) __asm__("FUN_L00_0024f7c8"); +extern int FUN_0022da68_2bffa8(int, int, void *) __asm__("FUN_0022da68"); +extern float FUN_001f9b48_2bffa8(void *, void *) __asm__("FUN_001f9b48"); +extern void FUN_001f4600_2bffa8(void (*)(char *), void *) __asm__("FUN_001f4600"); +extern void FUN_001f9a28_2bffa8(void *, void *, void *) __asm__("FUN_001f9a28"); +extern void FUN_001f9bf8_2bffa8(void *, void *, float) __asm__("FUN_001f9bf8"); +extern void FUN_001f9a10_2bffa8(void *, void *, void *) __asm__("FUN_001f9a10"); +extern float FUN_001f9af0_2bffa8(void *) __asm__("FUN_001f9af0"); +extern int FUN_001efa68_2bffa8(void *, void *, int, int, int) __asm__("FUN_001efa68"); +extern int FUN_L00_00205000_2bffa8(int) __asm__("FUN_L00_00205000"); +extern void FUN_L00_002323b8_2bffa8(int, int, float) __asm__("FUN_L00_002323b8"); +extern void FUN_L00_002c5dc8_2bffa8(char *) __asm__("FUN_L00_002c5dc8"); void FUN_L00_002c6158(Moby *m) { V_2C74B8 v0; @@ -2017,29 +2017,29 @@ void FUN_L00_002c6158(Moby *m) { int n; if (m == 0) return; - if (hero.state.current == 1) func_L00_00222B80_2C74B8(30, 1); + if (hero.state.current == 1) FUN_L00_002223f8_2bffa8(30, 1); d = (void *)m->pvars; if (d == 0) return; hd = 0; - if (!d->hook) d->hook = func_L00_002C82E8_2C74B8(m, frame_time * 24.0f); + if (!d->hook) d->hook = FUN_L00_002c6f88_2bffa8(m, frame_time * 24.0f); if (d->hook) hd = (void *)d->hook->pvars; if ((hero.state.current == 1 || hero.state.current == 30) && hero.state_timer >= 2) { - func_L00_001EE2E0_2C74B8((int)m, 0xFF0000FF, 1.0f, 0, 0x24, 0.0f, -1, 90.0f, 4); + FUN_L00_001edf60_2bffa8((int)m, 0xFF0000FF, 1.0f, 0, 0x24, 0.0f, -1, 90.0f, 4); if (hero.unk968 && hero.unk964) - func_L00_001EE2E0_2C74B8((int)m, 0xFF00FF00, 0.5f, &hero.unk964->pos, 0x24, 0.0f, -1, 90.0f, 4); + FUN_L00_001edf60_2bffa8((int)m, 0xFF00FF00, 0.5f, &hero.unk964->pos, 0x24, 0.0f, -1, 90.0f, 4); else if (hero.unk990) - func_L00_001EE2E0_2C74B8((int)m, 0xFF00FF00, 0.5f, &hero.unk990->pos, 0x24, 0.0f, -1, 90.0f, 4); + FUN_L00_001edf60_2bffa8((int)m, 0xFF00FF00, 0.5f, &hero.unk990->pos, 0x24, 0.0f, -1, 90.0f, 4); } switch (m->state) { case 0: case 1: if (m->anim_flags & 2) { - if (m->prev_seq != 1) func_00213DE0_2C74B8(m, 1, 0, func_001F9850_2C74B8(10)); + if (m->prev_seq != 1) FUN_00212f90_2bffa8(m, 1, 0, FUN_001f96f8_2bffa8(10)); m->state = 1; } if (d->hook) { - func_L00_00250800_2C74B8(m, 0, &d->hook->pos); + FUN_L00_0024f7c8_2bffa8(m, 0, &d->hook->pos); { Moby *h = d->hook; *(u128 *)&h->rot_row0 = *(u128 *)&m->rot_row0; @@ -2054,30 +2054,30 @@ void FUN_L00_002c6158(Moby *m) { d->scale = 1.0f; d->spin = 0.0f; hd->speed = frame_time * 24.0f; - if (m->prev_seq != 3) func_00213DE0_2C74B8(m, 3, 0, func_001F9850_2C74B8(10)); - func_0022ED80_2C74B8(0, 0, m); + if (m->prev_seq != 3) FUN_00212f90_2bffa8(m, 3, 0, FUN_001f96f8_2bffa8(10)); + FUN_0022da68_2bffa8(0, 0, m); m->state = 2; } } if (hero.state.current == 0x2C && hd) { - speed = func_001F9D10_2C74B8(&hero.unk994->pos, &d->hook->pos); - n = func_001F9850_2C74B8(7); - if (hero.items[0].unk20 < func_001F9850_2C74B8(30)) n = func_001F9850_2C74B8(5); + speed = FUN_001f9b48_2bffa8(&hero.unk994->pos, &d->hook->pos); + n = FUN_001f96f8_2bffa8(7); + if (hero.items[0].unk20 < FUN_001f96f8_2bffa8(30)) n = FUN_001f96f8_2bffa8(5); hd->speed = speed / (float)n; d->size = 0.280000001f; d->scale = 1.0f; d->spin = 0.0f; - if (m->prev_seq != 3) func_00213DE0_2C74B8(m, 3, 0, func_001F9850_2C74B8(10)); - func_0022ED80_2C74B8(0, 0, m); + if (m->prev_seq != 3) FUN_00212f90_2bffa8(m, 3, 0, FUN_001f96f8_2bffa8(10)); + FUN_0022da68_2bffa8(0, 0, m); m->state = 9; } break; case 2: - func_001F49B0_2C74B8(func_L00_002C7128_2C74B8, m); + FUN_001f4600_2bffa8(FUN_L00_002c5dc8_2bffa8, m); if (m->anim_flags & 2) { - if (m->prev_seq != 4) func_00213DE0_2C74B8(m, 4, 0, func_001F9850_2C74B8(10)); + if (m->prev_seq != 4) FUN_00212f90_2bffa8(m, 4, 0, FUN_001f96f8_2bffa8(10)); } - func_001F9BF0_2C74B8(&v0, &hero.unk964->pos, &d->hook->pos); + FUN_001f9a28_2bffa8(&v0, &hero.unk964->pos, &d->hook->pos); speed = hd->speed; if (hero.state.control_mode == 0xF) { speed = speed + hero.unk574; @@ -2086,60 +2086,60 @@ void FUN_L00_002c6158(Moby *m) { } qcopy(&v10, &hero.motion.pos); v10.f.z += 0.5f; - if (func_L00_001EFFF0_2C74B8(&v10, &hero.unk964->pos, 2, 0, 0)) { + if (FUN_001efa68_2bffa8(&v10, &hero.unk964->pos, 2, 0, 0)) { if (0.5f < hero.ground_distance) { - func_L00_00222B80_2C74B8(6, 1); + FUN_L00_002223f8_2bffa8(6, 1); } else { - func_L00_00222B80_2C74B8(0, 0); - func_L00_00232C10_2C74B8(func_L00_00205618_2C74B8(0), 0, (float)func_001F9850_2C74B8(14)); + FUN_L00_002223f8_2bffa8(0, 0); + FUN_L00_002323b8_2bffa8(FUN_L00_00205000_2bffa8(0), 0, (float)FUN_001f96f8_2bffa8(14)); } m->state = 6; - } else if (speed < func_001F9D10_2C74B8(&d->hook->pos, &hero.unk964->pos)) { - func_L00_001FF4B0_2C74B8(&v0, &v0, speed); - func_001F9BD8_2C74B8(&d->hook->pos, &d->hook->pos, &v0); + } else if (speed < FUN_001f9b48_2bffa8(&d->hook->pos, &hero.unk964->pos)) { + FUN_001f9bf8_2bffa8(&v0, &v0, speed); + FUN_001f9a10_2bffa8(&d->hook->pos, &d->hook->pos, &v0); } else { qcopy(&d->hook->pos, &hero.unk964->pos); m->state = 3; } break; case 3: - func_0022ED80_2C74B8(1, 0, m); - func_001F49B0_2C74B8(func_L00_002C7128_2C74B8, m); + FUN_0022da68_2bffa8(1, 0, m); + FUN_001f4600_2bffa8(FUN_L00_002c5dc8_2bffa8, m); qcopy(&d->hook->pos, &hero.unk964->pos); m->state = 4; break; case 4: - func_L00_00250800_2C74B8(m, 0, &v0); + FUN_L00_0024f7c8_2bffa8(m, 0, &v0); qcopy(&v0, &hero.motion.pos); v0.f.z += 0.5f; - if (func_L00_001EFFF0_2C74B8(&v0, &hero.unk964->pos, 2, 0, 0)) { - if (hero.air_frames.s) func_L00_00222B80_2C74B8(6, 1); - else func_L00_00222B80_2C74B8(0, 1); + if (FUN_001efa68_2bffa8(&v0, &hero.unk964->pos, 2, 0, 0)) { + if (hero.air_frames.s) FUN_L00_002223f8_2bffa8(6, 1); + else FUN_L00_002223f8_2bffa8(0, 1); m->state = 6; break; } if (m->anim_flags & 2) { - if (m->prev_seq != 4) func_00213DE0_2C74B8(m, 4, 0, func_001F9850_2C74B8(10)); + if (m->prev_seq != 4) FUN_00212f90_2bffa8(m, 4, 0, FUN_001f96f8_2bffa8(10)); } - func_001F49B0_2C74B8(func_L00_002C7128_2C74B8, m); + FUN_001f4600_2bffa8(FUN_L00_002c5dc8_2bffa8, m); d->spin = d->spin + 0.69813168f; d->size = d->size * (frame_scale * -0.100000024f + 1.0f); if (d->size < 0.168000013f) { hero.unk5B4 = 0; - if (d->hook && 3.5f < func_001F9D10_2C74B8(&d->hook->pos, &hero.motion.pos)) { + if (d->hook && 3.5f < FUN_001f9b48_2bffa8(&d->hook->pos, &hero.motion.pos)) { if (!(controller_state.held & hero.items[0].button_mask)) { hero.unk988 = 1; - func_L00_00222B80_2C74B8(0, 0); - func_L00_00232C10_2C74B8(func_L00_00205618_2C74B8(0), 0, (float)func_001F9850_2C74B8(14)); + FUN_L00_002223f8_2bffa8(0, 0); + FUN_L00_002323b8_2bffa8(FUN_L00_00205000_2bffa8(0), 0, (float)FUN_001f96f8_2bffa8(14)); m->state = 6; } else { - func_0022ED80_2C74B8(2, 0, m); - if (hero.unk978) func_L00_00222B80_2C74B8(0x26, 1); - else func_L00_00222B80_2C74B8(0x25, 1); + FUN_0022da68_2bffa8(2, 0, m); + if (hero.unk978) FUN_L00_002223f8_2bffa8(0x26, 1); + else FUN_L00_002223f8_2bffa8(0x25, 1); m->state = 5; } } else { - func_L00_00222B80_2C74B8(0, 1); + FUN_L00_002223f8_2bffa8(0, 1); m->state = 6; } } @@ -2147,57 +2147,57 @@ void FUN_L00_002c6158(Moby *m) { case 5: qcopy(&d->hook->pos, &hero.unk964->pos); if (m->anim_flags & 2) { - if (m->prev_seq != 4) func_00213DE0_2C74B8(m, 4, 0, func_001F9850_2C74B8(10)); + if (m->prev_seq != 4) FUN_00212f90_2bffa8(m, 4, 0, FUN_001f96f8_2bffa8(10)); } d->size = d->size * (frame_scale * -0.100000024f + 1.0f); d->spin = d->spin + 0.69813168f; - func_001F49B0_2C74B8(func_L00_002C7128_2C74B8, m); + FUN_001f4600_2bffa8(FUN_L00_002c5dc8_2bffa8, m); if ((unsigned int)(hero.state.current - 0x25) >= 2) m->state = 6; break; case 6: - func_001F49B0_2C74B8(func_L00_002C7128_2C74B8, m); + FUN_001f4600_2bffa8(FUN_L00_002c5dc8_2bffa8, m); hd->speed = frame_time * 80.0f; m->state = 7; break; case 7: - func_L00_00250800_2C74B8(m, 0, &v10); - func_001F9BF0_2C74B8(&v0, &v10, &d->hook->pos); - if (hd->speed < func_001F9D10_2C74B8(&d->hook->pos, &v10)) { - func_L00_001FF4B0_2C74B8(&v0, &v0, hd->speed); - func_001F9BD8_2C74B8(&d->hook->pos, &d->hook->pos, &v0); - func_001F49B0_2C74B8(func_L00_002C7128_2C74B8, m); + FUN_L00_0024f7c8_2bffa8(m, 0, &v10); + FUN_001f9a28_2bffa8(&v0, &v10, &d->hook->pos); + if (hd->speed < FUN_001f9b48_2bffa8(&d->hook->pos, &v10)) { + FUN_001f9bf8_2bffa8(&v0, &v0, hd->speed); + FUN_001f9a10_2bffa8(&d->hook->pos, &d->hook->pos, &v0); + FUN_001f4600_2bffa8(FUN_L00_002c5dc8_2bffa8, m); } else { qcopy(&d->hook->pos, &v10); - if (m->prev_seq != 1) func_00213DE0_2C74B8(m, 1, 0, func_001F9850_2C74B8(10)); + if (m->prev_seq != 1) FUN_00212f90_2bffa8(m, 1, 0, FUN_001f96f8_2bffa8(10)); m->state = 1; } break; case 8: break; case 9: - func_001F49B0_2C74B8(func_L00_002C7128_2C74B8, m); + FUN_001f4600_2bffa8(FUN_L00_002c5dc8_2bffa8, m); if (m->anim_flags & 2) { - if (m->prev_seq != 4) func_00213DE0_2C74B8(m, 4, 0, func_001F9850_2C74B8(10)); + if (m->prev_seq != 4) FUN_00212f90_2bffa8(m, 4, 0, FUN_001f96f8_2bffa8(10)); } - func_001F9BF0_2C74B8(&v0, &hero.unk994->pos, &d->hook->pos); - if (hd->speed < func_001F9CB8_2C74B8(&v0)) { - func_L00_001FF4B0_2C74B8(&v0, &v0, hd->speed); - func_001F9BD8_2C74B8(&d->hook->pos, &d->hook->pos, &v0); + FUN_001f9a28_2bffa8(&v0, &hero.unk994->pos, &d->hook->pos); + if (hd->speed < FUN_001f9af0_2bffa8(&v0)) { + FUN_001f9bf8_2bffa8(&v0, &v0, hd->speed); + FUN_001f9a10_2bffa8(&d->hook->pos, &d->hook->pos, &v0); } else { qcopy(&d->hook->pos, &hero.unk994->pos); m->state = 11; - func_0022ED80_2C74B8(1, 0, m); + FUN_0022da68_2bffa8(1, 0, m); } break; case 10: - func_001F49B0_2C74B8(func_L00_002C7128_2C74B8, m); + FUN_001f4600_2bffa8(FUN_L00_002c5dc8_2bffa8, m); m->state = 11; break; case 11: if (m->anim_flags & 2) { - if (m->prev_seq != 4) func_00213DE0_2C74B8(m, 4, 0, func_001F9850_2C74B8(10)); + if (m->prev_seq != 4) FUN_00212f90_2bffa8(m, 4, 0, FUN_001f96f8_2bffa8(10)); } - func_001F49B0_2C74B8(func_L00_002C7128_2C74B8, m); + FUN_001f4600_2bffa8(FUN_L00_002c5dc8_2bffa8, m); d->spin = d->spin + 0.69813168f; d->size = d->size * (frame_scale * -0.600000024f + 1.0f); if (d->size < 0.168000013f) { @@ -2209,42 +2209,42 @@ void FUN_L00_002c6158(Moby *m) { if (hero.unk994) qcopy(&d->hook->pos, &hero.unk994->pos); if (m->anim_flags & 2) { - if (m->prev_seq != 4) func_00213DE0_2C74B8(m, 4, 0, func_001F9850_2C74B8(10)); + if (m->prev_seq != 4) FUN_00212f90_2bffa8(m, 4, 0, FUN_001f96f8_2bffa8(10)); } d->size = d->size * (frame_scale * -0.600000024f + 1.0f); d->spin = d->spin + 0.69813168f; - func_001F49B0_2C74B8(func_L00_002C7128_2C74B8, m); + FUN_001f4600_2bffa8(FUN_L00_002c5dc8_2bffa8, m); if (hero.state.current != 0x2C) m->state = 13; break; case 13: if (m->anim_flags & 2) { - if (m->prev_seq != 4) func_00213DE0_2C74B8(m, 4, 0, func_001F9850_2C74B8(10)); + if (m->prev_seq != 4) FUN_00212f90_2bffa8(m, 4, 0, FUN_001f96f8_2bffa8(10)); } - func_001F49B0_2C74B8(func_L00_002C7128_2C74B8, m); + FUN_001f4600_2bffa8(FUN_L00_002c5dc8_2bffa8, m); hd->speed = frame_time * 80.0f; m->state = 14; break; case 14: if (m->anim_flags & 2) { - if (m->prev_seq != 4) func_00213DE0_2C74B8(m, 4, 0, func_001F9850_2C74B8(10)); - } - func_L00_00250800_2C74B8(m, 0, &v10); - func_001F9BF0_2C74B8(&v0, &v10, &d->hook->pos); - if (hd->speed < func_001F9D10_2C74B8(&d->hook->pos, &v10)) { - func_L00_001FF4B0_2C74B8(&v0, &v0, hd->speed); - func_001F9BD8_2C74B8(&d->hook->pos, &d->hook->pos, &v0); - func_001F49B0_2C74B8(func_L00_002C7128_2C74B8, m); + if (m->prev_seq != 4) FUN_00212f90_2bffa8(m, 4, 0, FUN_001f96f8_2bffa8(10)); + } + FUN_L00_0024f7c8_2bffa8(m, 0, &v10); + FUN_001f9a28_2bffa8(&v0, &v10, &d->hook->pos); + if (hd->speed < FUN_001f9b48_2bffa8(&d->hook->pos, &v10)) { + FUN_001f9bf8_2bffa8(&v0, &v0, hd->speed); + FUN_001f9a10_2bffa8(&d->hook->pos, &d->hook->pos, &v0); + FUN_001f4600_2bffa8(FUN_L00_002c5dc8_2bffa8, m); } else { qcopy(&d->hook->pos, &v10); - if (m->prev_seq != 1) func_00213DE0_2C74B8(m, 1, 0, func_001F9850_2C74B8(10)); + if (m->prev_seq != 1) FUN_00212f90_2bffa8(m, 1, 0, FUN_001f96f8_2bffa8(10)); m->state = 1; } if (hero.state.current == 0x2C && hd) { - hd->speed = func_001F9D10_2C74B8(&hero.unk994->pos, &d->hook->pos) / 10.0f; + hd->speed = FUN_001f9b48_2bffa8(&hero.unk994->pos, &d->hook->pos) / 10.0f; d->scale = 1.0f; d->size = 0.0f; d->spin = 0.0f; - if (m->prev_seq != 3) func_00213DE0_2C74B8(m, 3, 0, func_001F9850_2C74B8(10)); + if (m->prev_seq != 3) FUN_00212f90_2bffa8(m, 3, 0, FUN_001f96f8_2bffa8(10)); m->state = 9; } break; From 37b2e7350bf1d5dbf75fb29cccb56031be40acfc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mateusz=20K=C5=82ysz?= Date: Tue, 13 Oct 2026 14:15:10 +0000 Subject: [PATCH 11/12] overlay: match FUN_L06_0030bfa8 --- .../shared/gameplay/vendor/00307578.c | 36 +++++++++---------- 1 file changed, 16 insertions(+), 20 deletions(-) diff --git a/src/overlays/shared/gameplay/vendor/00307578.c b/src/overlays/shared/gameplay/vendor/00307578.c index 09bc204c9..2ada829f7 100644 --- a/src/overlays/shared/gameplay/vendor/00307578.c +++ b/src/overlays/shared/gameplay/vendor/00307578.c @@ -241,7 +241,7 @@ void FUN_L06_00309860(char *self) { /* UpdateMoby: state 0 deletes, state 1 draws and times out */ /* Ported from rac1-decomp (src/overlays/shared/vendor_002FF000.c: func_L06_0030D2A0), where it is exact; names translated to the US level program. */ -extern void FUN_L06_0030bfa8(void); +void FUN_L06_0030bfa8(char *moby); void enqueue_callback_list_1(s32 arg0, s32 arg1) __asm__("FUN_001f4600"); void mark_moby_for_removal(struct Obj *obj) __asm__("FUN_0020c828"); @@ -282,9 +282,6 @@ void FUN_L06_0030bef8(char *src, int a1, int a2, int a3) { m[0x20] = 1; } } -#ifndef NON_MATCHING -INCLUDE_ASM("config/us/overlays/asm/FUN_L06_0030bfa8.s", FUN_L06_0030bfa8); -#else extern void vu1_add_g_sregister(s32, s64) __asm__("FUN_00233980"); extern void project_to_screen(f32 *, void *) __asm__("FUN_001f2070"); extern s32 truncate_float_to_s32(f32) __asm__("FUN_001fa6d0"); @@ -299,8 +296,7 @@ extern s32 D_L06_00162420 __attribute__((sda)); extern s32 D_L06_00162424 __attribute__((sda)); extern s32 D_L06_00162428 __attribute__((sda)); -#define FUN_L06_0030bfa8 FUN_L06_0030bfa8_c -void FUN_L06_0030bfa8(char *moby) __asm__("FUN_L06_0030bfa8"); +/* Draws a screen-space sprite at the moby, grown and faded in by the first data float. */ void FUN_L06_0030bfa8(char *moby) { float *d = *(float **)(moby + 0x78); OvlVec4 pos; @@ -312,8 +308,6 @@ void FUN_L06_0030bfa8(char *moby) { float fade; s32 y, x, radius; s32 raw_x; - s32 left, right; - s64 upper_plus, upper_minus; u64 texture; u32 color; s32 *screen_center; @@ -331,7 +325,7 @@ void FUN_L06_0030bfa8(char *moby) { raw_x = truncate_float_to_s32(screen[0] - (float)screen_center[4]); screen_offset = (float)screen_center[4]; y = truncate_float_to_s32(screen[1] - screen_offset); - x = (s32)raw_x - 0x1000; + x = raw_x - 0x1000; y -= 0x1000; uvs[0] = D_L06_0016241C; uvs[1] = D_L06_00162420; @@ -343,20 +337,22 @@ void FUN_L06_0030bfa8(char *moby) { colors[1] = color; colors[0] = color; radius = truncate_float_to_s32((float)(D_L06_00162418 << 4) * size); - upper_plus = 0xfffff080008000LL + (s64)(s32)((y + radius) << 16); - upper_minus = 0xfffff080008000LL + (s64)(s32)((y - radius) << 16); - right = x + radius; - left = x - radius; - corners[0] = upper_minus + right; - corners[2] = upper_plus + right; - corners[1] = upper_minus + left; - corners[3] = upper_plus + left; - texture = get_effect_texture(D_L06_00162414); + corners[3] = 0xfffff080008000LL; + corners[2] = 0xfffff080008000LL; + corners[1] = 0xfffff080008000LL; + corners[0] = 0xfffff080008000LL; + corners[0] += (y - radius) << 16; + corners[0] += x + radius; + corners[1] += (y - radius) << 16; + corners[1] += x - radius; + corners[2] += (y + radius) << 16; + corners[2] += x + radius; + corners[3] += (y + radius) << 16; + corners[3] += x - radius; + texture = get_effect_texture(D_L06_00162414); FUN_L02_0020bc88(corners, uvs, colors, texture, 1); vu1_add_g_sregister(0x47, 0x5360B); } -#undef FUN_L06_0030bfa8 -#endif /* Ported from rac1-decomp (src/overlays/shared/vendor_002FF000.c: func_L06_00317770), where it is exact; names translated to the US level program. */ extern char *D_L06_0015EF50; From a9c29c2ca72a7e8253b066d98d39d71fe75602f9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mateusz=20K=C5=82ysz?= Date: Tue, 13 Oct 2026 14:30:07 +0000 Subject: [PATCH 12/12] overlay: restore the 00245c28 unit tail dropped by the port --- src/overlays/shared/rendering/00245c28.c | 247 +++++++++++++++++++++++ 1 file changed, 247 insertions(+) diff --git a/src/overlays/shared/rendering/00245c28.c b/src/overlays/shared/rendering/00245c28.c index 190c0d8ac..e2551bf95 100644 --- a/src/overlays/shared/rendering/00245c28.c +++ b/src/overlays/shared/rendering/00245c28.c @@ -1,5 +1,6 @@ /* Level overlay code after rendering; generated by `decomp overlays stubs`, stubs replaced by C as functions are matched. */ #include "types.h" +#include "asm.h" #include "rnc/gameplay/state/overlay_game_state.h" #include "rnc/globals.h" #include "sda.h" @@ -304,3 +305,249 @@ void FUN_L00_00245c28(void) { } do_space_transition(); } +#ifndef NON_MATCHING +INCLUDE_ASM("config/us/overlays/asm/FUN_L00_002464a8.s", FUN_L00_002464a8); +#else +#endif +#include "rnc/storage/disc_table.h" + +typedef struct { + u8 pad0[0x24]; + s32 active; + u8 pad28[0x1fc]; + s32 archive_index; + s32 load_state; + s32 file_handle; + s32 loaded; + s32 transfer_bytes; + u8 pad238[4]; + s32 old_base; + u8 pad240[0x38]; + s32 start; + s32 buffer; + s32 old_end; + s32 zero_284; + s32 zero_288; + s32 slot_28c; + s32 level_slot; + s32 slot_294; + s32 slot_298; + s32 slot_29c; + s32 slot_2a0; + u8 pad2a4[4]; + s32 last_transfer_bytes; +} RenderArchiveState; + +extern RenderArchiveState D_L00_001841F0 __asm__("D_L00_001841F0"); +extern u8 D_0013D4E1 __attribute__((section(".data"))); +extern struct DiscFile D_00138438[]; + +void FUN_001e93e8(void); +void FUN_0020bf90(s32, s32); +void FUN_00216788(s32, s32, s32); +void FUN_002168a8(s32); +void FUN_L00_00293d38(s32, s32, s32, s32); +void FUN_00232f20(s32, s32, s32, s32, s32); + +void FUN_L00_002468b8(void) { + s32 first_base; + s32 second_base; + s32 buffer; + s32 bytes; + s32 archive_index; + RenderArchiveState *state = &D_L00_001841F0; + + FUN_001e93e8(); + FUN_0020bf90(state->archive_index, 1); + first_base = D_L00_001B9CF0.first_base; + second_base = D_L00_001B9CF0.second_base; + buffer = first_base + 0x9a800; + D_L00_001B9CF0.first_base = buffer + 0x48000; + D_L00_001841F0.old_base = first_base; + D_L00_001841F0.start = 0; + D_L00_001841F0.buffer = buffer; + D_L00_001841F0.old_end = second_base; + D_L00_001B9CF0.second_base = second_base + 0x48000; + state->zero_284 = 0; + state->zero_288 = 0; + state->slot_28c = -1; + state->level_slot = -1; + state->slot_294 = -1; + state->slot_298 = -1; + state->slot_29c = -1; + state->slot_2a0 = -1; + if (state->file_handle != -1) { + if (state->loaded == 0 && D_0013D4E1 != 0) { + archive_index = state->archive_index; + bytes = disc_table.render_archives[archive_index].size << 7; + FUN_00216788(buffer, disc_table.render_archives[archive_index].sector, + disc_table.render_archives[archive_index].size); + FUN_002168a8(1); + state->loaded = 1; + state->transfer_bytes = bytes; + FUN_L00_00293d38(state->buffer, state->file_handle, 0, bytes); + state->level_slot = current_level_index + 0x100; + state->last_transfer_bytes = bytes; + state->active = 1; + state->load_state = -2; + return; + } + if (D_L00_001841F0.file_handle != -1) { + D_L00_001841F0.last_transfer_bytes = D_L00_001841F0.transfer_bytes; + FUN_00232f20(D_L00_001841F0.buffer, D_L00_001841F0.file_handle, 0, D_L00_001841F0.transfer_bytes, 0); + D_L00_001841F0.level_slot = D_0013D4E1 != 0 ? current_level_index + 0x100 : current_level_index; + D_L00_001841F0.active = 1; + D_L00_001841F0.load_state = -2; + return; + } + } + D_L00_001841F0.active = 0; +} +#ifdef NON_MATCHING +#include "rnc/storage/disc_table.h" +extern u8 D_0013D4E1; +extern s32 D_L00_00173E08 __attribute__((section(".data"))); + +typedef struct { + s32 first_data; + s32 second_data; + s32 scratch_data; + s32 mask_data; + s32 initialized; + s32 second_raw; + u8 pad18[0x20c]; + s32 archive_index; + u8 pad228[4]; + s32 file_handle; + s32 loaded; + s32 transfer_bytes; +} RenderArchiveLoad; +extern RenderArchiveLoad D_L00_001841F0_load __asm__("D_L00_001841F0"); + +void FUN_00266040(void *, s32, s32) __asm__("FUN_L00_00266040"); +s32 FUN_00293c58(void *, s32, s32, s32) __asm__("FUN_L00_00293c58"); +void FUN_L00_0024d8d0(void *, s32 *) __asm__("FUN_L00_0024d8d0"); +s32 FUN_002355f0(s32, s32, s32, s32) __asm__("FUN_L00_002355f0"); +void hud_send_resident_bank(s32, s32, s32) __asm__("FUN_001ff128"); +void FUN_L00_00248278(s32, s32, s32) __asm__("FUN_L00_00248278"); +void FUN_L00_00249f48(s32, void *, s32) __asm__("FUN_L00_00249f48"); + +extern u8 D_L00_00184394[]; +extern s32 D_L00_00183EF0[]; +extern char render_archive_source_file[] __asm__("D_L00_0015FE00"); + +void FUN_L00_002464a8(void) { + s32 i, x, y; + s32 *source; + s32 *destination; + s32 *archive; + s32 first_size, second_size; + s32 scratch; + s32 word0, word1; + s32 heap_tag; + s32 *archive_base; + f32 *points; + f32 *coefficients; + f32 x_slope, y_slope; + f32 x0, y0, x1, y1, x2, y2, x3, y3; + struct DiscFile *file; + u8 *level_data; + u8 *mask; + RenderArchiveLoad *state = &D_L00_001841F0_load; + + D_L00_001841F0_load.initialized = 1; + source = D_L00_00183EF0; + destination = (s32 *)((u8 *)state + 0x154); + for (i = 0x13; i >= 0; i--) { + word0 = source[0]; + word1 = source[1]; + *(s32 *)((u8 *)destination - 0x50) = word0; + destination[0] = word1; + *(f32 *)((u8 *)destination - 0xa0) = 0.65f; + source += 2; + destination++; + } + i = current_level_index; + D_L00_001841F0_load.file_handle = -1; + i = 0x12 < i ? 0 : i; + D_L00_001841F0_load.archive_index = i; + points = (f32 *)0x182810; + coefficients = (f32 *)0x182a70; + for (i = 0x12; i >= 0; i--) { + x0 = points[0]; + y0 = points[1]; + x1 = points[2]; + y1 = points[3]; + x2 = points[4]; + y2 = points[5]; + x3 = points[6]; + y3 = points[7]; + x_slope = (x2 - x3) / (x0 - x1); + y_slope = (y2 - y3) / (y0 - y1); + coefficients[1] = x_slope; + coefficients[3] = y_slope; + coefficients[0] = x2 - x_slope * x0; + coefficients[2] = y2 - y_slope * y0; + points += 8; + coefficients += 4; + } + if (D_0013D4E1 != 0) { + file = (struct DiscFile *)0x138438; + D_L00_001841F0_load.loaded = 1; + } else { + file = (struct DiscFile *)0x1383a0; + D_L00_001841F0_load.loaded = 0; + } + file += D_L00_001841F0_load.archive_index; + if (file->size != 0) { + *(s32 *)0x184218 = 1; + heap_tag = (s32)render_archive_source_file; + archive_base = (s32 *)D_L00_00173E08; + archive = (s32 *)((s32)archive_base + 0x9a800); + scratch = file->size << 7; + FUN_00266040(archive, file->sector, file->size); + state->file_handle = FUN_00293c58(archive, scratch, 0x4800, 0x1e8b00); + state->transfer_bytes = scratch; + FUN_L00_0024d8d0(archive, archive_base); + archive = archive_base; + first_size = archive[1] - archive[0]; + D_L00_001841F0_load.first_data = FUN_002355f0(first_size, 0, heap_tag, 0x2db); + hud_send_resident_bank(D_L00_001841F0_load.first_data, (s32)archive + archive[0], first_size); + D_L00_001841F0_load.first_data += 8; + state->second_data = D_L00_001841F0_load.first_data; + second_size = archive[2] - archive[1]; + state->second_raw = FUN_002355f0(second_size, 0, heap_tag, 0x2ec); + hud_send_resident_bank(state->second_raw, (s32)archive + archive[1], second_size); + state->scratch_data = FUN_002355f0(0x1000, 0, heap_tag, 0x2f3); + destination = (s32 *)0x184228; + for (i = 0; i < 8; i++) { + *(s32 *)((u8 *)destination - 8) = -1; + *(s32 *)((u8 *)destination - 4) = -1; + destination[0] = state->scratch_data + i * 0x200; + destination += 4; + } + state->mask_data = FUN_002355f0(0x8000, 0, (s32)render_archive_source_file, 0x2fc); + level_data = (u8 *)(0x141ec0 + state->archive_index * 0x800); + if (level_data[0] == 0) { + FUN_L00_00248278(state->mask_data, D_L00_001841F0_load.first_data, state->second_data); + } else { + FUN_L00_00249f48(state->mask_data, level_data, state->second_raw); + } + mask = D_L00_00184394; + for (y = 0; y < 32; y++) { + for (x = 0; x < 32; x++) { + if ((15.5f - (f32)x) * (15.5f - (f32)x) + + (15.5f - (f32)y) * (15.5f - (f32)y) > 256.0f) { + mask[x / 8 + y * 4] |= 1 << (x % 8); + } + } + } + } else { + D_L00_001841F0_load.first_data = 0; + *(s32 *)0x184218 = 0; + state->scratch_data = 0; + state->mask_data = 0; + state->second_data = 0; + } +} +#endif