From c2a2b608717c7b1b0166b384cdbb8fc4d23e7021 Mon Sep 17 00:00:00 2001 From: petrie911 <69443847+petrie911@users.noreply.github.com> Date: Wed, 22 Nov 2023 08:56:29 -0600 Subject: [PATCH] enemy drawing routines decomped (#28) * graphics? * more stuff * missed one --- include/functions.h | 30 +- include/gfx.h | 55 + include/structs.h | 150 ++- include/variables.h | 139 ++- linker_scripts/us/symbol_addrs.txt | 2 + src/main/matrix.c | 23 +- src/main/sf_2EFE0.c | 2 +- src/main/sf_5A0F0.c | 21 +- src/main/sf_5A2C0.c | 1727 +++++++++++++++++++++++++- src/main/sf_61B30.c | 258 ++-- src/main/sf_hud.c | 32 +- src/overlays/ovl_EBFBE0/fox_option.c | 46 +- 12 files changed, 2171 insertions(+), 314 deletions(-) diff --git a/include/functions.h b/include/functions.h index 7f7b7258..f4364785 100644 --- a/include/functions.h +++ b/include/functions.h @@ -16,7 +16,8 @@ void func_800033E0(void* var_s2, void* var_s1, s32 var_s0); void func_800034E8(u8 arg0); void func_8000372C(Gfx** dList, s32 dirX, s32 dirY, s32 dirZ, s32 colR, s32 colG, s32 colB, s32 ambR, s32 ambG, s32 ambB); - +void func_800038AC(Gfx** dList, s32 dir1x, s32 dir1y, s32 dir1z, s32 dir2x, s32 dir2y, s32 dir2z, s32 col1r, s32 col1g, + s32 col1b, s32 col2r, s32 col2g, s32 col2b, s32 ambR, s32 ambG, s32 ambB); f32 Math_ModF(f32 value, f32 mod); void Rand_Init(void); f32 Rand_ZeroOne(void); @@ -66,8 +67,8 @@ void Fault_Init(void); void func_80016A50(void); void func_800182F4(s32); -void func_80019218(u32, f32*, u8, f32*, f32*, s8*); -void func_8001A500(f32*); // might be Vec3f* +void func_80019218(u32, Vec3f*, u8, f32*, f32*, s8*); +void func_8001A500(Vec3f*); void func_8001A838(u32 arg0); void func_8001ACDC(s32); void func_8001AE58(void); @@ -139,13 +140,21 @@ void func_8003DAF0(void); void func_8003DE68(s32, s32); void func_80040CDC(void); void func_80042FAC(Object_408 *); -void func_80042FD0(Object_408 *); +void func_80042FD0(Object_408 *); +void func_80053658(UnkStruct_D_80161630 *, UnkStruct_D_80178280 *); +void func_8005465C(s32); u8 func_80058F14(u8 arg0, u8 arg1); void func_80059498(void); void func_8005980C(f32 arg0); void func_80057D00(void); - -void func_80060FBC(Object*, f32*); +void func_8005F030(Vec3f*); +void func_8005F0E8(Vec3f*, Vec3f*); +void func_8005F1EC(Vec3f*); +void func_8005F290(Vec3f*, Vec3f*); +void func_8005F670(Vec3f*); +s32 func_8005F9DC(Vec3f*); +void func_80060FBC(Object*, Vec3f*); +s32 func_80060FE4(Vec3f* arg0, f32 arg1); void func_800612B8(ObjectStruct_1C*, u32); void func_800613C4(Object_2F4*); void func_80061474(Object_8C* arg0); @@ -199,6 +208,7 @@ void func_80069FD4(Object_8C *); void func_8006A06C(UnkStruct_D_80174750*); void func_8006A38C(void); void func_8006B0A0(Object_2F4 *, s32); +void func_8006B74C(Object_2F4 *); void func_8006EEFC(s32, f32, f32, f32, f32, f32, f32, f32, f32, f32); @@ -247,6 +257,8 @@ s32 func_800915FC(Object_2F4*); void func_80092D48(Object_2F4 *); void func_80094D20(f32, f32); s32 func_800998FC(Vec3f*, Vec3f*, s32, s32, Vec3f*, Vec3f*); +void func_8009A72C(s32, void*, Vec3f*, OverrideLimbDraw, PostLimbDraw, s32*, Matrix*); +void func_8009AA20(void*, s32, Vec3f*); s16 func_8009ACDC(s16 *); f32 func_8009BC2C(f32*, f32, f32, f32, f32); f32 func_8009BD38(f32*, f32, f32, f32, f32); @@ -281,9 +293,7 @@ void func_800A5D6C(void); void func_800A6148(void); void func_800A6CD0(UnkStruct_D_80178280 *, s32, s32); void func_800B86CC(void); -void func_800B8DD0(Gfx**, s16); -void func_800BA490(void); -void func_800BA4F0(void); + s32 func_800BA7BC(u16*, s32); void func_800BA808(u16*, s32); void func_800BB5D0(void); @@ -300,6 +310,7 @@ s32 func_800C3194(void); void func_EFFA40_80187520(s32, void*); +void func_DF4260_80198310(Object_408 *); void func_DF4260_801878D8(Object_408 *); void func_DF4260_801988E0(void); void func_DF4260_8018B0B4(Object_2F4 *); @@ -312,6 +323,7 @@ void func_DF4260_801935CC(Object_408 *); void func_E08400_80188A40(Object_408 *); +void func_E16C50_80190F08(Object_2F4 *); void func_E16C50_80187754(Object_408 *); void func_E16C50_801932AC(Object_408 *); void func_E16C50_8019B1F0(Object_2F4 *); diff --git a/include/gfx.h b/include/gfx.h index 4d5a51dd..17060908 100644 --- a/include/gfx.h +++ b/include/gfx.h @@ -98,4 +98,59 @@ typedef enum SetupDL { extern Gfx gSetupDLs[SETUPDL_MAX][9]; // 0x800D31B0 +void func_800B8DD0(Gfx** gfxP, s16 i); +void func_800B8E14(Gfx** gfxP, s32 r, s32 g, s32 b, s32 a, s32 near, s32 far); +void func_800B8F18(void); +void func_800B8F48(void); +void func_800B8F78(void); +void func_800B8FA8(void); +void func_800B8FD8(void); +void func_800B9008(s32 r, s32 g, s32 b, s32 a, s32 near, s32 far); +void func_800B9120(void); +void func_800B9150(void); +void func_800B9180(s32 r, s32 g, s32 b, s32 a, s32 near, s32 far); +void func_800B9298(void); +void func_800B92C8(void); +void func_800B92F8(void); +void func_800B9328(void); +void func_800B9358(void); +void func_800B9388(s32 r, s32 g, s32 b, s32 a, s32 near, s32 far); +void func_800B94A0(void); +void func_800B94D0(s32 r, s32 g, s32 b, s32 a, s32 near, s32 far); +void func_800B95E8(void); +void func_800B9618(s32 r, s32 g, s32 b, s32 a, s32 near, s32 far); +void func_800B9730(void); +void func_800B9760(void); +void func_800B9790(s32 r, s32 g, s32 b, s32 a, s32 near, s32 far); +void func_800B98A8(s32 r, s32 g, s32 b, s32 a, s32 near, s32 far); +void func_800B99C0(void); +void func_800B99F0(void); +void func_800B9A20(s32 r, s32 g, s32 b, s32 a, s32 near, s32 far); +void func_800B9B38(s32 r, s32 g, s32 b, s32 a, s32 near, s32 far); +void func_800B9C50(s32 r, s32 g, s32 b, s32 a, s32 near, s32 far); +void func_800B9D68(s32 r, s32 g, s32 b, s32 a, s32 near, s32 far); +void func_800B9E80(void); +void func_800B9EB0(s32 r, s32 g, s32 b, s32 a, s32 near, s32 far); +void func_800B9FC8(s32 r, s32 g, s32 b, s32 a, s32 near, s32 far); +void func_800BA0E0(void); +void func_800BA110(void); +void func_800BA140(void); +void func_800BA170(void); +void func_800BA1A0(void); +void func_800BA1D0(s32 r, s32 g, s32 b, s32 a, s32 near, s32 far); +void func_800BA2E8(s32 r, s32 g, s32 b, s32 a, s32 near, s32 far); +void func_800BA400(void); +void func_800BA430(void); +void func_800BA460(void); +void func_800BA490(void); +void func_800BA4C0(void); +void func_800BA4F0(void); +void func_800BA520(void); +void func_800BA550(void); +void func_800BA580(void); +void func_800BA5B0(void); +void func_800BA5E0(void); +void func_800BA610(void); +void func_800BA640(s32 r, s32 g, s32 b, s32 a, s32 near, s32 far); + #endif diff --git a/include/structs.h b/include/structs.h index 1ed81484..6bf4f965 100644 --- a/include/structs.h +++ b/include/structs.h @@ -4,6 +4,11 @@ #include "global.h" #include "sf64math.h" +#define UNK_TYPE s32 + +typedef s32 (*OverrideLimbDraw)(s32, Gfx**, Vec3f*, Vec3f*, s32*); +typedef void (*PostLimbDraw)(s32, Vec3f*, s32*); + typedef struct { s32 unk0; u16* unk4; @@ -148,12 +153,33 @@ typedef struct { /* 0x14 */ char pad14[0x14]; } UnkStruct_D_80175A10; // size = 0x28 +typedef struct { + /* 0x00 */ u8 unk_00; + /* 0x01 */ u8 unk_01; + /* 0x04 */ f32 unk_04; + /* 0x08 */ f32 unk_08; + /* 0x0C */ f32 unk_0C; + /* 0x10 */ f32 unk_10; + /* 0x14 */ f32 unk_14; + /* 0x18 */ f32 unk_18; + /* 0x1C */ f32 unk_1C; + /* 0x20 */ f32 unk_20; + /* 0x24 */ f32 unk_24; + /* 0x28 */ f32 unk_28; + /* 0x2C */ s8 unk_2C; + /* 0x30 */ f32 unk_30; + /* 0x34 */ f32 unk_34; + /* 0x38 */ f32 unk_38; +} UnkStruct_D_80161630; // size = 0x3C + typedef struct UnkStruct_D_80178280 { /* 0x000 */ char pad0[0xC]; /* 0x00C */ f32 unk_00C; - /* 0x010 */ char pad10[0x30]; - /* 0x040 */ Vec3f unk_40; - /* 0x04C */ char pad4C[0xC]; + /* 0x010 */ char pad10[0x24]; + /* 0x034 */ f32 unk_034; + /* 0x038 */ char pad38[8]; + /* 0x040 */ Vec3f unk_040; + /* 0x04C */ Vec3f unk_04C; /* 0x058 */ f32 unk_058; /* 0x05C */ f32 unk_05C; /* 0x060 */ char pad060[0x14]; @@ -174,17 +200,24 @@ typedef struct UnkStruct_D_80178280 { /* 0x110 */ f32 unk_110; /* 0x114 */ f32 unk_114; /* 0x118 */ f32 unk_118; - /* 0x11C */ char pad11C[8]; + /* 0x11C */ char pad11C[4]; + /* 0x120 */ f32 unk_120; /* 0x124 */ f32 unk_124; /* 0x128 */ char pad128[0x10]; /* 0x138 */ f32 unk_138; - /* 0x13C */ char pad13C[0x8C]; + /* 0x13C */ char pad13C[8]; + /* 0x144 */ f32 unk_144; + /* 0x148 */ char pad148[0x54]; + /* 0x19C */ s32 unk_19C; + /* 0x1A0 */ char pad1A0[0x28]; /* 0x1C8 */ s32 unk_1C8; /* 0x1CC */ s32 unk_1CC; /* 0x1D0 */ s32 unk_1D0; /* 0x1D4 */ char pad1D4[0x20]; /* 0x1F4 */ s32 unk_1F4; - /* 0x1F8 */ char pad1F8[0x18]; + /* 0x1F8 */ char pad1F8[0xC]; + /* 0x204 */ s32 unk_204; + /* 0x208 */ char pad208[8]; /* 0x210 */ s32 unk_210; /* 0x214 */ char pad214[0x10]; /* 0x224 */ s32 unk_224; @@ -202,10 +235,10 @@ typedef struct UnkStruct_D_80178280 { /* 0x2B8 */ char pad2B8[0x4]; /* 0x2BC */ f32 unk_2BC; /* 0x2C0 */ char pad2C0[0x1A0]; - /* 0x460 */ f32 unk_460[1]; // might be Vec3f - /* 0x464 */ char pad464[0x38]; - /* 0x49C */ u8 unk_49C; - /* 0x49D */ u8 unk_49D; + /* 0x460 */ Vec3f unk_460[1]; + /* 0x46C */ char pad46C[0x30]; + /* 0x49C */ u8 unk_49C; // could be array + /* 0x49C */ u8 unk_49D; /* 0x49E */ char pad49E[0x42]; } UnkStruct_D_80178280; // size = 0x4E0 Might be Player @@ -228,20 +261,25 @@ typedef struct { } Object; // size = 0x1C typedef struct { - /* 0x00 */ char unk0[0x8]; - /* 0x08 */ void (*unk_8)(Object*); - /* 0x0C */ void* unk_C; + /* 0x00 */ void (*unk_00)(Object*); + /* 0x00 */ u8 unk_04; + /* 0x08 */ void (*unk_08)(Object*); + /* 0x0C */ void* unk_0C; /* 0x10 */ f32 unk_10; - /* 0x14 */ char unk14[0x2]; + /* 0x14 */ s16 unk_14; /* 0x16 */ s16 unk_16; - /* 0x18 */ char unk18[0x8]; + /* 0x18 */ u8 unk_18; + /* 0x19 */ u8 unk_19; + /* 0x1C */ f32 unk_1C; /* 0x20 */ u8 unk_20; } ObjectStruct_1C; // size = 0x24 typedef struct { /* 0x00 */ Object obj; /* 0x1C */ ObjectStruct_1C unk_1C; - /* 0x40 */ char unk40[0x18]; + /* 0x40 */ char unk40[0x8]; + /* 0x48 */ Vec3f unk_48; + /* 0x54 */ f32 unk_54; } Object_58; // size = 0x58 typedef struct { @@ -256,8 +294,12 @@ typedef struct { /* 0x1C */ f32 unk_1C; /* 0x20 */ f32 unk_20; /* 0x24 */ f32 unk_24; - /* 0x28 */ char pad28[8]; -} UnkStruct_D_80174750; + /* 0x28 */ f32 unk_28; + /* 0x2C */ u8 unk_2C; // possibly a color struct + /* 0x2D */ u8 unk_2D; + /* 0x2E */ u8 unk_2E; + /* 0x2F */ u8 unk_2F; +} UnkStruct_D_80174750; // size = 0x30 typedef struct { /* 0x00 */ Object obj; @@ -270,8 +312,8 @@ typedef struct { /* 0x60 */ f32 unk_60; /* 0x64 */ f32 unk_64; /* 0x68 */ char pad68[8]; - /* 0x70 */ f32 unk_70; - /* 0x74 */ char pad74[0xC]; + /* 0x70 */ Vec3f unk_70; + /* 0x7C */ char pad7C[4]; } Object_80; // size = 0x80 typedef struct { @@ -281,7 +323,7 @@ typedef struct { /* 0x44 */ char pad44[1]; /* 0x45 */ u8 unk_45; // could be short loaded as u8 /* 0x46 */ s8 unk_46; - /* 0x47 */ char pad47[5]; + /* 0x48 */ s32 unk_48; } Object_4C; // size = 0x4C typedef struct { @@ -297,7 +339,7 @@ typedef struct { /* 0x50 */ f32 unk_50; /* 0x54 */ f32 unk_54; /* 0x58 */ f32 unk_58; - /* 0x5C */ f32 unk_5C[3]; // could be Vec3f + /* 0x5C */ Vec3f unk_5C; /* 0x68 */ f32 unk_68; } Object_6C; // size 0x6C @@ -316,18 +358,17 @@ typedef struct { /* 0x54 */ f32 unk_54; /* 0x58 */ f32 unk_58; /* 0x5C */ f32 unk_5C; - /* 0x60 */ char pad60[0xC]; + /* 0x60 */ Vec3f unk_60; /* 0x6C */ f32 unk_6C; /* 0x70 */ f32 unk_70; /* 0x74 */ char pad74[0xC]; - /* 0x80 */ f32 unk_80[1]; // unknown size. Could be Vec3f - /* 0x84 */ char pad84[0x8]; + /* 0x80 */ Vec3f unk_80; } Object_8C; // size 0x8C typedef struct { /* 0x000 */ Object obj; /* 0x01C */ ObjectStruct_1C unk_01C; - /* 0x040 */ s32 unk_40; + /* 0x040 */ s32 unk_040; /* 0x044 */ char unk_44[0xA]; /* 0x04E */ s16 unk_04E; /* 0x050 */ s16 unk_050; @@ -337,31 +378,43 @@ typedef struct { /* 0x058 */ s16 unk_058; /* 0x05A */ s16 unk_05A; /* 0x05C */ s16 unk_05C; - /* 0x05E */ char pad5E[4]; + /* 0x05E */ u8 unk_05E; + /* 0x05F */ char pad5F[3]; /* 0x062 */ s8 unk_062; - /* 0x063 */ char pad63[9]; - /* 0x06C */ f32 unk_6C; - /* 0x070 */ f32 unk_70; - /* 0x074 */ f32 unk_74; + /* 0x063 */ char pad63[5]; + /* 0x068 */ f32 unk_068; + /* 0x06C */ f32 unk_06C; + /* 0x070 */ f32 unk_070; + /* 0x074 */ f32 unk_074; /* 0x078 */ char pad78[0xC]; - /* 0x084 */ f32 unk_84; - /* 0x088 */ char pad88[0x54]; + /* 0x084 */ f32 unk_084; + /* 0x088 */ char pad88[0x3E]; + /* 0x0C6 */ u16 unk_0C6; + /* 0x0C8 */ char padC8[1]; + /* 0x0C9 */ u8 unk_0C9; + /* 0x0CA */ char padCA[0x12]; /* 0x0DC */ f32 unk_0DC; /* 0x0E0 */ f32 unk_0E0; - /* 0x0E4 */ char padE4[0x314]; + /* 0x0E4 */ f32 unk_0E4; + /* 0x0E8 */ char padE8[0x28]; + /* 0x110 */ f32 unk_110; + /* 0x114 */ char pad114[0x1F4]; + /* 0x308 */ Vec3f unk_308; + /* 0x314 */ char pad314[0xE4]; /* 0x3F8 */ f32 unk_3F8; - /* 0x3FC */ f32 unk_3FC; - /* 0x400 */ char pad400[8]; + /* 0x3FC */ Vec3f unk_3FC; } Object_408; // size = 0x408 typedef struct { /* 0x000 */ Object obj; /* 0x01C */ ObjectStruct_1C unk_01C; /* 0x040 */ s32 unk_040; - /* 0x044 */ u8 unk_44; - /* 0x046 */ s16 unk_46; - /* 0x048 */ s16 unk_48; - /* 0x04A */ char pad4A[6]; + /* 0x044 */ u8 unk_044; + /* 0x046 */ s16 unk_046; + /* 0x048 */ s16 unk_048; + /* 0x04A */ s16 unk_04A; + /* 0x04C */ char pad4C[2]; + /* 0x04E */ s16 unk_04E; /* 0x050 */ s32 unk_050; /* 0x054 */ s32 unk_054; /* 0x058 */ s32 unk_058; @@ -375,9 +428,11 @@ typedef struct { /* 0x078 */ s32 unk_078; /* 0x07C */ s32 unk_07C; /* 0x080 */ s32 unk_080; - /* 0x084 */ char pad84[8]; + /* 0x084 */ char pad84[4]; + /* 0x088 */ s32 unk_88; /* 0x08C */ s32 unk_8C; - /* 0x090 */ char pad90[0x24]; + /* 0x090 */ char pad90[0x20]; + /* 0x0B0 */ s32 unk_0B0; /* 0x0B4 */ s16 unk_0B4; /* 0x0B6 */ s16 unk_0B6; /* 0x0B8 */ s16 unk_0B8; @@ -405,7 +460,7 @@ typedef struct { /* 0x0F4 */ f32 unk_0F4; /* 0x0F8 */ f32 unk_0F8; // angle /* 0x0FC */ f32 unk_0FC; - /* 0x100 */ f32 unk_100[3]; // may be Vec3f + /* 0x100 */ Vec3f unk_100; // may be Vec3f /* 0x10C */ f32 unk_10C; /* 0x110 */ f32 unk_110; /* 0x114 */ f32 unk_114; @@ -423,7 +478,11 @@ typedef struct { /* 0x14C */ f32 unk_14C; /* 0x150 */ f32 unk_150; /* 0x154 */ f32 unk_154; - /* 0x158 */ char pad158[0x14]; + /* 0x158 */ f32 unk_158; + /* 0x15C */ char pad15C[4]; + /* 0x160 */ f32 unk_160; + /* 0x164 */ f32 unk_164; + /* 0x168 */ f32 unk_168; /* 0x16C */ f32 unk_16C; /* 0x170 */ char pad170[8]; /* 0x178 */ f32 unk_178; @@ -431,7 +490,8 @@ typedef struct { /* 0x180 */ f32 unk_180; /* 0x184 */ f32 unk_184; /* 0x188 */ f32 unk_188; - /* 0x18C */ char pad18C[0x150]; + /* 0x18C */ Vec3f unk_18C; // could be joint table + /* 0x198 */ char pad198[0x144]; /* 0x2DC */ Vec3f unk_2DC; /* 0x2E8 */ Vec3f unk_2E8; } Object_2F4; // size = 0x2F4 diff --git a/include/variables.h b/include/variables.h index 461b031e..87fce7f8 100644 --- a/include/variables.h +++ b/include/variables.h @@ -21,7 +21,7 @@ extern s32 sFaultCharPixelFlags[]; extern const char* D_800C4870[]; extern const char* D_800C48B8[]; -extern f32 D_800C5D28[]; +extern Vec3f D_800C5D28; extern f32 D_800C5D34; extern s8 D_800C5D3C; extern s8 D_800C7C50; @@ -103,7 +103,7 @@ extern Lightsn* gLight; extern FrameBuffer *gFrameBuffer; extern s32* D_80137E74; -// some sort of struct I think +// some sort of struct? extern u8 D_80137E78; extern u32 D_80137E7C; extern u8 D_80137E80; @@ -163,13 +163,44 @@ extern OverlayInit D_800CBC0C[1]; // E08400 extern OverlayInit D_800CBD3C[1]; // EFFA40 extern f32 D_800CBF18[]; extern ObjectStruct_1C D_800CC124[400]; +extern f32 D_800CF9B0[]; +extern Gfx* D_800CFA54[]; +extern Gfx* D_800CFAC4[]; +extern Gfx* D_800CFADC[]; +extern Gfx* D_800CFB08[]; +extern Gfx* D_800CFB14[]; +extern Gfx* D_800CFB28[]; +extern Gfx* D_800CFB40[]; +extern Gfx* D_800CFB64[]; +extern Gfx* D_800CFB88[]; +extern Gfx* D_800CFBA8[]; +extern Gfx* D_800CFBE4[]; +extern Gfx* D_800CFC0C[]; +extern Gfx* D_800CFC40[]; +extern Gfx* D_800CFC50[]; +extern Gfx* D_800CFC64[]; +extern Gfx* D_800CFC7C[]; +extern f32 D_800CFC98[]; +extern Vec3f D_800CFCC0; // initializer in sf_5A240 +extern f32 D_800CFCCC[]; +extern Vec3f D_800CFCEC; +extern Vec3f D_800CFCF8; +extern Vec3f D_800CFD04; +extern Vec3f D_800CFD10; +extern Vec3f D_800CFD1C; +extern Vec3f D_800CFD28; +extern Vec3f D_800CFD34; extern ObjectInit* D_800CFDA0[]; +extern Gfx D_800CFD80[]; extern s32 D_800CFDF4[]; extern f32 D_800CFE5C[]; extern Vec3f D_800CFEC4[6]; extern Vec3f D_800CFF0C[6]; extern u32 D_800CFF54[9]; extern s32 D_800CFF90; +extern s16 D_800CFF94[]; +extern u8 D_800CFFB4[]; +extern f32 D_800CFFC4[]; extern f32 D_800D19AC[]; extern f32 D_800D19E0[]; extern Gfx D_800D1A40[]; @@ -202,6 +233,13 @@ extern s32 D_8015F930[3]; extern s32 D_8015F93C; extern s32 D_8015F940; extern f32 D_8015F944; +extern s16 D_80161410; +extern Vec3f D_80161578[]; +extern Vec3f D_801615D0; +extern Vec3f D_801615E0; +extern s32 D_801615EC; +extern Matrix D_801615F0; +extern UnkStruct_D_80161630 D_80161630; extern s32 D_80161670[4]; extern s32 D_80161680; extern u8 D_80161684; @@ -272,6 +310,7 @@ extern f32 D_80176B98[2][100]; extern f32 D_801771D8[2][100]; extern f32 D_80176EB8[2][100]; extern s32 D_801774F8; +extern f32 D_80177500[2][100]; extern s32 D_80177820; extern s32 D_80177824; extern s32 D_8017782C; @@ -304,6 +343,7 @@ extern s8 D_80177930; extern u16 D_80177938[]; extern f32 D_80177940; extern u16 D_80177948[]; +extern f32 D_80177950; extern f32 D_80177958[]; extern f32 D_80177978; extern UnkStruct_D_8017797C* D_8017797C; @@ -315,10 +355,11 @@ extern f32 D_801779A8[]; extern f32 D_801779B8; extern f32 D_801779C0; extern s32 D_801779C8[]; +extern Vec3f D_801779D8; extern s32 D_801779F8; extern s32 D_80177A80; extern s8 D_80177A98; -extern s8 D_80177AB0; +extern u8 D_80177AB0; extern s32 D_80177AE0; extern s32 D_80177AF8; extern s32 D_80177B40; @@ -354,6 +395,7 @@ extern s32 D_80177E70; extern s32 D_80177E78; extern s32 D_80177E80; extern Vec3f D_80177E88; +extern Vec3f D_80177E98[]; extern Vec3f D_80177F10; extern s32 D_8017812C; extern s32 D_80178234; @@ -373,20 +415,30 @@ extern ObjectInit* D_80178310; extern s32 D_80178320; extern s32 D_80178328; extern s32 D_80178330; +extern s32 D_80178338; extern s32 D_80178340; extern s32 D_80178348; extern s32 D_80178350; extern s32 D_80178354; +extern s32 D_80178360; +extern s32 D_80178364; +extern s32 D_80178368; +extern f32 D_8017836C; +extern f32 D_80178370; +extern f32 D_80178374; +extern f32 D_80178378; extern s32 D_80178380[]; extern s32 D_80178390[]; extern s32 D_801783A0[]; extern s32 D_801783B0[]; extern s32 D_801783D8; +extern s32 D_801783DC; extern s32 D_80178410; extern f32 D_80178420; extern f32 D_80178424; extern f32 D_80178428; extern f32 D_8017842C; +extern f32 D_8017847C; extern s32 D_80178480; extern s32 D_80178488; extern s32 D_801784A4; @@ -417,6 +469,7 @@ extern SaveFile D_80178870; extern u16 D_Tex_800D99F8[]; extern u16 D_Tex_800DBA20[]; extern Gfx D_Gfx_800DBAA0[]; +extern Gfx D_Gfx_800DAC20[]; extern DmaEntry gDmaTable[]; // 178A70 extern u8 D_80179010[][16 * 13 / 2]; @@ -438,6 +491,11 @@ extern u16 D_80183A08[]; extern u16 D_80183A64[]; extern UnkStruct_D_80185CBC D_80185CBC[]; +extern Gfx* D_DF4260_8019A008[]; +extern Matrix D_E51970_8019EE80; +extern Gfx* D_E6A810_801B769C[]; +extern Gfx* D_E6A810_801B7584[]; +extern Gfx* D_E6A810_801B7608[]; extern f32 D_E9F1D0_801A7F60; extern f32 D_E9F1D0_801A7F78; extern f32 D_EBFBE0_801B7BC8; @@ -484,6 +542,8 @@ extern f32 D_EBFBE0_801B9060; extern f32 D_EBFBE0_801B9064; extern s8 D_E6A810_801BA1E8; + + extern char D_EBFBE0_801ADA44[]; extern s32 D_EBFBE0_801ADA84[]; extern s32 D_EBFEB0_801ADA94; @@ -503,7 +563,8 @@ extern u16 D_10050E0[]; extern u16 D_100BAC0[]; extern u16 D_100D900[]; extern u16 D_10032A0[]; - +extern Gfx D_10194C0[]; +extern Gfx D_1024290[]; extern u8 D_1011A40[]; extern u16 D_1011AB0[]; extern u8 D_1011E80[]; @@ -524,6 +585,19 @@ extern Gfx D_1024830[]; extern u8 D_1024A58[]; extern Gfx D_102A8A0[]; extern Gfx D_1024AC0[]; +extern Gfx D_1028230[]; +extern Gfx D_101CAE0[]; +extern Gfx D_1023C80[]; +extern Gfx D_101A570[]; +extern Gfx D_1019CA0[]; +extern Gfx D_1016870[]; +extern Gfx D_1022E80[]; +extern Gfx D_102A010[]; +extern Gfx D_1032780[]; +extern Gfx D_1019820[]; +extern Gfx D_101A8E0[]; +extern Gfx D_102FE80[]; +extern Gfx D_10231A0[]; extern Gfx D_2000000[]; extern Gfx D_2000890[]; @@ -563,6 +637,17 @@ extern u8 D_300D3C0[]; extern u16 D_300D408[]; extern u8 D_300D440[]; extern u16 D_300D500[]; +extern Gfx D_30155E0[]; +extern Gfx D_3015D80[]; +extern Gfx D_3016660[]; +extern Gfx D_3011720[]; +extern Gfx D_3005980[]; + +extern Gfx D_40018A0[]; +extern Gfx D_4003BD0[]; +extern Gfx D_4007870[]; +extern Gfx D_4007AF0[]; +extern Gfx D_400B390[]; extern u8 D_5000000[]; extern u8 D_5000080[]; @@ -596,18 +681,48 @@ extern f32 D_60069CC[]; extern f32 D_60069E8[]; extern f32 D_6006A04[]; extern f32 D_6006A20[]; +extern Gfx D_6007650[]; +extern Gfx D_60148B0[]; +extern Gfx D_601AE40[]; +extern Gfx D_6023AC0[]; +extern s16 D_6029528[]; +extern Gfx D_602DA20[]; +extern Gfx D_6032BC0[]; +extern Gfx D_6034B90[]; +extern Gfx D_6035DA0[]; +extern Gfx D_60361F0[]; +extern Gfx D_60119A0[]; +extern Gfx D_6012C00[]; +extern Gfx D_6009F90[]; +extern Gfx D_600D730[]; +extern Gfx D_600DBC0[]; +extern Gfx D_60363B0[]; +extern Gfx D_6036840[]; +extern Gfx D_6036CD0[]; +extern Gfx D_6022920[]; +extern Gfx D_6020B40[]; +extern UNK_TYPE D_6029674; extern ObjectInit* D_6010088[]; extern u16 D_601B4B0[]; extern Gfx D_601D1F0[]; extern s16 D_6029528[]; extern ObjectInit* D_602B148[]; extern ObjectInit* D_602F18C[]; +extern UNK_TYPE D_601E8C4; +extern UNK_TYPE D_601E9D0; +extern Gfx D_6018C00[]; +extern Gfx D_6024B60[]; +extern Gfx D_6025B50[]; +extern Gfx D_6007CF0[]; +extern Gfx D_6007D90[]; extern u16 D_60447A0[]; extern u16 D_6047550[]; extern Gfx D_6004570[]; extern u8 D_6001B80[]; extern u8 D_60020D0[]; +extern Gfx D_7007350[]; +extern Gfx D_700BB10[]; extern u8 D_7004010[]; extern u8 D_80038E0[]; @@ -622,16 +737,26 @@ extern u8 D_8003B28[]; extern u8 D_800D070[]; extern u8 D_800D170[]; -extern Gfx D_D0098B0[]; -extern Gfx D_F014180[]; +extern Gfx D_900D180[]; +extern Gfx D_9010FD0[]; +extern Gfx D_9023290[]; +extern Gfx D_90234D0[]; +extern ObjectInit* D_C0356A4[]; +extern ObjectInit* D_C0356A4[]; +extern Gfx D_C017440[]; + +extern Gfx D_D0098B0[]; + +extern Gfx D_F014310[]; +extern Gfx D_F014180[]; extern u16 D_F000000[]; extern u16 D_F000800[]; extern u16 D_F001000[]; extern u16 D_F001800[]; extern u16 D_F002000[]; -extern ObjectInit* D_C0356A4[]; + #endif // VARIABLES_H diff --git a/linker_scripts/us/symbol_addrs.txt b/linker_scripts/us/symbol_addrs.txt index 20c715f5..65d92ebc 100644 --- a/linker_scripts/us/symbol_addrs.txt +++ b/linker_scripts/us/symbol_addrs.txt @@ -149,6 +149,8 @@ D_80177E88 = 0x80177E88; // size:0xC Mio0_Decompress = 0x8001EE70; RdRam_CheckIPL3 = 0x8001EF10; +D_800CFA54 = 0x800CFA54; + D_800D934C = 0x800D934C; // force_migration:True D_800D503C = 0x800D503C; // force_migration:True D_800D5248 = 0x800D5248; // force_migration:True diff --git a/src/main/matrix.c b/src/main/matrix.c index 93330396..91355453 100644 --- a/src/main/matrix.c +++ b/src/main/matrix.c @@ -21,7 +21,6 @@ Matrix* D_8013BBC8; Matrix D_8013BBD0[0x20]; #endif -// Matrix_Copy void Matrix_Copy(Matrix* dst, Matrix* src) { dst->m[0][0] = src->m[0][0]; dst->m[0][1] = src->m[0][1]; @@ -57,18 +56,15 @@ void Matrix_Copy(Matrix* dst, Matrix* src) { // dst->ww = src->ww; } -// Matrix_Push void Matrix_Push(Matrix** mtxStack) { Matrix_Copy(*mtxStack + 1, *mtxStack); *mtxStack += 1; } -// Matrix_Pop void Matrix_Pop(Matrix** mtxStack) { *mtxStack -= 1; } -// Matrix_Mult void Matrix_Mult(Matrix* mtx, Matrix* tf, u8 mode) { f32 rx; f32 ry; @@ -120,7 +116,6 @@ void Matrix_Mult(Matrix* mtx, Matrix* tf, u8 mode) { } } -// Matrix_Translate void Matrix_Translate(Matrix* mtx, f32 x, f32 y, f32 z, u8 mode) { f32 rx; f32 ry; @@ -186,7 +181,6 @@ void Matrix_Scale(Matrix* mtx, f32 xScale, f32 yScale, f32 zScale, u8 mode); #pragma GLOBAL_ASM("asm/us/nonmatchings/main/matrix/Matrix_Scale.s") #endif -// Matrix_RotateX void Matrix_RotateX(Matrix* mtx, f32 angle, u8 mode) { f32 cs; f32 sn; @@ -225,7 +219,6 @@ void Matrix_RotateX(Matrix* mtx, f32 angle, u8 mode) { } } -// Matrix_RotateY void Matrix_RotateY(Matrix* mtx, f32 angle, u8 mode) { f32 cs; f32 sn; @@ -264,7 +257,6 @@ void Matrix_RotateY(Matrix* mtx, f32 angle, u8 mode) { } } -// Matrix_RotateZ void Matrix_RotateZ(Matrix* mtx, f32 angle, u8 mode) { f32 cs; f32 sn; @@ -303,7 +295,6 @@ void Matrix_RotateZ(Matrix* mtx, f32 angle, u8 mode) { } } -// Matrix_RotateAxis void Matrix_RotateAxis(Matrix* mtx, f32 angle, f32 axisX, f32 axisY, f32 axisZ, u8 mode) { f32 rx; f32 ry; @@ -505,7 +496,6 @@ void Matrix_MultVec3fNoTranslate(Matrix* mtx, Vec3f* src, Vec3f* dest) { dest->z = (mtx->m[0][2] * src->x) + (mtx->m[1][2] * src->y) + (mtx->m[2][2] * src->z); } -// Matrix_GetYPRAngles void Matrix_GetYRPAngles(Matrix* mtx, Vec3f* rot) { Matrix invYP; Vec3f origin = { 0.0f, 0.0f, 0.0f }; @@ -525,16 +515,15 @@ void Matrix_GetYRPAngles(Matrix* mtx, Vec3f* rot) { xHatP.y -= originP.y; xHatP.z -= originP.z; rot->y = Math_Atan2F(zHatP.x, zHatP.z); - rot->x = -Math_Atan2F(zHatP.y, sqrtf((zHatP.x * zHatP.x) + (zHatP.z * zHatP.z))); + rot->x = -Math_Atan2F(zHatP.y, sqrtf(SQ(zHatP.x) + SQ(zHatP.z))); Matrix_RotateX(&invYP, -rot->x, 0); Matrix_RotateY(&invYP, -rot->y, 1); Matrix_MultVec3fNoTranslate(&invYP, &xHatP, &xHat); - rot->x *= 57.295776f; - rot->y *= 57.295776f; - rot->z = Math_Atan2F(xHat.y, xHat.x) * 57.295776f; + rot->x *= M_RTOD; + rot->y *= M_RTOD; + rot->z = Math_Atan2F(xHat.y, xHat.x) * M_RTOD; } -// Matrix_GetXYZAngles void Matrix_GetXYZAngles(Matrix* mtx, Vec3f* rot) { Matrix invYZ; Vec3f origin = { 0.0f, 0.0f, 0.0f }; @@ -554,7 +543,7 @@ void Matrix_GetXYZAngles(Matrix* mtx, Vec3f* rot) { yHatP.y -= originP.y; yHatP.z -= originP.z; rot->z = Math_Atan2F(xHatP.y, xHatP.x); - rot->y = -Math_Atan2F(xHatP.z, sqrtf((xHatP.x * xHatP.x) + (xHatP.y * xHatP.y))); + rot->y = -Math_Atan2F(xHatP.z, sqrtf(SQ(xHatP.x) + SQ(xHatP.y))); Matrix_RotateY(&invYZ, -rot->y, 0); Matrix_RotateZ(&invYZ, -rot->z, 1); Matrix_MultVec3fNoTranslate(&invYZ, &yHatP, &yHat); @@ -563,7 +552,6 @@ void Matrix_GetXYZAngles(Matrix* mtx, Vec3f* rot) { rot->z *= M_RTOD; } -// Matrix_LookAt void Matrix_LookAt(Matrix* mtx, f32 xEye, f32 yEye, f32 zEye, f32 xAt, f32 yAt, f32 zAt, f32 xUp, f32 yUp, f32 zUp, u8 mode) { Matrix lookAt; @@ -572,7 +560,6 @@ void Matrix_LookAt(Matrix* mtx, f32 xEye, f32 yEye, f32 zEye, f32 xAt, f32 yAt, Matrix_Mult(mtx, &lookAt, mode); } -// Matrix_SetMtx ? void Matrix_SetGfxMtx(Gfx** gfx) { Matrix_ToMtx(gGfxMtx); gSPMatrix((*gfx)++, gGfxMtx++, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW); diff --git a/src/main/sf_2EFE0.c b/src/main/sf_2EFE0.c index 355c7d7a..39231936 100644 --- a/src/main/sf_2EFE0.c +++ b/src/main/sf_2EFE0.c @@ -46,7 +46,7 @@ void func_8002E548(void) { func_8008E51C(D_8015F930, D_8015F944); if ((D_8015F930[0] == 0) && (sp24 != D_8015F930[1]) && (D_8015F930[1] < 15)) { - func_80019218(0x4900C02A, D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); + func_80019218(0x4900C02A, &D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); } } } diff --git a/src/main/sf_5A0F0.c b/src/main/sf_5A0F0.c index dfe33209..ff75c39b 100644 --- a/src/main/sf_5A0F0.c +++ b/src/main/sf_5A0F0.c @@ -1,7 +1,20 @@ -#include "common.h" +#include "global.h" -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A0F0/func_800594F0.s") +void func_800594F0(Object_80* arg0) { + func_800B9EB0(D_80178320, D_80178328, D_80178330, D_80178338, D_801783D8, D_801783DC); + Matrix_RotateY(D_8013B3C0, M_PI, 1); + Matrix_SetGfxMtx(&gMasterDisp); + gSPDisplayList(gMasterDisp++, D_6007D90); + func_800BA1D0(D_80178320, D_80178328, D_80178330, D_80178338, D_801783D8, D_801783DC); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A0F0/func_800595D0.s") +void func_800595D0(Object_80* arg0) { + func_800B9EB0(D_80178320, D_80178328, D_80178330, D_80178338, D_801783D8, D_801783DC); + Matrix_RotateY(D_8013B3C0, M_PI, 1); + Matrix_SetGfxMtx(&gMasterDisp); + gSPDisplayList(gMasterDisp++, D_6007CF0); + func_800BA1D0(D_80178320, D_80178328, D_80178330, D_80178338, D_801783D8, D_801783DC); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A0F0/func_800596B0.s") +void func_800596B0(Object_2F4* arg0) { +} diff --git a/src/main/sf_5A2C0.c b/src/main/sf_5A2C0.c index f5e55b5c..f1d63533 100644 --- a/src/main/sf_5A2C0.c +++ b/src/main/sf_5A2C0.c @@ -1,131 +1,1742 @@ -#include "common.h" +#include "global.h" -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_800596C0.s") +void func_800596C0(void) { + Matrix_RotateZ(D_8013B3C0, D_80177DB0 * 13.0f * M_DTOR, 1); + Matrix_Scale(D_8013B3C0, 1.02f, 0.98f, 1.0f, 1); + Matrix_RotateZ(D_8013B3C0, -(f32) D_80177DB0 * 13.0f * M_DTOR, 1); + Matrix_Scale(D_8013B3C0, 1.02f, 0.98f, 1.0f, 1); + Matrix_SetGfxMtx(&gMasterDisp); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_800597C0.s") +void func_800597C0(s32 arg0) { + if (arg0 < 0) { + gSPSetGeometryMode(gMasterDisp++, G_CULL_FRONT); + gSPClearGeometryMode(gMasterDisp++, G_CULL_BACK); + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005980C.s") +void func_8005980C(f32 arg0) { + Matrix_Scale(D_8013B3C0, arg0, arg0, arg0, 1); + Matrix_SetGfxMtx(&gMasterDisp); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_80059850.s") +void func_80059850(Object_4C* arg0) { + func_800B8DD0(&gMasterDisp, 0x40); + gDPSetPrimColor(gMasterDisp++, 0x00, 0x00, 255, 255, 255, 60); + func_800B9B38(D_80178320, D_80178328, D_80178330, D_80178338, D_801783D8, D_801783DC); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_800598DC.s") +void func_800598DC(s32 arg0) { +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_800598E8.s") +void func_800598E8(Object_2F4* arg0) { + func_800B9B38(D_80178320, D_80178328, D_80178330, D_80178338, D_801783D8, D_801783DC); + gSPDisplayList(gMasterDisp++, D_6025B50); + func_800BA1D0(D_80178320, D_80178328, D_80178330, D_80178338, D_801783D8, D_801783DC); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_800599A4.s") +void func_800599A4(s32 arg0, Vec3f* arg1, s32* arg2) { + Vec3f sp24; + Vec3f sp18; -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_80059A24.s") + if (arg0 == 1) { + sp24.x = 0.0f; + sp24.y = 0.0f; + sp24.z = 0.0f; + Matrix_MultVec3f(D_8013BBC8, &sp24, &sp18); + D_80163FE0[*arg2].unk_114 = sp18.y; + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_80059AEC.s") +void func_80059A24(Object_2F4* arg0) { + Vec3f sp30[30]; + f32 temp = D_800CF9B0[arg0->unk_0B6] - 114.0f; -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_80059B20.s") + Matrix_Translate(D_8013B3C0, 0.f, -temp, 0.0f, 1); + Matrix_SetGfxMtx(&gMasterDisp); + func_8009AA20(&D_601E8C4, arg0->unk_0B6, sp30); + func_8009A72C(1, &D_601E9D0, sp30, NULL, func_800599A4, &arg0->unk_040, &gIdentityMatrix); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_80059BB0.s") +void func_80059AEC(Object_80* arg0) { + gSPDisplayList(gMasterDisp++, D_601AE40); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_80059BBC.s") +void func_80059B20(Object_80* arg0) { + if (arg0->obj.id == 0x1D) { + gSPDisplayList(gMasterDisp++, D_7007350); + } else { + func_8005980C(D_800CF9B0[arg0->obj.id + 2]); + gSPDisplayList(gMasterDisp++, D_700BB10); + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_80059BF0.s") +void func_80059BB0(void* arg0) { +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_80059C28.s") +void func_80059BBC(Object_80* arg0) { + gSPDisplayList(gMasterDisp++, D_6023AC0); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_80059C34.s") +void func_80059BF0(Object_2F4* arg0) { + if (arg0->unk_0B6 != 0) { + gSPDisplayList(gMasterDisp++, D_6032BC0); + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_80059C40.s") +void func_80059C28(void* arg0) { +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_80059F68.s") +void func_80059C34(Object_4C* arg0) { +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_80059FDC.s") +void func_80059C40(Object_4C* arg0) { + func_800B9C50(D_80178320, D_80178328, D_80178330, D_80178338, D_801783D8, D_801783DC); + gDPSetPrimColor(gMasterDisp++, 0x00, 0x00, 255, 255, 255, 180); + switch (arg0->unk_45) { + case 0x0: + Matrix_Scale(D_8013B3C0, 2.0f, 1.0f, 0.7f, 1); + Matrix_SetGfxMtx(&gMasterDisp); + gSPDisplayList(gMasterDisp++, D_6034B90); + break; + case 0x15: + Matrix_Scale(D_8013B3C0, 1.0f, 1.0f, 0.7f, 1); + Matrix_SetGfxMtx(&gMasterDisp); + gSPDisplayList(gMasterDisp++, D_6034B90); + break; + case 0x6: + case 0x7: + Matrix_Scale(D_8013B3C0, 1.0f, 1.0f, 10.55f, 1); + Matrix_SetGfxMtx(&gMasterDisp); + gSPDisplayList(gMasterDisp++, D_Gfx_800DAC20); + break; + case 0x38: + Matrix_Scale(D_8013B3C0, 1.6f, 1.0f, 1.0f, 1); + Matrix_SetGfxMtx(&gMasterDisp); + gSPDisplayList(gMasterDisp++, D_6034B90); + break; + case 0x14: + Matrix_Scale(D_8013B3C0, 1.2f, 1.0f, 1.3f, 1); + Matrix_SetGfxMtx(&gMasterDisp); + gSPDisplayList(gMasterDisp++, D_6034B90); + break; + case 0x16: + Matrix_Scale(D_8013B3C0, 2.2f, 1.0f, 1.4f, 1); + Matrix_SetGfxMtx(&gMasterDisp); + gSPDisplayList(gMasterDisp++, D_6034B90); + break; + } + func_800B9B38(D_80178320, D_80178328, D_80178330, D_80178338, D_801783D8, D_801783DC); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005A010.s") +void func_80059F68(Object_6C* arg0) { + Matrix_Translate(D_8013B3C0, 0.0f, 0.0f, -95.0f, 1); + Matrix_SetGfxMtx(&gMasterDisp); + gSPDisplayList(gMasterDisp++, D_602DA20); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005A07C.s") +void func_80059FDC(Object_6C* arg0) { + gSPDisplayList(gMasterDisp++, D_6035DA0); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005A088.s") +void func_8005A010(Object_4C* arg0) { + if (arg0->unk_48 == 0) { + Matrix_RotateY(D_8013B3C0, M_PI / 2.0f, 1); + Matrix_SetGfxMtx(&gMasterDisp); + gSPDisplayList(gMasterDisp++, D_60361F0); + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005A094.s") +void func_8005A07C(void* arg0) { +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005ADAC.s") +void func_8005A088(void* arg0) { +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005B1E8.s") +void func_8005A094(Object_2F4* arg0) { + switch (arg0->unk_0B8) { + case 0: + Matrix_Translate(D_8013B3C0, 18.0f, 15.0f, -15.0f, 1); + Matrix_RotateY(D_8013B3C0, M_PI, 1U); + Matrix_SetGfxMtx(&gMasterDisp); + gSPDisplayList(gMasterDisp++, D_3016660); + break; + case 1: + Matrix_Translate(D_8013B3C0, -18.0f, 15.0f, -15.0f, 1); + Matrix_RotateY(D_8013B3C0, M_PI, 1U); + Matrix_SetGfxMtx(&gMasterDisp); + gSPDisplayList(gMasterDisp++, D_3015D80); + break; + case 2: + func_8005980C(arg0->unk_110); + gSPDisplayList(gMasterDisp++, D_30155E0); + break; + case 3: + gSPDisplayList(gMasterDisp++, D_3011720); + break; + case 4: + func_8005980C(arg0->unk_110); + if (arg0->unk_040 & 1) { + gSPDisplayList(gMasterDisp++, D_10194C0); + } else { + gSPDisplayList(gMasterDisp++, D_1024290); + } + break; + case 0x27: + gSPClearGeometryMode(gMasterDisp++, G_CULL_BACK); + gSPDisplayList(gMasterDisp++, D_800CFAC4[arg0->unk_048]); + break; + case 0x28: + gDPSetPrimColor(gMasterDisp++, 0x00, 0x00, 255, 255, 255, 255); + switch (arg0->unk_048) { + case 0: + break; + case 1: + func_800B8DD0(&gMasterDisp, 0x3D); + gSPClearGeometryMode(gMasterDisp++, G_CULL_BACK); + break; + case 2: + func_800B8DD0(&gMasterDisp, 0x39); + gSPClearGeometryMode(gMasterDisp++, G_CULL_BACK); + break; + case 3: + func_800B8DD0(&gMasterDisp, 0x21); + break; + } + if (D_80178234 != 7) { + gSPDisplayList(gMasterDisp++, D_E6A810_801B769C[arg0->unk_046]); + } else { + if (D_8016F110[0].unk_0E4 < 4800.0f) { + func_800B8DD0(&gMasterDisp, 0x1E); + gDPSetFogColor(gMasterDisp++, 0x40, 0x20, 0x20, D_80178338); + gSPFogPosition(gMasterDisp++, D_801783D8, D_801783DC); + } else { + func_800B8DD0(&gMasterDisp, 0x1E); + gDPSetFogColor(gMasterDisp++, 0x10, 0x10, 0x10, D_80178338); + gSPFogPosition(gMasterDisp++, D_801783D8, D_801783DC); + } + func_8005980C(arg0->unk_110); + gSPDisplayList(gMasterDisp++, D_800CFB40[arg0->unk_046]); + } + break; + case 0x29: + func_8005980C(arg0->unk_110); + gSPDisplayList(gMasterDisp++, D_800CFADC[arg0->unk_048]); + break; + case 0x2A: + func_8005980C(arg0->unk_110); + gSPDisplayList(gMasterDisp++, D_800CFB08[arg0->unk_048]); + break; + case 0x2B: + func_8005980C(arg0->unk_110); + gSPDisplayList(gMasterDisp++, D_800CFB14[arg0->unk_048]); + break; + case 0x2C: + func_8005980C(arg0->unk_110); + gSPDisplayList(gMasterDisp++, D_800CFB28[arg0->unk_048]); + break; + case 0x2D: + gSPDisplayList(gMasterDisp++, D_40018A0); + break; + case 0x2E: + if ((arg0->unk_048 == 2) || (arg0->unk_048 == 3) || (arg0->unk_048 == 4)) { + func_800B8DD0(&gMasterDisp, 0x21); + } + gSPClearGeometryMode(gMasterDisp++, G_CULL_BACK); + gSPDisplayList(gMasterDisp++, D_E6A810_801B7584[arg0->unk_048]); + break; + case 0x2F: + gSPDisplayList(gMasterDisp++, D_E6A810_801B7608[arg0->unk_048]); + break; + case 0x30: + func_8005980C(arg0->unk_110); + gSPDisplayList(gMasterDisp++, D_800CFB64[arg0->unk_048]); + break; + case 0x31: + func_8005980C(arg0->unk_110); + gSPDisplayList(gMasterDisp++, D_800CFB88[arg0->unk_048]); + break; + case 0x32: + func_8005980C(0.7f); + if (arg0->unk_054 == 1) { + func_800B8DD0(&gMasterDisp, 0x1E); + gDPSetPrimColor(gMasterDisp++, 0x00, 0x00, 255, 0, 0, 255); + } else if (arg0->unk_054 == 2) { + func_800B8DD0(&gMasterDisp, 0x1E); + gDPSetPrimColor(gMasterDisp++, 0x00, 0x00, 255, 0, 0, 255); + func_8005980C(0.7f); + } + switch (arg0->unk_050) { + case 0: + gSPDisplayList(gMasterDisp++, D_90234D0); + break; + case 1: + gSPDisplayList(gMasterDisp++, D_9023290); + break; + case 2: + gSPDisplayList(gMasterDisp++, D_900D180); + break; + case 3: + gSPDisplayList(gMasterDisp++, D_9010FD0); + break; + } + if (arg0->unk_054 != 0) { + func_800B8DD0(&gMasterDisp, 0x1D); + func_8005980C(0.7f); + } + break; + case 0x33: + func_8005980C(arg0->unk_110); + gSPDisplayList(gMasterDisp++, D_800CFBA8[arg0->unk_048]); + break; + case 0x34: + func_8005980C(arg0->unk_110); + gSPDisplayList(gMasterDisp++, D_800CFBE4[arg0->unk_048]); + break; + case 0x35: + func_8005980C(arg0->unk_110); + gSPDisplayList(gMasterDisp++, D_800CFC0C[arg0->unk_048]); + break; + case 0x36: + func_8005980C(arg0->unk_110); + gSPDisplayList(gMasterDisp++, D_800CFC40[arg0->unk_048]); + break; + case 0x37: + func_8005980C(arg0->unk_110); + gSPDisplayList(gMasterDisp++, D_800CFC50[arg0->unk_048]); + break; + case 0x38: + func_8005980C(arg0->unk_110); + func_800B8DD0(&gMasterDisp, 0x29); + Matrix_SetGfxMtx(&gMasterDisp); + gDPSetPrimColor(gMasterDisp++, 0x00, 0x00, 191, 255, 223, 255); + gSPDisplayList(gMasterDisp++, D_800CFC64[arg0->unk_048]); + break; + case 0x3A: + func_8005980C(arg0->unk_110); + Matrix_SetGfxMtx(&gMasterDisp); + gSPDisplayList(gMasterDisp++, D_60148B0); + break; + case 0x3B: + func_8005980C(arg0->unk_110); + Matrix_SetGfxMtx(&gMasterDisp); + gSPDisplayList(gMasterDisp++, D_800CFC7C[arg0->unk_048]); + break; + case 0x46: + gSPDisplayList(gMasterDisp++, D_10177C0); + break; + case 0x39: + gSPDisplayList(gMasterDisp++, D_DF4260_8019A008[arg0->unk_048]); + break; + default: + if (arg0->unk_0B8 > 9) { // part of switch tree somehow? + if (arg0->unk_0B8 == 0x24) { + gSPClearGeometryMode(gMasterDisp++, G_CULL_BACK); + } + gSPDisplayList(gMasterDisp++, D_800CFA54[arg0->unk_0B8 - 10]); + } + break; + } +} +void func_8005ADAC(Object_2F4* arg0) { + f32 sp5C; + f32 temp1; + f32 sp54; + s32 pad[5]; // fake? seems like a lot of padding + + if ((arg0->unk_07C != 0) && (arg0->obj.status == 2)) { + temp1 = 0.65250003f; + if (arg0->unk_07C >= 2) { + temp1 = 1.3050001f; + } + func_8009BC2C(&arg0->unk_188, temp1, 0.3f, 5.0f, 0.0f); + sp5C = arg0->unk_188; + if (D_80177DB0 & 1) { + sp5C *= 1.111f; + } + Matrix_Push(&D_8013B3C0); + Matrix_Translate(D_8013B3C0, 0.0f, 0.0f, -60.0f, 1); + Matrix_Scale(D_8013B3C0, sp5C, sp5C * 0.7f, sp5C, 1); + Matrix_RotateZ(D_8013B3C0, -arg0->obj.rot.z * M_DTOR, 1U); + Matrix_RotateX(D_8013B3C0, -arg0->obj.rot.x * M_DTOR, 1U); + Matrix_RotateY(D_8013B3C0, -arg0->obj.rot.y * M_DTOR, 1U); + Matrix_RotateY(D_8013B3C0, -D_80178280[D_801778A0].unk_058, 1U); + Matrix_RotateX(D_8013B3C0, D_80178280[D_801778A0].unk_05C, 1U); + Matrix_SetGfxMtx(&gMasterDisp); + func_8005465C(D_80177C98); + Matrix_Pop(&D_8013B3C0); + } + sp5C = arg0->unk_168; + if ((sp5C != 0.0f) && (D_80177C98 == 0)) { + sp54 = 0.0f; + if (D_80177DB0 & 1) { + sp54 = 180.0f; + } + func_800BA170(); + gDPSetPrimColor(gMasterDisp++, 0x00, 0x00, 255, 255, 255, 100); + Matrix_Push(&D_8013B3C0); + Matrix_Translate(D_8013B3C0, 70.0f, -10.0f, -100.0f, 1); + Matrix_Scale(D_8013B3C0, sp5C, 1.0f, 50.0f, 1); + Matrix_Translate(D_8013B3C0, 0.0f, 0.0f, -17.5f, 1); + Matrix_RotateX(D_8013B3C0, M_PI / 2.0f, 1); + Matrix_RotateY(D_8013B3C0, M_DTOR * sp54, 1); + Matrix_SetGfxMtx(&gMasterDisp); + gSPDisplayList(gMasterDisp++, D_102A8A0); + Matrix_Pop(&D_8013B3C0); + Matrix_Push(&D_8013B3C0); + Matrix_Translate(D_8013B3C0, -70.0f, -10.0f, -100.0f, 1); + Matrix_Scale(D_8013B3C0, sp5C, 1.0f, 50.0f, 1); + Matrix_Translate(D_8013B3C0, 0.0f, 0.0f, -17.5f, 1); + Matrix_RotateX(D_8013B3C0, M_PI / 2.0f, 1); + Matrix_RotateY(D_8013B3C0, M_DTOR * sp54, 1); + Matrix_SetGfxMtx(&gMasterDisp); + gSPDisplayList(gMasterDisp++, D_102A8A0); + Matrix_Pop(&D_8013B3C0); + } +} + +void func_8005B1E8(Object_2F4* arg0, s32 arg1) { + f32 var_fv0; + + if ((arg0->unk_07C != 0) && (arg0->obj.status == 2)) { + var_fv0 = 0.63f; + if (arg0->unk_07C >= 2) { + var_fv0 = D_800CFC98[arg0->unk_07C] * 0.45f; + } + if (D_80177DB0 & 1) { + var_fv0 *= 1.2f; + } + Matrix_Push(&D_8013B3C0); + Matrix_Scale(D_8013B3C0, var_fv0, var_fv0, var_fv0, 1); + Matrix_RotateZ(D_8013B3C0, -arg0->obj.rot.z * M_DTOR, 1); + Matrix_RotateX(D_8013B3C0, -arg0->obj.rot.x * M_DTOR, 1); + Matrix_RotateY(D_8013B3C0, -arg0->obj.rot.y * M_DTOR, 1); + Matrix_RotateY(D_8013B3C0, -D_80178280[D_801778A0].unk_058, 1); + Matrix_SetGfxMtx(&gMasterDisp); + func_8005465C(arg1); + Matrix_Pop(&D_8013B3C0); + } +} + +#ifdef NON_MATCHING +void func_8005B388(Object_2F4* arg0) { + Vec3f sp3C = D_800CFCC0; + Vec3f sp30; + + Matrix_MultVec3f(D_8013B3C0, &sp3C, &sp30); + if ((((fabsf(sp30.z) < 3000.0f) && (fabsf(sp30.x) < 3000.0f) && (D_80178284 == 0)) || + (D_80178280[0].unk_1C8 == 0) || (D_80178234 == 9) || (D_80178234 == 0x13) || (D_80178280[0].unk_1C8 == 7)) && + (D_80178234 != 0xB) && (D_80178234 != 0xC)) { + if (arg0->obj.id == 0xC3) { + if (((D_80178234 == 0x13) && (D_80178280[0].unk_1C8 == 7) && (arg0->unk_040 == 0xA)) || + ((D_80178280[0].unk_1C8 == 7) && (D_80178280[0].unk_1D0 >= 0x64) && (D_80178234 == 0x10) && + (arg0->unk_040 == 1)) || + ((D_80178234 == 5) && (D_80178280[0].unk_1C8 == 0) && (arg0->unk_0B8 == 5))) { + D_80161630.unk_00 = D_80178280[0].unk_49C; + D_80161630.unk_01 = D_80178280[0].unk_49D; + } else { + D_80161630.unk_00 = D_80161630.unk_01 = 2; + } + } else { + D_80161630.unk_00 = D_80161630.unk_01 = 2; + } + D_80161630.unk_04 = arg0->unk_150; + D_80161630.unk_0C = arg0->unk_154; + D_80161630.unk_08 = arg0->unk_17C; + D_80161630.unk_10 = arg0->unk_180; + D_80161630.unk_14 = D_80161630.unk_18 = D_80161630.unk_1C = D_80161630.unk_20 = D_80161630.unk_38 = + D_80161630.unk_24 = 0.0f; + D_80161630.unk_28 = arg0->unk_158; + D_80161630.unk_2C = arg0->unk_88; + D_80161630.unk_30 = arg0->unk_164; + D_80161630.unk_34 = arg0->unk_160; + if (D_80177C98 == 1) { + D_80161630.unk_04 = D_80161630.unk_08 = D_80161630.unk_0C = D_80161630.unk_10 = 0.0f; + } + func_80053658(&D_80161630, D_80178280); + } else if (D_80177C98 == 0) { + gSPDisplayList(gMasterDisp++, D_40018A0); + } else if (D_80178280[0].unk_204 == 2) { + gSPDisplayList(gMasterDisp++, D_4003BD0); + } else { + gSPDisplayList(gMasterDisp++, D_4007870); + } + func_8005ADAC(arg0); +} +#else +void func_8005B388(Object_2F4*); #pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005B388.s") +#endif -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005B6A4.s") +void func_8005B6A4(Object_2F4* arg0) { + Matrix_Scale(D_8013B3C0, 1.0f, 1.0f, 1.0f, 1); + Matrix_SetGfxMtx(&gMasterDisp); + gSPDisplayList(gMasterDisp++, D_6024B60); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005B71C.s") +void func_8005B71C(Object_2F4* arg0) { + func_800BA1D0(arg0->unk_046, D_80178328, D_80178330, D_80178338, arg0->unk_048, D_801783DC); + Matrix_Scale(D_8013B3C0, 0.5f, 0.5f, 0.5f, 1); + Matrix_SetGfxMtx(&gMasterDisp); + gSPDisplayList(gMasterDisp++, D_6018C00); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005B7CC.s") +void func_8005B7CC(Object_2F4* arg0) { + func_800BA1D0(arg0->unk_046, D_80178328, D_80178330, D_80178338, arg0->unk_048, D_801783DC); + gSPDisplayList(gMasterDisp++, D_6022920); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005B848.s") +void func_8005B848(Object_2F4* arg0) { + f32 var_fv0; -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005B9A4.s") + switch (arg0->unk_0B4) { + case 0: + gSPDisplayList(gMasterDisp++, D_1028230); + break; + case 1: + if (D_80178234 == 3) { + gSPDisplayList(gMasterDisp++, D_400B390); + } else { + gSPDisplayList(gMasterDisp++, D_4007AF0); + } + break; + } + var_fv0 = 2.0f; + if (D_80177DB0 & 1) { + var_fv0 = 1.7f; + } + Matrix_Translate(D_8013B3C0, 0.0f, 0.0f, -60.0f, 1); + arg0->unk_07C = 1; + Matrix_Scale(D_8013B3C0, var_fv0, var_fv0, var_fv0, 1); + func_8005B1E8(arg0, 2); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005BA30.s") +void func_8005B9A4(Object_2F4* arg0) { + Matrix_Translate(D_8013B3C0, 0.0f, -124.0f, 0.0f, 1); + func_8009AA20(D_6029528, arg0->unk_0B6, &arg0->unk_18C); + func_8009A72C(1, &D_6029674, &arg0->unk_18C, NULL, NULL, (s32*) arg0, &gIdentityMatrix); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005BAB4.s") +void func_8005BA30(Object_2F4* arg0) { + if (arg0->unk_0BC != 0) { + func_800BA400(); + gDPSetPrimColor(gMasterDisp++, 0x00, 0x00, 255, 0, 0, 255); + } + gSPDisplayList(gMasterDisp++, D_6020B40); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005C5F0.s") +void func_8005BAAC(void) { +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005C900.s") +void func_8005BAB4(s32 arg0, s32 arg1) { + f32 temp_fv0; + f32 temp1; + f32 temp2; -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005C9C0.s") + switch (arg0) { + case 0x176: + if (D_80170130[arg1].unk_4E == 0) { + Matrix_Scale(D_8013B3C0, 1.2f, 0.0f, 1.2f, 1); + Matrix_RotateX(D_8013B3C0, M_PI / 2.0f, 1); + Matrix_SetGfxMtx(&gMasterDisp); + gSPDisplayList(gMasterDisp++, D_102A8A0); + } + func_800B8DD0(&gMasterDisp, 0x40); + break; + case 0xC3: + case 0xC6: + case 0xC8: + switch (D_80163FE0[arg1].unk_0B4) { + case 0x3: + Matrix_Scale(D_8013B3C0, 2.3f, 0.0f, 2.3f, 1); + Matrix_RotateX(D_8013B3C0, M_PI / 2.0f, 1); + Matrix_SetGfxMtx(&gMasterDisp); + gSPDisplayList(gMasterDisp++, D_102A010); + break; + case 0x51: + func_800B8DD0(&gMasterDisp, 0x30); + gDPSetPrimColor(gMasterDisp++, 0x00, 0x00, 0, 0, 0, 255); + gDPSetEnvColor(gMasterDisp++, 0, 0, 0, 255); + temp_fv0 = D_80163FE0[arg1].unk_150 * 3.0f; + Matrix_Scale(D_8013B3C0, temp_fv0, temp_fv0, temp_fv0, 1); + Matrix_RotateX(D_8013B3C0, -M_PI / 2.0f, 1); + Matrix_SetGfxMtx(&gMasterDisp); + gSPDisplayList(gMasterDisp++, D_1024AC0); + break; + default: + temp1 = D_800CFCCC[D_80177DB0 % 8U]; + temp2 = D_800CFCCC[(D_80177DB0 + 4) % 8U]; + Matrix_Scale(D_8013B3C0, 1.4f + temp1, 0.0f, 1.4f + temp2, 1); + Matrix_RotateY(D_8013B3C0, M_PI, 1); + Matrix_Translate(D_8013B3C0, 0.0f, 0.0f, 30.0f, 1); + Matrix_SetGfxMtx(&gMasterDisp); + gSPSetGeometryMode(gMasterDisp++, G_CULL_BACK); + gSPDisplayList(gMasterDisp++, D_1032780); + break; + } + break; + case 0x124: + gSPDisplayList(gMasterDisp++, D_6034B90); + break; + case 0x13C: + if (D_80178280[0].unk_1C8 == 0) { + func_800B8DD0(&gMasterDisp, 0x40); + gDPSetPrimColor(gMasterDisp++, 0x00, 0x00, 0, 0, 0, 200); + } + Matrix_RotateX(D_8013B3C0, M_PI / 2.0f, 1); + func_8005980C(150.0f); + gSPDisplayList(gMasterDisp++, D_102A8A0); + break; + case 0x125: + case 0x126: + case 0x127: + case 0x128: + __cosf(D_8016F110[arg1].obj.rot.z * M_DTOR); + if (D_80161A88 == 2) { + gDPSetPrimColor(gMasterDisp++, 0x00, 0x00, 255, 255, 255, 90); + } else { + gDPSetPrimColor(gMasterDisp++, 0x00, 0x00, 255, 255, 255, 150); + } + switch (arg0) { + case 0x125: + gSPDisplayList(gMasterDisp++, D_6036840); + break; + case 0x126: + gSPDisplayList(gMasterDisp++, D_6036CD0); + break; + case 0x127: + case 0x128: + gSPDisplayList(gMasterDisp++, D_60363B0); + break; + } + break; + case 0xC0: + gDPSetPrimColor(gMasterDisp++, 0x00, 0x00, 255, 255, 255, 150); + Matrix_Scale(D_8013B3C0, 0.4f, 0.4f, D_80163FE0[arg1].unk_110, 1); + Matrix_SetGfxMtx(&gMasterDisp); + gSPDisplayList(gMasterDisp++, D_6034B90); + break; + case 0xE6: + func_800BA550(); + func_800B8DD0(&gMasterDisp, 0x45); + gSPSetGeometryMode(gMasterDisp++, G_CULL_BACK); + gDPSetPrimColor(gMasterDisp++, 0x00, 0x00, 0, 0, 0, 255); + gDPSetEnvColor(gMasterDisp++, 0, 0, 0, 0); + Matrix_RotateX(D_8013B3C0, D_80163FE0[arg1].unk_114, 1); + Matrix_RotateZ(D_8013B3C0, D_80163FE0[arg1].unk_11C, 1); + Matrix_Scale(D_8013B3C0, D_80163FE0[arg1].unk_110, 1.0f, D_80163FE0[arg1].unk_110, 1); + Matrix_RotateX(D_8013B3C0, -M_PI / 2.0f, 1); + Matrix_SetGfxMtx(&gMasterDisp); + gSPDisplayList(gMasterDisp++, D_1024AC0); + break; + case 0xE5: + func_800B8DD0(&gMasterDisp, 0x44); + gSPSetGeometryMode(gMasterDisp++, G_CULL_BACK); + gDPSetPrimColor(gMasterDisp++, 0x00, 0x00, 0, 0, 0, 255); + gDPSetEnvColor(gMasterDisp++, 0, 0, 0, 0); + Matrix_Translate(D_8013B3C0, 0.0f, 0.0f, 120.0f, 1); + Matrix_RotateX(D_8013B3C0, D_80163FE0[arg1].unk_118 * M_DTOR, 1); + Matrix_RotateZ(D_8013B3C0, D_80163FE0[arg1].unk_11C * M_DTOR, 1); + Matrix_RotateY(D_8013B3C0, D_80163FE0[arg1].obj.rot.y * M_DTOR, 1); + Matrix_Scale(D_8013B3C0, 6.0f, 1.0f, 7.5f, 1); + Matrix_RotateX(D_8013B3C0, -M_PI / 2.0f, 1); + Matrix_SetGfxMtx(&gMasterDisp); + gSPDisplayList(gMasterDisp++, D_1024AC0); + break; + case 0xE7: + func_800B8DD0(&gMasterDisp, 0x45); + gDPSetPrimColor(gMasterDisp++, 0x00, 0x00, 0, 0, 0, 255); + gDPSetEnvColor(gMasterDisp++, 0, 0, 0, 0); + Matrix_RotateX(D_8013B3C0, D_80163FE0[arg1].unk_118, 1); + Matrix_RotateZ(D_8013B3C0, D_80163FE0[arg1].unk_11C, 1); + Matrix_Translate(D_8013B3C0, 0.0f, 0.0f, 0.0f, 1); + Matrix_Scale(D_8013B3C0, 1.2f, 1.0f, 1.2f, 1); + Matrix_RotateX(D_8013B3C0, -M_PI / 2.0f, 1U); + Matrix_SetGfxMtx(&gMasterDisp); + gSPDisplayList(gMasterDisp++, D_1024AC0); + break; + case 0xD7: + func_800BA550(); + gDPSetPrimColor(gMasterDisp++, 0x00, 0x00, 0, 0, 0, 255); + gDPSetEnvColor(gMasterDisp++, 0, 0, 0, 255); + Matrix_Scale(D_8013B3C0, 4.0f, 4.0f, 4.0f, 1); + Matrix_SetGfxMtx(&gMasterDisp); + gSPDisplayList(gMasterDisp++, D_1024AC0); + break; + case 0x13F: + func_DF4260_80198310(&D_8016F110[arg1]); + break; + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005CA80.s") +void func_8005C5F0(Object_6C* arg0) { + s32 i; -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005CB44.s") + if ((D_80177DB0 & 0x18) && (arg0->unk_46 == 0)) { + Matrix_Push(&D_8013B3C0); + func_800B8DD0(&gMasterDisp, 0x40); + gDPSetPrimColor(gMasterDisp++, 0x00, 0x00, 255, 255, 0, 255); + Matrix_Scale(D_8013B3C0, 3.2f, 3.2f, 3.2f, 1); + Matrix_SetGfxMtx(&gMasterDisp); + gDPSetTextureFilter(gMasterDisp++, G_TF_POINT); + gSPDisplayList(gMasterDisp++, D_1023C80); + gDPSetTextureFilter(gMasterDisp++, G_TF_BILERP); + Matrix_Pop(&D_8013B3C0); + } + func_800B8DD0(&gMasterDisp, 0x1D); + gSPTexture(gMasterDisp++, 2000, 2000, 0, G_TX_RENDERTILE, G_ON); + gSPSetGeometryMode(gMasterDisp++, G_TEXTURE_GEN); + Matrix_RotateZ(D_8013B3C0, arg0->unk_58 * M_DTOR, 1); -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005CC9C.s") + for (i = 0; i < 8; i++) { + Matrix_Push(&D_8013B3C0); + Matrix_RotateZ(D_8013B3C0, i * 45.0f * M_DTOR, 1); + Matrix_Translate(D_8013B3C0, 2.0f * arg0->unk_68, 0.0f, 0.0f, 1); + Matrix_RotateZ(D_8013B3C0, (D_80177DB0 + (i * 110.0f)) * M_DTOR * 7.2f * arg0->unk_54, 1); + func_8005980C(2.0f * arg0->unk_50); + gSPDisplayList(gMasterDisp++, D_101CAE0); + Matrix_Pop(&D_8013B3C0); + } + gSPClearGeometryMode(gMasterDisp++, G_TEXTURE_GEN); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005CDA8.s") +void func_8005C900(Object_6C* arg0) { + func_800B8DD0(&gMasterDisp, 0x1D); + gSPTexture(gMasterDisp++, 3000, 0, 0, G_TX_RENDERTILE, G_ON); + gSPSetGeometryMode(gMasterDisp++, G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR); + func_8005980C(arg0->unk_68); + gSPDisplayList(gMasterDisp++, D_101A570); + gSPClearGeometryMode(gMasterDisp++, G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005D008.s") +void func_8005C9C0(Object_6C* arg0) { + func_800B8DD0(&gMasterDisp, 0x1D); + gSPTexture(gMasterDisp++, 3000, 0, 0, G_TX_RENDERTILE, G_ON); + gSPSetGeometryMode(gMasterDisp++, G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR); + func_8005980C(arg0->unk_68); + gSPDisplayList(gMasterDisp++, D_1019CA0); + gSPClearGeometryMode(gMasterDisp++, G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005D1F0.s") +void func_8005CA80(Object_6C* arg0) { + func_800B8DD0(&gMasterDisp, 0x1D); + gSPTexture(gMasterDisp++, 1900, 1700, 0, G_TX_RENDERTILE, G_ON); + gSPSetGeometryMode(gMasterDisp++, G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR); + func_8005980C(arg0->unk_68); + gSPDisplayList(gMasterDisp++, D_1016870); + gSPClearGeometryMode(gMasterDisp++, G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005D3CC.s") +void func_8005CB44(Object_6C* arg0) { + if (D_80178234 == 0xD) { + func_8005980C(arg0->unk_68); + gSPDisplayList(gMasterDisp++, D_3005980); + } else { + func_8005980C(arg0->unk_68 * 0.1f); + func_800B8DD0(&gMasterDisp, 0x1D); + gSPTexture(gMasterDisp++, 2000, 2000, 0, G_TX_RENDERTILE, G_ON); + gSPSetGeometryMode(gMasterDisp++, G_TEXTURE_GEN); + gSPDisplayList(gMasterDisp++, D_10231A0); + gSPClearGeometryMode(gMasterDisp++, G_TEXTURE_GEN); + func_800B8DD0(&gMasterDisp, 0x1B); + gDPSetPrimColor(gMasterDisp++, 0x00, 0x00, 255, 255, 255, 255); + gSPDisplayList(gMasterDisp++, D_1022E80); + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005D654.s") +void func_8005CC9C(Object_6C* arg0) { + func_8005980C(arg0->unk_68 * 0.1f); + func_800B8DD0(&gMasterDisp, 0x1D); + gSPTexture(gMasterDisp++, 2000, 2000, 0, G_TX_RENDERTILE, G_ON); + gSPSetGeometryMode(gMasterDisp++, G_TEXTURE_GEN); + gSPDisplayList(gMasterDisp++, D_1019820); + gSPClearGeometryMode(gMasterDisp++, G_TEXTURE_GEN); + func_800B8DD0(&gMasterDisp, 0x1B); + gDPSetPrimColor(gMasterDisp++, 0x00, 0x00, 255, 255, 255, 255); + gSPDisplayList(gMasterDisp++, D_101A8E0); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005D8B8.s") +void func_8005CDA8(Object_6C* arg0) { + s32 i; -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005D954.s") + arg0->obj.rot.y = (Math_Atan2F(D_80178280[D_801778A0].unk_040.x - arg0->obj.pos.x, + D_80178280[D_801778A0].unk_040.z - (arg0->obj.pos.z + D_80177D20)) * + 180.0f) / + M_PI; + if (arg0->unk_46 != 0) { + func_800B8DD0(&gMasterDisp, 0x29); + gDPSetPrimColor(gMasterDisp++, 0x00, 0x00, 255, 255, 255, arg0->unk_44); + } else { + func_800B9B38(D_80178320, D_80178328, D_80178330, D_80178338, D_801783D8, D_801783DC); + } + gSPClearGeometryMode(gMasterDisp++, G_CULL_BACK | G_LIGHTING); // wrong order? + for (i = 0; i < 7; i++) { + Matrix_Push(&D_8013B3C0); + Matrix_RotateZ(D_8013B3C0, (i * 360.0f / 7.0f) * M_DTOR, 1); + Matrix_Translate(D_8013B3C0, 0.0f, arg0->unk_68, 0.0f, 1); + Matrix_SetGfxMtx(&gMasterDisp); + gSPDisplayList(gMasterDisp++, D_102FE80); + Matrix_Pop(&D_8013B3C0); + } + gSPSetGeometryMode(gMasterDisp++, G_CULL_BACK | G_LIGHTING); +} +void func_8005D008(Object* arg0, s32 arg1) { + if (arg1 == 2) { + Matrix_Translate(D_8013B3C0, 0.0f, 0.0f, D_80177D20, 1); + Matrix_Translate(D_8013BBC8, arg0->pos.x, arg0->pos.y, arg0->pos.z, 0); + Matrix_Push(&D_8013B3C0); + Matrix_Mult(D_8013B3C0, D_8013BBC8, 1); + Matrix_Copy(&D_801615F0, D_8013B3C0); + Matrix_Pop(&D_8013B3C0); + Matrix_RotateY(D_8013BBC8, arg0->rot.y * M_DTOR, 1); + Matrix_RotateX(D_8013BBC8, arg0->rot.x * M_DTOR, 1); + Matrix_RotateZ(D_8013BBC8, arg0->rot.z * M_DTOR, 1); + } else { + Matrix_Translate(D_8013B3C0, arg0->pos.x, arg0->pos.y, arg0->pos.z + D_80177D20, 1); + Matrix_Copy(&D_801615F0, D_8013B3C0); + Matrix_RotateY(D_8013B3C0, arg0->rot.y * M_DTOR, 1); + Matrix_RotateX(D_8013B3C0, arg0->rot.x * M_DTOR, 1); + Matrix_RotateZ(D_8013B3C0, arg0->rot.z * M_DTOR, 1); + Matrix_SetGfxMtx(&gMasterDisp); + } +} + +void func_8005D1F0(Object* arg0, s32 arg1) { + if (arg1 == 2) { + Matrix_Translate(D_8013B3C0, 0.0f, 0.0f, D_80177D20, 1); + Matrix_Translate(D_8013BBC8, arg0->pos.x, arg0->pos.y, arg0->pos.z, 0); + Matrix_Push(&D_8013B3C0); + Matrix_Mult(D_8013B3C0, D_8013BBC8, 1); + Matrix_Copy(&D_801615F0, D_8013B3C0); + Matrix_Pop(&D_8013B3C0); + Matrix_RotateY(D_8013BBC8, arg0->rot.y * M_DTOR, 1); + Matrix_RotateX(D_8013BBC8, arg0->rot.x * M_DTOR, 1); + Matrix_RotateZ(D_8013BBC8, arg0->rot.z * M_DTOR, 1); + } else { + Matrix_Translate(D_8013B3C0, arg0->pos.x, arg0->pos.y, arg0->pos.z + D_80177D20, 1); + Matrix_Copy(&D_801615F0, D_8013B3C0); + Matrix_RotateY(D_8013B3C0, arg0->rot.y * M_DTOR, 1); + Matrix_RotateX(D_8013B3C0, arg0->rot.x * M_DTOR, 1); + Matrix_RotateZ(D_8013B3C0, arg0->rot.z * M_DTOR, 1); + } +} + +void func_8005D3CC(Object* arg0, f32 arg1, f32 arg2, f32 arg3, s32 arg4) { + if (arg4 == 2) { + Matrix_Translate(D_8013B3C0, 0.0f, 0.0f, D_80177D20, 1); + Matrix_Translate(D_8013BBC8, arg0->pos.x, arg0->pos.y, arg0->pos.z, 0); + Matrix_Push(&D_8013B3C0); + Matrix_Mult(D_8013B3C0, D_8013BBC8, 1); + Matrix_Copy(&D_801615F0, D_8013B3C0); + Matrix_Pop(&D_8013B3C0); + Matrix_RotateY(D_8013BBC8, M_DTOR * arg2, 1); + Matrix_RotateX(D_8013BBC8, M_DTOR * arg1, 1); + Matrix_RotateZ(D_8013BBC8, M_DTOR * arg3, 1); + Matrix_RotateY(D_8013BBC8, arg0->rot.y * M_DTOR, 1); + Matrix_RotateX(D_8013BBC8, arg0->rot.x * M_DTOR, 1); + Matrix_RotateZ(D_8013BBC8, arg0->rot.z * M_DTOR, 1); + } else { + Matrix_Translate(D_8013B3C0, arg0->pos.x, arg0->pos.y, arg0->pos.z + D_80177D20, 1); + Matrix_Copy(&D_801615F0, D_8013B3C0); + Matrix_RotateY(D_8013B3C0, M_DTOR * arg2, 1); + Matrix_RotateX(D_8013B3C0, M_DTOR * arg1, 1); + Matrix_RotateZ(D_8013B3C0, M_DTOR * arg3, 1); + Matrix_RotateY(D_8013B3C0, arg0->rot.y * M_DTOR, 1); + Matrix_RotateX(D_8013B3C0, arg0->rot.x * M_DTOR, 1); + Matrix_RotateZ(D_8013B3C0, arg0->rot.z * M_DTOR, 1); + Matrix_SetGfxMtx(&gMasterDisp); + } +} + +void func_8005D654(Object_80* arg0, s32 arg1) { + arg0->obj.pos.y += D_8017847C; + func_8005D008(&arg0->obj, arg0->unk_1C.unk_04); + arg0->obj.pos.y -= D_8017847C; + if (arg0->unk_1C.unk_04 == 0) { + if ((arg0->obj.id == 0x13) || (arg0->obj.id == 0x37) || (arg0->obj.id == 9) || (arg0->obj.id == 0x32)) { + func_800B9EB0(D_80178320, D_80178328, D_80178330, D_80178338, D_801783D8, D_801783DC); + gSPClearGeometryMode(gMasterDisp++, G_CULL_BACK); + if (arg1 < 0) { + func_800596C0(); + } + gSPDisplayList(gMasterDisp++, arg0->unk_1C.unk_00); + func_800BA1D0(D_80178320, D_80178328, D_80178330, D_80178338, D_801783D8, D_801783DC); + } else { + if (arg0->obj.id == 8) { + if (arg1 < 0) { + return; // weird control flow + } + func_800B9B38(D_80178320, D_80178328, D_80178330, D_80178338, D_801783D8, D_801783DC); + } + func_800597C0(arg1); + if (arg1 < 0) { + func_800596C0(); + } + gSPDisplayList(gMasterDisp++, arg0->unk_1C.unk_00); + if (arg0->obj.id == 8) { + func_800BA1D0(D_80178320, D_80178328, D_80178330, D_80178338, D_801783D8, D_801783DC); + } + } + } else if (arg0->unk_1C.unk_00 != NULL) { + func_800597C0(arg1); + arg0->unk_1C.unk_00(arg0); + } +} + +void func_8005D8B8(Object_4C* arg0, s32 arg1) { + if (arg1 >= 0) { + arg0->obj.pos.y += D_8017847C; + func_8005D008(&arg0->obj, 0); + arg0->obj.pos.y -= D_8017847C; + if (arg0->unk_1C.unk_04 == 0) { + gSPDisplayList(gMasterDisp++, arg0->unk_1C.unk_00); + } else if (arg0->unk_1C.unk_00 != NULL) { + arg0->unk_1C.unk_00(&arg0->obj); + } + } +} + +void func_8005D954(Object_2F4* arg0) { + Vec3f sp34 = D_800CFCEC; + + if (arg0->unk_01C.unk_00 != NULL) { + switch (arg0->obj.id) { + case 0xC2: + func_8006B74C(arg0); + return; + case 0xEC: + func_E16C50_80190F08(arg0); + return; + } + if ((arg0->obj.id == 0xC8) && (arg0->unk_0B4 == 200)) { + func_8006B74C(arg0); + } else { + if (arg0->unk_01C.unk_19 != 0) { + arg0->obj.pos.y += D_8017847C; + func_8005D008(&arg0->obj, arg0->unk_01C.unk_04); + arg0->obj.pos.y -= D_8017847C; + } else if ((arg0->obj.id == 0xC8) && (arg0->unk_0B4 != 0x1F)) { + func_8005D3CC(&arg0->obj, arg0->unk_2E8.x, arg0->unk_2E8.y, arg0->unk_2E8.z + arg0->unk_0FC, + arg0->unk_01C.unk_04); + } else { + func_8005D008(&arg0->obj, arg0->unk_01C.unk_04); + } + if (arg0->unk_01C.unk_04 == 0) { + gSPDisplayList(gMasterDisp++, arg0->unk_01C.unk_00); + func_8005F1EC(&arg0->unk_100); + } else { + arg0->unk_01C.unk_00(&arg0->obj); + func_8005F1EC(&arg0->unk_100); + if (((arg0->obj.id == 0xC6) || ((arg0->obj.id == 0xCB) && (arg0->unk_0B6 > 0))) && (D_80161410 > 0)) { + Matrix_MultVec3f(D_8013B3C0, &sp34, &D_80177E98[arg0->unk_0E4]); + } + } + if ((arg0->unk_0CA[0] != 0) && (D_80161410 > 0)) { + sp34.y += arg0->unk_01C.unk_1C; + Matrix_MultVec3f(D_8013B3C0, &sp34, &D_80161578[0]); + if (D_80161578[0].z > -200.0f) { + arg0->unk_0CA[0] = 0; + } + } + } + } +} + +#ifdef NON_MATCHING +void func_8005DBC0(Object_2F4* arg0) { + s32 var_v1; + Vec3f sp50 = D_800CFCF8; + f32 var_fa1; + f32 var_ft5; + f32 var_fv0; + f32 var_fv1; + + D_801615EC = 0; + if (arg0->unk_01C.unk_04 == 2) { + Matrix_Translate(D_8013B3C0, 0.0f, 0.0f, D_80177D20, 1); + Matrix_Translate(D_8013BBC8, arg0->obj.pos.x, arg0->obj.pos.y, arg0->obj.pos.z, 0); + Matrix_Push(&D_8013B3C0); + Matrix_Mult(D_8013B3C0, D_8013BBC8, 1); + Matrix_MultVec3f(D_8013B3C0, &sp50, &D_801615E0); + Matrix_Pop(&D_8013B3C0); + var_fv0 = 0.0f; + var_fv1 = -12000.0f; + if ((arg0->obj.id == 197) && (arg0->unk_0E4 >= 100)) { + var_fv0 = 1000.0f; + var_fv1 = -25000.0f; + } + if (((var_fv0 > D_801615E0.z) && (D_801615E0.z > var_fv1)) && + ((fabsf(D_801615E0.x) < (fabsf(D_801615E0.z * 0.5f) + 500.0f)) && + (fabsf(D_801615E0.y) < (fabsf(D_801615E0.z * 0.5f) + 500.0f)))) { + Matrix_RotateY(D_8013BBC8, arg0->obj.rot.y * M_DTOR, 1); + Matrix_RotateX(D_8013BBC8, arg0->obj.rot.x * M_DTOR, 1); + Matrix_RotateZ(D_8013BBC8, arg0->obj.rot.z * M_DTOR, 1); + arg0->unk_01C.unk_00(&arg0->obj); + D_801615EC = 1; + if ((D_80178280->unk_1C8 == 3) && (arg0->obj.id == 0xC5) && (arg0->unk_0E4 == 0xC8)) { + D_80177E98[0] = D_801615E0; + } + } + } else { + Matrix_Translate(D_8013B3C0, arg0->obj.pos.x, arg0->obj.pos.y, arg0->obj.pos.z, 1); + Matrix_MultVec3f(D_8013B3C0, &sp50, &D_801615E0); + if ((D_80178280->unk_1C8 == 2) || (D_80178280->unk_1C8 == 0) || + ((arg0->obj.id == 0xC5) && (arg0->unk_0E4 >= 0x64)) || + ((arg0->obj.id == 0xC3) && (arg0->unk_01C.unk_20 != 0))) { + var_ft5 = var_fv0 = 3000.0f; + var_fv1 = -29000.0f; + var_fa1 = 0.7f; + } else { + var_ft5 = 500.0f; + var_fv0 = 0.0f; + var_fv1 = -20000.0f; + var_fa1 = 0.5f; + } + if (((D_801615E0.z < var_fv0) && (var_fv1 < D_801615E0.z)) && + ((fabsf(D_801615E0.x) < (fabsf(D_801615E0.z * var_fa1) + var_ft5)) && + (fabsf(D_801615E0.y) < (fabsf(D_801615E0.z * var_fa1) + var_ft5)) && (arg0->unk_01C.unk_00 != NULL))) { + Matrix_RotateY(D_8013B3C0, arg0->obj.rot.y * M_DTOR, 1); + Matrix_RotateX(D_8013B3C0, arg0->obj.rot.x * M_DTOR, 1); + Matrix_RotateZ(D_8013B3C0, arg0->obj.rot.z * M_DTOR, 1); + Matrix_SetGfxMtx(&gMasterDisp); + arg0->unk_01C.unk_00(&arg0->obj); + D_801615EC = 1; + if ((D_80178280->unk_1C8 == 3) && + (((arg0->obj.id == 0xC5) && ((arg0->unk_0E4 < 4) || (arg0->unk_0E4 == 8) || (arg0->unk_0E4 == 9))) || + (arg0->obj.id == 0xC6))) { + D_80177E98[arg0->unk_0E4] = D_801615E0; + } + } + } + if (D_801615EC == 0) { + arg0->unk_0CA[D_801778A0] = 0; + if ((arg0->obj.id == 0xBD) || (arg0->obj.id == 0x11E)) { + func_80060FBC(&arg0->obj, &arg0->unk_100); + } + } + for (var_v1 = 0; var_v1 < D_801778A8; var_v1++) { + if (arg0->unk_0CA[var_v1] != 0) { + D_80161578[var_v1] = D_801615E0; + D_80161578[var_v1].y += arg0->unk_01C.unk_1C; + if ((var_v1 == D_801778A0) && (D_80161578[var_v1].z > -300.0f)) { + arg0->unk_0CA[var_v1] = 0; + } + } + } + func_8005F290(&arg0->unk_100, &D_801615E0); + arg0->unk_0B0 = D_801615EC; +} +#else +void func_8005DBC0(Object_2F4* arg0); #pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005DBC0.s") +#endif +#ifdef NON_MATCHING +void func_8005E1B8(Object_408* arg0, s32 arg1) { + f32 var_fa1; + f32 var_ft5; + f32 var_fv0; + f32 var_fv1; + f32 sp3C; + Vec3f sp30 = D_800CFD04; + + if (arg0->unk_01C.unk_19 != 0) { + arg0->obj.pos.y += arg0->unk_068 + D_8017847C; + func_8005D1F0(&arg0->obj, arg0->unk_01C.unk_04); + arg0->obj.pos.y -= arg0->unk_068 + D_8017847C; + } else { + func_8005D1F0(&arg0->obj, arg0->unk_01C.unk_04); + } + Matrix_MultVec3f(&D_801615F0, &sp30, &D_801615D0); + func_8005F290(&arg0->unk_3FC, &D_801615D0); + if ((arg0->obj.id == 0x13C) || (arg0->obj.id == 0x13D)) { + var_fa1 = 6000.0f; + var_fv0 = 6000.0f; + var_ft5 = 0.9f; + var_fv1 = -20000.0f; + } else if (arg0->obj.id == 0x139) { + var_fv1 = -25000.0f; + var_ft5 = 0.7f; + var_fa1 = 3000.0f; + var_fv0 = 2000.0f; + } else { + var_ft5 = 0.5f; + var_fa1 = 2000.0f; + var_fv0 = 1000.0f; + var_fv1 = -15000.0f; + } + sp3C = -1.0f; + if (((D_801615D0.z < var_fv0) && (var_fv1 < D_801615D0.z)) && + ((fabsf(D_801615D0.x) < (fabsf(D_801615D0.z * var_ft5) + var_fa1)) && + (fabsf(D_801615D0.y) < (fabsf(D_801615D0.z * var_ft5) + var_fa1)))) { + sp3C = 1.0f; + if (arg0->obj.id != 0x135) { + if (arg0->obj.id != 0x13C) { + func_8005F670(&arg0->obj.pos); + } + if (arg0->unk_01C.unk_04 != 2) { + Matrix_SetGfxMtx(&gMasterDisp); + } + if (arg1 < 0) { + func_800596C0(); + } + arg0->unk_01C.unk_00(&arg0->obj); + } + } + D_801615D0.y = sp3C; + if (arg0->obj.id == 0x135) { + arg0->unk_308 = D_801615D0; + func_8005F670(&arg0->obj.pos); + Matrix_SetGfxMtx(&gMasterDisp); + arg0->unk_01C.unk_00(&arg0->obj); + } +} +#else +void func_8005E1B8(Object_408* arg0, s32 arg1); #pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005E1B8.s") +#endif -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005E454.s") +void func_8005E454(Object_8C* arg0, s32 arg1) { + if ((arg1 < 0) && (arg0->obj.pos.y < 7.0f)) { + return; + } + if ((arg0->obj.id == 0x161) || (arg0->obj.id == 0x171)) { + func_8005D3CC(&arg0->obj, arg0->unk_60.x, arg0->unk_60.y, arg0->unk_60.z, 0); + } else if (arg0->unk_1C.unk_14 == -1) { + arg0->obj.pos.y += D_8017847C; + func_8005D008(&arg0->obj, 0); + arg0->obj.pos.y -= D_8017847C; + } else { + func_8005D008(&arg0->obj, 0); + } + if (arg0->unk_1C.unk_00 != NULL) { + arg0->unk_1C.unk_00(&arg0->obj); + } +} +#ifdef NON_MATCHING +void func_8005E538(Object_8C* arg0) { + Vec3f sp4C = D_800CFD10; + Vec3f sp40; + f32 var_fv0; + u8 sp3B = 0; + + if (arg0->unk_1C.unk_14 == -1) { + Matrix_Translate(D_8013B3C0, arg0->obj.pos.x, arg0->obj.pos.y + D_8017847C, arg0->obj.pos.z + D_80177D20, 1); + } else { + Matrix_Translate(D_8013B3C0, arg0->obj.pos.x, arg0->obj.pos.y, arg0->obj.pos.z + D_80177D20, 1); + } + Matrix_MultVec3f(D_8013B3C0, &sp4C, &sp40); + if ((D_80178234 == 0x12) || (D_80178234 == 0x11)) { + var_fv0 = -20000.0f; + } else { + var_fv0 = -10000.0f; + } + if ((sp40.z < 0.0f) && (var_fv0 < sp40.z) && (fabsf(sp40.x) < (fabsf(sp40.z * 0.5f) + 500.0f)) && + (fabsf(sp40.y) < (fabsf(sp40.z * 0.5f) + 500.0f))) { + if (arg0->unk_1C.unk_00 != NULL) { + Matrix_RotateY(D_8013B3C0, arg0->obj.rot.y * M_DTOR, 1); + Matrix_RotateX(D_8013B3C0, arg0->obj.rot.x * M_DTOR, 1); + Matrix_RotateZ(D_8013B3C0, arg0->obj.rot.z * M_DTOR, 1); + Matrix_SetGfxMtx(&gMasterDisp); + arg0->unk_1C.unk_00(&arg0->obj); + } + sp3B = 1; + } + func_8005F290(&arg0->unk_80, &sp40); + if ((sp3B == 0) && (arg0->obj.id != 0x160) && (arg0->obj.id != 0x175) && (D_801778E8 == 0)) { + func_80060FBC(&arg0->obj, &arg0->unk_80); + } +} +#else +void func_8005E538(Object_8C* arg0); #pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005E538.s") +#endif +#ifdef NON_MATCHING +void func_8005E7B8(Object_6C* arg0, s32 arg1) { + Vec3f sp44 = D_800CFD1C; + Vec3f sp38; + u8 var_v0; + + Matrix_Translate(D_8013B3C0, arg0->obj.pos.x, arg0->obj.pos.y, arg0->obj.pos.z + D_80177D20, 1); + Matrix_MultVec3f(D_8013B3C0, &sp44, &sp38); + var_v0 = 0; + if ((sp38.z < 0.0f) && (sp38.z > -12000.0f) && (fabsf(sp38.x) < (fabsf(sp38.z * 0.5f) + 500.0f)) && + (fabsf(sp38.y) < (fabsf(sp38.z * 0.5f) + 500.0f))) { + if (arg0->unk_1C.unk_00 != NULL) { + Matrix_RotateY(D_8013B3C0, arg0->obj.rot.y * M_DTOR, 1); + Matrix_RotateX(D_8013B3C0, arg0->obj.rot.x * M_DTOR, 1); + Matrix_RotateZ(D_8013B3C0, arg0->obj.rot.z * M_DTOR, 1); + Matrix_SetGfxMtx(&gMasterDisp); + if (arg0->unk_1C.unk_04 == 0) { + gSPDisplayList(gMasterDisp++, arg0->unk_1C.unk_00); + } else { + arg0->unk_1C.unk_00(&arg0->obj); + } + } + var_v0 = 1; + } + func_8005F290(&arg0->unk_5C, &sp38); + if ((var_v0 == 0) && (D_80177880 == 1) && (D_801778A8 == 1) && (arg0->obj.id < 0x150) && (D_80178234 != 9)) { + func_80060FBC(&arg0->obj, &arg0->unk_5C); + } +} +#else +void func_8005E7B8(Object_6C* arg0, s32 arg1); #pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005E7B8.s") +#endif -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005EA24.s") +void func_8005EA24(Object_2F4* arg0) { + Matrix_Translate(D_8013B3C0, arg0->obj.pos.x, arg0->unk_178 + 3.0f, arg0->obj.pos.z, 1); + if (D_80178234 == 0xE) { + Matrix_RotateY(D_8013B3C0, arg0->unk_180, 1); + Matrix_RotateX(D_8013B3C0, arg0->unk_17C, 1); + Matrix_RotateZ(D_8013B3C0, arg0->unk_184, 1); + Matrix_RotateY(D_8013B3C0, -arg0->unk_180, 1); + } + Matrix_Scale(D_8013B3C0, 1.4f, 0.0f, 1.4f, 1); + Matrix_RotateY(D_8013B3C0, (arg0->obj.rot.y + 180.0f) * M_DTOR, 1); + Matrix_RotateZ(D_8013B3C0, arg0->obj.rot.z * M_DTOR, 1); + Matrix_SetGfxMtx(&gMasterDisp); + if (arg0->unk_0E4 < 4) { + Matrix_Translate(D_8013B3C0, 0.0f, 0.0f, 30.0f, 1); + Matrix_SetGfxMtx(&gMasterDisp); + gSPDisplayList(gMasterDisp++, D_1032780); + } else if (D_80178234 == 0x10) { + if ((arg0->unk_0B6 == 1) || (arg0->unk_0B6 == 2)) { + gSPDisplayList(gMasterDisp++, D_600D730); + } else { + gSPDisplayList(gMasterDisp++, D_600DBC0); + } + } else if ((arg0->unk_0E4 < 8) || (D_80178234 != 0xE)) { + gSPDisplayList(gMasterDisp++, D_F014310); + } else if (D_80178234 == 0xE) { + gSPDisplayList(gMasterDisp++, D_6009F90); + } else { + gSPDisplayList(gMasterDisp++, D_F014310); + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005ECD8.s") +void func_8005ECD8(s32 arg0, Object* arg1) { + func_800B8DD0(&gMasterDisp, 0x42); + gDPSetPrimColor(gMasterDisp++, 0x00, 0x00, 0, 0, 0, 180); + if (arg1->id == 0xC5) { + func_8005EA24(&D_80163FE0[arg0]); + } else { + switch (arg1->id) { + case 0xE6: + Matrix_Translate(D_8013B3C0, arg1->pos.x, D_80177940 + 2.0f + D_80163FE0[arg0].unk_118, + arg1->pos.z + D_80177D20, 1); + break; + case 0xE5: + case 0xE7: + Matrix_Translate(D_8013B3C0, arg1->pos.x, D_80177940 + 2.0f + D_80163FE0[arg0].unk_114, + arg1->pos.z + D_80177D20, 1); + break; + case 0x13C: + Matrix_Translate(D_8013B3C0, arg1->pos.x, D_80177940 + 2.0f + D_8017847C, arg1->pos.z, 1); + break; + default: + Matrix_Translate(D_8013B3C0, arg1->pos.x, D_80177940 + 2.0f, arg1->pos.z + D_80177D20, 1); + break; + } + if ((D_801784AC != 4) || (arg1->id == 0xC8) || (arg1->id == 0xC3) || (arg1->id == 0xC6)) { + Matrix_Scale(D_8013B3C0, 1.0f, 0.0f, 1.0f, 1); + Matrix_RotateY(D_8013B3C0, arg1->rot.y * M_DTOR, 1); + } + if ((arg1->id < 0x124) && (arg1->id != 0xE6) && (arg1->id != 0xE5) && (arg1->id != 0xE7)) { + Matrix_RotateX(D_8013B3C0, arg1->rot.x * M_DTOR, 1); + Matrix_RotateZ(D_8013B3C0, arg1->rot.z * M_DTOR, 1); + } + Matrix_SetGfxMtx(&gMasterDisp); + func_8005BAB4(arg1->id, arg0); + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005F030.s") +void func_8005F030(Vec3f* arg0) { + if (arg0->x > 5000.0f) { + arg0->x = 5000.0f; + } + if (arg0->x < -5000.0f) { + arg0->x = -5000.0f; + } + if (arg0->y > 2000.0f) { + arg0->y = 2000.0f; + } + if (arg0->y < -2000.0f) { + arg0->y = -2000.0f; + } + if (arg0->z > 5000.0f) { + arg0->z = 5000.0f; + } + if (arg0->z < -5000.0f) { + arg0->z = -5000.0f; + } +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005F0E8.s") +void func_8005F0E8(Vec3f* arg0, Vec3f* arg1) { + Vec3f sp2C; + Vec3f sp20; -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005F1EC.s") + if (D_801778A8 != 1) { + arg0->x = arg0->y = arg0->z = 0.0f; + } else { + Matrix_RotateY(D_8013BBC8, D_80178280->unk_058, 0); + Matrix_RotateX(D_8013BBC8, D_80178280->unk_05C, 1); + sp2C.x = arg1->x - D_801779D8.x; + sp2C.y = arg1->y - D_801779D8.y; + sp2C.z = arg1->z + D_80177D20 - D_801779D8.z; + Matrix_MultVec3f(D_8013BBC8, &sp2C, &sp20); + arg0->x = sp20.x; + arg0->y = sp20.y; + arg0->z = sp20.z; + } + func_8005F030(arg0); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005F290.s") +void func_8005F1EC(Vec3f* arg0) { + Vec3f sp2C = D_800CFD28; + Vec3f sp20; + s32 pad; + if (D_801778A8 != 1) { + arg0->z = 0.0f; + arg0->y = 0.0f; + arg0->x = 0.0f; + } else { + Matrix_MultVec3f(&D_801615F0, &sp2C, &sp20); + arg0->x = sp20.x; + arg0->y = sp20.y; + arg0->z = sp20.z; + } + func_8005F030(arg0); +} + +void func_8005F290(Vec3f* arg0, Vec3f* arg1) { + if (D_801778A8 != 1) { + arg0->z = 0.0f; + arg0->y = 0.0f; + arg0->x = 0.0f; + } else { + arg0->x = arg1->x; + arg0->y = arg1->y; + arg0->z = arg1->z; + } + func_8005F030(arg0); +} + +#ifdef NON_MATCHING +void func_8005F2F4(Object_58* arg0) { + Vec3f sp54 = D_800CFD34; + Vec3f sp48; + f32 sp44 = 1000.0f; + f32 sp40 = -12000.0f; + f32 sp3C = 2000.0f; + f32 sp38 = 0.5f; + + if (arg0->obj.id == 0x9C) { + sp44 = 4000.0f; + sp40 = -13000.0f; + sp3C = 4500.0f; + } else if (D_80178234 == 9) { + sp40 = -20000.0f; + sp38 = 0.4f; + } else if (arg0->obj.id == 0x8F) { + sp44 = 6000.0f; + sp40 = -20000.0f; + sp3C = 6000.0f; + sp38 = 0.9f; + } + if ((D_80177C98 == 0) || (D_80178234 == 0x11)) { + Matrix_Translate(D_8013B3C0, arg0->obj.pos.x, arg0->obj.pos.y + D_8017847C, arg0->obj.pos.z, 1); + } else { + Matrix_Translate(D_8013B3C0, arg0->obj.pos.x, arg0->obj.pos.y, arg0->obj.pos.z, 1); + } + Matrix_MultVec3f(D_8013B3C0, &sp54, &sp48); + if ((sp48.z < sp44) && (sp40 < sp48.z) && (fabsf(sp48.y) < (fabsf(sp48.z * sp38) + sp3C)) && + (fabsf(sp48.x) < (fabsf(sp48.z * sp38) + sp3C))) { + func_8005F670(&arg0->obj.pos); + if (arg0->obj.id == 0x83) { + Matrix_RotateY(D_8013B3C0, arg0->obj.rot.y * M_DTOR, 1); + Matrix_RotateX(D_8013B3C0, arg0->obj.rot.x * M_DTOR, 1); + Matrix_RotateZ(D_8013B3C0, arg0->obj.rot.z * M_DTOR, 1); + Matrix_RotateY(D_8013B3C0, M_PI / 2.0f, 1); + Matrix_Translate(D_8013B3C0, -551.0f, 0.0f, 0.0f, 1); + Matrix_SetGfxMtx(&gMasterDisp); + gSPDisplayList(gMasterDisp++, D_6007650); + } else { + Matrix_RotateY(D_8013B3C0, arg0->obj.rot.y * M_DTOR, 1); + Matrix_SetGfxMtx(&gMasterDisp); + gSPDisplayList(gMasterDisp++, arg0->unk_1C.unk_00); + } + } +} +#else +void func_8005F2F4(Object_58*); #pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005F2F4.s") +#endif -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005F670.s") +void func_8005F670(Vec3f* arg0) { + Vec3f sp9C; + f32 sp98; + f32 sp94; + f32 temp_fv0; + Vec3f sp84; + f32 temp1; + f32 temp2; + f32 var_fs0; + Vec3f sp6C; + f32 temp3; + f32 pad; + if (D_8017836C > 0.01f) { + sp9C.x = arg0->x - D_80178370; + sp9C.y = arg0->y - D_80178374; + sp9C.z = arg0->z - D_80178378; + temp_fv0 = sqrtf(VEC3F_SQ(sp9C)); + if (D_80178280->unk_1C8 == 2) { + var_fs0 = 700.0f / temp_fv0; + } else { + var_fs0 = 200.0f / temp_fv0; + } + if (var_fs0 > 1.0f) { + var_fs0 = 1.0f; + } + if (D_8017812C == 2) { + var_fs0 = 1.0f; + } + sp94 = Math_Atan2F(sp9C.x, sp9C.z); + sp98 = -Math_Atan2F(sp9C.y, sqrtf(SQ(sp9C.x) + SQ(sp9C.z))); + Matrix_Push(&D_8013BBC8); + Matrix_RotateZ(D_8013BBC8, D_80178280[D_801778A0].unk_034 * D_80177950 * M_DTOR, 0); + Matrix_RotateX(D_8013BBC8, -D_80178280[D_801778A0].unk_05C, 1); + Matrix_RotateY(D_8013BBC8, D_80178280[D_801778A0].unk_058 + sp94, 1); + Matrix_RotateX(D_8013BBC8, sp98, 1); + sp6C.x = 0.0f; + sp6C.y = 0.0f; + sp6C.z = -100.0f; + Matrix_MultVec3fNoTranslate(D_8013BBC8, &sp6C, &sp84); + Matrix_Pop(&D_8013BBC8); + temp1 = D_80178360 * D_8017836C * var_fs0; + temp2 = D_80178364 * D_8017836C * var_fs0; + temp3 = D_80178368 * D_8017836C * var_fs0; + func_800038AC(&gMasterDisp, D_801784DC, D_801784E0, D_801784E4, sp84.x, sp84.y, sp84.z, D_80178548, D_8017854C, + D_80178550, temp1, temp2, temp3, D_80178554, D_80178558, D_8017855C); + } +} + +#ifdef NON_MATCHING +s32 func_8005F9DC(Vec3f* arg0) { + Vec3f sp2C; + Vec3f sp20; + + Matrix_RotateY(D_8013BBC8, D_80178280[D_801778A0].unk_058, 0); + Matrix_RotateX(D_8013BBC8, D_80178280[D_801778A0].unk_05C, 1); + sp2C.x = arg0->x - D_80178280[D_801778A0].unk_040.x; + sp2C.y = arg0->y - D_80178280[D_801778A0].unk_040.y; + sp2C.z = arg0->z - D_80178280[D_801778A0].unk_040.z; + Matrix_MultVec3fNoTranslate(D_8013BBC8, &sp2C, &sp20); + if ((sp20.z < 1000.0f) && (sp20.z > -13000.0f) && (fabsf(sp20.x) < (fabsf(sp20.z * 0.4f) + 2000.0f)) && + (fabsf(sp20.y) < (fabsf(sp20.y * 0.4f) + 2000.0f))) { + return 1; + } + return 0; +} +#else #pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005F9DC.s") +#endif -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8005FB70.s") +void func_8005FB70(s32 arg0) { + Vec3f spAC; + s32 i; + s32 pad[5]; // probably separate iterators for each loop + Object_2F4* var_s0_5; + Object_408* var_s0_3; + Object_4C* var_s0_4; + Object_58* var_s0; + Object_6C* var_s0_6; + Object_80* var_s0_2; -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8006046C.s") + if ((D_80177880 == 1) && (D_80178234 != 0x10)) { + func_800BA1D0(D_80178320, D_80178328, D_80178330, D_80178338, D_801783D8, D_801783DC); + if (D_80177AB0 == 5) { + gSPClearGeometryMode(gMasterDisp++, G_CULL_BACK); + } + for (i = 0, var_s0 = D_801782A8; i < 200; i++, var_s0++) { + if ((var_s0->obj.status == 2) && (var_s0->obj.id != 0x93)) { + if (D_80178234 == 0x11) { + spAC.x = var_s0->unk_48.x; + spAC.y = var_s0->unk_48.y; + spAC.z = var_s0->unk_48.z; + Matrix_MultVec3fNoTranslate(&D_E51970_8019EE80, &spAC, &var_s0->obj.pos); + var_s0->obj.rot.y = var_s0->unk_54 + D_8016F110->obj.rot.y; + } + Matrix_Push(&D_8013B3C0); + func_8005F2F4(var_s0); + Matrix_Pop(&D_8013B3C0); + } + } + } else { + func_800BA1D0(D_80178320, D_80178328, D_80178330, D_80178338, D_801783D8, D_801783DC); + for (i = 0, var_s0_2 = D_80161B00; i < ARRAY_COUNT(D_80161B00); i++, var_s0_2++) { + if (var_s0_2->obj.status >= 2) { + if (arg0 > 0) { + func_8005F670(&var_s0_2->obj.pos); + } + Matrix_Push(&D_8013B3C0); + func_8005D654(var_s0_2, arg0); + Matrix_Pop(&D_8013B3C0); + func_8005F1EC(&var_s0_2->unk_70); + } + } + } + for (i = 0, var_s0_3 = D_8016F110; i < ARRAY_COUNT(D_8016F110); i++, var_s0_3++) { + if ((var_s0_3->obj.status >= 2) && (var_s0_3->obj.id != 0x136)) { + if (!(var_s0_3->unk_05C & 1)) { + func_800BA1D0(D_80178320, D_80178328, D_80178330, D_80178338, D_801783D8, D_801783DC); + } else { + func_800BA400(); + gDPSetPrimColor(gMasterDisp++, 0x00, 0x00, 64, 64, 255, 255); + } + func_800597C0(arg0); + Matrix_Push(&D_8013B3C0); + func_8005E1B8(var_s0_3, arg0); + Matrix_Pop(&D_8013B3C0); + if ((var_s0_3->unk_05E != 0) && (D_801615D0.y > 0.0f)) { + Matrix_Push(&D_8013B3C0); + func_8005ECD8(i, &var_s0_3->obj); + Matrix_Pop(&D_8013B3C0); + } + } + } + func_8000372C(&gMasterDisp, D_801784DC, D_801784E0, D_801784E4, D_80178548, D_8017854C, D_80178550, D_80178554, + D_80178558, D_8017855C); + for (i = 0, var_s0_4 = D_80163400; i < ARRAY_COUNT(D_80163400); i++, var_s0_4++) { + if ((var_s0_4->obj.status >= 2) && (func_80060FE4(&var_s0_4->obj.pos, -12000.0f) != 0)) { + Matrix_Push(&D_8013B3C0); + if ((var_s0_4->obj.id == 0xA5) || (var_s0_4->obj.id == 0xA6)) { + func_800B9EB0(D_80178320, D_80178328, D_80178330, D_80178338, D_801783D8, D_801783DC); + } else { + func_800B9B38(D_80178320, D_80178328, D_80178330, D_80178338, D_801783D8, D_801783DC); + } + func_8005D8B8(var_s0_4, arg0); + Matrix_Pop(&D_8013B3C0); + } + } + for (i = 0, var_s0_5 = D_80163FE0; i < ARRAY_COUNT(D_80163FE0); i++, var_s0_5++) { + if (var_s0_5->obj.status >= 2) { + if (!(var_s0_5->unk_0C6 & 1)) { + if (D_80178234 == 0xF) { + func_800BA1A0(); + } else { + func_800BA1D0(D_80178320, D_80178328, D_80178330, D_80178338, D_801783D8, D_801783DC); + } + } else { + func_800BA400(); + if (var_s0_5->unk_110 >= 0.0f) { + gDPSetPrimColor(gMasterDisp++, 0x00, 0x00, 255, 0, 0, 255); + } else { + gDPSetPrimColor(gMasterDisp++, 0x00, 0x00, 64, 64, 255, 255); + } + } + switch (D_80177880) { + case 0: + case 2: + Matrix_Push(&D_8013B3C0); + if ((D_80178280->unk_1C8 == 2) || (D_80178280->unk_1C8 == 7) || (D_80178234 == 0xD)) { + func_8005F670(&var_s0_5->obj.pos); + } + func_800597C0(arg0); + func_8005D954(var_s0_5); + Matrix_Pop(&D_8013B3C0); + if (var_s0_5->unk_0C9 != 0) { + Matrix_Push(&D_8013B3C0); + func_8005ECD8(i, &var_s0_5->obj); + Matrix_Pop(&D_8013B3C0); + } + break; + case 1: + Matrix_Push(&D_8013B3C0); + func_8005DBC0(var_s0_5); + Matrix_Pop(&D_8013B3C0); + if ((var_s0_5->unk_0C9 != 0) && (D_801615EC != 0) && + ((D_801615E0.z > -4000.0f) || (D_80178234 != 0x10))) { + Matrix_Push(&D_8013B3C0); + func_8005ECD8(i, &var_s0_5->obj); + Matrix_Pop(&D_8013B3C0); + } + break; + } + } + } + gDPSetFogColor(gMasterDisp++, D_80178320, D_80178328, D_80178330, D_80178338); + gSPFogPosition(gMasterDisp++, D_801783D8, D_801783DC); + func_8000372C(&gMasterDisp, -0x3C, -0x3C, 0x3C, 0x96, 0x96, 0x96, 0x14, 0x14, 0x14); + for (i = 0, var_s0_6 = D_801737E0; i < ARRAY_COUNT(D_801737E0); i++, var_s0_6++) { + if (var_s0_6->obj.status >= 2) { + Matrix_Push(&D_8013B3C0); + func_800B8DD0(&gMasterDisp, 0x1D); + func_800597C0(arg0); + func_8005E7B8(var_s0_6, arg0); + Matrix_Pop(&D_8013B3C0); + } + } + func_8000372C(&gMasterDisp, D_801784DC, D_801784E0, D_801784E4, D_80178548, D_8017854C, D_80178550, D_80178554, + D_80178558, D_8017855C); +} -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_80060714.s") +void func_8006046C(s32 arg0) { + s32 i; + Object_408* var_s0_2; + Object_8C* var_s0; -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_8006089C.s") + func_800B8DD0(&gMasterDisp, 0x40); + for (i = 0, var_s0 = D_80170130; i < ARRAY_COUNT(D_80170130); i++, var_s0++) { + if (var_s0->obj.status >= 2) { + if (var_s0->unk_1C.unk_14 == 1) { + var_s0->obj.rot.y = (-D_80178280[D_801778A0].unk_058 * 180.0f) / M_PI; + var_s0->obj.rot.x = (D_80178280[D_801778A0].unk_05C * 180.0f) / M_PI; + } + if (D_80177880 == 1) { + Matrix_Push(&D_8013B3C0); + func_8005E538(var_s0); + Matrix_Pop(&D_8013B3C0); + } else { + Matrix_Push(&D_8013B3C0); + func_8005E454(var_s0, arg0); + Matrix_Pop(&D_8013B3C0); + func_8005F1EC(&var_s0->unk_80); + if (var_s0->obj.id == 0x176) { + Matrix_Push(&D_8013B3C0); + func_8005ECD8(i, &var_s0->obj); + Matrix_Pop(&D_8013B3C0); + } + } + } + } + for (i = 0, var_s0_2 = D_8016F110; i < ARRAY_COUNT(D_8016F110); i++, var_s0_2++) { + if ((var_s0_2->obj.status >= 2) && (var_s0_2->obj.id == 0x136)) { + if (!(var_s0_2->unk_05C & 1)) { + func_800BA1D0(D_80178320, D_80178328, D_80178330, D_80178338, D_801783D8, D_801783DC); + } else { + func_800BA400(); + gDPSetPrimColor(gMasterDisp++, 0x00, 0x00, 64, 64, 255, 255); + } + Matrix_Push(&D_8013B3C0); + func_8005E1B8(var_s0_2, arg0); + Matrix_Pop(&D_8013B3C0); + } + } +} +void func_80060714(s32 arg0) { + D_80161410 = 1; + func_8005FB70(1); + if ((D_80161A88 == 2) && (D_80178280[0].unk_1C8 != 2)) { + D_80161410 = -1; + func_8000372C(&gMasterDisp, D_801784DC, -1 * D_801784E0, D_801784E4, D_80178548, D_8017854C, D_80178550, + D_80178554, D_80178558, D_8017855C); + Matrix_Push(&D_8013B3C0); + Matrix_Scale(D_8013B3C0, 1.0f, -1.0f, 1.0f, 1); + func_8005FB70(-1); + Matrix_Pop(&D_8013B3C0); + func_8000372C(&gMasterDisp, D_801784DC, D_801784E0, D_801784E4, D_80178548, D_8017854C, D_80178550, D_80178554, + D_80178558, D_8017855C); + } +} + +void func_8006089C(u8 arg0) { + if (arg0 == 0) { + D_80161410 = 1; + func_8006046C(1); + } else if ((D_80161A88 == 2) && (D_80178280->unk_1C8 != 2)) { + D_80161410 = -1; + Matrix_Push(&D_8013B3C0); + Matrix_Scale(D_8013B3C0, 1.0f, -1.0f, 1.0f, 1); + func_8006046C(-1); + Matrix_Pop(&D_8013B3C0); + } + D_80161410 = 1; +} + +#ifdef NON_MATCHING +void func_80060968(void) { + s32 i; + s32 var_a1; + + if (D_80178234 == 0xB) { + func_800B8DD0(&gMasterDisp, 0x21); + gSPClearGeometryMode(gMasterDisp++, G_CULL_BACK); + } else if ((D_80178234 == 0xD) || (D_80178234 == 9)) { + func_800B8DD0(&gMasterDisp, 0x29); + } else { + func_800B92F8(); + } + for (i = 0; i < ARRAY_COUNT(D_80174750); i++) { + if (D_80174750[i].unk_00 != 0) { + Matrix_Push(&D_8013B3C0); + Matrix_Translate(D_8013B3C0, D_80174750[i].unk_04, D_80174750[i].unk_08, D_80174750[i].unk_0C + D_80177D20, + 1); + Matrix_RotateY(D_8013B3C0, D_80174750[i].unk_20, 1); + Matrix_RotateX(D_8013B3C0, D_80174750[i].unk_1C, 1); + Matrix_RotateZ(D_8013B3C0, D_80174750[i].unk_20, 1); + Matrix_Scale(D_8013B3C0, D_80174750[i].unk_28, D_80174750[i].unk_28, D_80174750[i].unk_24, 1); + if ((D_80178234 == 0xD) || (D_80178234 == 9)) { + var_a1 = (D_80177DB0 & 1) ? 180 : 50; + gDPSetPrimColor(gMasterDisp++, 0x00, 0x00, 255, 255, 255, var_a1); + if (D_80178234 == 0xD) { + Matrix_Scale(D_8013B3C0, 0.01f, 0.3f, 0.0025f, 1); + Matrix_Translate(D_8013B3C0, 0.0f, 0.0f, -200.0f, 1); + Matrix_RotateZ(D_8013B3C0, D_80177DB0 * 5.0f * M_DTOR, 1); + Matrix_SetGfxMtx(&gMasterDisp); + gSPDisplayList(gMasterDisp++, D_60119A0); + } else if (D_80178234 == 9) { + Matrix_Scale(D_8013B3C0, 1.0f, 1.0f, 0.0025f, 1); + Matrix_Translate(D_8013B3C0, 0.0f, 0.0f, -200.0f, 1); + Matrix_RotateZ(D_8013B3C0, D_80177DB0 * 25.0f * M_DTOR, 1); + Matrix_SetGfxMtx(&gMasterDisp); + gSPDisplayList(gMasterDisp++, D_C017440); + } + } else { + Matrix_SetGfxMtx(&gMasterDisp); + if (D_80178234 == 0xB) { + gSPDisplayList(gMasterDisp++, D_6012C00); + } else { + gDPSetPrimColor(gMasterDisp++, 0x00, 0x00, D_80174750[i].unk_2C, D_80174750[i].unk_2D, + D_80174750[i].unk_2E, D_80174750[i].unk_2F); + gSPDisplayList(gMasterDisp++, D_800CFD80); + } + } + Matrix_Pop(&D_8013B3C0); + } + } +} +#else +void func_80060968(void); #pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_80060968.s") +#endif -#pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_5A2C0/func_80060D94.s") +void func_80060D94(s32 arg0) { + UnkStruct_D_80174750* temp_s0 = &D_80174750[arg0]; + + if (temp_s0->unk_2F == 0xFF) { + func_800B8DD0(&gMasterDisp, 5); + } else { + func_800B8DD0(&gMasterDisp, 0xE); + } + gDPSetPrimColor(gMasterDisp++, 0x00, 0x00, temp_s0->unk_2C, temp_s0->unk_2D, temp_s0->unk_2E, temp_s0->unk_2F); + Matrix_Push(&D_8013B3C0); + Matrix_Translate(D_8013B3C0, temp_s0->unk_04, temp_s0->unk_08, temp_s0->unk_0C, 1); + Matrix_RotateY(D_8013B3C0, temp_s0->unk_20, 1); + Matrix_RotateX(D_8013B3C0, temp_s0->unk_1C, 1); + Matrix_RotateZ(D_8013B3C0, temp_s0->unk_1C, 1); + Matrix_Scale(D_8013B3C0, temp_s0->unk_28, 1.0f, temp_s0->unk_24, 1); + Matrix_SetGfxMtx(&gMasterDisp); + gSPClearGeometryMode(gMasterDisp++, G_CULL_BACK); + gSPDisplayList(gMasterDisp++, D_800CFD80); + gSPSetGeometryMode(gMasterDisp++, G_CULL_BACK); + Matrix_Pop(&D_8013B3C0); +} diff --git a/src/main/sf_61B30.c b/src/main/sf_61B30.c index 42664a90..038e6043 100644 --- a/src/main/sf_61B30.c +++ b/src/main/sf_61B30.c @@ -1,14 +1,14 @@ #include "global.h" -void func_80060F30(f32* arg0, u32 arg1, s32 arg2) { +void func_80060F30(Vec3f* arg0, u32 arg1, s32 arg2) { if (D_801778E8 == 0) { - func_80019218(arg1, D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); + func_80019218(arg1, &D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); } else { func_80019218(arg1, arg0, arg2, &D_800C5D34, &D_800C5D34, &D_800C5D3C); } } -void func_80060FBC(Object* arg0, f32* arg1) { +void func_80060FBC(Object* arg0, Vec3f* arg1) { arg0->status = 0; func_8001A500(arg1); } @@ -21,9 +21,9 @@ s32 func_80060FE4(Vec3f* arg0, f32 arg1) { return 1; } Matrix_RotateY(D_8013BBC8, D_80178280[D_801778A0].unk_058, 0); - sp2C.x = arg0->x - D_80178280[D_801778A0].unk_40.x; + sp2C.x = arg0->x - D_80178280[D_801778A0].unk_040.x; sp2C.y = 0.0f; - sp2C.z = arg0->z - D_80178280[D_801778A0].unk_40.z; + sp2C.z = arg0->z - D_80178280[D_801778A0].unk_040.z; Matrix_MultVec3fNoTranslate(D_8013BBC8, &sp2C, &sp20); if ((sp20.z < 1000.0f) && (arg1 < sp20.z) && (fabsf(sp20.x) < (fabsf(sp20.z * 0.5f) + 2000.0f))) { @@ -43,9 +43,9 @@ s32 func_80061148(Vec3f* arg0, f32 arg1) { return func_80060FE4(arg0, arg1); } Matrix_RotateY(D_8013BBC8, D_80178280[D_801778A0].unk_058, 0); - sp2C.x = arg0->x - D_80178280[D_801778A0].unk_40.x; + sp2C.x = arg0->x - D_80178280[D_801778A0].unk_040.x; sp2C.y = 0.0f; - sp2C.z = arg0->z - D_80178280[D_801778A0].unk_40.z; + sp2C.z = arg0->z - D_80178280[D_801778A0].unk_040.z; Matrix_MultVec3fNoTranslate(D_8013BBC8, &sp2C, &sp20); if ((sp20.z < 0.0f) && (arg1 < sp20.z) && (fabsf(sp20.x) < (fabsf(sp20.z * 0.5f) + 500.0f))) { @@ -56,7 +56,7 @@ s32 func_80061148(Vec3f* arg0, f32 arg1) { void func_800612B8(ObjectStruct_1C* arg0, u32 arg1) { *arg0 = D_800CC124[arg1]; - arg0->unk_C = SEGMENTED_TO_VIRTUAL(D_800CC124[arg1].unk_C); + arg0->unk_0C = SEGMENTED_TO_VIRTUAL(D_800CC124[arg1].unk_0C); if (D_80177880 == 2) { arg0->unk_10 += 200.0f; } @@ -751,7 +751,7 @@ s32 func_8006351C(s32 arg0, Vec3f* arg1, s32 arg2, s32 arg3) { } } else if ((fabsf(arg1->x - var_s0->obj.pos.x) < 2000.0f) && (fabsf(arg1->z - var_s0->obj.pos.z) < 2000.0f)) { - if (func_80062DBC(arg1, var_s0->unk_1C.unk_C, &var_s0->obj, 0.0f, 0.0f, 0.0f)) { + if (func_80062DBC(arg1, var_s0->unk_1C.unk_0C, &var_s0->obj, 0.0f, 0.0f, 0.0f)) { return 2; } } @@ -768,7 +768,7 @@ s32 func_8006351C(s32 arg0, Vec3f* arg1, s32 arg2, s32 arg3) { } } else if ((fabsf(arg1->x - var_s0_2->obj.pos.x) < 2000.0f) && (fabsf(arg1->z - var_s0_2->obj.pos.z) < 2000.0f)) { - if (func_80062DBC(arg1, var_s0_2->unk_1C.unk_C, &var_s0_2->obj, 0.0f, 0.0f, 0.0f)) { + if (func_80062DBC(arg1, var_s0_2->unk_1C.unk_0C, &var_s0_2->obj, 0.0f, 0.0f, 0.0f)) { return i + 10; } } @@ -778,7 +778,7 @@ s32 func_8006351C(s32 arg0, Vec3f* arg1, s32 arg2, s32 arg3) { for (i = 0; i < ARRAY_COUNT(D_80163400); i++, var_s0_3++) { if ((var_s0_3->obj.status == 2) && (fabsf(arg1->x - var_s0_3->obj.pos.x) < 500.0f) && (fabsf(arg1->z - var_s0_3->obj.pos.z) < 500.0f) && - func_800631A8(arg1, var_s0_3->unk_1C.unk_C, &var_s0_3->obj.pos)) { + func_800631A8(arg1, var_s0_3->unk_1C.unk_0C, &var_s0_3->obj.pos)) { if ((var_s0_3->obj.id == 163) || (var_s0_3->obj.id == 162) || (var_s0_3->obj.id == 162)) { var_s0_3->unk_46 = 1; } @@ -814,7 +814,7 @@ s32 func_8006351C(s32 arg0, Vec3f* arg1, s32 arg2, s32 arg3) { } if ((fabsf(arg1->x - var_s0_4->obj.pos.x) < 2000.0f) && (fabsf(arg1->z - var_s0_4->obj.pos.z) < 2000.0f)) { - if (func_80062DBC(arg1, var_s0_4->unk_01C.unk_C, &var_s0_4->obj, 0.0f, 0.0f, 0.0f)) { + if (func_80062DBC(arg1, var_s0_4->unk_01C.unk_0C, &var_s0_4->obj, 0.0f, 0.0f, 0.0f)) { return 2; } } @@ -832,7 +832,7 @@ s32 func_8006351C(s32 arg0, Vec3f* arg1, s32 arg2, s32 arg3) { return 2; } } else if (var_s0_5->unk_110 < 0.0f) { - if (func_80062DBC(arg1, var_s0_5->unk_01C.unk_C, &var_s0_5->obj, var_s0_5->unk_2E8.x, + if (func_80062DBC(arg1, var_s0_5->unk_01C.unk_0C, &var_s0_5->obj, var_s0_5->unk_2E8.x, var_s0_5->unk_2E8.y, var_s0_5->unk_2E8.z + var_s0_5->unk_0FC)) { var_s0_5->unk_0D0 = 1; var_s0_5->unk_0D6 = 10; @@ -843,7 +843,7 @@ s32 func_8006351C(s32 arg0, Vec3f* arg1, s32 arg2, s32 arg3) { return 2; } } else if ((arg3 != 2) && (arg3 != 3)) { - if (func_800631A8(arg1, var_s0_5->unk_01C.unk_C, &var_s0_5->obj.pos)) { + if (func_800631A8(arg1, var_s0_5->unk_01C.unk_0C, &var_s0_5->obj.pos)) { var_s0_5->unk_0D0 = 1; var_s0_5->unk_0D6 = 10; var_s0_5->unk_0D2 = -1; @@ -920,7 +920,7 @@ void func_80063E5C(Object* arg0, f32* arg1) { var_v1->obj.pos.z = arg0->pos.z; var_v1->obj.rot.y = arg0->rot.y; func_800612B8(&var_v1->unk_1C, var_v1->obj.id); - var_v1->unk_1C.unk_C = SEGMENTED_TO_VIRTUAL(arg1); + var_v1->unk_1C.unk_0C = SEGMENTED_TO_VIRTUAL(arg1); break; } } @@ -950,7 +950,7 @@ void func_80063F90(s32 arg0, s32 arg1) { func_8007A6F0(&D_80163400[arg0].obj.pos, 0x11000055); break; case 0xEA: - func_80019218(0x11030010, D_80163FE0[arg0].unk_100, 0, &D_800C5D34, &D_800C5D34, &D_800C5D3C); + func_80019218(0x11030010, &D_80163FE0[arg0].unk_100, 0, &D_800C5D34, &D_800C5D34, &D_800C5D3C); break; case 0x36: func_80019218(0x11000000, &D_80161B00[arg0].unk_70, 0, &D_800C5D34, &D_800C5D34, &D_800C5D3C); @@ -1050,8 +1050,8 @@ void func_80063F90(s32 arg0, s32 arg1) { break; case 0xB6: case 0xBA: - D_80163FE0[arg0].unk_46 = D_80178320; - D_80163FE0[arg0].unk_48 = D_801783D8; + D_80163FE0[arg0].unk_046 = D_80178320; + D_80163FE0[arg0].unk_048 = D_801783D8; D_80163FE0[arg0].obj.rot.x = Rand_ZeroOne() * 360.0f; D_80163FE0[arg0].obj.rot.y = Rand_ZeroOne() * 360.0f; break; @@ -1065,7 +1065,7 @@ void func_80063F90(s32 arg0, s32 arg1) { break; case 0xFC: if (D_80178280[0].unk_07C < D_80163FE0[arg0].obj.pos.z) { - func_80060FBC(&D_80163FE0[arg0].obj, D_80163FE0[arg0].unk_100); + func_80060FBC(&D_80163FE0[arg0].obj, &D_80163FE0[arg0].unk_100); } break; case 0xEF: @@ -1089,11 +1089,11 @@ void func_80063F90(s32 arg0, s32 arg1) { } break; case 0xC2: - D_80163FE0[arg0].unk_46 = 100; + D_80163FE0[arg0].unk_046 = 100; for (var_a0 = 0; var_a0 < 2; var_a0++) { if (D_80176550[var_a0] == 0) { D_80176550[var_a0] = 1; - D_80163FE0[arg0].unk_46 = var_a0; + D_80163FE0[arg0].unk_046 = var_a0; for (var_a2 = 0; var_a2 < 100; var_a2++) { D_80176878[var_a0][var_a2] = D_80163FE0[arg0].obj.pos.y; D_80176B98[var_a0][var_a2] = D_80163FE0[arg0].obj.pos.z; @@ -1101,13 +1101,13 @@ void func_80063F90(s32 arg0, s32 arg1) { break; } } - if (D_80163FE0[arg0].unk_46 == 100) { + if (D_80163FE0[arg0].unk_046 == 100) { D_80163FE0[arg0].obj.status = 0; } break; case 0xBE: case 0xBF: - func_80019218(0x31000012, D_80163FE0[arg0].unk_100, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); + func_80019218(0x31000012, &D_80163FE0[arg0].unk_100, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); break; case 0xC0: D_80163FE0[arg0].unk_0C9 = 1; @@ -1159,7 +1159,7 @@ void func_80063F90(s32 arg0, s32 arg1) { /* fallthrough */ case 0xB0: D_80163FE0[arg0].unk_0CE = 24; - func_80019218(0x31000016, D_80163FE0[arg0].unk_100, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); + func_80019218(0x31000016, &D_80163FE0[arg0].unk_100, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); break; case 0x129: func_E08400_80188A40(&D_8016F110[arg0]); @@ -1278,8 +1278,8 @@ void func_800652CC(Object_80* arg0) { if ((D_801784AC == 4) && (arg0->unk_48 == 0)) { func_E6A810_801B6E20(arg0->obj.pos.x, arg0->obj.pos.z + D_80177D20, &sp2C, &sp24, &sp28); arg0->obj.pos.y = sp24 + 3.0f; - arg0->obj.rot.x = (sp2C * 180.0f) / 3.1415927f; - arg0->obj.rot.z = (sp28 * 180.0f) / 3.1415927f; + arg0->obj.rot.x = (sp2C * 180.0f) / M_PI; + arg0->obj.rot.z = (sp28 * 180.0f) / M_PI; arg0->unk_48 += 1; } } @@ -1296,8 +1296,8 @@ void func_80065380(Object_2F4* arg0, f32 arg1, f32 arg2, f32 arg3, f32 arg4, f32 arg0->obj.pos.x = arg1; arg0->obj.pos.y = arg2; arg0->obj.pos.z = arg3; - arg0->unk_46 = 0xFF; - arg0->unk_48 = 900; + arg0->unk_046 = 0xFF; + arg0->unk_048 = 900; arg0->obj.rot.z = Rand_ZeroOne() * 360.0f; arg0->obj.rot.y = Rand_ZeroOne() * 360.0f; func_800612B8(&arg0->unk_01C, arg0->obj.id); @@ -1471,7 +1471,7 @@ void func_800656D4(Object_2F4* arg0) { D_80163FE0[spC4].unk_0D4 = 2; func_8007A6F0(&arg0->obj.pos, 0x2903A008); func_8007D2C8(arg0->obj.pos.x, arg0->obj.pos.y, arg0->obj.pos.z, 5.0f); - func_80060FBC(&arg0->obj, arg0->unk_100); + func_80060FBC(&arg0->obj, &arg0->unk_100); } } func_8009F6CC(&sp98, arg0->obj.rot.x, arg0->obj.rot.y, arg0->unk_124.y); @@ -1498,7 +1498,7 @@ void func_800656D4(Object_2F4* arg0) { if ((D_801784AC == 4) && (func_E6A810_801B6AEC(arg0->obj.pos.x, arg0->obj.pos.y, arg0->obj.pos.z + D_80177D20) != 0)) { func_8007D2C8(arg0->obj.pos.x, arg0->obj.pos.y, arg0->obj.pos.z, 5.0f); - func_80060FBC(&arg0->obj, arg0->unk_100); + func_80060FBC(&arg0->obj, &arg0->unk_100); } sp8C.x = arg0->unk_0E8; sp8C.y = arg0->unk_0EC; @@ -1506,18 +1506,18 @@ void func_800656D4(Object_2F4* arg0) { if ((func_8006351C(arg0->unk_040, &arg0->obj.pos, (s32) &sp8C, 1) != 0) || (arg0->unk_0D0 != 0) || (arg0->obj.pos.y < (D_80177940 + 10.0f)) || (D_80178280[0].unk_1C8 == 7)) { func_8007D2C8(arg0->obj.pos.x, arg0->obj.pos.y, arg0->obj.pos.z, 3.0f); - func_80060FBC(&arg0->obj, arg0->unk_100); + func_80060FBC(&arg0->obj, &arg0->unk_100); if (arg0->unk_0D0 != 0) { - arg0->unk_44 = 2; + arg0->unk_044 = 2; if ((D_80178234 == 0)) { if (D_80177880 == 1) { - arg0->unk_44 = 2; + arg0->unk_044 = 2; } else { - arg0->unk_44 = 4; + arg0->unk_044 = 4; } } if (D_80178234 == 3) { - arg0->unk_44 = 22; + arg0->unk_044 = 22; } func_80066254(arg0); } @@ -1527,8 +1527,8 @@ void func_800656D4(Object_2F4* arg0) { if (fabsf(arg0->obj.pos.z - D_80178280[0].unk_138) < 100.0f) { arg0->unk_078 = 1; } - if (D_80178280[0].unk_40.z < (arg0->obj.pos.z + D_80177D20)) { - func_80060FBC(&arg0->obj, arg0->unk_100); + if (D_80178280[0].unk_040.z < (arg0->obj.pos.z + D_80177D20)) { + func_80060FBC(&arg0->obj, &arg0->unk_100); } } } @@ -1544,7 +1544,7 @@ void func_800660F0(Object_2F4* arg0) { if (var_s0->obj.status == 0) { func_80061444(var_s0); var_s0->obj.status = 1; - var_s0->obj.id = D_800CFDF4[arg0->unk_44]; + var_s0->obj.id = D_800CFDF4[arg0->unk_044]; var_s0->obj.pos.x = arg0->obj.pos.x; var_s0->obj.pos.y = arg0->obj.pos.y; var_s0->obj.pos.z = arg0->obj.pos.z; @@ -1555,10 +1555,10 @@ void func_800660F0(Object_2F4* arg0) { } if ((var_s0->obj.id >= 0x150) || (var_s0->obj.id == 0x14F)) { var_s0->unk_50 = 90.0f; - func_80019218(0x4900000C, D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); + func_80019218(0x4900000C, &D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); var_s0->unk_48 = 1000; if (var_s0->obj.id == 0x151) { - func_80019218(0x1900302B, var_s0->unk_5C, 0, &D_800C5D34, &D_800C5D34, &D_800C5D3C); + func_80019218(0x1900302B, &var_s0->unk_5C, 0, &D_800C5D34, &D_800C5D34, &D_800C5D3C); } } break; @@ -1589,10 +1589,10 @@ void func_80066254(Object_2F4* arg0) { case 4: case 19: case 29: - arg0->unk_44 = 0xE; + arg0->unk_044 = 0xE; break; case 14: - arg0->unk_44 = 9; + arg0->unk_044 = 9; break; } D_80161A62 = 0; @@ -1603,8 +1603,8 @@ void func_80066254(Object_2F4* arg0) { } } } - if (arg0->unk_44) { - if (D_800CFE5C[arg0->unk_44] < 0.0f) { + if (arg0->unk_044) { + if (D_800CFE5C[arg0->unk_044] < 0.0f) { var_v0 = D_80163FE0; for (i = 0, var_v0 = D_80163FE0; i < ARRAY_COUNT(D_80163FE0); i++, var_v0++) { if ((var_v0->obj.status != 0) && (var_v0->unk_040 != arg0->unk_040) && @@ -1613,8 +1613,8 @@ void func_80066254(Object_2F4* arg0) { } } func_800660F0(arg0); - func_80019218(0x4900000C, D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); - } else if (arg0->unk_44 == 0x18) { + func_80019218(0x4900000C, &D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); + } else if (arg0->unk_044 == 0x18) { if (D_801778B0[3] > 0) { func_800BA808(D_80183CA8, 0x1E); } else if (D_801778B0[2] > 0) { @@ -1622,7 +1622,7 @@ void func_80066254(Object_2F4* arg0) { } else if (D_801778B0[1] > 0) { func_800BA808(D_80183CF0, 0xA); } - } else if (Rand_ZeroOne() <= D_800CFE5C[arg0->unk_44]) { + } else if (Rand_ZeroOne() <= D_800CFE5C[arg0->unk_044]) { func_800660F0(arg0); } } @@ -1682,22 +1682,22 @@ void func_8006654C(Object_2F4* arg0) { arg0->unk_0F0 = -15.0f; arg0->unk_10C = 0.5f; func_8007D2C8(arg0->obj.pos.x, arg0->obj.pos.y + 30.0f, arg0->obj.pos.z, 13.0f); - func_80019218(0x2903A008, arg0->unk_100, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); + func_80019218(0x2903A008, &arg0->unk_100, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); } } void func_8006684C(Object_2F4* arg0) { - s32 pad; // possible recast from Object* + s32 pad; if (arg0->unk_0BE != 0) { arg0->unk_0F0 = 0.0f; arg0->unk_0E8 = 0.0f; arg0->unk_0EC = 0.0f; if (arg0->unk_0BE == 1) { - func_80060FBC(&arg0->obj, arg0->unk_100); - arg0->unk_44 = 1; + func_80060FBC(&arg0->obj, &arg0->unk_100); + arg0->unk_044 = 1; func_80066254(arg0); - func_80019218(0x2903B009, arg0->unk_100, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); + func_80019218(0x2903B009, &arg0->unk_100, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); func_80077240(arg0->obj.pos.x, arg0->obj.pos.y + 250.0f, arg0->obj.pos.z, 3); D_80161A98 += 3; D_80177850 = 0xF; @@ -1715,7 +1715,7 @@ void func_8006684C(Object_2F4* arg0) { void func_800669A0(Object_2F4* arg0) { if (arg0->unk_0BC != 0) { if (arg0->unk_0BC == 1) { - func_80060FBC(&arg0->obj, arg0->unk_100); + func_80060FBC(&arg0->obj, &arg0->unk_100); } } else { arg0->obj.rot.y += 5.0f; @@ -1803,7 +1803,7 @@ void func_80066E8C(Object_4C* arg0) { void func_80066EA8(Object_80* arg0) { arg0->obj.rot.y = 0.0f; - if (D_80178280[0].unk_40.x < arg0->obj.pos.x) { + if (D_80178280[0].unk_040.x < arg0->obj.pos.x) { arg0->obj.rot.y = 271.0f; } } @@ -1815,7 +1815,7 @@ void func_80066EF0(Object_6C* arg0) { f32 var_fa1; if ((D_80178280[0].unk_1C8 == 7) || (D_80178280[0].unk_1C8 == 0)) { - func_80060FBC(&arg0->obj, arg0->unk_5C); + func_80060FBC(&arg0->obj, &arg0->unk_5C); } if ((D_80177880 == 0) && (D_80161680 == 0)) { var_fa1 = 900.0f; @@ -1868,7 +1868,7 @@ void func_800671D0(Object_6C* arg0) { var_v0 = 7; } if (!(var_v0 & D_80177DB0)) { - Matrix_RotateY(D_8013BBC8, D_80177DB0 * 23.0f * 0.017453292f, 0U); + Matrix_RotateY(D_8013BBC8, D_80177DB0 * 23.0f * M_DTOR, 0); sp40.x = 50.0f; sp40.y = (Rand_ZeroOne() - 0.5f) * 120.0f; sp40.z = 0.0f; @@ -1929,13 +1929,13 @@ void func_8006753C(Object_2F4* arg0) { func_8007A6F0(&arg0->obj.pos, 0x2903A008); func_8007D2C8(arg0->obj.pos.x, arg0->obj.pos.y, arg0->obj.pos.z, 5.0f); if (((new_var[0].unk_49C < 2) || (new_var[0].unk_49D < 2)) && (new_var[0].unk_1CC != 1)) { - arg0->unk_44 = 0x17; + arg0->unk_044 = 0x17; } else if (D_80178280[0].unk_264 < 0x80) { - arg0->unk_44 = 0x19; + arg0->unk_044 = 0x19; } else if ((D_80161AA8[0] == 0) && (new_var[0].unk_1CC != 1)) { - arg0->unk_44 = 9; + arg0->unk_044 = 9; } else { - arg0->unk_44 = 5; + arg0->unk_044 = 5; } func_80066254(arg0); for (i = 0; i < 6; i++) { @@ -1945,7 +1945,7 @@ void func_8006753C(Object_2F4* arg0) { (Rand_ZeroOne() * 10.0f) + 10.0f, (Rand_ZeroOne() - 0.5f) * 40.0f); func_800794CC(arg0->obj.pos.x, arg0->obj.pos.y, arg0->obj.pos.z, 0.6f); } - func_80060FBC(&arg0->obj, arg0->unk_100); + func_80060FBC(&arg0->obj, &arg0->unk_100); } } D_80175A10[63].unk_00 = 1; @@ -1963,8 +1963,8 @@ void func_80067874(Object_2F4* arg0) { for (i = 0; i < 6; i++) { Matrix_Push(&D_8013B3C0); Matrix_Translate(D_8013B3C0, D_800CFEC4[i].x, D_800CFEC4[i].y, D_800CFEC4[i].z, 1); - Matrix_RotateY(D_8013B3C0, D_800CFF0C[i].y * 0.017453292f, 1); - Matrix_RotateX(D_8013B3C0, D_800CFF0C[i].x * 0.017453292f, 1); + Matrix_RotateY(D_8013B3C0, D_800CFF0C[i].y * M_DTOR, 1); + Matrix_RotateX(D_8013B3C0, D_800CFF0C[i].x * M_DTOR, 1); Matrix_SetGfxMtx(&gMasterDisp); gSPDisplayList(gMasterDisp++, D_10177C0); Matrix_Pop(&D_8013B3C0); @@ -1994,14 +1994,14 @@ void func_80067B1C(Object_6C* arg0) { func_80066EF0(arg0); func_800671D0(arg0); if (arg0->unk_4C != 0) { - func_80060FBC(&arg0->obj, arg0->unk_5C); + func_80060FBC(&arg0->obj, &arg0->unk_5C); func_80060F30(D_80178280[arg0->unk_4E].unk_460, 0x4900C024, arg0->unk_4E); if (D_80178234 != 0xA) { D_80161AA0[arg0->unk_4E]++; } } if (arg0->unk_48 == 1) { - func_80060FBC(&arg0->obj, arg0->unk_5C); + func_80060FBC(&arg0->obj, &arg0->unk_5C); } } @@ -2054,7 +2054,7 @@ void func_80067BEC(Object_6C* arg0) { } arg0->obj.pos.z += (D_80178280[arg0->unk_4E].unk_138 - arg0->obj.pos.z) * 0.5f; if (arg0->unk_48 == 0) { - func_80060FBC(&arg0->obj, arg0->unk_5C); + func_80060FBC(&arg0->obj, &arg0->unk_5C); } } } @@ -2064,7 +2064,7 @@ void func_80067F6C(Object_6C* arg0) { arg0->obj.id = 337; func_800612B8(&arg0->unk_1C, arg0->obj.id); arg0->unk_48 = 2000; - func_80019218(0x1900302B, arg0->unk_5C, 0, &D_800C5D34, &D_800C5D34, &D_800C5D3C); + func_80019218(0x1900302B, &arg0->unk_5C, 0, &D_800C5D34, &D_800C5D34, &D_800C5D3C); } else { func_80067BEC(arg0); } @@ -2107,7 +2107,7 @@ void func_80068020(Object_6C* arg0) { } } if ((arg0->obj.id == 0x150) && (arg0->unk_48 == 1)) { - func_80060FBC(&arg0->obj, arg0->unk_5C); + func_80060FBC(&arg0->obj, &arg0->unk_5C); } break; case 1: @@ -2130,11 +2130,11 @@ void func_80068020(Object_6C* arg0) { arg0->obj.rot.z += 22.0f; func_8009BD38(&arg0->obj.rot.y, func_8009F768(-D_80178280[arg0->unk_4E].unk_058), 0.2f, 10.0f, 0.0f); if (arg0->unk_48 == 0) { - func_80060FBC(&arg0->obj, arg0->unk_5C); + func_80060FBC(&arg0->obj, &arg0->unk_5C); } if (arg0->unk_68 > 0.3f) { - Matrix_RotateY(D_8013BBC8, arg0->obj.rot.y * 0.017453292f, 0); - Matrix_RotateZ(D_8013BBC8, D_80177DB0 * 37.0f * 0.017453292f, 1); + Matrix_RotateY(D_8013BBC8, arg0->obj.rot.y * M_DTOR, 0); + Matrix_RotateZ(D_8013BBC8, D_80177DB0 * 37.0f * M_DTOR, 1); sp4C.x = 0.0f; sp4C.y = arg0->unk_68 * 100.0f; sp4C.z = 0.0f; @@ -2158,10 +2158,10 @@ void func_80068618(Object_6C* arg0) { func_800671D0(arg0); if (arg0->unk_4C != 0) { func_80067A40(); - func_80060FBC(&arg0->obj, arg0->unk_5C); + func_80060FBC(&arg0->obj, &arg0->unk_5C); } if (arg0->unk_48 == 1) { - func_80060FBC(&arg0->obj, arg0->unk_5C); + func_80060FBC(&arg0->obj, &arg0->unk_5C); } } @@ -2180,7 +2180,7 @@ void func_80068688(Object_6C* arg0) { } arg0->unk_44 -= 10; if (arg0->unk_44 < 0) { - func_80060FBC(&arg0->obj, arg0->unk_5C); + func_80060FBC(&arg0->obj, &arg0->unk_5C); } } else { arg0->unk_68 = 100.0f; @@ -2199,7 +2199,7 @@ void func_80068688(Object_6C* arg0) { if (D_80177E80 >= 7) { D_80178280[0].unk_1C8 = 8; D_80178280[0].unk_1D0 = 0; - func_80019218(0x1900602A, D_800C5D28, 0, &D_800C5D34, &D_800C5D34, &D_800C5D3C); + func_80019218(0x1900602A, &D_800C5D28, 0, &D_800C5D34, &D_800C5D34, &D_800C5D3C); D_80177930 = 2; D_800D3180[D_80178234] = 1; } @@ -2231,7 +2231,7 @@ void func_80068914(Object_6C* arg0) { func_8009BC2C(&arg0->unk_54, 4.0f, 0.1f, 0.2f, 0.01f); } if (arg0->unk_68 <= 6.5f) { - func_80060FBC(&arg0->obj, arg0->unk_5C); + func_80060FBC(&arg0->obj, &arg0->unk_5C); } } else { arg0->unk_44 = 2; @@ -2251,14 +2251,14 @@ void func_80068914(Object_6C* arg0) { for (i = 1; i < 4; i++) { D_801778D0[i] = D_801778B0[i]; } - func_80019218(0x4900400F, D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); + func_80019218(0x4900400F, &D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); } } } void func_80068C48(Object_6C* arg0) { if (arg0->unk_4C != 0) { - func_80060FBC(&arg0->obj, arg0->unk_5C); + func_80060FBC(&arg0->obj, &arg0->unk_5C); D_80177E80++; } } @@ -2266,15 +2266,15 @@ void func_80068C48(Object_6C* arg0) { void func_80068C88(Object_6C* arg0) { D_80161680 = arg0->obj.id; if (D_80178280[0].unk_1C8 != 3) { - func_80060FBC(&arg0->obj, arg0->unk_5C); + func_80060FBC(&arg0->obj, &arg0->unk_5C); } else if (((D_80178234 == 1) || (D_80178234 == 2)) && (D_8017827C == 1)) { D_80178280[0].unk_1C8 = 7; D_80178280[0].unk_1D0 = 0; - func_80060FBC(&arg0->obj, arg0->unk_5C); + func_80060FBC(&arg0->obj, &arg0->unk_5C); } else if (D_80178234 == 0xA) { D_80178280[0].unk_1C8 = 9; D_80178280[0].unk_1D0 = 0; - func_80060FBC(&arg0->obj, arg0->unk_5C); + func_80060FBC(&arg0->obj, &arg0->unk_5C); } else if (arg0->unk_46 == 0) { if (((arg0->obj.pos.z + D_80177D20) > -2700.0f) && (fabsf(arg0->obj.pos.x - D_80178280[0].unk_074) < 1000.0f)) { switch (arg0->obj.id) { @@ -2294,7 +2294,7 @@ void func_80068C88(Object_6C* arg0) { } } if (arg0->unk_4C != 0) { - func_80060FBC(&arg0->obj, arg0->unk_5C); + func_80060FBC(&arg0->obj, &arg0->unk_5C); D_80178280[0].unk_0B4 = 0.0f; D_80178280[0].unk_210 = arg0->unk_68 * 0.05f; switch (arg0->obj.id) { @@ -2338,10 +2338,10 @@ void func_80068C88(Object_6C* arg0) { } void func_80068FE0(Object_4C* arg0) { - arg0->obj.rot.y = (Math_Atan2F(D_80178280[0].unk_40.x - arg0->obj.pos.x, - D_80178280[0].unk_40.z - (arg0->obj.pos.z + D_80177D20)) * + arg0->obj.rot.y = (Math_Atan2F(D_80178280[0].unk_040.x - arg0->obj.pos.x, + D_80178280[0].unk_040.z - (arg0->obj.pos.z + D_80177D20)) * 180.0f) / - 3.1415927f; + M_PI; if (arg0->unk_46 != 0) { arg0->obj.status = 0; func_8007A6F0(&arg0->obj.pos, 0x1903400F); @@ -2379,11 +2379,11 @@ void func_800690D0(s32 arg0, s32 arg1) { func_E08400_80187B08(&D_80163FE0[arg0], arg1); break; case 0xB5: - func_80060FBC(&D_80163FE0[arg0].obj, D_80163FE0[arg0].unk_100); + func_80060FBC(&D_80163FE0[arg0].obj, &D_80163FE0[arg0].unk_100); func_8007D2C8(D_80163FE0[arg0].obj.pos.x, D_80163FE0[arg0].obj.pos.y, D_80163FE0[arg0].obj.pos.z, 20.0f); break; case 0xB6: - func_80060FBC(&D_80163FE0[arg0].obj, D_80163FE0[arg0].unk_100); + func_80060FBC(&D_80163FE0[arg0].obj, &D_80163FE0[arg0].unk_100); func_8007D2C8(D_80163FE0[arg0].obj.pos.x, D_80163FE0[arg0].obj.pos.y, D_80163FE0[arg0].obj.pos.z, 10.0f); func_80066254(&D_80163FE0[arg0]); break; @@ -2415,13 +2415,13 @@ void func_800693E8(Object_2F4* arg0) { } else if (D_80178280[0].unk_1C8 == 8) { var_fv0 = 100000.0f; } - if (((D_80178280[0].unk_40.z + arg0->unk_01C.unk_10) < (arg0->obj.pos.z + D_80177D20)) || + if (((D_80178280[0].unk_040.z + arg0->unk_01C.unk_10) < (arg0->obj.pos.z + D_80177D20)) || ((arg0->obj.pos.z + D_80177D20) < -15000.0f) || (arg0->obj.pos.y < (D_80178280[0].unk_0B0 - var_fv0)) || ((D_80178280[0].unk_0B0 + var_fv0) < arg0->obj.pos.y) || ((D_80178280[0].unk_0AC + var_fv0) < arg0->obj.pos.x) || (arg0->obj.pos.x < (D_80178280[0].unk_0AC - var_fv0))) { - func_80060FBC(&arg0->obj, arg0->unk_100); - switch (arg0->obj.id) { /* irregular */ + func_80060FBC(&arg0->obj, &arg0->unk_100); + switch (arg0->obj.id) { case 0xEC: D_801784A4 = 0; break; @@ -2429,12 +2429,12 @@ void func_800693E8(Object_2F4* arg0) { func_E6A810_8018E3B0(arg0); break; case 0xC2: - D_80176550[arg0->unk_46] = 0; + D_80176550[arg0->unk_046] = 0; break; case 0xC8: if ((arg0->unk_0B4 >= 0xC8) && (arg0->unk_0B4 < 0x12C)) { - D_80176550[arg0->unk_46] = 0; - } else if ((arg0->unk_0B4 == 0x26) && (arg0->unk_46 != 2)) { + D_80176550[arg0->unk_046] = 0; + } else if ((arg0->unk_0B4 == 0x26) && (arg0->unk_046 != 2)) { D_80177E80 = -1; } break; @@ -2446,15 +2446,13 @@ void func_800693E8(Object_2F4* arg0) { } } -// #pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_61B30/func_800693E8.s") - void func_80069658(Object_408* arg0) { - arg0->obj.pos.x += arg0->unk_6C; - arg0->obj.pos.y += arg0->unk_70; - arg0->obj.pos.z += arg0->unk_74; - arg0->unk_70 -= arg0->unk_84; - if ((D_80161AB8 != 0) && ((arg0->obj.pos.z + D_80177D20) > (arg0->unk_01C.unk_10 - D_80178280[0].unk_40.z))) { - if (D_80178280[0].unk_40.z) {} // fake + arg0->obj.pos.x += arg0->unk_06C; + arg0->obj.pos.y += arg0->unk_070; + arg0->obj.pos.z += arg0->unk_074; + arg0->unk_070 -= arg0->unk_084; + if ((D_80161AB8 != 0) && ((arg0->obj.pos.z + D_80177D20) > (arg0->unk_01C.unk_10 - D_80178280[0].unk_040.z))) { + if (D_80178280[0].unk_040.z) {} // fake func_80060FBC(&arg0->obj, &arg0->unk_3FC); } } @@ -2466,7 +2464,7 @@ void func_800696F8(Object_80* arg0) { func_80060FBC(&arg0->obj, &arg0->unk_70); } } else if ((D_80177880 == 0) && (D_80178284 != 2)) { - f32 temp_fv0 = fabsf(arg0->obj.pos.x - D_80178280[0].unk_40.x); + f32 temp_fv0 = fabsf(arg0->obj.pos.x - D_80178280[0].unk_040.x); f32 var_fa0 = 500.0f; if ((arg0->obj.id == 6) || (arg0->obj.id == 7)) { @@ -2476,7 +2474,7 @@ void func_800696F8(Object_80* arg0) { if ((fabsf(D_80178280[0].unk_114) > 1.0f) || (D_80178234 == 0xB)) { temp_fv0 = 0.0f; } - temp_fv0 -= D_80178280[0].unk_40.z; + temp_fv0 -= D_80178280[0].unk_040.z; if ((arg0->unk_1C.unk_10 - temp_fv0) < (arg0->obj.pos.z + D_80177D20)) { func_80060FBC(&arg0->obj, &arg0->unk_70); } @@ -2485,44 +2483,40 @@ void func_800696F8(Object_80* arg0) { void func_80069858(Object_4C* arg0) { if (D_80161AB8 != 0) { - f32 temp_fv0 = fabsf(arg0->obj.pos.x - D_80178280[0].unk_40.x); + f32 temp_fv0 = fabsf(arg0->obj.pos.x - D_80178280[0].unk_040.x); f32 var_fa0 = 500.0f; if (((arg0->obj.id == 0xA4) && ((arg0->unk_45 == 6) || (arg0->unk_45 == 7))) || (arg0->obj.id == 8)) { var_fa0 = 1000.0f; } temp_fv0 = ((var_fa0 > temp_fv0) ? 0.0f : (temp_fv0 - var_fa0) * 1.7f); - temp_fv0 -= D_80178280[0].unk_40.z; + temp_fv0 -= D_80178280[0].unk_040.z; if ((arg0->unk_1C.unk_10 - temp_fv0) < (arg0->obj.pos.z + D_80177D20)) { arg0->obj.status = 0; } } } -// #pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_61B30/func_80069858.s") - -// #pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_61B30/func_80069924.s") - void func_80069924(Object_8C* arg0) { arg0->obj.pos.x += arg0->unk_54; arg0->obj.pos.y += arg0->unk_58; arg0->obj.pos.z += arg0->unk_5C; if (D_80161AB8 != 0) { - if ((D_80178280[0].unk_40.z + arg0->unk_1C.unk_10) < (arg0->obj.pos.z + D_80177D20)) { - func_80060FBC(&arg0->obj, arg0->unk_80); - } else if ((fabsf(arg0->obj.pos.y - D_80178280[0].unk_40.y) > 25000.0f) || - (fabsf(arg0->obj.pos.x - D_80178280[0].unk_40.x) > 25000.0f)) { - func_80060FBC(&arg0->obj, arg0->unk_80); + if ((D_80178280[0].unk_040.z + arg0->unk_1C.unk_10) < (arg0->obj.pos.z + D_80177D20)) { + func_80060FBC(&arg0->obj, &arg0->unk_80); + } else if ((fabsf(arg0->obj.pos.y - D_80178280[0].unk_040.y) > 25000.0f) || + (fabsf(arg0->obj.pos.x - D_80178280[0].unk_040.x) > 25000.0f)) { + func_80060FBC(&arg0->obj, &arg0->unk_80); } } } void func_80069A10(Object_6C* arg0) { if (D_80161AB8 != 0) { - f32 temp = (0.0f - D_80178280[0].unk_40.z); + f32 temp = (0.0f - D_80178280[0].unk_040.z); if ((arg0->unk_1C.unk_10 - temp) < (arg0->obj.pos.z + D_80177D20)) { - func_80060FBC(&arg0->obj, arg0->unk_5C); + func_80060FBC(&arg0->obj, &arg0->unk_5C); if ((arg0->obj.id == 326) && (arg0->unk_46 == 0)) { D_80177E80 = -1; } @@ -2530,8 +2524,6 @@ void func_80069A10(Object_6C* arg0) { } } -// #pragma GLOBAL_ASM("asm/us/nonmatchings/main/sf_61B30/func_80069A10.s") - void func_80069AAC(Object_2F4* arg0) { s32 i; @@ -2578,8 +2570,8 @@ void func_80069AAC(Object_2F4* arg0) { break; case 2: func_800693E8(arg0); - if ((arg0->obj.status != 0) && (arg0->unk_01C.unk_8 != NULL)) { - arg0->unk_01C.unk_8(&arg0->obj); + if ((arg0->obj.status != 0) && (arg0->unk_01C.unk_08 != NULL)) { + arg0->unk_01C.unk_08(&arg0->obj); } break; case 3: @@ -2616,19 +2608,19 @@ void func_80069CBC(Object_408* arg0) { switch (arg0->obj.status) { case 1: arg0->obj.status = 2; - func_80063F90(arg0->unk_40, arg0->obj.id); + func_80063F90(arg0->unk_040, arg0->obj.id); func_80069658(arg0); break; case 2: func_80069658(arg0); - if ((arg0->obj.status != 0) && (arg0->unk_01C.unk_8 != NULL)) { - arg0->unk_01C.unk_8(&arg0->obj); + if ((arg0->obj.status != 0) && (arg0->unk_01C.unk_08 != NULL)) { + arg0->unk_01C.unk_08(&arg0->obj); } break; case 3: func_80069658(arg0); if (arg0->obj.status != 0) { - func_800690D0(arg0->unk_40, arg0->obj.id); + func_800690D0(arg0->unk_040, arg0->obj.id); } break; } @@ -2646,8 +2638,8 @@ void func_80069DF4(Object_80* arg0) { break; case 2: func_800696F8(arg0); - if (arg0->unk_1C.unk_8 != NULL) { - arg0->unk_1C.unk_8(&arg0->obj); + if (arg0->unk_1C.unk_08 != NULL) { + arg0->unk_1C.unk_08(&arg0->obj); } break; } @@ -2662,8 +2654,8 @@ void func_80069E88(Object_4C* arg0) { break; case 2: func_80069858(arg0); - if (arg0->unk_1C.unk_8 != NULL) { - arg0->unk_1C.unk_8(&arg0->obj); + if (arg0->unk_1C.unk_08 != NULL) { + arg0->unk_1C.unk_08(&arg0->obj); } break; case 3: @@ -2688,8 +2680,8 @@ void func_80069F30(Object_6C* arg0) { break; case 2: func_80069A10(arg0); - if (arg0->unk_1C.unk_8 != NULL) { - arg0->unk_1C.unk_8(&arg0->obj); + if (arg0->unk_1C.unk_08 != NULL) { + arg0->unk_1C.unk_08(&arg0->obj); } break; } @@ -2706,8 +2698,8 @@ void func_80069FD4(Object_8C* arg0) { /* fallthrough */ case 2: func_80069924(arg0); - if ((arg0->obj.status != 0) && (arg0->unk_1C.unk_8 != NULL)) { - arg0->unk_1C.unk_8(&arg0->obj); + if ((arg0->obj.status != 0) && (arg0->unk_1C.unk_08 != NULL)) { + arg0->unk_1C.unk_08(&arg0->obj); } break; } @@ -2821,7 +2813,7 @@ void func_8006A3E8(void) { } for (i = 0, sp34 = D_8016F110; i < ARRAY_COUNT(D_8016F110); i++, sp34++) { if (sp34->obj.status != 0) { - sp34->unk_40 = i; + sp34->unk_040 = i; func_80069CBC(sp34); } } diff --git a/src/main/sf_hud.c b/src/main/sf_hud.c index bc49ee9c..903eac97 100644 --- a/src/main/sf_hud.c +++ b/src/main/sf_hud.c @@ -83,10 +83,10 @@ void func_80084B94(s32 arg0) { Matrix_Push(&D_8013B3C0); Matrix_Translate(D_8013B3C0, D_800D1A70[i - 1].x, D_800D1A70[i - 1].y, D_800D1A70[i - 1].z, 1); Matrix_Scale(D_8013B3C0, 0.68f, 0.68f, 1.0f, 1); - Matrix_RotateZ(D_8013B3C0, 0.7853982f, 1); + Matrix_RotateZ(D_8013B3C0, M_PI / 4.0f, 1); Matrix_SetGfxMtx(&gMasterDisp); gSPDisplayList(gMasterDisp++, D_500B600); - Matrix_RotateZ(D_8013B3C0, 4.712389f, 1); + Matrix_RotateZ(D_8013B3C0, 3.0f * M_PI / 2.0f, 1); Matrix_SetGfxMtx(&gMasterDisp); gSPDisplayList(gMasterDisp++, D_500B600); Matrix_Pop(&D_8013B3C0); @@ -95,11 +95,11 @@ void func_80084B94(s32 arg0) { } else { Matrix_Push(&D_8013B3C0); Matrix_Translate(D_8013B3C0, -234.0f, -167.0f, -600.0f, 1); - Matrix_RotateZ(D_8013B3C0, 0.7853982f, 1); + Matrix_RotateZ(D_8013B3C0, M_PI / 4.0f, 1); Matrix_Scale(D_8013B3C0, 0.68f, 0.68f, 1.0f, 1); Matrix_SetGfxMtx(&gMasterDisp); gSPDisplayList(gMasterDisp++, D_500B600); - Matrix_RotateZ(D_8013B3C0, 4.712389f, 1); + Matrix_RotateZ(D_8013B3C0, 3.0f * M_PI / 2.0f, 1); Matrix_SetGfxMtx(&gMasterDisp); gSPDisplayList(gMasterDisp++, D_500B600); Matrix_Pop(&D_8013B3C0); @@ -610,7 +610,7 @@ void func_80089D28(void) { if ((gb == 10) || (gb == 0)) { // clang-format off //! FAKE: Probably a MACRO - if (1) {func_80019218(0x4900001c, D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C);} + if (1) {func_80019218(0x4900001c, &D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C);} // clang-format on } @@ -792,7 +792,7 @@ void func_8008B044(void) { return; } - func_80019218(0x49002018, D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); + func_80019218(0x49002018, &D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); if (D_800CFF90 != 0) { func_8001AF40(1); @@ -805,7 +805,7 @@ void func_8008B044(void) { D_80161790++; if (D_80161790 >= 7) { if (D_80161794 & 1) { - func_80019218(0x49002018, D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); + func_80019218(0x49002018, &D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); } D_80161790 = 0; D_80161794++; @@ -1320,7 +1320,7 @@ void func_8008DE68(void) { if ((D_80161734 == 1) && (D_801778B0[2] > 0)) { if ((D_80177848 >= 0) && (D_801616BC == -1.0f)) { - func_80019218(0x4900C028, D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); + func_80019218(0x4900C028, &D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); D_801616BC = 255.0f; } @@ -1712,7 +1712,7 @@ s32 func_80090A00(Object_2F4* arg0) { arg0->unk_124.x = D_80178280[0].unk_074 - 1000.0f; arg0->unk_058++; if (arg0->unk_05C == arg0->unk_058) { - func_80060FBC(&arg0->obj, arg0->unk_100); + func_80060FBC(&arg0->obj, &arg0->unk_100); } break; } @@ -1893,7 +1893,7 @@ s32 func_80091368(Object_2F4* arg0) { } if (arg0->obj.pos.y > 3000.0f) { - func_80060FBC(&arg0->obj, arg0->unk_100); + func_80060FBC(&arg0->obj, &arg0->unk_100); } break; } @@ -2029,7 +2029,7 @@ s32 func_80091CF8(Object_2F4* arg0) { if (arg0->unk_054 != 0) { if (arg0->unk_13C < 0.1f) { arg0->unk_13C = 20.0f; - func_80019218(0x09000002, arg0->unk_100, 0, &D_800C5D34, &D_800C5D34, &D_800C5D3C); + func_80019218(0x09000002, &arg0->unk_100, 0, &D_800C5D34, &D_800C5D34, &D_800C5D3C); arg0->unk_188 = 5.0f; } arg0->unk_054 = 0; @@ -2078,9 +2078,9 @@ s32 func_80091F00(Object_2F4* arg0) { } arg0->unk_0C6 = 20; - func_80019218(0x2903300E, arg0->unk_100, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); + func_80019218(0x2903300E, &arg0->unk_100, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); func_8007D10C(arg0->obj.pos.x, arg0->obj.pos.y, arg0->obj.pos.z, 1.5f); - Matrix_RotateY(D_8013BBC8, arg0->unk_0F8 * (M_PI / 180), 0); + Matrix_RotateY(D_8013BBC8, arg0->unk_0F8 * M_DTOR, 0); if (Rand_ZeroOne() < 0.5f) { sp40.x = -20.0f; @@ -2212,7 +2212,7 @@ void func_80093310(void) { if (1) {} this->obj.id = 195; func_800612B8(&this->unk_01C, this->obj.id); - func_80019218(0x11030010, this->unk_100, 0, &D_800C5D34, &D_800C5D34, &D_800C5D3C); + func_80019218(0x11030010, &this->unk_100, 0, &D_800C5D34, &D_800C5D34, &D_800C5D3C); } void func_800933D8(f32 x, f32 y, f32 z, f32 arg3) { @@ -2289,7 +2289,7 @@ void func_80094954(Object_8C* arg0) { } if ((arg0->unk_4E == 1) && (arg0->unk_4A <= 0)) { - func_80060FBC(&arg0->obj, arg0->unk_80); + func_80060FBC(&arg0->obj, &arg0->unk_80); } arg0->unk_58 += arg0->unk_6C; @@ -2318,7 +2318,7 @@ void func_80094954(Object_8C* arg0) { arg0->unk_4A -= arg0->unk_46; if ((arg0->unk_4A < 0) || ((temp->unk_1C8 == 2) && (D_80178234 == 13) && (temp->unk_1D0 == 5))) { - func_80060FBC(&arg0->obj, arg0->unk_80); + func_80060FBC(&arg0->obj, &arg0->unk_80); } arg0->obj.rot.z += arg0->unk_48; } diff --git a/src/overlays/ovl_EBFBE0/fox_option.c b/src/overlays/ovl_EBFBE0/fox_option.c index e41fb97c..4d70e100 100644 --- a/src/overlays/ovl_EBFBE0/fox_option.c +++ b/src/overlays/ovl_EBFBE0/fox_option.c @@ -724,7 +724,7 @@ void func_EBFBE0_801948A8(void) { temp = func_EBFBE0_8019C418(&D_EBFBE0_801B9288, 3, 1, 0, 20, 5, 4, D_80177AF8, &D_EBFBE0_801B9250); if (temp != 0) { D_EBFBE0_801B9270[sp34] = 255.0f; - func_80019218(0x49000002U, D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); + func_80019218(0x49000002U, &D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); } if (D_EBFBE0_801B9288 == 0) { @@ -740,12 +740,12 @@ void func_EBFBE0_801948A8(void) { } if (D_800DD898[D_80177AF8].button & A_BUTTON) { - func_80019218(0x49000003, D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); + func_80019218(0x49000003, &D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); D_EBFBE0_801B9288 = (D_EBFBE0_801B9288 + 1) & 3; } if (D_800DD898[D_80177AF8].button & B_BUTTON) { - func_80019218(0x49000021, D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); + func_80019218(0x49000021, &D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); if (D_EBFBE0_801B9284 == 1) { D_EBFBE0_801B9284 = 0; func_8001D8F4(D_EBFBE0_801B9284); @@ -763,7 +763,7 @@ void func_EBFBE0_80194AEC(void) { s32 pad; if (func_EBFBE0_8019C418(&sp3C, 2, 0, 0, 20, 5, 4, D_80177AF8, &D_EBFBE0_801B9260) != 0) { - func_80019218(0x49000002, D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); + func_80019218(0x49000002, &D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); D_80177C74 = sp3C; if (D_80177C74 >= 3) { D_80177C74 = 0; @@ -831,7 +831,7 @@ void func_EBFBE0_80195944(void) { f32 sp28 = D_EBFBE0_801B931C; if (func_EBFBE0_8019C66C(&sp28, 0.0f, 49.0f, &D_EBFBE0_801B9290) != 0) { - func_80019218(0x49000002, D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); + func_80019218(0x49000002, &D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); D_EBFBE0_801B931C = sp28; } @@ -842,14 +842,14 @@ void func_EBFBE0_80195944(void) { if (D_800DD898[D_80177AF8].button & B_BUTTON) { if (!D_EBFBE0_801B9320) { - func_80019218(0x49000021, D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); + func_80019218(0x49000021, &D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); func_8001D444(0, 0x24, 0, 0xFF); D_80177898 = 0; D_EBFBE0_801B9124 = 1000; D_EBFBE0_801B912C = 0; D_EBFBE0_801B9244 = 1; } else { - func_80019218(0x4900101D, D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); + func_80019218(0x4900101D, &D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); func_800182F4(0x100100FF); func_800182F4(0x110100FF); D_EBFBE0_801B9320 = false; @@ -918,7 +918,7 @@ void func_EBFBE0_801962A4(void) { case 1: D_EBFBE0_801B91CC = 2; - func_80019218(0x0940A00B, D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); + func_80019218(0x0940A00B, &D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); D_801779A8[D_80177AF8] = 50.0f; D_80177990[D_80177AF8] = 0; break; @@ -971,36 +971,36 @@ void func_EBFBE0_801962A4(void) { void func_EBFBE0_8019669C(void) { if ((D_EBFBE0_801B91CC == 0) || (D_EBFBE0_801B91CC == 1)) { if (func_EBFBE0_8019C5A0(&D_EBFBE0_801B91C0) != 0) { - func_80019218(0x49000002, D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); + func_80019218(0x49000002, &D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); } if (1) {} } if (D_800DD898[D_80177AF8].button & 0x8000) { if (D_EBFBE0_801B91CC == 3) { - func_80019218(0x49000021, D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); + func_80019218(0x49000021, &D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); D_EBFBE0_801B912C = 3; } else { D_EBFBE0_801B9330[D_EBFBE0_801B91C0] = 10; if (D_EBFBE0_801B91C0 == 0) { if (D_EBFBE0_801B91CC == 1) { - func_80019218(0x49000003, D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); + func_80019218(0x49000003, &D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); D_EBFBE0_801B912C = 2; } else { - func_80019218(0x49000021, D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); + func_80019218(0x49000021, &D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); D_EBFBE0_801B912C = 3; } } else { - func_80019218(0x49000003, D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); + func_80019218(0x49000003, &D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); D_EBFBE0_801B912C = 4; } } } else if (D_800DD898[D_80177AF8].button & 0x4000) { if (D_EBFBE0_801B91CC == 1) { - func_80019218(0x4900101D, D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); + func_80019218(0x4900101D, &D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); D_EBFBE0_801B912C = 2; } else { - func_80019218(0x49000021, D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); + func_80019218(0x49000021, &D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); D_EBFBE0_801B912C = 3; } } @@ -1037,7 +1037,7 @@ void func_EBFBE0_80196EFC(void) { func_EBFBE0_80196FC4(); if (D_800DD898[D_80177AF8].button & B_BUTTON) { - func_80019218(0x49000021, D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); + func_80019218(0x49000021, &D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); D_80177898 = 0; D_EBFBE0_801B9124 = 1000; D_EBFBE0_801B912C = 0; @@ -1052,7 +1052,7 @@ void func_EBFBE0_80196F9C(void) { void func_EBFBE0_80196FC4(void) { if (D_800DD898[D_80177AF8].button & A_BUTTON) { - func_80019218(0x49000003, D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); + func_80019218(0x49000003, &D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); D_EBFBE0_801B93E0 ^= 1; } @@ -1066,7 +1066,7 @@ void func_EBFBE0_80196FC4(void) { void func_EBFBE0_80197074(void) { if (func_EBFBE0_8019C418(&D_EBFBE0_801B93E4, 9, 1, 0, 20, 5, 4, D_80177AF8, &D_EBFBE0_801B9400) != 0) { - func_80019218(0x49000002, D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); + func_80019218(0x49000002, &D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); D_EBFBE0_801B91D4 = 114.0f - D_EBFBE0_801B93E4 * 130.0f; D_EBFBE0_801B91DC = 114.0f - D_EBFBE0_801B93E4 * 130.0f; D_EBFBE0_801B91D8 = -6.0f + D_EBFBE0_801B93E4 * 130.0f; @@ -1083,7 +1083,7 @@ void func_EBFBE0_8019715C(void) { if (D_EBFBE0_801B91D0 != 0) { if (func_EBFBE0_8019C418(&D_EBFBE0_801B93E4, 9, 1, 1, 20, 2, 9, D_80177AF8, &D_EBFBE0_801B9408) != 0.00f) { - func_80019218(0x49000002, D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); + func_80019218(0x49000002, &D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); D_EBFBE0_801B91DC = 114.0f - D_EBFBE0_801B93E4 * 130.0f; D_EBFBE0_801B91E0 = -6.0f + D_EBFBE0_801B93E4 * 130.0f; D_EBFBE0_801B91D0 = 0; @@ -1765,7 +1765,7 @@ void func_EBFBE0_8019DE74(void) { func_EBFBE0_8019715C(); if (D_800DD898[D_80177AF8].button & 0xD00E) { // START, A, B, C-UP, C-LEFT, C-DOWN - func_80019218(0x49000003, D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); + func_80019218(0x49000003, &D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); D_80177898 = 0; D_EBFBE0_801B912C = 0; @@ -1808,10 +1808,10 @@ void func_EBFBE0_8019E030(void) { case 1: if (D_EBFBE0_801B9178 == 0) { if (((D_80161714 * 64) >= 50000) && ((D_80161714 * 64) < 70000)) { - func_80019218(0x49000032, D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); + func_80019218(0x49000032, &D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); } if ((D_80161714 * 64) >= 70000) { - func_80019218(0x49000033, D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); + func_80019218(0x49000033, &D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); } D_EBFBE0_801B9178 = 20; D_EBFBE0_801B912C++; @@ -1820,7 +1820,7 @@ void func_EBFBE0_8019E030(void) { case 2: if ((D_EBFBE0_801B9178 == 0) && (D_800DD898[D_80177AF8].button & 0xD00E)) { - func_80019218(0x19031083, D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); + func_80019218(0x19031083, &D_800C5D28, 4, &D_800C5D34, &D_800C5D34, &D_800C5D3C); D_EBFBE0_801B9090 = 1; D_EBFBE0_801B9178 = 60; D_EBFBE0_801B912C++;