From d340ccf0618f81b0d83a91c7a514f0194fc0a580 Mon Sep 17 00:00:00 2001 From: mrshigure Date: Tue, 4 Feb 2025 17:54:29 -0800 Subject: [PATCH 1/6] Making some Runtime progress (#557) --- config/GMPE01_00/rels/m463Dll/symbols.txt | 2 +- config/GMPE01_00/splits.txt | 4 +- config/GMPE01_00/symbols.txt | 8 +- config/GMPE01_01/splits.txt | 4 +- configure.py | 12 +- .../Runtime/Gecko_ExceptionPPC.h | 231 ++++ .../Runtime/NMWException.h | 22 +- .../PowerPC_EABI_Support/Runtime/exception.h | 38 + src/MSL_C.PPCEABI.bare.H/abort_exit.c | 1 - src/Runtime.PPCEABI.H/GCN_mem_alloc.c | 30 + src/Runtime.PPCEABI.H/Gecko_ExceptionPPC.cpp | 1052 +++++++++++++++++ src/Runtime.PPCEABI.H/NMWException.cpp | 157 +++ 12 files changed, 1537 insertions(+), 24 deletions(-) create mode 100755 include/PowerPC_EABI_Support/Runtime/Gecko_ExceptionPPC.h create mode 100755 include/PowerPC_EABI_Support/Runtime/exception.h create mode 100755 src/Runtime.PPCEABI.H/GCN_mem_alloc.c create mode 100755 src/Runtime.PPCEABI.H/Gecko_ExceptionPPC.cpp create mode 100755 src/Runtime.PPCEABI.H/NMWException.cpp diff --git a/config/GMPE01_00/rels/m463Dll/symbols.txt b/config/GMPE01_00/rels/m463Dll/symbols.txt index 351f689b..e336c47f 100644 --- a/config/GMPE01_00/rels/m463Dll/symbols.txt +++ b/config/GMPE01_00/rels/m463Dll/symbols.txt @@ -157,7 +157,7 @@ lbl_1_bss_54 = .bss:0x00000054; // type:object size:0x4 data:4byte lbl_1_bss_58 = .bss:0x00000058; // type:object size:0x4 data:4byte lbl_1_bss_5C = .bss:0x0000005C; // type:object size:0x2D0 lbl_1_bss_32C = .bss:0x0000032C; // type:object size:0x4 data:4byte -lbl_1_bss_330 = .bss:0x00000330; // type:object size:0x24 data:4byte +lbl_1_bss_330 = .bss:0x00000330; // type:object size:0x24 scope:local data:4byte lbl_1_bss_354 = .bss:0x00000354; // type:object size:0x4 data:4byte lbl_1_bss_358 = .bss:0x00000358; // type:object size:0x4 data:4byte lbl_1_bss_35C = .bss:0x0000035C; // type:object size:0x1C0 data:4byte diff --git a/config/GMPE01_00/splits.txt b/config/GMPE01_00/splits.txt index d7d8237a..4751f858 100644 --- a/config/GMPE01_00/splits.txt +++ b/config/GMPE01_00/splits.txt @@ -955,7 +955,7 @@ Runtime.PPCEABI.H/NewMore.cp: .data start:0x8013E208 end:0x8013E218 .sdata start:0x801D39A0 end:0x801D39A8 -Runtime.PPCEABI.H/NMWException.cp: +Runtime.PPCEABI.H/NMWException.cpp: extab start:0x80005650 end:0x80005670 extabindex start:0x80005718 end:0x80005748 .text start:0x800E2108 end:0x800E23CC @@ -971,7 +971,7 @@ Runtime.PPCEABI.H/__init_cpp_exceptions.cpp: .dtors start:0x8011DCE0 end:0x8011DCE8 .sdata start:0x801D39B0 end:0x801D39B8 -Runtime.PPCEABI.H/Gecko_ExceptionPPC.cp: +Runtime.PPCEABI.H/Gecko_ExceptionPPC.cpp: extab start:0x80005670 end:0x800056E4 extabindex start:0x80005748 end:0x8000579C .text start:0x800E2B24 end:0x800E3F5C diff --git a/config/GMPE01_00/symbols.txt b/config/GMPE01_00/symbols.txt index d4d7595a..43ae5aae 100644 --- a/config/GMPE01_00/symbols.txt +++ b/config/GMPE01_00/symbols.txt @@ -3646,10 +3646,10 @@ __THPAANScaleFactor = .rodata:0x8011E490; // type:object size:0x40 data:byte lbl_8011E4D0 = .rodata:0x8011E4D0; // type:object size:0x10 lbl_8011E4E0 = .rodata:0x8011E4E0; // type:object size:0x10 __constants = .rodata:0x8011E4F0; // type:object size:0x18 scope:local data:double -lbl_8011E508 = .rodata:0x8011E508; // type:object size:0x54 -lbl_8011E55C = .rodata:0x8011E55C; // type:object size:0x14 -lbl_8011E570 = .rodata:0x8011E570; // type:object size:0x10 -lbl_8011E580 = .rodata:0x8011E580; // type:object size:0x20 +lbl_8011E508 = .rodata:0x8011E508; // type:object size:0x54 data:string +lbl_8011E55C = .rodata:0x8011E55C; // type:object size:0x14 data:string +lbl_8011E570 = .rodata:0x8011E570; // type:object size:0x10 data:string +lbl_8011E580 = .rodata:0x8011E580; // type:object size:0x20 data:string lbl_8011E5A0 = .rodata:0x8011E5A0; // type:object size:0x38 lbl_8011E5D8 = .rodata:0x8011E5D8; // type:object size:0x40 fix_pool_sizes = .rodata:0x8011E618; // type:object size:0x18 scope:local data:4byte diff --git a/config/GMPE01_01/splits.txt b/config/GMPE01_01/splits.txt index d7d8237a..4751f858 100644 --- a/config/GMPE01_01/splits.txt +++ b/config/GMPE01_01/splits.txt @@ -955,7 +955,7 @@ Runtime.PPCEABI.H/NewMore.cp: .data start:0x8013E208 end:0x8013E218 .sdata start:0x801D39A0 end:0x801D39A8 -Runtime.PPCEABI.H/NMWException.cp: +Runtime.PPCEABI.H/NMWException.cpp: extab start:0x80005650 end:0x80005670 extabindex start:0x80005718 end:0x80005748 .text start:0x800E2108 end:0x800E23CC @@ -971,7 +971,7 @@ Runtime.PPCEABI.H/__init_cpp_exceptions.cpp: .dtors start:0x8011DCE0 end:0x8011DCE8 .sdata start:0x801D39B0 end:0x801D39B8 -Runtime.PPCEABI.H/Gecko_ExceptionPPC.cp: +Runtime.PPCEABI.H/Gecko_ExceptionPPC.cpp: extab start:0x80005670 end:0x800056E4 extabindex start:0x80005748 end:0x8000579C .text start:0x800E2B24 end:0x800E3F5C diff --git a/configure.py b/configure.py index b3b128bd..6d5e0024 100644 --- a/configure.py +++ b/configure.py @@ -209,7 +209,7 @@ else: cflags_runtime = [ *cflags_base, "-use_lmw_stmw on", - "-str reuse,pool,readonly", + "-str reuse,readonly", "-common off", "-inline auto,deferred", ] @@ -668,11 +668,15 @@ config.libs = [ Object(MatchingFor("GMPE01_00", "GMPE01_01"), "Runtime.PPCEABI.H/__mem.c"), Object(NonMatching, "Runtime.PPCEABI.H/New.cp"), Object(NonMatching, "Runtime.PPCEABI.H/NewMore.cp"), - Object(NonMatching, "Runtime.PPCEABI.H/NMWException.cp"), + Object(NonMatching, "Runtime.PPCEABI.H/NMWException.cpp"), Object(MatchingFor("GMPE01_00", "GMPE01_01"), "Runtime.PPCEABI.H/runtime.c"), Object(MatchingFor("GMPE01_00", "GMPE01_01"), "Runtime.PPCEABI.H/__init_cpp_exceptions.cpp"), - Object(NonMatching, "Runtime.PPCEABI.H/Gecko_ExceptionPPC.cp"), - Object(NonMatching, "Runtime.PPCEABI.H/GCN_mem_alloc.c"), + Object( + NonMatching, + "Runtime.PPCEABI.H/Gecko_ExceptionPPC.cpp", + extra_cflags=["-Cpp_exceptions on"] + ), + Object(MatchingFor("GMPE01_00", "GMPE01_01"), "Runtime.PPCEABI.H/GCN_mem_alloc.c"), ], }, { diff --git a/include/PowerPC_EABI_Support/Runtime/Gecko_ExceptionPPC.h b/include/PowerPC_EABI_Support/Runtime/Gecko_ExceptionPPC.h new file mode 100755 index 00000000..a864ea0d --- /dev/null +++ b/include/PowerPC_EABI_Support/Runtime/Gecko_ExceptionPPC.h @@ -0,0 +1,231 @@ +#ifndef _RUNTIME_GECKO_EXCEPTIONPPC_H +#define _RUNTIME_GECKO_EXCEPTIONPPC_H + +#include + +typedef u8 exaction_type; + +#define EXACTION_ENDBIT 0x80 +#define EXACTION_MASK 0x7F + +// EXAction structs + +#define EXACTION_ENDOFLIST 0 +#define EXACTION_BRANCH 1 + +typedef struct ex_branch { + exaction_type action; + u8 unused; + u16 target; +} ex_branch; + +#define EXACTION_DESTROYLOCAL 2 + +typedef struct ex_destroylocal { + exaction_type action; + u8 unused; + s16 local; + void* dtor; +} ex_destroylocal; + +#define EXACTION_DESTROYLOCALCOND 3 + +typedef struct ex_destroylocalcond { + exaction_type action; + u8 dlc_field; + s16 cond; + s16 local; + void* dtor; +} ex_destroylocalcond; + +#define ex_destroylocalcond_MakeField(regcond) (((regcond) << 7)) +#define ex_destroylocalcond_GetRegCond(field) ((field) >> 7) + +#define EXACTION_DESTROYLOCALPOINTER 4 + +typedef struct ex_destroylocalpointer { + exaction_type action; + u8 dlp_field; + s16 pointer; + void* dtor; +} ex_destroylocalpointer; + +#define ex_destroylocalpointer_MakeField(regpointer) (((regpointer) << 7)) +#define ex_destroylocalpointer_GetRegPointer(field) ((field) >> 7) + +#define EXACTION_DESTROYLOCALARRAY 5 + +typedef struct ex_destroylocalarray { + exaction_type action; + u8 unused; + s16 localarray; + u16 elements; + u16 element_size; + void* dtor; +} ex_destroylocalarray; + +#define EXACTION_DESTROYBASE 6 +#define EXACTION_DESTROYMEMBER 7 + +typedef struct ex_destroymember { + exaction_type action; + u8 dm_field; + s16 objectptr; + s32 offset; + void* dtor; +} ex_destroymember; + +#define ex_destroymember_MakeField(regpointer) (((regpointer) << 7)) +#define ex_destroymember_GetRegPointer(field) ((field) >> 7) + +#define EXACTION_DESTROYMEMBERCOND 8 + +typedef struct ex_destroymembercond { + exaction_type action; + u8 dmc_field; + s16 cond; + s16 objectptr; + s32 offset; + void* dtor; +} ex_destroymembercond; + +#define ex_destroymembercond_MakeField(regcond, regpointer) (((regcond) << 7) | (((regpointer)&0x1) << 6)) +#define ex_destroymembercond_GetRegCond(field) ((field) >> 7) +#define ex_destroymembercond_GetRegPointer(field) (((field) >> 6) & 0x1) + +#define EXACTION_DESTROYMEMBERARRAY 9 + +typedef struct ex_destroymemberarray { + exaction_type action; + u8 dma_field; + s16 objectptr; + s32 offset; + s32 elements; + s32 element_size; + void* dtor; +} ex_destroymemberarray; + +#define ex_destroymemberarray_MakeField(regpointer) (((regpointer) << 7)) +#define ex_destroymemberarray_GetRegPointer(field) ((field) >> 7) + +#define EXACTION_DELETEPOINTER 10 + +typedef struct ex_deletepointer { + exaction_type action; + u8 dp_field; + s16 objectptr; + void* deletefunc; +} ex_deletepointer; + +#define ex_deletepointer_MakeField(regpointer) (((regpointer) << 7)) +#define ex_deletepointer_GetRegPointer(field) ((field) >> 7) + +#define EXACTION_DELETEPOINTERCOND 11 + +typedef struct ex_deletepointercond { + exaction_type action; + u8 dpc_field; + s16 cond; + s16 objectptr; + void* deletefunc; +} ex_deletepointercond; + +#define ex_deletepointercond_MakeField(regcond, regpointer) (((regcond) << 7) | (((regpointer)&0x1) << 6)) +#define ex_deletepointercond_GetRegCond(field) ((field) >> 7) +#define ex_deletepointercond_GetRegPointer(field) (((field) >> 6) & 0x1) + +#define EXACTION_CATCHBLOCK 12 + +typedef struct ex_catchblock { + exaction_type action; + u8 unused; + char* catch_type; + u16 catch_pcoffset; + s16 cinfo_ref; +} ex_catchblock; + +#define EXACTION_ACTIVECATCHBLOCK 13 + +typedef struct ex_activecatchblock { + exaction_type action; + u8 unused; + s16 cinfo_ref; +} ex_activecatchblock; + +#define EXACTION_TERMINATE 14 + +typedef struct ex_terminate { + exaction_type action; + u8 unused; +} ex_terminate; + +#define EXACTION_SPECIFICATION 15 + +typedef struct ex_specification { + exaction_type action; + u8 unused; + u16 specs; + s32 pcoffset; + s32 cinfo_ref; + char* spec[]; +} ex_specification; + +#define EXACTION_CATCHBLOCK_32 16 + +typedef struct ex_catchblock_32 { + exaction_type action; + u8 unused; + char* catch_type; + s32 catch_pcoffset; + s32 cinfo_ref; +} ex_catchblock_32; + +// Other structs + +typedef struct ExceptionRangeSmall { + u16 start; + u16 end; + u16 action; +} ExceptionRangeSmall; + +typedef struct ExceptionTableSmall { + u16 et_field; + ExceptionRangeSmall ranges[0]; +} ExceptionTableSmall; + +typedef struct ExceptionRangeLarge { + u32 start; + u16 size; + u16 action; +} ExceptionRangeLarge; + +typedef struct ExceptionTableLarge { + u16 et_field; + u16 et_field2; + ExceptionRangeLarge ranges[]; +} ExceptionTableLarge; + +#define ET_MakeField(savedGPRs, savedFPRs, savedCR, hasframeptr, isLarge) \ + (((savedGPRs) << 11) | ((savedFPRs & 0x1f) << 6) | ((savedCR & 0x1) << 5) | ((hasframeptr & 0x1) << 4) | ((isLarge & 1) << 3)) + +#define ET_GetSavedGPRs(field) ((field) >> 11) +#define ET_GetSavedFPRs(field) (((field) >> 6) & 0x1f) +#define ET_GetSavedCR(field) (((field) >> 5) & 0x1) +#define ET_GetHasFramePtr(field) (((field) >> 4) & 0x1) +#define ET_IsLargeTable(field) (((field) >> 3) & 0x1) +#define ET_ClearLargeBit(field) ((field) & ~(1 << 3)) +#define ET_SetLargeBit(field) ((field) | (1 << 3)) + +#define ET_HasElfVector(field) (((field) >> 1) & 0x1) + +typedef struct ExceptionTableIndex { + u32 functionoffset; + u32 eti_field; + u32 exceptionoffset; +} ExceptionTableIndex; + +#define ETI_MakeField(direct, fsize) ((((s32)(direct)) << 31) | ((fsize)&0x7fffffff)) +#define ETI_GetDirectStore(field) ((field) >> 31) +#define ETI_GetFunctionSize(field) ((field)&0x7fffffff) + +#endif diff --git a/include/PowerPC_EABI_Support/Runtime/NMWException.h b/include/PowerPC_EABI_Support/Runtime/NMWException.h index 2358f785..aba83f4d 100644 --- a/include/PowerPC_EABI_Support/Runtime/NMWException.h +++ b/include/PowerPC_EABI_Support/Runtime/NMWException.h @@ -1,7 +1,15 @@ #ifndef _NMWEXCEPTION #define _NMWEXCEPTION -typedef short vbase_ctor_arg_type; +#include "types.h" +#include "PowerPC_EABI_Support/Runtime/exception.h" +#include "PowerPC_EABI_Support/Runtime/__ppc_eabi_linker.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef s16 vbase_ctor_arg_type; typedef char local_cond_type; typedef struct CatchInfo { @@ -9,7 +17,7 @@ typedef struct CatchInfo { void* typeinfo; void* dtor; void* sublocation; - long pointercopy; + s32 pointercopy; void* stacktop; } CatchInfo; @@ -19,18 +27,12 @@ typedef struct DestructorChain { void* object; } DestructorChain; -#ifdef __cplusplus -extern "C" { -#endif - -extern void* __register_global_object(void* object, void* destructor, - void* registration); +extern void* __register_global_object(void* object, void* destructor, void* registration); extern void __destroy_global_chain(void); extern void __end__catch(CatchInfo* catchinfo); extern void __throw(char* throwtype, void* location, void* dtor); -extern char __throw_catch_compare(const char* throwtype, const char* catchtype, - long* offset_result); +extern char __throw_catch_compare(const char* throwtype, const char* catchtype, s32* offset_result); extern void __unexpected(CatchInfo* catchinfo); extern int __register_fragment(struct __eti_init_info* info, char* TOC); diff --git a/include/PowerPC_EABI_Support/Runtime/exception.h b/include/PowerPC_EABI_Support/Runtime/exception.h new file mode 100755 index 00000000..2530b3de --- /dev/null +++ b/include/PowerPC_EABI_Support/Runtime/exception.h @@ -0,0 +1,38 @@ +#ifndef _EXCEPTION +#define _EXCEPTION + +namespace std { +class exception { +public: + exception() { } + virtual ~exception() { } + virtual const char* what() const { return "exception"; } +}; + +class bad_exception : public exception { +public: + bad_exception() { } + virtual ~bad_exception() { } + virtual const char* what() const { return "bad_exception"; } +}; + +typedef void (*unexpected_handler)(); +unexpected_handler set_unexpected(unexpected_handler handler); +void unexpected(); + +typedef void (*terminate_handler)(); +terminate_handler set_terminate(terminate_handler handler); +void terminate(); + +} // namespace std + +using std::bad_exception; +using std::exception; +using std::set_terminate; +using std::set_unexpected; +using std::terminate; +using std::terminate_handler; +using std::unexpected; +using std::unexpected_handler; + +#endif diff --git a/src/MSL_C.PPCEABI.bare.H/abort_exit.c b/src/MSL_C.PPCEABI.bare.H/abort_exit.c index b54f4742..4432d145 100644 --- a/src/MSL_C.PPCEABI.bare.H/abort_exit.c +++ b/src/MSL_C.PPCEABI.bare.H/abort_exit.c @@ -2,7 +2,6 @@ #include "PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/critical_regions.h" #include "PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/signal.h" #include "stddef.h" -#include "PowerPC_EABI_Support/Runtime/NMWException.h" void _ExitProcess(); diff --git a/src/Runtime.PPCEABI.H/GCN_mem_alloc.c b/src/Runtime.PPCEABI.H/GCN_mem_alloc.c new file mode 100755 index 00000000..c36465e2 --- /dev/null +++ b/src/Runtime.PPCEABI.H/GCN_mem_alloc.c @@ -0,0 +1,30 @@ +#include "dolphin/os.h" + +inline static void InitDefaultHeap(void) { + void* arenaLo; + void* arenaHi; + + OSReport("GCN_Mem_Alloc.c : InitDefaultHeap. No Heap Available\n"); + OSReport("Metrowerks CW runtime library initializing default heap\n"); + + arenaLo = OSGetArenaLo(); + arenaHi = OSGetArenaHi(); + + arenaLo = OSInitAlloc(arenaLo, arenaHi, 1); + OSSetArenaLo(arenaLo); + + arenaLo = OSRoundUpPtr(arenaLo, 0x20); + arenaHi = OSRoundDownPtr(arenaHi, 0x20); + + OSSetCurrentHeap(OSCreateHeap(arenaLo, arenaHi)); + OSSetArenaLo(arenaLo = arenaHi); +} + +/* 80362914-803629CC 35D254 00B8+00 0/0 1/1 0/0 .text __sys_free */ +void __sys_free(void* p) { + if (__OSCurrHeap == -1) { + InitDefaultHeap(); + } + + OSFreeToHeap(__OSCurrHeap, p); +} diff --git a/src/Runtime.PPCEABI.H/Gecko_ExceptionPPC.cpp b/src/Runtime.PPCEABI.H/Gecko_ExceptionPPC.cpp new file mode 100755 index 00000000..faa1385f --- /dev/null +++ b/src/Runtime.PPCEABI.H/Gecko_ExceptionPPC.cpp @@ -0,0 +1,1052 @@ +#include "PowerPC_EABI_Support/Runtime/MWCPlusLib.h" +#include "PowerPC_EABI_Support/Runtime/Gecko_ExceptionPPC.h" +#include "PowerPC_EABI_Support/Runtime/NMWException.h" +#include "PowerPC_EABI_Support/Runtime/__ppc_eabi_linker.h" + +#define RETURN_ADDRESS 4 + +union MWE_GeckoVector64 { + f64 d; + f32 f[2]; +}; + +typedef union MWE_GeckoVector64 MWE_GeckoVector64; + +struct GeckoFPRContext { + f64 d; + MWE_GeckoVector64 v; +}; + +typedef struct GeckoFPRContext GeckoFPRContext; + +typedef struct ThrowContext { + GeckoFPRContext FPR[32]; + s32 GPR[32]; + s32 CR; + char* SP; + char* FP; + char* throwSP; + char* returnaddr; + char* throwtype; + void* location; + void* dtor; + CatchInfo* catchinfo; +} ThrowContext; + +typedef ThrowContext* ThrowContextPtr; + +typedef struct MWExceptionInfo { + ExceptionTableSmall* exception_record; + char* current_function; + char* action_pointer; + char* code_section; + char* data_section; + char* TOC; +} MWExceptionInfo; + +typedef struct FragmentInfo { + ExceptionTableIndex* exception_start; + ExceptionTableIndex* exception_end; + char* code_start; + char* code_end; + char* data_start; + char* data_end; + char* TOC; + int active; +} FragmentInfo; + +typedef struct ProcessInfo { + __eti_init_info* exception_info; + char* TOC; + int active; +} ProcessInfo; + +typedef struct ActionIterator { + MWExceptionInfo info; + char* current_SP; + char* current_FP; + s32 current_R31; +} ActionIterator; + +#define MAXFRAGMENTS 1 +static ProcessInfo fragmentinfo[MAXFRAGMENTS]; + +typedef void (*DeleteFunc)(void*); + +/** + * @note Address: 0x800C2374 + * @note Size: 0x34 + */ +int __register_fragment(struct __eti_init_info* info, char* TOC) +{ + + ProcessInfo* f = fragmentinfo; + int i; + + for (i = 0; i < MAXFRAGMENTS; i++, f++) { + if (f->active == 0) { + f->exception_info = info; + f->TOC = TOC; + f->active = 1; + return i; + } + } + + return -1; +} + +/** + * @note Address: 0x800C2340 + * @note Size: 0x34 + */ +void __unregister_fragment(int fragmentID) +{ + ProcessInfo* f; + + if (fragmentID >= 0 && fragmentID < MAXFRAGMENTS) { + f = &fragmentinfo[fragmentID]; + f->exception_info = 0; + f->TOC = 0; + f->active = 0; + } +} + +/** + * @note Address: N/A + * @note Size: 0x88 + */ +static inline int ExPPC_FindExceptionFragment(char* returnaddr, FragmentInfo* frag) +{ + ProcessInfo* f; + int i; + __eti_init_info* eti_info; + + for (i = 0, f = fragmentinfo; i < MAXFRAGMENTS; ++i, ++f) { + if (f->active) { + eti_info = f->exception_info; + while (1) { + if (eti_info->code_size == 0) + break; + if (returnaddr >= eti_info->code_start && returnaddr < (char*)eti_info->code_start + eti_info->code_size) { + frag->exception_start = (ExceptionTableIndex*)eti_info->eti_start; + frag->exception_end = (ExceptionTableIndex*)eti_info->eti_end; + frag->code_start = 0; + frag->code_end = 0; + frag->data_start = 0; + frag->data_end = 0; + frag->TOC = f->TOC; + frag->active = f->active; + return 1; + } + eti_info++; + } + } + } + + return 0; +} + +/** + * @note Address: N/A + * @note Size: 0x204 + */ +static void ExPPC_FindExceptionRecord(char* returnaddr, MWExceptionInfo* info) +{ + FragmentInfo* fragment; + FragmentInfo frag; + ExceptionTableIndex *exceptionindex, *p; + u32 returnoffset; + s32 i, m, n; + + info->exception_record = 0; + info->action_pointer = 0; + + if ((ExPPC_FindExceptionFragment(returnaddr, &frag)) == 0) + return; + fragment = &frag; + + info->code_section = fragment->code_start; + info->data_section = fragment->data_start; + info->TOC = fragment->TOC; + + returnoffset = returnaddr - fragment->code_start; + exceptionindex = fragment->exception_start; + for (i = 0, n = fragment->exception_end - fragment->exception_start;;) { + if (i > n) + return; + p = &exceptionindex[m = (i + n) / 2]; + + if (returnoffset < p->functionoffset) { + n = m - 1; + } else if (returnoffset > p->functionoffset + ETI_GetFunctionSize(p->eti_field)) { + i = m + 1; + } else + break; + } + info->current_function = fragment->code_start + p->functionoffset; + info->exception_record = ETI_GetDirectStore(p->eti_field) ? (ExceptionTableSmall*)(&p->exceptionoffset) + : (ExceptionTableSmall*)(fragment->data_start + p->exceptionoffset); + + returnoffset -= p->functionoffset; + + if (ET_IsLargeTable(info->exception_record->et_field)) { + ExceptionTableLarge* etl = (ExceptionTableLarge*)info->exception_record; + ExceptionRangeLarge* erl; + + for (erl = etl->ranges; erl->start != 0; erl++) { + u32 range_end = erl->start + (erl->size * 4); + + if (erl->start <= returnoffset && range_end >= returnoffset) { + info->action_pointer = (char*)etl + erl->action; + break; + } + } + } else { + ExceptionTableSmall* ets = (ExceptionTableSmall*)info->exception_record; + ExceptionRangeSmall* ers; + + for (ers = ets->ranges; ers->start != 0; ers++) { + if (ers->start <= returnoffset && ers->end >= returnoffset) { + info->action_pointer = (char*)ets + ers->action; + break; + } + } + } +} + +/** + * @note Address: N/A + * @note Size: 0x18 + */ +static inline s32 ExPPC_PopR31(char* SP, MWExceptionInfo* info) +{ + f64* FPR_save_area; + s32* GPR_save_area; + int saved_GPRs, saved_FPRs; + + saved_FPRs = ET_GetSavedFPRs(info->exception_record->et_field); + FPR_save_area = (f64*)(SP - saved_FPRs * 8); + saved_GPRs = ET_GetSavedGPRs(info->exception_record->et_field); + GPR_save_area = (s32*)FPR_save_area; + + return GPR_save_area[-1]; +} + +/** + * @note Address: N/A + * @note Size: 0x20 + */ +static inline exaction_type ExPPC_CurrentAction(const ActionIterator* iter) +{ + if (iter->info.action_pointer == 0) { + return EXACTION_ENDOFLIST; + } + + return ((ex_destroylocal*)iter->info.action_pointer)->action & EXACTION_MASK; +} + +/** + * @note Address: N/A + * @note Size: 0x1C0 + */ +static exaction_type ExPPC_NextAction(ActionIterator* iter) +{ + exaction_type action; + + for (;;) { + if (iter->info.action_pointer == 0 || ((action = ((ex_destroylocal*)iter->info.action_pointer)->action) & EXACTION_ENDBIT) != 0) { + char *return_addr, *callers_SP; + + callers_SP = *(char**)iter->current_SP; + + if (ET_GetSavedGPRs(iter->info.exception_record->et_field)) { + iter->current_R31 = ExPPC_PopR31(callers_SP, &iter->info); + } + + return_addr = *(char**)(callers_SP + RETURN_ADDRESS); + + ExPPC_FindExceptionRecord(return_addr, &iter->info); + + if (iter->info.exception_record == 0) { + terminate(); + } + + iter->current_SP = callers_SP; + iter->current_FP = (ET_GetHasFramePtr(iter->info.exception_record->et_field)) ? (char*)iter->current_R31 : iter->current_SP; + + if (iter->info.action_pointer == 0) + continue; + } else { + switch (action) { + case EXACTION_DESTROYLOCAL: + iter->info.action_pointer += sizeof(ex_destroylocal); + break; + case EXACTION_DESTROYLOCALCOND: + iter->info.action_pointer += sizeof(ex_destroylocalcond); + break; + case EXACTION_DESTROYLOCALPOINTER: + iter->info.action_pointer += sizeof(ex_destroylocalpointer); + break; + case EXACTION_DESTROYLOCALARRAY: + iter->info.action_pointer += sizeof(ex_destroylocalarray); + break; + case EXACTION_DESTROYBASE: + case EXACTION_DESTROYMEMBER: + iter->info.action_pointer += sizeof(ex_destroymember); + break; + case EXACTION_DESTROYMEMBERCOND: + iter->info.action_pointer += sizeof(ex_destroymembercond); + break; + case EXACTION_DESTROYMEMBERARRAY: + iter->info.action_pointer += sizeof(ex_destroymemberarray); + break; + case EXACTION_DELETEPOINTER: + iter->info.action_pointer += sizeof(ex_deletepointer); + break; + case EXACTION_DELETEPOINTERCOND: + iter->info.action_pointer += sizeof(ex_deletepointercond); + break; + case EXACTION_CATCHBLOCK: + iter->info.action_pointer += sizeof(ex_catchblock); + break; + case EXACTION_CATCHBLOCK_32: + iter->info.action_pointer += sizeof(ex_catchblock_32); + break; + case EXACTION_ACTIVECATCHBLOCK: + iter->info.action_pointer += sizeof(ex_activecatchblock); + break; + case EXACTION_SPECIFICATION: + iter->info.action_pointer + += sizeof(ex_specification) + ((ex_specification*)iter->info.action_pointer)->specs * sizeof(void*); + break; + default: + terminate(); + } + } + + action = ((ex_destroylocal*)iter->info.action_pointer)->action & EXACTION_MASK; + + if (action == EXACTION_BRANCH) { + iter->info.action_pointer = ((char*)iter->info.exception_record) + ((ex_branch*)iter->info.action_pointer)->target; + action = ((ex_destroylocal*)iter->info.action_pointer)->action & EXACTION_MASK; + } + return action; + } +} + +/** + * @note Address: N/A + * @note Size: 0x248 + */ +static char* ExPPC_PopStackFrame(ThrowContext* context, MWExceptionInfo* info) +{ + char *SP, *callers_SP; + f64* FPR_save_area; + s32* GPR_save_area; + int saved_GPRs, saved_FPRs; + GeckoFPRContext* Vector_save_area; + int i, j; + + SP = context->SP; + callers_SP = *(char**)SP; + saved_FPRs = ET_GetSavedFPRs(info->exception_record->et_field); + + if (ET_HasElfVector(info->exception_record->et_field)) { + Vector_save_area = (GeckoFPRContext*)(callers_SP - saved_FPRs * 16); + FPR_save_area = (f64*)Vector_save_area; + } else { + FPR_save_area = (f64*)(callers_SP - saved_FPRs * 8); + } + + if (ET_HasElfVector(info->exception_record->et_field)) { + for (i = 32 - saved_FPRs, j = 0; i < 32; ++i, ++j) { + context->FPR[i].v.f[0] = Vector_save_area[j].v.f[0]; + context->FPR[i].v.f[1] = Vector_save_area[j].v.f[1]; + context->FPR[i].d = Vector_save_area[j].d; + } + } else { + for (i = 32 - saved_FPRs, j = 0; i < 32; ++i, ++j) { + context->FPR[i].d = FPR_save_area[j]; + } + } + + saved_GPRs = ET_GetSavedGPRs(info->exception_record->et_field); + GPR_save_area = (s32*)FPR_save_area; + GPR_save_area -= saved_GPRs; + + for (i = 32 - saved_GPRs, j = 0; i < 32; ++i, ++j) { + context->GPR[i] = GPR_save_area[j]; + } + + context->SP = callers_SP; + return *(char**)(callers_SP + RETURN_ADDRESS); +} + +/** + * @note Address: N/A + * @note Size: 0x3C + */ +static inline void ExPPC_DestroyLocal(ThrowContext* context, const ex_destroylocal* ex) { DTORCALL_COMPLETE(ex->dtor, context->FP + ex->local); } + +/** + * @note Address: N/A + * @note Size: 0x74 + */ +static inline void ExPPC_DestroyLocalCond(ThrowContext* context, const ex_destroylocalcond* ex) +{ + int cond = ex_destroylocalcond_GetRegCond(ex->dlc_field) ? (local_cond_type)context->GPR[ex->cond] + : *(local_cond_type*)(context->FP + ex->cond); + + if (cond) { + DTORCALL_COMPLETE(ex->dtor, context->FP + ex->local); + } +} + +/** + * @note Address: N/A + * @note Size: 0x58 + */ +static inline void ExPPC_DestroyLocalPointer(ThrowContext* context, const ex_destroylocalpointer* ex) +{ + void* pointer + = ex_destroylocalpointer_GetRegPointer(ex->dlp_field) ? (void*)context->GPR[ex->pointer] : *(void**)(context->FP + ex->pointer); + + DTORCALL_COMPLETE(ex->dtor, pointer); +} + +/** + * @note Address: N/A + * @note Size: 0x84 + */ +static inline void ExPPC_DestroyLocalArray(ThrowContext* context, const ex_destroylocalarray* ex) +{ + char* ptr = context->FP + ex->localarray; + s32 n = ex->elements; + s32 size = ex->element_size; + + for (ptr = ptr + size * n; n > 0; n--) { + ptr -= size; + DTORCALL_COMPLETE(ex->dtor, ptr); + } +} + +/** + * @note Address: N/A + * @note Size: 0x64 + */ +static inline void ExPPC_DestroyMember(ThrowContext* context, const ex_destroymember* ex) +{ + char* objectptr + = ex_destroymember_GetRegPointer(ex->dm_field) ? (char*)context->GPR[ex->objectptr] : *(char**)(context->FP + ex->objectptr); + + DTORCALL_COMPLETE(ex->dtor, objectptr + ex->offset); +} + +/** + * @note Address: N/A + * @note Size: 0x64 + */ +static inline void ExPPC_DestroyBase(ThrowContext* context, const ex_destroymember* ex) +{ + char* objectptr + = ex_destroymember_GetRegPointer(ex->dm_field) ? (char*)context->GPR[ex->objectptr] : *(char**)(context->FP + ex->objectptr); + + DTORCALL_PARTIAL(ex->dtor, objectptr + ex->offset); +} + +/** + * @note Address: N/A + * @note Size: 0x98 + */ +static inline void ExPPC_DestroyMemberCond(ThrowContext* context, const ex_destroymembercond* ex) +{ + char* objectptr + = ex_destroymembercond_GetRegPointer(ex->dmc_field) ? (char*)context->GPR[ex->objectptr] : *(char**)(context->FP + ex->objectptr); + int cond = ex_destroymembercond_GetRegCond(ex->dmc_field) ? (vbase_ctor_arg_type)context->GPR[ex->cond] + : *(vbase_ctor_arg_type*)(context->FP + ex->cond); + + if (cond) { + DTORCALL_PARTIAL(ex->dtor, objectptr + ex->offset); + } +} + +/** + * @note Address: N/A + * @note Size: 0xAC + */ +static inline void ExPPC_DestroyMemberArray(ThrowContext* context, const ex_destroymemberarray* ex) +{ + char* ptr + = ex_destroymemberarray_GetRegPointer(ex->dma_field) ? (char*)context->GPR[ex->objectptr] : *(char**)(context->FP + ex->objectptr); + s32 n = ex->elements; + s32 size = ex->element_size; + + ptr += ex->offset; + + for (ptr = ptr + size * n; n > 0; n--) { + ptr -= size; + DTORCALL_COMPLETE(ex->dtor, ptr); + } +} + +/** + * @note Address: N/A + * @note Size: 0x54 + */ +static inline void ExPPC_DeletePointer(ThrowContext* context, const ex_deletepointer* ex) +{ + char* objectptr + = ex_deletepointer_GetRegPointer(ex->dp_field) ? (char*)context->GPR[ex->objectptr] : *(char**)(context->FP + ex->objectptr); + + ((DeleteFunc)ex->deletefunc)(objectptr); +} + +/** + * @note Address: N/A + * @note Size: 0x8C + */ +static inline void ExPPC_DeletePointerCond(ThrowContext* context, const ex_deletepointercond* ex) +{ + char* objectptr + = ex_deletepointercond_GetRegPointer(ex->dpc_field) ? (char*)context->GPR[ex->objectptr] : *(char**)(context->FP + ex->objectptr); + int cond = ex_deletepointercond_GetRegCond(ex->dpc_field) ? (local_cond_type)context->GPR[ex->cond] + : *(local_cond_type*)(context->FP + ex->cond); + + if (cond) { + ((DeleteFunc)ex->deletefunc)(objectptr); + } +} + +/** + * @note Address: N/A + * @note Size: 0x50C + */ +static void ExPPC_UnwindStack(ThrowContext* context, MWExceptionInfo* info, void* catcher) +{ + exaction_type action; + +#pragma exception_terminate + + for (;;) { + if (info->action_pointer == 0) { + char* return_addr; + + return_addr = ExPPC_PopStackFrame(context, info); + ExPPC_FindExceptionRecord(return_addr, info); + + if (info->exception_record == 0) { + terminate(); + } + + context->FP = (ET_GetHasFramePtr(info->exception_record->et_field)) ? (char*)context->GPR[31] : context->SP; + continue; + } + + action = ((ex_destroylocal*)info->action_pointer)->action; + + switch (action & EXACTION_MASK) { + case EXACTION_BRANCH: + info->action_pointer = ((char*)info->exception_record) + ((ex_branch*)info->action_pointer)->target; + break; + case EXACTION_DESTROYLOCAL: + ExPPC_DestroyLocal(context, (ex_destroylocal*)info->action_pointer); + info->action_pointer += sizeof(ex_destroylocal); + break; + case EXACTION_DESTROYLOCALCOND: + ExPPC_DestroyLocalCond(context, (ex_destroylocalcond*)info->action_pointer); + info->action_pointer += sizeof(ex_destroylocalcond); + break; + case EXACTION_DESTROYLOCALPOINTER: + ExPPC_DestroyLocalPointer(context, (ex_destroylocalpointer*)info->action_pointer); + info->action_pointer += sizeof(ex_destroylocalpointer); + break; + case EXACTION_DESTROYLOCALARRAY: + ExPPC_DestroyLocalArray(context, (ex_destroylocalarray*)info->action_pointer); + info->action_pointer += sizeof(ex_destroylocalarray); + break; + case EXACTION_DESTROYBASE: + ExPPC_DestroyBase(context, (ex_destroymember*)info->action_pointer); + info->action_pointer += sizeof(ex_destroymember); + break; + case EXACTION_DESTROYMEMBER: + ExPPC_DestroyMember(context, (ex_destroymember*)info->action_pointer); + info->action_pointer += sizeof(ex_destroymember); + break; + case EXACTION_DESTROYMEMBERCOND: + ExPPC_DestroyMemberCond(context, (ex_destroymembercond*)info->action_pointer); + info->action_pointer += sizeof(ex_destroymembercond); + break; + case EXACTION_DESTROYMEMBERARRAY: + ExPPC_DestroyMemberArray(context, (ex_destroymemberarray*)info->action_pointer); + info->action_pointer += sizeof(ex_destroymemberarray); + break; + case EXACTION_DELETEPOINTER: + ExPPC_DeletePointer(context, (ex_deletepointer*)info->action_pointer); + info->action_pointer += sizeof(ex_deletepointer); + break; + case EXACTION_DELETEPOINTERCOND: + ExPPC_DeletePointerCond(context, (ex_deletepointercond*)info->action_pointer); + info->action_pointer += sizeof(ex_deletepointercond); + break; + case EXACTION_CATCHBLOCK: + if (catcher == (void*)info->action_pointer) + return; + info->action_pointer += sizeof(ex_catchblock); + break; + case EXACTION_CATCHBLOCK_32: + if (catcher == (void*)info->action_pointer) + return; + info->action_pointer += sizeof(ex_catchblock_32); + break; + case EXACTION_ACTIVECATCHBLOCK: { + CatchInfo* catchinfo; + + catchinfo = (CatchInfo*)(context->FP + ((ex_activecatchblock*)info->action_pointer)->cinfo_ref); + + if (catchinfo->dtor) { + if (context->location == catchinfo->location) { + context->dtor = catchinfo->dtor; + } else { + DTORCALL_COMPLETE(catchinfo->dtor, catchinfo->location); + } + } + info->action_pointer += sizeof(ex_activecatchblock); + } break; + case EXACTION_SPECIFICATION: + if (catcher == (void*)info->action_pointer) + return; + info->action_pointer += sizeof(ex_specification) + ((ex_specification*)info->action_pointer)->specs * sizeof(void*); + break; + default: + terminate(); + } + + if (action & EXACTION_ENDBIT) + info->action_pointer = 0; + } +} + +/** + * @note Address: N/A + * @note Size: 0x88 + */ +static inline int ExPPC_IsInSpecification(char* extype, ex_specification* spec) +{ + s32 i, offset; + + for (i = 0; i < spec->specs; i++) { + if (__throw_catch_compare(extype, spec->spec[i], &offset)) + return 1; + } + + return 0; +} + +/** + * @note Address: N/A + * @note Size: 0x1B4 + */ +extern void __unexpected(CatchInfo* catchinfo) +{ + ex_specification* unexp = (ex_specification*)catchinfo->stacktop; + +#pragma exception_magic // allow access to __exception_magic in try/catch blocks + + try { + unexpected(); + } catch (...) { + if (ExPPC_IsInSpecification((char*)((CatchInfo*)&__exception_magic)->typeinfo, unexp)) { + throw; + } + if (ExPPC_IsInSpecification("!bad_exception!!", unexp)) { + throw bad_exception(); + } + if (ExPPC_IsInSpecification("!std::bad_exception!!", unexp)) { + throw bad_exception(); + } + } + terminate(); +} + +/** + * @note Address: N/A + * @note Size: 0x104 + */ +asm static void ExPPC_LongJump(register ThrowContext* context, register void* newRTOC, register void* newPC) +{ +#ifdef __MWERKS__ // clang-format off + nofralloc + + mr r8, newPC + mr RTOC, newRTOC + lwz r0, context->CR + mtcrf 255, r0 + + lmw r13, context->GPR[13] + + la r7, context->FPR[14].v + psq_lx fp14, 0, r7, 0, 0 + lfd fp14, context->FPR[14].d + + la r7, context->FPR[15].v + psq_lx fp15, 0, r7, 0, 0 + lfd fp15, context->FPR[15].d + + la r7, context->FPR[16].v + psq_lx fp16, 0, r7, 0, 0 + lfd fp16, context->FPR[16].d + + la r7, context->FPR[17].v + psq_lx fp17, 0, r7, 0, 0 + lfd fp17, context->FPR[17].d + + la r7, context->FPR[18].v + psq_lx fp18, 0, r7, 0, 0 + lfd fp18, context->FPR[18].d + + la r7, context->FPR[19].v + psq_lx fp19, 0, r7, 0, 0 + lfd fp19, context->FPR[19].d + + la r7, context->FPR[20].v + psq_lx fp20, 0, r7, 0, 0 + lfd fp20, context->FPR[20].d + + la r7, context->FPR[21].v + psq_lx fp21, 0, r7, 0, 0 + lfd fp21, context->FPR[21].d + + la r7, context->FPR[22].v + psq_lx fp22, 0, r7, 0, 0 + lfd fp22, context->FPR[22].d + + la r7, context->FPR[23].v + psq_lx fp23, 0, r7, 0, 0 + lfd fp23, context->FPR[23].d + + la r7, context->FPR[24].v + psq_lx fp24, 0, r7, 0, 0 + lfd fp24, context->FPR[24].d + + la r7, context->FPR[25].v + psq_lx fp25, 0, r7, 0, 0 + lfd fp25, context->FPR[25].d + + la r7, context->FPR[26].v + psq_lx fp26, 0, r7, 0, 0 + lfd fp26, context->FPR[26].d + + la r7, context->FPR[27].v + psq_lx fp27, 0, r7, 0, 0 + lfd fp27, context->FPR[27].d + + la r7, context->FPR[28].v + psq_lx fp28, 0, r7, 0, 0 + lfd fp28, context->FPR[28].d + + la r7, context->FPR[29].v + psq_lx fp29, 0, r7, 0, 0 + lfd fp29, context->FPR[29].d + + la r7, context->FPR[30].v + psq_lx fp30, 0, r7, 0, 0 + lfd fp30, context->FPR[30].d + + la r7, context->FPR[31].v + psq_lx fp31, 0, r7, 0, 0 + lfd fp31, context->FPR[31].d + + mtlr r8 + + lwz SP, context->throwSP + lwz r3, context->SP + lwz r3, 0(r3) + stw r3, 0(SP) + blr +#endif // clang-format on +} + +/** + * @note Address: N/A + * @note Size: 0x84 + */ +static inline void ExPPC_HandleUnexpected(ThrowContext* context, MWExceptionInfo* info, ex_specification* unexp) +{ + CatchInfo* catchinfo; + +#pragma exception_terminate + + ExPPC_UnwindStack(context, info, unexp); + + catchinfo = (CatchInfo*)(context->FP + unexp->cinfo_ref); + catchinfo->location = context->location; + catchinfo->typeinfo = context->throwtype; + catchinfo->dtor = context->dtor; + catchinfo->stacktop = unexp; + + ExPPC_LongJump(context, info->TOC, info->current_function + unexp->pcoffset); +} + +/** + * @note Address: N/A + * @note Size: 0x410 + */ +static void ExPPC_ThrowHandler(ThrowContext* context) +{ + ActionIterator iter; + MWExceptionInfo info; + exaction_type action; + CatchInfo* catchinfo; + s32 offset; + + ExPPC_FindExceptionRecord(context->returnaddr, &info); + + if (info.exception_record == 0) { + terminate(); + } + + context->FP = (ET_GetHasFramePtr(info.exception_record->et_field)) ? (char*)context->GPR[31] : context->SP; + + if (context->throwtype == 0) { + iter.info = info; + iter.current_SP = context->SP; + iter.current_FP = context->FP; + iter.current_R31 = context->GPR[31]; + + for (action = ExPPC_CurrentAction(&iter);; action = ExPPC_NextAction(&iter)) { + switch (action) { + case EXACTION_ACTIVECATCHBLOCK: + break; + case EXACTION_ENDOFLIST: + case EXACTION_DESTROYLOCAL: + case EXACTION_DESTROYLOCALCOND: + case EXACTION_DESTROYLOCALPOINTER: + case EXACTION_DESTROYLOCALARRAY: + case EXACTION_DESTROYBASE: + case EXACTION_DESTROYMEMBER: + case EXACTION_DESTROYMEMBERCOND: + case EXACTION_DESTROYMEMBERARRAY: + case EXACTION_DELETEPOINTER: + case EXACTION_DELETEPOINTERCOND: + case EXACTION_CATCHBLOCK: + case EXACTION_CATCHBLOCK_32: + case EXACTION_SPECIFICATION: + continue; + case EXACTION_TERMINATE: + default: + terminate(); + } + break; + } + + catchinfo = (CatchInfo*)(iter.current_FP + ((ex_activecatchblock*)iter.info.action_pointer)->cinfo_ref); + context->throwtype = (char*)catchinfo->typeinfo; + context->location = catchinfo->location; + context->dtor = 0; + context->catchinfo = catchinfo; + } else { + context->catchinfo = 0L; + } + + iter.info = info; + iter.current_SP = context->SP; + iter.current_FP = context->FP; + iter.current_R31 = context->GPR[31]; + + for (action = ExPPC_CurrentAction(&iter);; action = ExPPC_NextAction(&iter)) { + switch (action) { + case EXACTION_CATCHBLOCK_32: + if (__throw_catch_compare(context->throwtype, ((ex_catchblock_32*)iter.info.action_pointer)->catch_type, &offset)) { + break; + } + continue; + case EXACTION_CATCHBLOCK: + if (__throw_catch_compare(context->throwtype, ((ex_catchblock*)iter.info.action_pointer)->catch_type, &offset)) { + break; + } + continue; + case EXACTION_SPECIFICATION: + if (!ExPPC_IsInSpecification(context->throwtype, (ex_specification*)iter.info.action_pointer)) { + ExPPC_HandleUnexpected(context, &info, (ex_specification*)iter.info.action_pointer); + } + continue; + case EXACTION_ENDOFLIST: + case EXACTION_DESTROYLOCAL: + case EXACTION_DESTROYLOCALCOND: + case EXACTION_DESTROYLOCALPOINTER: + case EXACTION_DESTROYLOCALARRAY: + case EXACTION_DESTROYBASE: + case EXACTION_DESTROYMEMBER: + case EXACTION_DESTROYMEMBERCOND: + case EXACTION_DESTROYMEMBERARRAY: + case EXACTION_DELETEPOINTER: + case EXACTION_DELETEPOINTERCOND: + case EXACTION_ACTIVECATCHBLOCK: + continue; + case EXACTION_TERMINATE: + default: + terminate(); + } + break; + } + + if (action == EXACTION_CATCHBLOCK_32) { + ex_catchblock_32* catchblock_32; + catchblock_32 = (ex_catchblock_32*)iter.info.action_pointer; + + ExPPC_UnwindStack(context, &info, catchblock_32); + + catchinfo = (CatchInfo*)(context->FP + catchblock_32->cinfo_ref); + catchinfo->location = context->location; + catchinfo->typeinfo = context->throwtype; + catchinfo->dtor = context->dtor; + + if (*context->throwtype == '*') { + catchinfo->sublocation = &catchinfo->pointercopy; + catchinfo->pointercopy = *(s32*)context->location + offset; + } else { + catchinfo->sublocation = (char*)context->location + offset; + } + + ExPPC_LongJump(context, info.TOC, info.current_function + catchblock_32->catch_pcoffset); + } else { + ex_catchblock* catchblock; + + catchblock = (ex_catchblock*)iter.info.action_pointer; + ExPPC_UnwindStack(context, &info, catchblock); + + catchinfo = (CatchInfo*)(context->FP + catchblock->cinfo_ref); + catchinfo->location = context->location; + catchinfo->typeinfo = context->throwtype; + catchinfo->dtor = context->dtor; + + if (*context->throwtype == '*') { + catchinfo->sublocation = &catchinfo->pointercopy; + catchinfo->pointercopy = *(s32*)context->location + offset; + } else { + catchinfo->sublocation = (char*)context->location + offset; + } + + ExPPC_LongJump(context, info.TOC, info.current_function + catchblock->catch_pcoffset); + } +} + +/** + * @note Address: N/A + * @note Size: 0x44 + */ +void __end__catch(CatchInfo* catchinfo) +{ + if (catchinfo->location && catchinfo->dtor) { + DTORCALL_COMPLETE(catchinfo->dtor, catchinfo->location); + } +} + +/** + * @note Address: N/A + * @note Size: 0x144 + */ +asm void __throw(char* throwtype, void* location, void* dtor) +{ +#ifdef __MWERKS__ // clang-format off + ThrowContext throwcontext; + + fralloc + + stmw r13, throwcontext.GPR[13] + + stfd fp14, throwcontext.FPR[14].d + la r3, throwcontext.FPR[14].v + psq_stx fp14, 0, r3,0,0 + + stfd fp15, throwcontext.FPR[15].d + la r3, throwcontext.FPR[15].v + psq_stx fp15, 0, r3, 0, 0 + + stfd fp16, throwcontext.FPR[16].d + la r3, throwcontext.FPR[16].v + psq_stx fp16, 0, r3, 0, 0 + + stfd fp17, throwcontext.FPR[17].d + la r3, throwcontext.FPR[17].v + psq_stx fp17, 0, r3, 0, 0 + + stfd fp18, throwcontext.FPR[18].d + la r3, throwcontext.FPR[18].v + psq_stx fp18, 0, r3, 0, 0 + + stfd fp19, throwcontext.FPR[19].d + la r3, throwcontext.FPR[19].v + psq_stx fp19, 0, r3, 0, 0 + + stfd fp20, throwcontext.FPR[20].d + la r3, throwcontext.FPR[20].v + psq_stx fp20, 0, r3, 0, 0 + + stfd fp21, throwcontext.FPR[21].d + la r3, throwcontext.FPR[21].v + psq_stx fp21, 0, r3, 0, 0 + + stfd fp22, throwcontext.FPR[22].d + la r3, throwcontext.FPR[22].v + psq_stx fp22, 0, r3, 0, 0 + + stfd fp23, throwcontext.FPR[23].d + la r3, throwcontext.FPR[23].v + psq_stx fp23, 0, r3, 0, 0 + + stfd fp24, throwcontext.FPR[24].d + la r3, throwcontext.FPR[24].v + psq_stx fp24, 0, r3, 0, 0 + + stfd fp25, throwcontext.FPR[25].d + la r3, throwcontext.FPR[25].v + psq_stx fp25, 0, r3, 0, 0 + + stfd fp26, throwcontext.FPR[26].d + la r3, throwcontext.FPR[26].v + psq_stx fp26, 0, r3, 0, 0 + + stfd fp27, throwcontext.FPR[27].d + la r3, throwcontext.FPR[27].v + psq_stx fp27, 0, r3, 0, 0 + + stfd fp28, throwcontext.FPR[28].d + la r3, throwcontext.FPR[28].v + psq_stx fp28, 0, r3, 0, 0 + + stfd fp29, throwcontext.FPR[29].d + la r3, throwcontext.FPR[29].v + psq_stx fp29, 0, r3, 0, 0 + + stfd fp30, throwcontext.FPR[30].d + la r3, throwcontext.FPR[30].v + psq_stx fp30, 0, r3, 0, 0 + + stfd fp31, throwcontext.FPR[31].d + la r3, throwcontext.FPR[31].v + psq_stx fp31, 0, r3, 0, 0 + + + mfcr r3 + stw r3, throwcontext.CR; + + lwz r3, 0(sp) + lwz r4, RETURN_ADDRESS(r3) + stw r3, throwcontext.SP; + stw r3, throwcontext.throwSP; + stw r4, throwcontext.returnaddr; + + lwz r3,throwtype + stw r3, throwcontext.throwtype + lwz r3,location + stw r3, throwcontext.location + lwz r3,dtor + stw r3, throwcontext.dtor + la r3, throwcontext + bl ExPPC_ThrowHandler + nop + frfree + blr +#endif // clang-format on +} diff --git a/src/Runtime.PPCEABI.H/NMWException.cpp b/src/Runtime.PPCEABI.H/NMWException.cpp new file mode 100755 index 00000000..b5f722de --- /dev/null +++ b/src/Runtime.PPCEABI.H/NMWException.cpp @@ -0,0 +1,157 @@ +#include "PowerPC_EABI_Support/Runtime/NMWException.h" +#include "PowerPC_EABI_Support/Runtime/MWCPlusLib.h" + +#define ARRAY_HEADER_SIZE 16 + +extern "C" { +extern void abort(); +} + +namespace std { +/** + * @note Address: N/A + * @note Size: 0x20 + */ +static void dthandler() { abort(); } + +static terminate_handler thandler = dthandler; + +/** + * @note Address: N/A + * @note Size: 0x28 + */ +static void duhandler() { terminate(); } + +static unexpected_handler uhandler = duhandler; + +/** + * @note Address: N/A + * @note Size: 0x28 + */ +extern void terminate() { thandler(); } + +/** + * @note Address: N/A + * @note Size: 0x28 + */ +extern void unexpected() { uhandler(); } +} // namespace std + +/** + * @note Address: N/A + * @note Size: 0x22C + */ +extern char __throw_catch_compare(const char* throwtype, const char* catchtype, s32* offset_result) +{ + const char *cptr1, *cptr2; + + *offset_result = 0; + + if ((cptr2 = catchtype) == 0) { + return true; + } + + cptr1 = throwtype; + + if (*cptr2 == 'P') { + cptr2++; + if (*cptr2 == 'C') + cptr2++; + if (*cptr2 == 'V') + cptr2++; + if (*cptr2 == 'v') { + if (*cptr1 == 'P' || *cptr1 == '*') { + return true; + } + } + cptr2 = catchtype; + } + + switch (*cptr1) { + case '*': + case '!': + if (*cptr1++ != *cptr2++) + return false; + for (;;) { + if (*cptr1 == *cptr2++) { + if (*cptr1++ == '!') { + s32 offset; + + for (offset = 0; *cptr1 != '!';) { + offset = offset * 10 + *cptr1++ - '0'; + } + *offset_result = offset; + return true; + } + } else { + while (*cptr1++ != '!') { } + while (*cptr1++ != '!') { } + if (*cptr1 == 0) + return false; + + cptr2 = catchtype + 1; + } + } + return false; + } + + while ((*cptr1 == 'P' || *cptr1 == 'R') && *cptr1 == *cptr2) { + cptr1++; + cptr2++; + + if (*cptr2 == 'C') { + if (*cptr1 == 'C') + cptr1++; + cptr2++; + } + if (*cptr1 == 'C') + return false; + + if (*cptr2 == 'V') { + if (*cptr1 == 'V') + cptr1++; + cptr2++; + } + if (*cptr1 == 'V') + return false; + } + + for (; *cptr1 == *cptr2; cptr1++, cptr2++) { + if (*cptr1 == 0) + return true; + } + + return false; +} + +class __partial_array_destructor { +private: + void* p; + size_t size; + size_t n; + ConstructorDestructor dtor; + +public: + size_t i; + + __partial_array_destructor(void* array, size_t elementsize, size_t nelements, ConstructorDestructor destructor) + { + p = array; + size = elementsize; + n = nelements; + dtor = destructor; + i = n; + } + + ~__partial_array_destructor() + { + char* ptr; + + if (i < n && dtor) { + for (ptr = (char*)p + size * i; i > 0; i--) { + ptr -= size; + DTORCALL_COMPLETE(dtor, ptr); + } + } + } +}; From 312f8471c8ebce75a58edbabebec89ae5118216a Mon Sep 17 00:00:00 2001 From: dbalatoni13 <40299962+dbalatoni13@users.noreply.github.com> Date: Wed, 5 Feb 2025 03:08:50 +0100 Subject: [PATCH 2/6] Finish m427Dll (#558) --- config/GMPE01_00/rels/m427Dll/symbols.txt | 16 +- configure.py | 2 +- include/REL/m427Dll.h | 36 +- src/REL/m427Dll/main.c | 5 - src/REL/m427Dll/map.c | 2645 +++++++++++++++++++-- src/REL/m427Dll/player.c | 10 +- 6 files changed, 2495 insertions(+), 219 deletions(-) diff --git a/config/GMPE01_00/rels/m427Dll/symbols.txt b/config/GMPE01_00/rels/m427Dll/symbols.txt index d075d6af..96db2763 100644 --- a/config/GMPE01_00/rels/m427Dll/symbols.txt +++ b/config/GMPE01_00/rels/m427Dll/symbols.txt @@ -271,11 +271,11 @@ lbl_1_rodata_328 = .rodata:0x00000328; // type:object size:0x8 scope:local data: lbl_1_rodata_330 = .rodata:0x00000330; // type:object size:0x4 scope:local data:float lbl_1_rodata_334 = .rodata:0x00000334; // type:object size:0x4 scope:local data:float lbl_1_rodata_338 = .rodata:0x00000338; // type:object size:0x4 scope:local data:float -lbl_1_rodata_33C = .rodata:0x0000033C; // type:object size:0xC scope:local data:4byte +lbl_1_rodata_33C = .rodata:0x0000033C; // type:object size:0xC scope:local data:float lbl_1_rodata_348 = .rodata:0x00000348; // type:object size:0x4 scope:local data:float lbl_1_rodata_34C = .rodata:0x0000034C; // type:object size:0x4 scope:local data:float lbl_1_rodata_350 = .rodata:0x00000350; // type:object size:0x4 scope:local data:float -lbl_1_rodata_354 = .rodata:0x00000354; // type:object size:0x1 scope:local data:byte +lbl_1_rodata_354 = .rodata:0x00000354; // type:object size:0x4 scope:local data:byte lbl_1_rodata_358 = .rodata:0x00000358; // type:object size:0x4 scope:local data:float lbl_1_rodata_35C = .rodata:0x0000035C; // type:object size:0x4 scope:local data:float lbl_1_rodata_360 = .rodata:0x00000360; // type:object size:0x4 scope:local data:float @@ -353,8 +353,8 @@ lbl_1_data_D0 = .data:0x000000D0; // type:object size:0x8 lbl_1_data_D8 = .data:0x000000D8; // type:object size:0x4 lbl_1_data_DC = .data:0x000000DC; // type:object size:0x4 lbl_1_data_E0 = .data:0x000000E0; // type:object size:0x4 data:2byte -lbl_1_data_E8 = .data:0x000000E8; // type:object size:0x4 data:2byte -lbl_1_data_EC = .data:0x000000EC; // type:object size:0x5 data:string +lbl_1_data_E8 = .data:0x000000E8; // type:object size:0x4 data:byte +lbl_1_data_EC = .data:0x000000EC; // type:object size:0x5 scope:local data:string lbl_1_data_F4 = .data:0x000000F4; // type:object size:0x4 data:float lbl_1_data_F8 = .data:0x000000F8; // type:object size:0x4 data:float lbl_1_data_FC = .data:0x000000FC; // type:object size:0x30 @@ -365,10 +365,10 @@ lbl_1_data_1D4 = .data:0x000001D4; // type:object size:0x8 lbl_1_data_1DC = .data:0x000001DC; // type:object size:0x8 lbl_1_data_1E4 = .data:0x000001E4; // type:object size:0x8 lbl_1_data_1EC = .data:0x000001EC; // type:object size:0x4 -lbl_1_data_1F0 = .data:0x000001F0; // type:object size:0x13 data:string -lbl_1_data_203 = .data:0x00000203; // type:object size:0x10 data:string -lbl_1_data_213 = .data:0x00000213; // type:object size:0x26 data:string -lbl_1_data_239 = .data:0x00000239; // type:object size:0x25 +lbl_1_data_1F0 = .data:0x000001F0; // type:object size:0x13 scope:local data:string +lbl_1_data_203 = .data:0x00000203; // type:object size:0x10 scope:local data:string +lbl_1_data_213 = .data:0x00000213; // type:object size:0x26 scope:local data:string +lbl_1_data_239 = .data:0x00000239; // type:object size:0x24 scope:local data:string lbl_1_data_260 = .data:0x00000260; // type:object size:0x15C lbl_1_data_3BC = .data:0x000003BC; // type:object size:0x15C lbl_1_data_518 = .data:0x00000518; // type:object size:0x1C diff --git a/configure.py b/configure.py index 6d5e0024..1a3c04d9 100644 --- a/configure.py +++ b/configure.py @@ -1084,7 +1084,7 @@ config.libs = [ "m427Dll", # Right Oar Left? objects={ Object(MatchingFor("GMPE01_00", "GMPE01_01"), "REL/m427Dll/main.c"), - Object(NonMatching, "REL/m427Dll/map.c"), + Object(MatchingFor("GMPE01_00", "GMPE01_01"), "REL/m427Dll/map.c"), Object(MatchingFor("GMPE01_00", "GMPE01_01"), "REL/m427Dll/player.c"), }, ), diff --git a/include/REL/m427Dll.h b/include/REL/m427Dll.h index c8290376..ceda94c3 100644 --- a/include/REL/m427Dll.h +++ b/include/REL/m427Dll.h @@ -1,21 +1,35 @@ #include "dolphin.h" #include "game/object.h" -s32 fn_1_1788(void); -void fn_1_1798(s32 arg0, float arg8); -s32 fn_1_1884(void); -s32 fn_1_32EC(void); +typedef struct M427DllStruct { + s32 unk0; + s32 unk4; +} M427DllStruct; -void fn_1_32F4(Process* arg0); -void fn_1_3B20(s8 arg0, s16 arg1); +s32 fn_1_1788(void); +void fn_1_1798(s32 arg0, float arg8); +s32 fn_1_1884(void); +s32 fn_1_32EC(void); + +void fn_1_32F4(Process *arg0); +void fn_1_3B20(s8 arg0, s16 arg1); void fn_1_3A88(void); -void fn_1_91E0(s16 arg0, float arg8, float arg9, float argA, float argB); -float fn_1_AE78(s16 arg0, float arg8, float arg9); -void fn_1_E98C(Process*); +void fn_1_91E0(s16 arg0, float arg8, float arg9, float argA, float argB); +float fn_1_AE78(s16 arg0, float arg8, float arg9); +void fn_1_E98C(Process *); void fn_1_EC54(void); s32 fn_1_10FE8(s32 arg0, s32 *arg1); -void fn_1_110E8(s32, s32*); -void fn_1_111C0(s32, s32*); +void fn_1_110E8(s32, s32 *); +void fn_1_111C0(s32, s32 *); void fn_1_11298(f32); s32 fn_1_113F0(s32); f32 fn_1_168FC(f32, f32, f32); + +s32 fn_1_15F10(Vec arg0, Vec arg1, s32 arg2, s32 arg3, s32 arg4); +s32 fn_1_15FD0(Vec arg0, float arg8, s32 arg1, s32 arg2, s32 arg3); + +extern s32 lbl_1_bss_580; +extern Vec *lbl_1_bss_558; +extern Vec *lbl_1_bss_554; +extern Vec *lbl_1_bss_550; +extern M427DllStruct lbl_1_bss_0[8]; diff --git a/src/REL/m427Dll/main.c b/src/REL/m427Dll/main.c index 84bcb03b..fdf0de2d 100644 --- a/src/REL/m427Dll/main.c +++ b/src/REL/m427Dll/main.c @@ -10,11 +10,6 @@ #include "game/objsub.h" #include "game/wipe.h" -typedef struct M427DllStruct { - s32 unk0; - s32 unk4; -} M427DllStruct; - typedef struct M427DllStruct2 { s32 unk0[3]; s32 unkC; diff --git a/src/REL/m427Dll/map.c b/src/REL/m427Dll/map.c index acbbb20e..1678f422 100644 --- a/src/REL/m427Dll/map.c +++ b/src/REL/m427Dll/map.c @@ -1,19 +1,27 @@ #include "REL/m427Dll.h" +#include "dolphin/gx/GXEnum.h" +#include "dolphin/gx/GXStruct.h" +#include "dolphin/gx/GXVert.h" +#include "dolphin/pad.h" #include "ext_math.h" #include "game/animdata.h" +#include "game/audio.h" +#include "game/hsfanim.h" #include "game/hsfdraw.h" #include "game/hsfman.h" #include "game/hsfmotion.h" +#include "game/memory.h" +#include "game/object.h" +#include "game/pad.h" #include "game/sprite.h" +#include "string.h" + +extern s32 rand8(void); +extern LightData Hu3DLocalLight[0x20]; #define FABS(value) ((value < 0) ? -(value) : (value)) -typedef struct M427DllStruct { - s32 unk0; - s32 unk4; -} M427DllStruct; - typedef struct M427DllStruct2 { s32 unk0[3]; s32 unkC; @@ -35,24 +43,38 @@ typedef struct M427DllStruct3 { Vec rot; Vec cen; f32 zoom; -} M427DllStruct3; +} M427DllStruct3; // sizeof 0x1C typedef struct M427DllMapStruct { - char unk_0[0x2]; + u8 unk0; + char unk_1; s16 unk2; s16 unk4; char unk_6[0x2]; - AnimData* unk8; - char unk_C[0x74]; - void* unk80; - char unk_84[0x14]; + AnimData *unk8; + Vec unkC; + Vec unk18; + Vec unk24; + Vec unk30; + Vec2f unk3C; + Vec2f unk44; + Vec2f unk4C; + Vec2f unk54; + Vec2f unk5C[4]; + GXColor unk7C; + void *unk80; + s32 unk84; + float unk88; + float unk8C; + float unk90; + float unk94; } M427DllMapStruct; // sizeof 0x98 typedef struct M427DllMapStruct2 { s8 unk0; s16 unk2; s16 unk4; -} M427DllMapStruct2; +} M427DllMapStruct2; // sizeof 0x6 typedef struct M427DllMapSubstruct { s16 unk0; @@ -62,31 +84,46 @@ typedef struct M427DllMapSubstruct { typedef struct M427DllMapSubstruct2 { s16 unk0; Vec unk4; - s16 unk10; - s16 unk12; + s16 unk10[2]; s16 unk14[4]; } M427DllMapSubstruct2; // sizeof 0x1C -typedef struct M427DllMapSubstruct4 { - char unk[0x28]; - AnimData* unk28; -} M427DllMapSubstruct4; - typedef struct M427DllMapSubstruct7 { s16 unk0; s32 unk4; - void* unk8; -} M427DllMapSubstruct7; + void *unk8; +} M427DllMapSubstruct7; // sizeof 0xC -typedef struct M427DllMapUNKBA { - s16 unk0; - char unk[0x2E]; -} M427DllMapUNKBA; - -typedef struct M427DllMapUNK180 { +typedef struct M427DllMapUNKB8 { s16 unk0; s16 unk2; -} M427DllMapUNK180; + s16 unk4; + s16 unk6; + u8 unk8; + s16 unkA; + float unkC; + float unk_10; + float unk_14; + s16 unk18; + s16 unk1A; + s16 unk1C; + s16 unk1E; + float unk20; + float unk24; + float unk28; + float unk2C; +} M427DllMapUNKB8; // sizeof 0x30 + +typedef struct M427DllMapUNK17E { + s16 unk0; + s16 unk2; +} M427DllMapUNK17E; // sizeof 0x4 + +typedef struct M427DllMapSubstruct3Sub { + s16 unk0; + void *unk4; + u32 unk8; +} M427DllMapSubstruct3Sub; // sizeof 0xC typedef struct M427DllMapSubstruct3 { s16 unk0; @@ -96,30 +133,44 @@ typedef struct M427DllMapSubstruct3 { s16 unk1C; s16 unk1E; s16 unk20; - char unk_22[0x3A]; + char unk_22[2]; + float unk24[4]; + s16 unk34[4]; + s16 unk3C[4]; + s16 unk44[0xB]; + s16 unk5A; s16 unk5C; - char unk_5E[0x1A]; + char unk_5E[2]; + Vec unk_60; + Vec unk_6C; Vec unk78; Vec unk84; f32 unk90; - char unk_94[0x4]; - void* unk98; - M427DllMapSubstruct7* unk9C; + M427DllMapSubstruct3Sub unk94; char unk_A0[0xC]; - M427DllMapSubstruct4* unkAC; - char unk_B0[0xA]; - M427DllMapUNKBA unkBA[2][2]; - char unk_17A[0x6]; - M427DllMapUNK180 unk180[2][2]; - char unk_190[0x8]; + struct M427DllMapStruct6 *unkAC; + s16 unkB0[1]; + char unk_B2[0x6]; + M427DllMapUNKB8 unkB8[2][2]; + s16 unk178[3]; + M427DllMapUNK17E unk17E[2][2]; + s16 unk18E[2]; + char unk194[4]; } M427DllMapSubstruct3; // sizeof 0x198 +typedef struct M427DllMapStruct3Sub { + AnimData *unk_00; + AnimData *unk_04; + float unk_08; + float unk_0C; + float unk_10; + float unk_14; +} M427DllMapStruct3Sub; // sizeof 0x18 + typedef struct M427DllMapStruct3 { u8 unk0; M427DllMapSubstruct3 unk4[2]; - AnimData* unk334; - AnimData* unk338; - char unk_33C[0x10]; + M427DllMapStruct3Sub unk334; M427DllMapSubstruct2 unk34C[3]; M427DllMapSubstruct unk3A0[5]; } M427DllMapStruct3; // sizeof 0x3F0 @@ -130,24 +181,24 @@ typedef struct M427DllMapSubstruct5 { s16 unk4; s16 unk6; Vec unk8; - char unk[0x8]; -} M427DllMapSubstruct5; + char unk14[0x8]; +} M427DllMapSubstruct5; // sizeof 0x1C typedef struct M427DllMapStruct4 { s16 unk0; - Vec* unk4; - Vec2f* unk8; - Vec* unkC; - GXColor* unk10; + Vec *unk4; + Vec2f *unk8; + Vec *unkC; + GXColor *unk10; s16 unk14; s16 unk16; s16 unk18; - M427DllMapSubstruct5* unk1C; - void* unk20; + M427DllMapSubstruct5 *unk1C; + void *unk20; u32 unk24; - void* unk28; + void *unk28; u32 unk2C; - void* unk30; + void *unk30; u32 unk34; f32 unk38; f32 unk3C; @@ -155,7 +206,7 @@ typedef struct M427DllMapStruct4 { f32 unk44; s16 unk48[1]; s16 unk4A; -} M427DllMapStruct4; +} M427DllMapStruct4; // sizeof 0x4C typedef struct M427DllMapStruct5 { f32 unk0; @@ -165,56 +216,193 @@ typedef struct M427DllMapStruct5 { f32 unk10; } M427DllMapStruct5; // sizeof 0x14 -omObjData* lbl_1_bss_548; +typedef struct M427DllMapStruct6 { + s16 unk_00; + Vec *unk_04; + Vec *unk_08; + float unk_0C; + float unk_10; + float unk_14; + float unk_18; + float unk_1C; + float unk_20; + float unk_24; + AnimData *unk_28; + Vec *unk_2C; + Vec2f *unk_30; + Vec *unk_34; + s16 unk_38; + s16 unk_3A; + s16 unk_3C; + char pad_3E[2]; + void *unk_40; + u32 unk_44; + M427DllMapSubstruct5 *unk_48; + float unk_4C; + float unk_50; + float unk_54; + float unk_58; + float unk_5C; + /* 0x60 */ float unk_60; +} M427DllMapStruct6; /* size = 0x64, stored in unk_120 */ + +typedef struct M427DllMapSubstruct6 { + /* 0x00 */ float unk_00; + /* 0x04 */ float unk_04; + /* 0x08 */ float unk_08; + /* 0x0C */ char pad_0C[0xC]; /* maybe part of unk_08[4]? */ + /* 0x18 */ float unk_18; + /* 0x1C */ float unk_1C; + /* 0x20 */ float unk_20; + /* 0x24 */ float unk_24; + /* 0x28 */ float unk_28; + /* 0x2C */ float unk_2C; + /* 0x30 */ float unk_30; + /* 0x34 */ s16 unk_34; + /* 0x36 */ s16 unk_36; + /* 0x38 */ s16 unk_38; + /* 0x3A */ char pad_3A[2]; + /* 0x3C */ s32 unk_3C; + /* 0x40 */ s16 unk_40; + /* 0x42 */ char pad_42[2]; + /* 0x44 */ float unk_44; + /* 0x48 */ Vec unk_48; + /* 0x54 */ Vec unk_54; + /* 0x60 */ s16 unk_60; + /* 0x62 */ s8 unk_62; + /* 0x63 */ char pad_63[1]; +} M427DllMapSubstruct6; // sizeof 0x64 + +typedef void (*M427DllHook)(ModelData *model, struct M427DllMapStruct7 *particle, Mtx matrix); + +typedef struct M427DllMapStruct7 { + /* 0x00 */ s16 unk_00; + /* 0x02 */ char pad_02[2]; + /* 0x04 */ u32 unk_04; + /* 0x08 */ u8 unk_08; + /* 0x09 */ char pad_09[3]; /* maybe part of unk_08[4]? */ + /* 0x0C */ M427DllHook unk_0C; + /* 0x10 */ AnimData *unk_10; + /* 0x14 */ s16 unk_14; + /* 0x16 */ char pad_16[2]; + /* 0x18 */ M427DllMapSubstruct6 *unk_18; + /* 0x1C */ Vec *unk_1C; + /* 0x20 */ Vec2f *unk_20; + /* 0x24 */ GXColor *unk_24; + /* 0x28 */ void *unk_28; + /* 0x2C */ Vec unk_2C; + /* 0x38 */ float unk_38; + /* 0x3C */ float unk_3C; + /* 0x40 */ float unk_40; + /* 0x44 */ float unk_44; + /* 0x48 */ float unk_48; + /* 0x4C */ float unk_4C; + /* 0x50 */ float unk_50; + /* 0x54 */ float unk_54; + /* 0x58 */ float unk_58; + /* 0x5C */ Vec2f *unk_5C; + /* 0x60 */ float unk_60; + /* 0x64 */ float unk_64; +} M427DllMapStruct7; /* size = 0x68, stored in unk_120 */ + +GXColor lbl_1_data_E8 = { 0xFF, 0xFF, 0xFF, 0xFF }; + +omObjData *lbl_1_bss_548; M427DllMapStruct3 lbl_1_bss_158; M427DllMapStruct2 lbl_1_bss_F8[0x10]; -M427DllMapStruct* lbl_1_bss_F0; +AnimData *lbl_1_bss_F4; +M427DllMapStruct *lbl_1_bss_F0; s16 lbl_1_bss_EC[2]; s16 lbl_1_bss_E8[2]; -M427DllMapStruct5* lbl_1_bss_E4; +M427DllMapStruct5 *lbl_1_bss_E4; M427DllMapStruct4 lbl_1_bss_98; f32 lbl_1_bss_94; +s8 lbl_1_bss_91; +s8 lbl_1_bss_90; void fn_1_372C(void); -void fn_1_4218(omObjData*); +void fn_1_4218(omObjData *object); void fn_1_44F4(f32, f32, f32, f32, f32); -void fn_1_48EC(ModelData*, Mtx); -void fn_1_4D7C(ModelData*, Mtx); -void fn_1_50A0(ModelData*, Mtx); +void fn_1_48EC(ModelData *model, Mtx matrix); +void fn_1_4D7C(ModelData *model, Mtx matrix); +void fn_1_50A0(ModelData *model, Mtx matrix); void fn_1_510C(s32, s16, s16); -void fn_1_558C(M427DllMapStruct4*); -void fn_1_618C(ModelData*, Mtx); -void fn_1_6760(omObjData*); -void fn_1_C2C8(Vec*, Vec*, Vec*, void*); -void fn_1_D22C(void); -s16 fn_1_D63C(AnimData*, s32, f32, s32, s32); +void fn_1_558C(M427DllMapStruct4 *); +void fn_1_618C(ModelData *model, Mtx matrix); +void fn_1_6760(omObjData *object); +void fn_1_C2C8(Vec *arg0, Vec *arg1, Vec *arg2, Vec *arg3); +void fn_1_D22C(ModelData *model, struct M427DllMapStruct7 *arg1, Mtx matrix); +s16 fn_1_D63C(AnimData *arg0, s16 arg1, float arg8, s16 arg2, s16 arg3); void fn_1_DB80(s16); -void fn_1_DC64(s16, void (*)(void)); -void fn_1_DC9C(s16, s32); +void fn_1_DC64(s16, M427DllHook); +void fn_1_DC9C(s16, u8); +void fn_1_72E4(omObjData *arg0); +void fn_1_73BC(void); +void fn_1_794C(M427DllMapSubstruct3 *arg0, s16 arg1); +void fn_1_7C34(void); +void fn_1_7E60(s16 arg0, M427DllMapSubstruct3 *arg1); +void fn_1_7F38(void); +void fn_1_85D4(s16 arg0, M427DllMapSubstruct3 *arg1); +void fn_1_8768(M427DllMapSubstruct3 *arg0, M427DllMapUNKB8 *arg1, s16 arg2, float arg8, float arg9); +void fn_1_8E1C(u8 arg0, M427DllMapSubstruct3 *arg1, M427DllMapUNKB8 *arg2); +void fn_1_8F90(omObjData *object); +void fn_1_9240(void); +void fn_1_9318(s16 *arg0, s16 arg1); +void fn_1_93EC(s32 arg0, s32 arg1, float arg8, float arg9, float argA, float argB); +s16 fn_1_95E8(s32 arg0, s16 arg1, s16 arg2, float arg8, float arg9, float argA, float argB, float argC); +void fn_1_9958(s16 arg0, u8 arg1); +void fn_1_999C(s16 arg0, u8 arg1); +void fn_1_99E4(s16 arg0, u8 arg1, u8 arg2, u8 arg3, u8 arg4); +void fn_1_9A2C(s16 arg0, float arg8, float arg9, float argA); +void fn_1_9AA0(s16 arg0, float arg8, float arg9, float argA); +void fn_1_9B14(s16 arg0, float arg8, float arg9, float argA); +void fn_1_9B88(ModelData *model, Mtx matrix); +void fn_1_A148(ModelData *model, Mtx matrix); +s16 fn_1_A1F4(s32 arg0, s16 arg1, s16 arg2, s16 arg3, float arg8, Vec *arg4, Vec *arg5); +void fn_1_A7F8(M427DllMapStruct6 *arg0); +void fn_1_B194(M427DllMapStruct6 *arg0, float arg8, Vec *arg1); +void fn_1_B3CC(ModelData *model, Mtx matrix); +void fn_1_C154(ModelData *model, Mtx matrix); +void fn_1_C200(ModelData *model, Mtx matrix); +void fn_1_C2AC(Vec *arg0, float arg8, float arg9, float argA); +void fn_1_C2BC(Vec2f *arg0, float arg8, float arg9); +s16 fn_1_C41C(float arg8, float arg9, float argA, float argB, float argC, float argD, u8 arg0, u8 arg1, u8 arg2); +void fn_1_C528(s16 arg0, s16 arg1, float arg8, float arg9, float argA, float argB, float argC, float argD, u8 arg2, u8 arg3, u8 arg4); +void fn_1_C68C(LightData *arg0, Vec *arg1, Vec *arg2, GXColor *arg3); +void fn_1_C76C(u8 arg0, float arg8, float arg9, float argA, s16 arg1, float argB, float argC, s16 arg2); +s16 fn_1_D430(float arg8, float arg9, float argA, s16 arg0); +M427DllMapSubstruct6 *fn_1_D4FC(s16 arg0, Vec *arg1, Vec *arg2, float arg8, GXColor *arg3); +M427DllMapSubstruct6 *fn_1_DC0C(s16 arg0, s16 arg1); +void fn_1_DCD4(ModelData *model, Mtx matrix); +void fn_1_E2B0(Vec2f *arg0, s16 arg1, s16 arg2, float arg8, float arg9); +void fn_1_E37C(Vec2f *arg0, Vec2f *arg1, s16 arg2, float arg8, float arg9); +void fn_1_E420(Vec *arg0, Vec *arg1, Vec *arg2, s16 arg3); -void fn_1_32F4(Process* arg0) { +void fn_1_32F4(Process *arg0) +{ s16 var_r31; - AnimData* temp_r30; + AnimData *temp_r30; s32 var_r29; s32 var_r28; lbl_1_bss_158.unk0 = 0; lbl_1_bss_548 = omAddObjEx(arg0, 0x7F, 0, 0, -1, fn_1_6760); - lbl_1_bss_F0 = HuMemDirectMallocNum(HEAP_SYSTEM, 0x10 * sizeof(M427DllMapStruct), 0x10000000); - + lbl_1_bss_F0 = HuMemDirectMallocNum(HEAP_SYSTEM, 0x10 * sizeof(M427DllMapStruct), MEMORY_DEFAULT_NUM); + for (var_r31 = 0; var_r31 < 0x10; var_r31++) { lbl_1_bss_F0[var_r31].unk2 = -1; } - temp_r30 = HuSprAnimRead(HuDataReadNum(0x3A0017, MEMORY_DEFAULT_NUM)); + temp_r30 = HuSprAnimRead(HuDataReadNum(0x3A0017, MEMORY_DEFAULT_NUM)); for (var_r31 = 0; var_r31 < 2; var_r31++) { lbl_1_bss_EC[var_r31] = fn_1_D63C(temp_r30, 0x200, 80.0f, 0x40, 0x40); - fn_1_DC64(lbl_1_bss_EC[var_r31], &fn_1_D22C); + fn_1_DC64(lbl_1_bss_EC[var_r31], fn_1_D22C); fn_1_DC9C(lbl_1_bss_EC[var_r31], 1); Hu3DModelLayerSet(lbl_1_bss_EC[var_r31], 7); if (var_r31 == 0) { var_r29 = 1; - } else { + } + else { var_r29 = 2; } Hu3DModelCameraSet(lbl_1_bss_EC[var_r31], var_r29); @@ -226,13 +414,14 @@ void fn_1_32F4(Process* arg0) { Hu3DModelLayerSet(lbl_1_bss_E8[var_r31], 7); if (var_r31 == 0) { var_r28 = 1; - } else { + } + else { var_r28 = 2; } Hu3DModelCameraSet(lbl_1_bss_E8[var_r31], var_r28); } fn_1_372C(); - + for (var_r31 = 0; var_r31 < 0x10; var_r31++) { lbl_1_bss_F8[var_r31].unk0 = -1; lbl_1_bss_F8[var_r31].unk2 = Hu3DModelCreateFile(0x3A0012); @@ -245,77 +434,62 @@ void fn_1_32F4(Process* arg0) { } } -void fn_1_372C(void) { - M427DllMapSubstruct* var_r29 = &lbl_1_bss_158.unk3A0[0]; - M427DllMapSubstruct2* var_r30 = &lbl_1_bss_158.unk34C[0]; +void fn_1_372C(void) +{ + M427DllMapSubstruct *var_r29 = &lbl_1_bss_158.unk3A0[0]; + M427DllMapSubstruct2 *var_r30 = &lbl_1_bss_158.unk34C[0]; s16 sp1A[5] = { 0, 0, 1, 1, 0 }; - Vec sp60[5] = { - { -700.0f, -150.0f, -7000.0f }, - { 0.0f, -300.0f, -12000.0f }, - { 800.0f, -350.0f, -12700.0f }, - { 600.0f, -350.0f, -13700.0f }, - { 825.0f, -450.0f, -15000.0f } - }; + Vec sp60[5] = { { -700.0f, -150.0f, -7000.0f }, { 0.0f, -300.0f, -12000.0f }, { 800.0f, -350.0f, -12700.0f }, { 600.0f, -350.0f, -13700.0f }, + { 825.0f, -450.0f, -15000.0f } }; s16 sp8[3] = { 1, 1, 0 }; - s16 spE[3][2] = { { 4, 5 }, { 8, -1 }, { 9, -1 } }; - s16 sp24[3][4] = { - { 180, 120, 60, 60 }, - { 90, 180, 60, 60 }, - { 90, 180, 60, 60 } - }; - Vec sp3C[3] = { - -350.0f, -300.0f, -10000.0f, - -700.0f, -600.0f, -17000.0f, - 700.0f, -600.0f, -19000.0f - }; + s16 spE[3][2] = { { 4, 5 }, { 8, -1 }, { 9, -1 } }; + s16 sp24[3][4] = { { 180, 120, 60, 60 }, { 90, 180, 60, 60 }, { 90, 180, 60, 60 } }; + Vec sp3C[3] = { -350.0f, -300.0f, -10000.0f, -700.0f, -600.0f, -17000.0f, 700.0f, -600.0f, -19000.0f }; s16 var_r28; s16 var_r31; - + for (var_r31 = 0; var_r31 < 5; var_r31++, var_r29++) { var_r29->unk0 = sp1A[var_r31]; var_r29->unk4.x = sp60[var_r31].x; var_r29->unk4.y = sp60[var_r31].y; var_r29->unk4.z = sp60[var_r31].z; } - + for (var_r31 = 0; var_r31 < 3; var_r31++, var_r30++) { var_r30->unk0 = sp8[var_r31]; var_r30->unk4.x = sp3C[var_r31].x; var_r30->unk4.y = sp3C[var_r31].y; var_r30->unk4.z = sp3C[var_r31].z; - var_r30->unk10 = spE[var_r31][0]; - var_r30->unk12 = spE[var_r31][1]; + var_r30->unk10[0] = spE[var_r31][0]; + var_r30->unk10[1] = spE[var_r31][1]; for (var_r28 = 0; var_r28 < 4; var_r28++) { var_r30->unk14[var_r28] = sp24[var_r31][var_r28]; } } } -void fn_1_3A88(void) { - M427DllMapStruct* sp8; +void fn_1_3A88(void) +{ + M427DllMapStruct *sp8; s16 var_r30; - M427DllMapSubstruct3* var_r31; + M427DllMapSubstruct3 *var_r31; sp8 = lbl_1_bss_F0; - HuSprAnimKill(lbl_1_bss_158.unk334); - HuSprAnimKill(lbl_1_bss_158.unk338); - + HuSprAnimKill(lbl_1_bss_158.unk334.unk_00); + HuSprAnimKill(lbl_1_bss_158.unk334.unk_04); + for (var_r30 = 0, var_r31 = &lbl_1_bss_158.unk4[0]; var_r30 < 2; var_r30++, var_r31++) { - if (var_r31->unk98) { - HuMemDirectFree(var_r31->unk98); + if (var_r31->unk94.unk4) { + HuMemDirectFree(var_r31->unk94.unk4); } } } -void fn_1_3B20(s8 arg0, s16 arg1) { - M427DllMapStruct2* var_r31 = &lbl_1_bss_F8[0]; - M427DllMapSubstruct3* temp_r30 = &lbl_1_bss_158.unk4[arg1]; - Vec sp54[4] = { - { 110.0f, -20.0f, 0.0f }, - { -110.0f, -20.0f, 0.0f }, - { 110.0f, -20.0f, 190.0f }, - { -110.0f, -20.0f, 190.0f } - }; +void fn_1_3B20(s8 arg0, s16 arg1) +{ + M427DllMapStruct2 *var_r31 = &lbl_1_bss_F8[0]; + M427DllMapSubstruct3 *temp_r30 = &lbl_1_bss_158.unk4[arg1]; + Vec sp54[4] = { { 110.0f, -20.0f, 0.0f }, { -110.0f, -20.0f, 0.0f }, { 110.0f, -20.0f, 190.0f }, { -110.0f, -20.0f, 190.0f } }; Mtx sp24; f32 sp14[4] = { 135.0f, 225.0f, 45.0f, 315.0f }; Point3d sp8; @@ -324,20 +498,22 @@ void fn_1_3B20(s8 arg0, s16 arg1) { s32 var_r27; for (var_r29 = 0; var_r29 < 0x10; var_r29++, var_r31++) { - if (var_r31->unk0 == -1) break; + if (var_r31->unk0 == -1) + break; } if (var_r29 != 0x10) { var_r31->unk0 = arg0; temp_f31 = temp_r30->unk90; - PSMTXRotRad(sp24, 0x59, MTXDegToRad(temp_f31)); - PSMTXMultVec(sp24, &sp54[arg0], &sp8); + MTXRotRad(sp24, 0x59, MTXDegToRad(temp_f31)); + MTXMultVec(sp24, &sp54[arg0], &sp8); sp8.x += temp_r30->unk84.x; sp8.y += temp_r30->unk84.y; sp8.z += temp_r30->unk84.z; Hu3DModelAttrReset(var_r31->unk2, 1); if (arg1 == 0) { var_r27 = 1; - } else { + } + else { var_r27 = 2; } Hu3DModelCameraSet(var_r31->unk2, var_r27); @@ -346,15 +522,17 @@ void fn_1_3B20(s8 arg0, s16 arg1) { Hu3DMotionTimeSet(var_r31->unk2, 0.0f); if (arg0 < 2) { Hu3DModelAmbSet(var_r31->unk2, 1.0f, 1.0f, 1.0f); - } else { + } + else { Hu3DModelAmbSet(var_r31->unk2, 0.5f, 0.5f, 0.5f); } Hu3DAnimBankSet(var_r31->unk4, 0); } } -void fn_1_3DBC(void) { - M427DllMapStruct2* var_r31; +void fn_1_3DBC(void) +{ + M427DllMapStruct2 *var_r31; s16 var_r30; f32 temp_f31; @@ -370,13 +548,14 @@ void fn_1_3DBC(void) { } } -void fn_1_3E58(omObjData* arg0) { +void fn_1_3E58(omObjData *arg0) +{ s32 sp8[8]; - M427DllMapStruct* var_r26; - M427DllMapSubstruct3* var_r31; - ModelData* temp_r25; + M427DllMapStruct *var_r26; + M427DllMapSubstruct3 *var_r31; + ModelData *temp_r25; s16 var_r30; - M427DllMapStruct4* var_r29; + M427DllMapStruct4 *var_r29; s16 var_r28; s16 var_r27; @@ -388,22 +567,22 @@ void fn_1_3E58(omObjData* arg0) { temp_r25 = &Hu3DData[sp8[var_r30]]; temp_r25->unk_38[4] = temp_r25->unk_38[5] = temp_r25->unk_38[6] = temp_r25->unk_38[7] = -1; } - + for (var_r30 = 0; var_r30 < 2; var_r30++) { for (var_r27 = 0; var_r27 < 2; var_r27++) { - Hu3DModelKill(var_r31->unk180[var_r30][var_r27].unk0); + Hu3DModelKill(var_r31->unk17E[var_r30][var_r27].unk2); } } for (var_r30 = 0; var_r30 < 2; var_r30++) { for (var_r27 = 0; var_r27 < 2; var_r27++) { - Hu3DModelKill(var_r31->unkBA[var_r30][var_r27].unk0); + Hu3DModelKill(var_r31->unkB8[var_r30][var_r27].unk2); } } - HuSprAnimKill(var_r31->unkAC->unk28); + HuSprAnimKill(var_r31->unkAC->unk_28); Hu3DModelKill(var_r31->unk1A); Hu3DModelKill(var_r31->unk1C); - HuMemDirectFree(var_r31->unk98); - var_r31->unk98 = NULL; + HuMemDirectFree(var_r31->unk94.unk4); + var_r31->unk94.unk4 = NULL; fn_1_DB80(lbl_1_bss_EC[var_r28]); fn_1_DB80(lbl_1_bss_E8[var_r28]); @@ -442,13 +621,14 @@ void fn_1_3E58(omObjData* arg0) { arg0->func = fn_1_4218; } -void fn_1_4218(omObjData* arg0) { +void fn_1_4218(omObjData *arg0) +{ f32 var_f31; f32 temp_f30; f32 var_f29; - M427DllMapStruct5* var_r31; + M427DllMapStruct5 *var_r31; s16 var_r30; - M427DllMapStruct4* var_r29; + M427DllMapStruct4 *var_r29; s32 temp_r28; var_r29 = &lbl_1_bss_98; @@ -462,7 +642,7 @@ void fn_1_4218(omObjData* arg0) { fn_1_44F4(var_f31, 0.0f, temp_f30, var_f29, 0.0f); } } - + for (var_r30 = 0; var_r30 < 0x10; var_r30++, var_r31++) { if (-1.0f != var_r31->unk10) { var_r31->unkC += 20.0f; @@ -474,14 +654,16 @@ void fn_1_4218(omObjData* arg0) { } } -void fn_1_44F4(f32 arg0, f32 arg1, f32 arg2, f32 arg3, f32 arg4) { - M427DllMapStruct5* var_r31; +void fn_1_44F4(f32 arg0, f32 arg1, f32 arg2, f32 arg3, f32 arg4) +{ + M427DllMapStruct5 *var_r31; s16 var_r30; var_r31 = &lbl_1_bss_E4[0]; - + for (var_r30 = 0; var_r30 < 0x10; var_r30++, var_r31++) { - if (-1.0f == var_r31->unk10) break; + if (-1.0f == var_r31->unk10) + break; } if (var_r30 != 0x10) { var_r31->unk0 = arg0; @@ -494,18 +676,19 @@ void fn_1_44F4(f32 arg0, f32 arg1, f32 arg2, f32 arg3, f32 arg4) { f32 lbl_1_data_F4 = 450.0f; -f32 fn_1_4570(Vec* arg0) { +f32 fn_1_4570(Vec *arg0) +{ f32 temp_f31; f32 temp_f30; f32 var_f28; f32 var_f27; f32 var_f23; - M427DllMapStruct5* var_r31; + M427DllMapStruct5 *var_r31; s16 var_r30; var_r31 = &lbl_1_bss_E4[0]; var_f27 = 0.0f; - + for (var_r30 = 0; var_r30 < 0x10; var_r30++, var_r31++) { if (-1.0f != var_r31->unk10) { temp_f31 = arg0->x - var_r31->unk0; @@ -527,7 +710,8 @@ f32 fn_1_4570(Vec* arg0) { return var_f27; } -void fn_1_48EC(ModelData* arg0, Mtx arg1) { +void fn_1_48EC(ModelData *arg0, Mtx arg1) +{ Vec sp3C; Vec sp30; Vec sp24; @@ -548,7 +732,7 @@ void fn_1_48EC(ModelData* arg0, Mtx arg1) { CenterM->x = -CenterM->x; CenterM->y = -CenterM->y; CenterM->z = CenterM->z; - CRotM->x = 180.0f + CRotM->x; + CRotM->x = 180.0f + CRotM->x; CRotM->y = 180.0f + -CRotM->y; CRotM->z = CRotM->z; *CZoomM = *CZoomM; @@ -574,7 +758,8 @@ void fn_1_48EC(ModelData* arg0, Mtx arg1) { *CZoomM = temp_f29; } -void fn_1_4D7C(ModelData* arg0, Mtx arg1) { +void fn_1_4D7C(ModelData *arg0, Mtx arg1) +{ Vec sp24; Vec sp18; Vec spC; @@ -602,7 +787,8 @@ void fn_1_4D7C(ModelData* arg0, Mtx arg1) { } } -void fn_1_50A0(ModelData* arg0, Mtx arg1) { +void fn_1_50A0(ModelData *arg0, Mtx arg1) +{ if (lbl_1_bss_98.unk28) { GXSetTexCopySrc(0, 0, 0x280, 0x1E0); GXSetTexCopyDst(0x280, 0x1E0, GX_TF_RGB5A3, 0); @@ -610,20 +796,21 @@ void fn_1_50A0(ModelData* arg0, Mtx arg1) { } } -void fn_1_510C(s32 arg0, s16 arg1, s16 arg2) { +void fn_1_510C(s32 arg0, s16 arg1, s16 arg2) +{ s16 sp12; s16 sp10; s16 spE; s16 spC; s16 spA; s16 sp8; - M427DllMapStruct4* var_r31; - M427DllMapSubstruct5* var_r30; + M427DllMapStruct4 *var_r31; + M427DllMapSubstruct5 *var_r30; s16 var_r29; - ModelData* temp_r28; + ModelData *temp_r28; s16 var_r27; - M427DllMapSubstruct5* var_r26; - M427DllMapSubstruct5* var_r23; + M427DllMapSubstruct5 *var_r26; + M427DllMapSubstruct5 *var_r23; var_r31 = &lbl_1_bss_98; var_r29 = Hu3DHookFuncCreate(fn_1_618C); @@ -657,7 +844,7 @@ void fn_1_510C(s32 arg0, s16 arg1, s16 arg2) { DCFlushRange(var_r26, 0x20000); GXBeginDisplayList(var_r23, 0x20000); GXBegin(GX_QUADS, GX_VTXFMT0, (arg1 * arg2 * 4)); - + for (var_r29 = 0; var_r29 < arg2; var_r29++) { for (var_r27 = 0; var_r27 < arg1; var_r30++, var_r27++) { var_r30->unk0 = var_r27 + var_r29 * var_r31->unk16; @@ -689,7 +876,8 @@ void fn_1_510C(s32 arg0, s16 arg1, s16 arg2) { f32 lbl_1_data_F8 = -1.0f; -void fn_1_558C(M427DllMapStruct4* arg0) { +void fn_1_558C(M427DllMapStruct4 *arg0) +{ Mtx spAC; Mtx sp7C; Mtx sp4C; @@ -703,14 +891,14 @@ void fn_1_558C(M427DllMapStruct4* arg0) { f32 var_f26; f32 var_f25; f32 var_f20; - M427DllMapSubstruct5* var_r30; - Vec* var_r29; - Vec* var_r28; + M427DllMapSubstruct5 *var_r30; + Vec *var_r29; + Vec *var_r28; s16 var_r27; - M427DllMapStruct5* var_r26; - Vec2f* var_r25; + M427DllMapStruct5 *var_r26; + Vec2f *var_r25; s16 var_r24; - CameraData* var_r23; + CameraData *var_r23; s16 var_r22; var_r23 = &Hu3DCamera[0]; @@ -737,12 +925,12 @@ void fn_1_558C(M427DllMapStruct4* arg0) { sp2C.x = sp44.x; sp2C.y = (sp44.y - sp44.x) / (arg0->unk18 - 1); var_f25 = arg0->unk44; - + for (var_r27 = 0; var_r27 < arg0->unk18; var_r27++) { sp34.x = sp3C.x; sp34.y = (sp3C.y - sp3C.x) / (arg0->unk16 - 1); var_f26 = arg0->unk40; - + for (var_r24 = 0; var_r24 < arg0->unk16; var_r28++, var_r29++, var_r24++) { var_r28->x = sp34.x; var_r28->z = sp2C.x; @@ -763,7 +951,7 @@ void fn_1_558C(M427DllMapStruct4* arg0) { } var_r30 = arg0->unk1C; var_r24 = (arg0->unk16 - 1) * (arg0->unk18 - 1); - + for (var_r27 = 0; var_r27 < var_r24; var_r27++, var_r30++) { fn_1_C2C8(&arg0->unk4[var_r30->unk0], &arg0->unk4[var_r30->unk2], &arg0->unk4[var_r30->unk4], &var_r30->unk8); arg0->unkC[var_r30->unk0].x += var_r30->unk8.x; @@ -779,7 +967,7 @@ void fn_1_558C(M427DllMapStruct4* arg0) { arg0->unkC[var_r30->unk6].y += var_r30->unk8.y; arg0->unkC[var_r30->unk6].z += var_r30->unk8.z; } - + var_r29 = arg0->unkC; for (var_r27 = 0; var_r27 < arg0->unk14; var_r27++, var_r29++) { var_f20 = sqrtf((var_r29->x * var_r29->x) + (var_r29->y * var_r29->y) + (var_r29->z * var_r29->z)); @@ -792,7 +980,7 @@ void fn_1_558C(M427DllMapStruct4* arg0) { C_MTXLookAt(spAC, &var_r23->pos, &var_r23->up, &var_r23->target); GXGetProjectionv(&sp7C[0][0]); GXGetViewportv(&sp4C[0][0]); - + for (var_r27 = 0; var_r27 < arg0->unk14; var_r27++, var_r28++, var_r25++) { GXProject(var_r28->x, var_r28->y, var_r28->z, spAC, &sp7C[0][0], &sp4C[0][0], &sp28, &sp24, &sp20); var_r25->x = 0.0015625f * sp28; @@ -811,14 +999,15 @@ void fn_1_558C(M427DllMapStruct4* arg0) { PPCSync(); } -void fn_1_618C(ModelData* arg0, Mtx arg1) { +void fn_1_618C(ModelData *arg0, Mtx arg1) +{ Mtx sp64; Mtx sp34; GXTexObj sp14; GXColor spC; - M427DllMapStruct4* var_r31 = &lbl_1_bss_98; - AnimData** var_r30 = &lbl_1_bss_158.unk334; - + M427DllMapStruct4 *var_r31 = &lbl_1_bss_98; + M427DllMapStruct3Sub *var_r30 = &lbl_1_bss_158.unk334; + fn_1_558C(var_r31); GXLoadPosMtxImm(arg1, 0); GXClearVtxDesc(); @@ -837,7 +1026,7 @@ void fn_1_618C(ModelData* arg0, Mtx arg1) { GXInitTexObj(&sp14, var_r31->unk28, 0x280, 0x1E0, GX_TF_RGB5A3, GX_CLAMP, GX_CLAMP, 0); GXInitTexObjLOD(&sp14, GX_LINEAR, GX_LINEAR, 0.0f, 0.0f, 0.0f, 0, 0, GX_ANISO_1); GXLoadTexObj(&sp14, GX_TEXMAP1); - HuSprTexLoad(*var_r30, 0, 2, GX_REPEAT, GX_REPEAT, GX_LINEAR); + HuSprTexLoad(var_r30->unk_00, 0, 2, GX_REPEAT, GX_REPEAT, GX_LINEAR); GXSetNumTevStages(3); spC.r = 0; spC.g = 0x10; @@ -846,40 +1035,40 @@ void fn_1_618C(ModelData* arg0, Mtx arg1) { GXSetTevColor(GX_TEVREG2, spC); GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR_NULL); GXSetTevColorIn(GX_TEVSTAGE0, GX_CC_ZERO, GX_CC_TEXC, GX_CC_ONE, GX_CC_ZERO); - GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, 1, GX_TEVREG0); + GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVREG0); GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_KONST, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO); - GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, 1, GX_TEVREG0); + GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVREG0); GXSetTevOrder(GX_TEVSTAGE1, GX_TEXCOORD0, GX_TEXMAP1, GX_COLOR0A0); GXSetTevColorIn(GX_TEVSTAGE1, GX_CC_TEXC, GX_CC_C0, GX_CC_A2, GX_CC_ZERO); - GXSetTevColorOp(GX_TEVSTAGE1, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, 1, GX_TEVREG1); + GXSetTevColorOp(GX_TEVSTAGE1, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVREG1); GXSetTevAlphaIn(GX_TEVSTAGE1, GX_CA_KONST, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO); - GXSetTevAlphaOp(GX_TEVSTAGE1, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, 1, GX_TEVREG1); + GXSetTevAlphaOp(GX_TEVSTAGE1, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVREG1); GXSetTevOrder(GX_TEVSTAGE2, GX_TEXCOORD0, GX_TEXMAP1, GX_COLOR0A0); GXSetTevColorIn(GX_TEVSTAGE2, GX_CC_C1, GX_CC_ZERO, GX_CC_ZERO, GX_CC_C2); - GXSetTevColorOp(GX_TEVSTAGE2, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, 1, GX_TEVPREV); + GXSetTevColorOp(GX_TEVSTAGE2, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV); GXSetTevAlphaIn(GX_TEVSTAGE2, GX_CA_KONST, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO); - GXSetTevAlphaOp(GX_TEVSTAGE2, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, 1, GX_TEVPREV); + GXSetTevAlphaOp(GX_TEVSTAGE2, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV); GXSetNumIndStages(1); GXSetIndTexOrder(GX_INDTEXSTAGE0, GX_TEXCOORD1, GX_TEXMAP2); GXSetTevIndWarp(GX_TEVSTAGE0, GX_INDTEXSTAGE0, 1, 0, GX_ITM_0); GXSetIndTexCoordScale(GX_INDTEXSTAGE0, GX_ITS_1, GX_ITS_1); - PSMTXScale(sp64, -0.1f, 0.0f, 1.0f); + MTXScale(sp64, -0.1f, 0.0f, 1.0f); GXSetIndTexMtx(GX_ITM_0, (f32(*)[3])(sp64), 0); GXSetNumTexGens(2); if (omPauseChk() == 0) { var_r31->unk38 += 0.001f; var_r31->unk3C += 0.0005f; } - PSMTXRotRad(sp64, 0x58, 1.5707964f); - PSMTXScale(sp34, 0.001f, 0.001f, 0.001f); - PSMTXConcat(sp64, sp34, sp64); + MTXRotRad(sp64, 0x58, 1.5707964f); + MTXScale(sp34, 0.001f, 0.001f, 0.001f); + MTXConcat(sp64, sp34, sp64); mtxTransCat(sp64, var_r31->unk38, var_r31->unk3C, 0.0f); GXLoadTexMtxImm(sp64, 0x1E, GX_MTX2x4); - GXSetTexCoordGen2(GX_TEXCOORD0, GX_TG_MTX2x4, GX_TG_TEX0, 0x3C, 0, 0x7D); - GXSetTexCoordGen2(GX_TEXCOORD1, GX_TG_MTX2x4, GX_TG_POS, 0x1E, 0, 0x7D); + GXSetTexCoordGen2(GX_TEXCOORD0, GX_TG_MTX2x4, GX_TG_TEX0, 0x3C, GX_FALSE, 0x7D); + GXSetTexCoordGen2(GX_TEXCOORD1, GX_TG_MTX2x4, GX_TG_POS, 0x1E, GX_FALSE, 0x7D); GXSetNumChans(1); GXSetChanCtrl(GX_COLOR0A0, 0, GX_SRC_REG, GX_SRC_VTX, 0, GX_DF_CLAMP, GX_AF_NONE); - GXSetZMode(1, GX_LEQUAL, 1); + GXSetZMode(GX_TRUE, GX_LEQUAL, GX_TRUE); GXSetAlphaCompare(GX_GEQUAL, 1, GX_AOP_AND, GX_GEQUAL, 1); GXSetZCompLoc(0); GXSetBlendMode(GX_BM_NONE, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_NOOP); @@ -888,3 +1077,2081 @@ void fn_1_618C(ModelData* arg0, Mtx arg1) { GXSetTevDirect(GX_TEVSTAGE0); GXSetTevDirect(GX_TEVSTAGE1); } + +s32 lbl_1_data_FC[0xC] = { + 0x3A0000, + 0x3A0001, + 0x3A0002, + 0x3A0003, + 0x3A0004, + 0x3A0005, + 0x3A0006, + 0x3A0007, + 0x3A0008, + 0x3A0009, + 0x3A000A, + 0x3A000B, +}; +s32 lbl_1_data_12C[2] = { 0x3A000C, 0x3A000D }; +s32 lbl_1_data_134[4] = { 0x3A000E, 0x3A000F, 0x3F800000, 0x01000000 }; + +void fn_1_6760(omObjData *object) +{ + s16 sp14[2][0x20]; + s16 sp10[2]; + s16 spC[2]; + s16 sp8[2]; + M427DllMapSubstruct3 *var_r31; + s16 var_r30; + M427DllMapUNKB8 *var_r29; + s16 var_r28; + M427DllMapUNK17E *var_r27; + s16 var_r26; + M427DllMapSubstruct3Sub *var_r25; + M427DllMapStruct3 *var_r24; + u16 var_r23; + + var_r24 = &lbl_1_bss_158; + Hu3DFogSet(3500.0f, 20000.0f, 0, 0, 0); + for (var_r28 = 0, var_r31 = &var_r24->unk4[0]; var_r28 < 2; var_r28++, var_r31++) { + var_r31->unk0 = var_r28; + sp10[var_r28] = 0; + for (var_r30 = 0; var_r30 < 3; var_r30++) { + var_r31->unk178[var_r30] = 0; + } + for (var_r30 = 0; var_r30 < 0xB; var_r30++) { + var_r31->unk2[var_r30] = Hu3DModelCreateFile(lbl_1_data_FC[var_r30]); + var_r31->unk44[var_r30] = -1; + if (var_r30 < 0xA) { + Hu3DModelLayerSet(var_r31->unk2[var_r30], 2); + } + else { + Hu3DModelLayerSet(var_r31->unk2[var_r30], 5); + } + Hu3DModelAmbSet(var_r31->unk2[var_r30], 0.1f, 0.1f, 0.1f); + if (var_r28 == 0) { + Hu3DModelCameraSet(var_r31->unk2[var_r30], 1); + } + else { + Hu3DModelCameraSet(var_r31->unk2[var_r30], 2); + } + sp14[var_r28][sp10[var_r28]++] = var_r31->unk2[var_r30]; + } + var_r30 = Hu3DHookFuncCreate(fn_1_C154); + var_r31->unk1E = var_r30; + Hu3DModelLayerSet(var_r30, 4); + if (var_r28 == 0) { + Hu3DModelCameraSet(var_r30, 1); + } + else { + Hu3DModelCameraSet(var_r30, 2); + } + var_r30 = Hu3DHookFuncCreate(fn_1_C200); + var_r31->unk20 = var_r30; + Hu3DModelLayerSet(var_r30, 6); + if (var_r28 == 0) { + Hu3DModelCameraSet(var_r30, 1); + } + else { + Hu3DModelCameraSet(var_r30, 2); + } + for (var_r30 = 0; var_r30 < 2; var_r30++) { + var_r29 = var_r31->unkB8[var_r30]; + for (var_r26 = 0; var_r26 < 2; var_r26++, var_r29++) { + if ((var_r28 == 0) && (var_r26 == 0)) { + var_r29->unk2 = spC[var_r30] = Hu3DModelCreateFile(lbl_1_data_134[var_r30]); + } + else { + var_r29->unk2 = Hu3DModelLink(spC[var_r30]); + } + Hu3DModelAttrSet(var_r29->unk2, HU3D_ATTR_DISPOFF); + Hu3DModelLayerSet(var_r29->unk2, 2); + Hu3DModelAmbSet(var_r29->unk2, 0.0f, 0.0f, 0.0f); + if (var_r28 == 0) { + Hu3DModelCameraSet(var_r29->unk2, 1); + } + else { + Hu3DModelCameraSet(var_r29->unk2, 2); + } + sp14[var_r28][sp10[var_r28]++] = var_r29->unk2; + var_r29->unk6 = fn_1_95E8(0x3A0018, var_r28, 0, 0.0f, -400.0f, 700.0f, 800.0f, -5.0f); + fn_1_9958(var_r29->unk6, 1); + fn_1_99E4(var_r29->unk6, 0xFF, 0xFF, 0xFF, 0); + var_r29->unk4 = 2 * var_r30 + 4 + var_r26; + fn_1_C528(var_r29->unk2, var_r29->unk4, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0xFF, 0xA0, 0x60); + Hu3DLLightStaticSet(var_r29->unk2, var_r29->unk4, 1); + Hu3DLLightPointSet(var_r29->unk2, var_r29->unk4, 1.0f, 0.6f, 3); + } + } + for (var_r30 = 0; var_r30 < 2; var_r30++) { + var_r27 = var_r31->unk17E[var_r30]; + for (var_r26 = 0; var_r26 < 2; var_r26++, var_r27++) { + if ((var_r28 == 0) && (var_r26 == 0)) { + var_r27->unk2 = sp8[var_r30] = Hu3DModelCreateFile(lbl_1_data_12C[var_r30]); + } + else { + var_r27->unk2 = Hu3DModelLink(sp8[var_r30]); + } + Hu3DModelAttrSet(var_r27->unk2, HU3D_ATTR_DISPOFF); + Hu3DModelLayerSet(var_r27->unk2, 2); + Hu3DModelAmbSet(var_r27->unk2, 0.0f, 0.0f, 0.0f); + if (var_r28 == 0) { + Hu3DModelCameraSet(var_r27->unk2, 1); + } + else { + Hu3DModelCameraSet(var_r27->unk2, 2); + } + sp14[var_r28][sp10[var_r28]++] = var_r27->unk2; + } + } + for (var_r30 = 0; var_r30 < 4; var_r30++) { + var_r31->unk34[var_r30] = fn_1_C41C(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0xFF, 0xFF, 0xFF); + var_r31->unk24[var_r30] = -1.0f; + } + } + for (var_r28 = 0, var_r31 = var_r24->unk4; var_r28 < 2; var_r28++, var_r31++) { + var_r31->unk5C = Hu3DLLightCreate(var_r31->unk2[0], 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0xFA, 0xF0, 0xD2); + Hu3DLLightSpotSet(var_r31->unk2[0], var_r31->unk5C, 37.5f, 4); + Hu3DLLightStaticSet(var_r31->unk2[0], var_r31->unk5C, 1); + var_r31->unk78.x = 0.0f; + var_r31->unk78.y = 0.0f; + var_r31->unk78.z = 0.0f; + var_r31->unk84.x = 0.0f; + var_r31->unk84.y = 0.0f; + var_r31->unk84.z = 0.0f; + var_r31->unk90 = 0.0f; + } + fn_1_93EC(0x3A0016, 0x3A0014, 2000.0f, 6000.0f, 4.0f, 9.0f); + for (var_r28 = 0, var_r31 = var_r24->unk4; var_r28 < 2; var_r28++, var_r31++) { + var_r31->unkB0[0] = fn_1_95E8(0x3A0015, var_r28, 0.0f, 0.0f, -900.0f, 500.0f, 700.0f, -10.0f); + var_r25 = &var_r31->unk94; + var_r25->unk0 = var_r28; + var_r25->unk8 = GXGetTexBufferSize(0x140, 0x1E0, 5, 0, 0); + var_r25->unk4 = HuMemDirectMalloc(HEAP_DATA, var_r25->unk8); + var_r30 = Hu3DHookFuncCreate(fn_1_A148); + var_r31->unk1C = var_r30; + Hu3DModelCameraSet(var_r30, var_r28 ? 2 : 1); + Hu3DModelLayerSet(var_r30, 1); + Hu3DData[var_r30].unk_120 = var_r25; + var_r31->unk1A = fn_1_A1F4(0x3A0013, 0xA, 0x1E, var_r28, 6000.0f, lbl_1_bss_554, lbl_1_bss_558); + fn_1_C528(var_r31->unk1A, 1, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0xC8, 0xF0, 0xA0); + Hu3DLLightStaticSet(var_r31->unk1A, 1, 1); + Hu3DLLightPointSet(var_r31->unk1A, 1, 125.0f, 0.5f, 3); + fn_1_C528(var_r31->unk1A, 2, 0.0f, -500.0f, -23500.0f, 0.0f, 0.0f, 0.0f, 0xFA, 0xF0, 0xD2); + Hu3DLLightStaticSet(var_r31->unk1A, 2, 1); + Hu3DLLightPointSet(var_r31->unk1A, 2, 800.0f, 0.5f, 3); + sp14[var_r28][sp10[var_r28]++] = var_r31->unk1A; + fn_1_9318(sp14[var_r28], sp10[var_r28]); + } + object->func = fn_1_72E4; +} + +void fn_1_72E4(omObjData *object) +{ + float var_f31; + M427DllMapStruct2 *var_r31; + s16 var_r30; + + if (fn_1_1788() == 7) { + object->func = fn_1_3E58; + } + fn_1_73BC(); + fn_1_7C34(); + fn_1_7F38(); + fn_1_8F90(object); + fn_1_9240(); + for (var_r31 = lbl_1_bss_F8, var_r30 = 0; var_r30 < 0x10; var_r30++, var_r31++) { + if (var_r31->unk0 != -1) { + var_f31 = Hu3DMotionMaxTimeGet(var_r31->unk2); + if (Hu3DMotionTimeGet(var_r31->unk2) >= var_f31) { + var_r31->unk0 = -1; + Hu3DModelAttrSet(var_r31->unk2, HU3D_ATTR_DISPOFF); + } + } + } +} + +void fn_1_73BC(void) +{ + float var_f31; + M427DllMapSubstruct3 *var_r31; + M427DllMapSubstruct6 *var_r30; + s16 var_r29; + ModelData *var_r28; + s16 var_r27; + + for (var_r27 = 0, var_r31 = lbl_1_bss_158.unk4; var_r27 < 2; var_r27++, var_r31++) { + for (var_r29 = 0; var_r29 < 0xA; var_r29++) { + var_r28 = &Hu3DData[var_r31->unk2[var_r29]]; + var_r30 = fn_1_DC0C(lbl_1_bss_E8[var_r31->unk0], var_r31->unk3C[var_r31->unk44[var_r29]]); + var_f31 = -2000.0f * var_r29; + if (((var_r31->unk84.z - 25000.0f) < var_f31) && ((3000.0f + var_r31->unk84.z) > var_f31)) { + if (var_r31->unk44[var_r29] == -1) { + fn_1_794C(var_r31, var_r29); + var_r28->attr &= 0xFFFFFFFE; + } + else { + if (var_r30) { + var_r30->unk_24 += 5.0f; + if (var_r30->unk_24 >= 360.0f) { + var_r30->unk_24 -= 360.0f; + } + var_r30->unk_48.x = var_r30->unk_48.y = var_r30->unk_48.z = 1.0 + (0.05000000074505806 * sind(var_r30->unk_24)); + } + var_r31->unk24[var_r31->unk44[var_r29]] += 5.0f; + if (var_r31->unk24[var_r31->unk44[var_r29]] >= 360.0f) { + var_r31->unk24[var_r31->unk44[var_r29]] -= 360.0f; + } + var_f31 = 50.0 * sind(var_r31->unk24[var_r31->unk44[var_r29]]); + var_f31 = var_f31; + Hu3DLLightPointSet(var_r31->unk2[var_r29], 1, 400.0f + var_f31, 0.5f, 3); + if (var_r29 == 0) { + var_r30 = fn_1_DC0C(lbl_1_bss_E8[var_r31->unk0], var_r31->unk5A); + if (var_r30->unk_24 >= 360.0f) { + var_r30->unk_24 -= 360.0f; + } + var_r30->unk_48.x = var_r30->unk_48.y = var_r30->unk_48.z = 1.0 + (0.05000000074505806 * sind(var_r30->unk_24)); + var_r31->unk24[1] += 5.0f; + if (var_r31->unk24[1] >= 360.0f) { + var_r31->unk24[1] -= 360.0f; + } + var_f31 = 50.0 * sind(var_r31->unk24[1]); + var_f31 = var_f31; + Hu3DLLightPointSet(var_r31->unk2[var_r29], 2, 400.0f + var_f31, 0.5f, 3); + } + } + } + else { + if (var_r31->unk44[var_r29] != -1) { + if (var_r30) { + var_r30->unk_62 = 0; + } + var_r28->unk_38[1] = -1; + var_r31->unk24[var_r31->unk44[var_r29]] = -1.0f; + var_r31->unk44[var_r29] = -1; + if (var_r29 == 0) { + var_r30 = fn_1_DC0C(lbl_1_bss_E8[var_r31->unk0], var_r31->unk5A); + var_r30->unk_62 = 0; + var_r28->unk_38[2] = -1; + var_r31->unk24[1] = -1.0f; + } + } + var_r28->attr |= 1; + } + } + } +} + +Vec lbl_1_data_144[0xC] = { + { -670.0f, 400.0f, 1750.0f }, + { 930.0f, 400.0f, -1000.0f }, + { -930.0f, 400.0f, -3000.0f }, + { 230.0f, 400.0f, -5000.0f }, + { -1630.0f, 300.0f, -7000.0f }, + { 530.0f, 100.0f, -9000.0f }, + { -530.0f, 100.0f, -11000.0f }, + { 1630.0f, 100.0f, -13000.0f }, + { -230.0f, 0.0f, -15000.0f }, + { 930.0f, -200.0f, -17000.0f }, + { -930.0f, -200.0f, -19000.0f }, + { 930.0f, -200.0f, -21000.0f }, +}; + +void fn_1_794C(M427DllMapSubstruct3 *arg0, s16 arg1) +{ + Vec sp14; + s16 var_r30; + ModelData *var_r28; + + var_r28 = &Hu3DData[arg0->unk2[arg1]]; + { + Vec sp8 = { 0.0f, 0.0f, 0.0f }; + if (arg1 != 0xA) { + for (var_r30 = 0; var_r30 < 4; var_r30++) { + if (arg0->unk24[var_r30] == -1.0f) { + break; + } + } + if (var_r30 != 4) { + var_r28->unk_38[1] = arg0->unk34[var_r30]; + arg0->unk24[var_r30] = 0.0f; + arg0->unk44[arg1] = var_r30; + if (var_r28->unk_38[1] != -1) { + sp14.x = lbl_1_data_144[arg1 + 1].x; + sp14.y = lbl_1_data_144[arg1 + 1].y; + sp14.z = lbl_1_data_144[arg1 + 1].z; + Hu3DLLightPointSet(arg0->unk2[arg1], 1, 400.0f, 0.5f, 3); + Hu3DLLightPosSetV(arg0->unk2[arg1], 1, &sp14, &sp8); + } + arg0->unk3C[var_r30] = fn_1_D430(sp14.x, sp14.y, sp14.z, lbl_1_bss_E8[arg0->unk0]); + if (arg1 == 0) { + var_r30 = 1; + var_r28->unk_38[2] = arg0->unk34[var_r30]; + arg0->unk24[var_r30] = 0.0f; + sp14.x = lbl_1_data_144[0].x; + sp14.y = lbl_1_data_144[0].y; + sp14.z = lbl_1_data_144[0].z; + Hu3DLLightPointSet(arg0->unk2[0], 2, 400.0f, 0.5f, 3); + Hu3DLLightPosSetV(arg0->unk2[0], 2, &sp14, &sp8); + arg0->unk5A = fn_1_D430(sp14.x, sp14.y, sp14.z, lbl_1_bss_E8[arg0->unk0]); + } + } + } + } +} + +float lbl_1_data_1D4[2] = { 50.0f, 80.0f }; + +void fn_1_7C34(void) +{ + Vec sp14; + M427DllMapSubstruct3 *var_r31; + ModelData *var_r30; + s16 var_r29; + s16 var_r28; + M427DllMapUNK17E *var_r27; + M427DllMapSubstruct *var_r26; + s16 var_r25; + + for (var_r26 = lbl_1_bss_158.unk3A0, var_r29 = 0; var_r29 < 5; var_r29++, var_r26++) { + for (var_r28 = 0, var_r31 = lbl_1_bss_158.unk4; var_r28 < 2; var_r28++, var_r31++) { + if ((var_r31->unk18E[var_r29] == 0) && ((var_r31->unk84.z - 7000.0f) < var_r26->unk4.z) + && ((1000.0f + var_r31->unk84.z) > var_r26->unk4.z)) { + fn_1_7E60(var_r29, var_r31); + } + } + } + for (var_r29 = 0, var_r31 = lbl_1_bss_158.unk4; var_r29 < 2; var_r29++, var_r31++) { + for (var_r28 = 0; var_r28 < 2; var_r28++) { + var_r27 = var_r31->unk17E[var_r28]; + for (var_r25 = 0; var_r25 < 2; var_r25++, var_r27++) { + var_r30 = &Hu3DData[var_r27->unk2]; + if ((var_r30->attr & 1) == 0) { + if (((var_r31->unk84.z - 7000.0f) > var_r30->pos.z) || ((1000.0f + var_r31->unk84.z) < var_r30->pos.z)) { + var_r30->attr |= 1; + var_r31->unk18E[var_r27->unk0] = 0; + } + else { + sp14.x = var_r30->pos.x; + sp14.z = var_r30->pos.z; + fn_1_15FD0(sp14, lbl_1_data_1D4[var_r28], 0, 1, var_r31->unk0); + } + } + } + } + } +} + +void fn_1_7E60(s16 arg0, M427DllMapSubstruct3 *arg1) +{ + M427DllMapUNK17E *var_r31; + M427DllMapSubstruct *var_r30; + s16 var_r29; + ModelData *var_r28; + + var_r30 = &lbl_1_bss_158.unk3A0[arg0]; + var_r31 = arg1->unk17E[var_r30->unk0]; + for (var_r29 = 0; var_r29 < 2; var_r29++, var_r31++) { + var_r28 = &Hu3DData[var_r31->unk2]; + if ((var_r28->attr & 1) != 0) { + Hu3DModelAttrReset(var_r31->unk2, HU3D_ATTR_DISPOFF); + Hu3DModelPosSet(var_r31->unk2, var_r30->unk4.x, var_r30->unk4.y, var_r30->unk4.z); + var_r31->unk0 = arg0; + arg1->unk18E[arg0] = 1; + return; + } + } +} + +void fn_1_7F38(void) +{ + Vec sp14; + float var_f31; + M427DllMapUNKB8 *var_r31; + M427DllMapSubstruct3 *var_r30; + ModelData *var_r29; + s16 var_r28; + s16 var_r27; + M427DllMapSubstruct2 *var_r26; + s16 var_r25; + s32 var_r24; + s32 var_r23; + + for (var_r26 = lbl_1_bss_158.unk34C, var_r27 = 0; var_r27 < 3; var_r27++, var_r26++) { + for (var_r28 = 0, var_r30 = lbl_1_bss_158.unk4; var_r28 < 2; var_r28++, var_r30++) { + if ((var_r30->unk178[var_r27] == 0) && ((var_r30->unk84.z - 7000.0f) < var_r26->unk4.z) + && ((1000.0f + var_r30->unk84.z) > var_r26->unk4.z)) { + fn_1_85D4(var_r27, var_r30); + } + } + } + for (var_r27 = 0, var_r30 = lbl_1_bss_158.unk4; var_r27 < 2; var_r27++, var_r30++) { + for (var_r28 = 0; var_r28 < 2; var_r28++) { + var_r31 = var_r30->unkB8[var_r28]; + for (var_r25 = 0; var_r25 < 2; var_r25++, var_r31++) { + var_r29 = &Hu3DData[var_r31->unk2]; + if ((var_r29->attr & 1) == 0) { + if (((var_r30->unk84.z - 7000.0f) > var_r29->pos.z) || ((1000.0f + var_r30->unk84.z) < var_r29->pos.z)) { + if (var_r31->unk8 == 0) { + fn_1_8E1C(1, var_r30, var_r31); + fn_1_9958(var_r31->unk6, 1); + var_r29->attr |= 1; + var_r31->unk8 = 0x63; + var_r30->unk178[var_r31->unk0] = 0; + } + else if (var_r31->unk8 != 2) { + var_r31->unkA = 0; + var_r31->unk8 = 2; + } + } + switch (var_r31->unk8) { + case 0: + if (++var_r31->unkA > var_r31->unk18) { + var_r31->unkA = 0; + var_r31->unkC = 0.0f; + var_r31->unk20 = ((rand8() << 8) | rand8()) % 361; + var_r31->unk24 = ((rand8() << 8) | rand8()) % 361; + var_r31->unk28 = 1.0f; + var_r31->unk2C = 0.0f; + var_r31->unk8++; + } + break; + case 1: + if (++var_r31->unkA > var_r31->unk1E) { + var_r31->unkA = 0; + var_r31->unk8++; + if (fn_1_1788() <= 4) { + if (var_r27 == 0) { + var_r24 = HuAudFXPlay(0x65A); + } + else { + var_r24 = HuAudFXPlay(0x65B); + } + var_r23 = var_r27 * 4 + var_r28 * 2 + var_r25; + lbl_1_bss_0[var_r23].unk0 = var_r24; + lbl_1_bss_0[var_r23].unk4 = 0x78; + } + } + var_r31->unk_14 = 0.1f; + fn_1_8768(var_r30, var_r31, var_r28, 0.2f, var_r31->unk_14); + break; + case 2: + if (++var_r31->unkA > var_r31->unk1A) { + var_r31->unkA = 0; + var_r31->unk8++; + } + if (var_r31->unk_14 < 1.0f) { + var_r31->unk_14 += 0.05f; + } + if (var_r31->unk_14 > 1.0f) { + var_r31->unk_14 = 1.0f; + } + var_r31->unk_10 += 40.0f; + var_r31->unkC += 0.05f; + fn_1_8768(var_r30, var_r31, var_r28, 1.0f, var_r31->unk_14); + break; + case 3: + var_r31->unkA++; + var_f31 = 1.0f - ((float)var_r31->unkA / var_r31->unk1C); + if (var_r31->unkA > var_r31->unk1C) { + var_r31->unkA = 0; + var_f31 = 0.0f; + var_r31->unk8 = 0; + } + var_r31->unk_10 = 400.0 * sind((90.0f * var_f31)); + var_r31->unkC = 1.2f * var_f31; + var_r31->unk_14 = var_f31; + fn_1_8768(var_r30, var_r31, var_r28, var_f31, var_r31->unk_14); + break; + } + sp14.x = var_r29->pos.x; + sp14.z = var_r29->pos.z; + fn_1_15FD0(sp14, 50.0f, 0, 1, var_r30->unk0); + } + } + } + } +} + +void fn_1_85D4(s16 arg0, M427DllMapSubstruct3 *arg1) +{ + float var_f31; + M427DllMapUNKB8 *var_r31; + M427DllMapSubstruct2 *var_r30; + s16 var_r29; + ModelData *var_r27; + + var_r30 = &lbl_1_bss_158.unk34C[arg0]; + var_r31 = arg1->unkB8[var_r30->unk0]; + for (var_r29 = 0; var_r29 < 2; var_r29++, var_r31++) { + var_r27 = &Hu3DData[var_r31->unk2]; + if ((var_r27->attr & 1) != 0) { + Hu3DModelAttrReset(var_r31->unk2, HU3D_ATTR_DISPOFF); + Hu3DModelPosSet(var_r31->unk2, var_r30->unk4.x, var_r30->unk4.y, var_r30->unk4.z); + var_r31->unk8 = 0; + var_r31->unkA = 0; + var_r31->unk18 = var_r30->unk14[0]; + var_r31->unk1A = var_r30->unk14[1]; + var_r31->unk1C = var_r30->unk14[2]; + var_r31->unk1E = var_r30->unk14[3]; + var_r31->unk0 = arg0; + arg1->unk178[arg0] = 1; + fn_1_9A2C(var_r31->unk6, var_r30->unk4.x, var_r30->unk4.y, var_r30->unk4.z); + if (var_r30->unk0 == 0) { + var_f31 = 90.0f; + } + else { + var_f31 = 270.0f; + } + fn_1_9B14(var_r31->unk6, 0.0f, var_f31, 0.0f); + fn_1_999C(var_r31->unk6, 1); + fn_1_8E1C(0, arg1, var_r31); + return; + } + } +} + +float lbl_1_data_1DC[2] = { -1.0f, 1.0f }; +float lbl_1_data_1E4[2] = { 270.0f, 90.0f }; + +void fn_1_8768(M427DllMapSubstruct3 *var_r28, M427DllMapUNKB8 *var_r31, s16 var_r27, float var_f28, float var_f29) +{ + Vec sp50; + Vec sp44; + Vec sp38; + Vec sp2C; + Vec sp20; + float var_f31; + float var_f30; + ModelData *var_r30; + M427DllMapStruct *var_r29; + + var_r30 = &Hu3DData[var_r31->unk2]; + var_f31 = var_f28 * var_r31->unk28; + sp50.x = var_r30->pos.x + (60.0f * lbl_1_data_1DC[var_r27]); + sp50.y = 80.0f + var_r30->pos.y; + sp50.z = var_r30->pos.z; + if (var_r31->unk8 == 1) { + fn_1_C76C(0, sp50.x, sp50.y, sp50.z, 1, lbl_1_data_1E4[var_r27], var_f31, lbl_1_bss_EC[var_r28->unk0]); + return; + } + fn_1_C76C(1, sp50.x, sp50.y, sp50.z, 1, lbl_1_data_1E4[var_r27], var_f31, lbl_1_bss_EC[var_r28->unk0]); + if (var_r31->unk_10 > (400.0f * var_r31->unk28)) { + var_r31->unk_10 = 400.0f * var_r31->unk28; + } + else if (var_r31->unk_10 < 1.0f) { + var_r31->unk_10 = 1.0f; + } + var_r31->unk2C += 30.0f; + if (var_r31->unk2C >= 360.0f) { + var_r31->unk2C -= 360.0f; + } + sp50.x = var_r30->pos.x + (240.0f * lbl_1_data_1DC[var_r27]); + sp50.y = 100.0f + var_r30->pos.y; + sp50.z = var_r30->pos.z; + sp44.x = sp44.y = sp44.z = 0.0f; + var_f30 = var_r31->unk_10 + (var_f28 * (50.0 * sind(var_r31->unk2C))); + Hu3DLLightPointSet(var_r31->unk2, var_r31->unk4, var_f30, 0.5f, 3); + Hu3DLLightPosSetV(var_r31->unk2, var_r31->unk4, &sp50, &sp44); + var_r29 = &lbl_1_bss_F0[var_r31->unk6]; + var_r29->unk90 -= 0.0005f; + var_r29->unk8C += 0.005f; + var_r29->unk94 += 0.001f; + if (var_r31->unkC > 1.0f) { + var_r31->unkC = 1.0f; + } + else if (var_r31->unkC < 0.0f) { + var_r31->unkC = 0.0f; + } + fn_1_99E4(var_r31->unk6, 0xFF, 0xA0, 0x60, 255.0f * var_r31->unkC); + var_r31->unk20 += 2.0f; + var_r31->unk24 += (((rand8() << 8) | rand8()) % 5) + 4; + if (var_r31->unk20 >= 360.0f) { + var_r31->unk20 -= 360.0f; + } + if (var_r31->unk24 >= 360.0f) { + var_r31->unk24 -= 360.0f; + } + sp38.x = 1.0 + (0.009999999776482582 * sind(var_r31->unk24)); + sp38.z = var_r31->unk28 + (0.009999999776482582 * sind(var_r31->unk20)); + fn_1_9AA0(var_r31->unk6, sp38.x, 1.0f, sp38.z); + if (var_r27 == 0) { + sp2C.x = var_r30->pos.x - (700.0f * var_f31 * var_f29); + sp20.x = var_r30->pos.x - 50.0f; + } + else { + sp2C.x = 50.0f + var_r30->pos.x; + sp20.x = var_r30->pos.x + (700.0f * var_f31 * var_f29); + } + sp2C.z = var_r30->pos.z - 30.0f; + sp20.z = 30.0f + var_r30->pos.z; + fn_1_15F10(sp2C, sp20, 1, 1, var_r28->unk0); +} + +void fn_1_8E1C(u8 arg0, M427DllMapSubstruct3 *arg1, M427DllMapUNKB8 *arg2) +{ + s32 spC[8]; + s16 var_r30; + ModelData *var_r29; + M427DllMapSubstruct2 *var_r27; + s16 var_r26; + ModelData *var_r25; + s16 var_r24; + + var_r27 = &lbl_1_bss_158.unk34C[arg2->unk0]; + var_r25 = &Hu3DData[arg2->unk2]; + if (arg0 == 0) { + var_r26 = var_r25->unk_38[arg2->unk4]; + } + else { + var_r26 = -1; + } + var_r24 = fn_1_10FE8(arg1->unk0, spC); + for (var_r30 = 0; var_r30 < var_r24; var_r30++) { + var_r29 = &Hu3DData[spC[var_r30]]; + var_r29->unk_38[arg2->unk4] = var_r26; + } + var_r29 = &Hu3DData[arg1->unk1A]; + var_r29->unk_38[arg2->unk4] = var_r26; + for (var_r30 = 0; var_r30 < 2; var_r30++) { + if (var_r27->unk10[var_r30] != -1) { + var_r29 = &Hu3DData[arg1->unk2[var_r27->unk10[var_r30]]]; + var_r29->unk_38[arg2->unk4] = var_r26; + } + } +} + +void fn_1_8F90(omObjData *object) +{ + Vec sp14; + Vec sp8; + float var_f31; + float var_f30; + M427DllMapSubstruct3 *var_r31; + s16 var_r30; + M427DllMapStruct3 *var_r29; + + var_r29 = &lbl_1_bss_158; + for (var_r30 = 0, var_r31 = var_r29->unk4; var_r30 < 2; var_r30++, var_r31++) { + var_f31 = sind(var_r31->unk90); + var_f30 = cosd(var_r31->unk90); + var_r31->unk_60.x = var_r31->unk84.x - (25.0f * var_f31); + var_r31->unk_60.y = 100.0f + var_r31->unk84.y; + var_r31->unk_60.z = var_r31->unk84.z - (25.0f * var_f30); + var_r31->unk_6C.x = var_r31->unk_60.x - (50.0f * var_f31); + var_r31->unk_6C.y = var_r31->unk_60.y; + var_r31->unk_6C.z = var_r31->unk_60.z - (50.0f * var_f30); + Hu3DLLightPosSet(var_r31->unk2[0], var_r31->unk5C, var_r31->unk_60.x, var_r31->unk_60.y, var_r31->unk_60.z, 0.0f, 0.0f, 0.0f); + Hu3DLLightPosAimSetV(var_r31->unk2[0], var_r31->unk5C, &var_r31->unk_60, &var_r31->unk_6C); + fn_1_9A2C(var_r31->unkB0[0], var_r31->unk84.x, var_r31->unk84.y, var_r31->unk84.z); + fn_1_9B14(var_r31->unkB0[0], 0.0f, var_r31->unk90, 0.0f); + sp14.x = var_r31->unk84.x; + sp14.y = 100.0f + var_r31->unk84.y; + sp14.z = 50.0f + var_r31->unk84.z; + sp8.x = sp8.y = sp8.z = 0.0f; + Hu3DLLightPosSetV(var_r31->unk1A, 1, &sp14, &sp8); + } +} + +void fn_1_91E0(s16 arg0, float arg8, float arg9, float argA, float argB) +{ + M427DllMapSubstruct3 *var_r31; + + var_r31 = &lbl_1_bss_158.unk4[arg0]; + var_r31->unk84.x = arg8; + var_r31->unk84.y = arg9; + var_r31->unk84.z = argA; + var_r31->unk90 = argB; + if (var_r31->unkAC) { + var_r31->unkAC->unk_0C = 1500.0f + argA; + } +} + +void fn_1_9240(void) +{ + M427DllMapStruct *var_r31; + M427DllMapSubstruct3 *var_r30; + s16 var_r29; + s16 var_r28; + + for (var_r30 = lbl_1_bss_158.unk4, var_r28 = 0; var_r28 < 2; var_r28++, var_r30++) { + for (var_r29 = 0; var_r29 < 1; var_r29++) { + var_r31 = &lbl_1_bss_F0[var_r30->unkB0[var_r29]]; + var_r31->unk90 -= 0.0005f; + var_r31->unk8C += 0.0005f; + var_r31->unk94 += 0.0005f; + } + } +} + +void fn_1_9318(s16 *arg0, s16 arg1) +{ + s16 var_r31; + ModelData *var_r30; + ModelData *var_r29; + s16 var_r28; + + var_r30 = &Hu3DData[*arg0]; + for (var_r28 = 1; var_r28 < arg1; var_r28++) { + var_r29 = &Hu3DData[arg0[var_r28]]; + for (var_r31 = 0; var_r31 < 8; var_r31++) { + if (var_r30->unk_38[var_r31] != -1) { + var_r29->unk_38[var_r31] = var_r30->unk_38[var_r31]; + } + } + var_r29->attr |= 0x1000; + } +} + +void fn_1_93EC(s32 sp8, s32 spC, float var_f30, float var_f31, float sp10, float sp14) +{ + M427DllMapStruct3Sub *var_r31; + + var_r31 = &lbl_1_bss_158.unk334; + var_r31->unk_00 = HuSprAnimRead(HuDataReadNum(sp8, MEMORY_DEFAULT_NUM)); + var_r31->unk_04 = HuSprAnimRead(HuDataReadNum(spC, MEMORY_DEFAULT_NUM)); + var_r31->unk_08 = 0.5f * var_f30; + var_r31->unk_0C = 0.5f * var_f31; + var_r31->unk_10 = sp10 / var_f30; + var_r31->unk_14 = sp14 / var_f31; +} + +void fn_1_94BC(Vec *arg0, Vec *arg1, Vec *arg2, Vec *arg3, float arg8, Vec2f *arg4, s16 arg5) +{ + Mtx sp58; + Mtx sp28; + Vec sp1C; + Vec sp10; + M427DllMapStruct3Sub *var_r31; + s16 var_r28; + + var_r31 = &lbl_1_bss_158.unk334; + for (var_r28 = 0; var_r28 < arg5; var_r28++, arg2++, arg4++) { + MTXScale(sp58, arg3->x, arg3->y, arg3->z); + MTXRotRad(sp28, 0x59, MTXDegToRad(arg8)); + MTXConcat(sp58, sp28, sp58); + MTXMultVec(sp58, arg2, &sp1C); + sp10.x = var_r31->unk_08 + ((sp1C.x + arg1->x) - arg0->x); + sp10.z = var_r31->unk_0C + ((sp1C.z + arg1->z) - arg0->z); + arg4->x = sp10.x * var_r31->unk_10; + arg4->y = sp10.z * var_r31->unk_14; + } +} + +s16 fn_1_95E8(s32 arg0, s16 arg1, s16 arg2, float arg8, float arg9, float argA, float argB, float argC) +{ + M427DllMapStruct *var_r31; + s16 var_r30; + s16 var_r29; + void *var_r28; + void *var_r26; + + for (var_r31 = lbl_1_bss_F0, var_r29 = 0; var_r29 < 0x10; var_r29++, var_r31++) { + if (var_r31->unk2 == -1) { + break; + } + } + if (var_r29 == 0x10) { + return -1; + } + var_r31->unk4 = Hu3DHookFuncCreate(fn_1_9B88); + Hu3DModelCameraSet(var_r31->unk4, arg1 ? 2 : 1); + Hu3DModelLayerSet(var_r31->unk4, arg2); + Hu3DData[var_r31->unk4].unk_120 = var_r31; + Hu3DModelPosSet(var_r31->unk4, 0.0f, 0.0f, -2000.0f); + var_r31->unk0 = 0; + var_r31->unk2 = arg1; + var_r31->unk7C.r = var_r31->unk7C.g = var_r31->unk7C.b = var_r31->unk7C.a = 0xFF; + var_r31->unk88 = var_r31->unk8C = 0.0f; + var_r31->unk90 = var_r31->unk94 = 0.0f; + var_r31->unk8 = HuSprAnimRead(HuDataReadNum(arg0, MEMORY_DEFAULT_NUM)); + fn_1_C2AC(&var_r31->unkC, arg8 - argA, argC, arg9 - argB); + fn_1_C2BC(&var_r31->unk3C, 0.0f, 0.0f); + fn_1_C2AC(&var_r31->unk18, arg8 + argA, argC, arg9 - argB); + fn_1_C2BC(&var_r31->unk44, 1.0f, 0.0f); + fn_1_C2AC(&var_r31->unk24, arg8 + argA, argC, arg9 + argB); + fn_1_C2BC(&var_r31->unk4C, 1.0f, 1.0f); + fn_1_C2AC(&var_r31->unk30, arg8 - argA, argC, arg9 + argB); + fn_1_C2BC(&var_r31->unk54, 0.0f, 1.0f); + DCFlushRangeNoSync(&var_r31->unkC, 0x30); + DCFlushRangeNoSync(&var_r31->unk3C, 0x20); + PPCSync(); + var_r28 = HuMemDirectMallocNum(HEAP_SYSTEM, 0x1000, MEMORY_DEFAULT_NUM); + var_r26 = var_r28; + DCFlushRange(var_r28, 0x1000); + GXBeginDisplayList(var_r26, 0x1000); + GXBegin(GX_QUADS, GX_VTXFMT0, 4); + for (var_r30 = 0; var_r30 < 4; var_r30++) { + GXPosition1x16(var_r30); + GXPosition1x16(var_r30); + GXPosition1x16(var_r30); + } + var_r31->unk84 = GXEndDisplayList(); + var_r31->unk80 = HuMemDirectMallocNum(HEAP_SYSTEM, var_r31->unk84, MEMORY_DEFAULT_NUM); + memcpy(var_r31->unk80, var_r28, var_r31->unk84); + DCFlushRange(var_r31->unk80, var_r31->unk84); + HuMemDirectFree(var_r28); + return var_r29; +} + +void fn_1_9958(s16 arg0, u8 arg1) +{ + M427DllMapStruct *var_r31; + + if (arg0 != -1) { + var_r31 = &lbl_1_bss_F0[arg0]; + var_r31->unk0 |= arg1; + } +} + +void fn_1_999C(s16 arg0, u8 arg1) +{ + M427DllMapStruct *var_r31; + + if (arg0 != -1) { + var_r31 = &lbl_1_bss_F0[arg0]; + var_r31->unk0 &= ~arg1; + } +} + +void fn_1_99E4(s16 arg0, u8 arg1, u8 arg2, u8 arg3, u8 arg4) +{ + M427DllMapStruct *var_r31; + + if (arg0 != -1) { + var_r31 = &lbl_1_bss_F0[arg0]; + var_r31->unk7C.r = arg1; + var_r31->unk7C.g = arg2; + var_r31->unk7C.b = arg3; + var_r31->unk7C.a = arg4; + } +} + +void fn_1_9A2C(s16 arg0, float arg8, float arg9, float argA) +{ + M427DllMapStruct *var_r31; + + if (arg0 != -1) { + var_r31 = &lbl_1_bss_F0[arg0]; + Hu3DModelPosSet(var_r31->unk4, arg8, arg9, argA); + } +} + +void fn_1_9AA0(s16 arg0, float arg8, float arg9, float argA) +{ + M427DllMapStruct *var_r31; + + if (arg0 != -1) { + var_r31 = &lbl_1_bss_F0[arg0]; + Hu3DModelScaleSet(var_r31->unk4, arg8, arg9, argA); + } +} + +void fn_1_9B14(s16 arg0, float arg8, float arg9, float argA) +{ + M427DllMapStruct *var_r31; + + if (arg0 != -1) { + var_r31 = &lbl_1_bss_F0[arg0]; + Hu3DModelRotSet(var_r31->unk4, arg8, arg9, argA); + } +} + +void fn_1_9B88(ModelData *model, Mtx matrix) +{ + Mtx sp88; + M427DllMapStruct *var_r31; + M427DllMapSubstruct3 *var_r27; + M427DllMapStruct3Sub *var_r26; + + var_r31 = model->unk_120; + var_r27 = &lbl_1_bss_158.unk4[var_r31->unk2]; + var_r26 = &lbl_1_bss_158.unk334; + if ((var_r31->unk0 & 1) == 0) { + fn_1_94BC(&var_r27->unk78, &model->pos, &var_r31->unkC, &model->scale, model->rot.y, var_r31->unk5C, 4); + DCFlushRangeNoSync(var_r31->unk5C, 4 * sizeof(Vec2f)); + PPCSync(); + GXLoadPosMtxImm(matrix, 0); + GXClearVtxDesc(); + GXSetVtxDesc(GX_VA_POS, GX_INDEX16); + GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_TEX_ST, GX_RGBA6, 0); + GXSetArray(GX_VA_POS, &var_r31->unkC, sizeof(Vec)); + GXSetVtxDesc(GX_VA_TEX0, GX_INDEX16); + GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX0, GX_TEX_ST, GX_RGBA6, 0); + GXSetArray(GX_VA_TEX0, &var_r31->unk3C, sizeof(Vec2f)); + GXSetVtxDesc(GX_VA_TEX1, GX_INDEX16); + GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX1, GX_TEX_ST, GX_RGBA6, 0); + GXSetArray(GX_VA_TEX1, var_r31->unk5C, sizeof(Vec2f)); + HuSprTexLoad(var_r31->unk8, 0, 0, GX_REPEAT, GX_REPEAT, GX_LINEAR); + HuSprTexLoad(var_r26->unk_04, 0, 1, GX_REPEAT, GX_REPEAT, GX_LINEAR); + HuSprTexLoad(var_r26->unk_00, 0, 2, GX_REPEAT, GX_REPEAT, GX_LINEAR); + GXSetNumTexGens(3); + MTXScale(sp88, 1.0f, 1.0f, 1.0f); + mtxTransCat(sp88, var_r31->unk88, var_r31->unk90, 0.0f); + GXLoadTexMtxImm(sp88, 0x1E, GX_MTX2x4); + MTXScale(sp88, 1.0f, 1.0f, 1.0f); + mtxTransCat(sp88, var_r31->unk8C, var_r31->unk94, 0.0f); + GXLoadTexMtxImm(sp88, 0x21, GX_MTX2x4); + GXSetTexCoordGen2(GX_TEXCOORD0, GX_TG_MTX2x4, GX_TG_TEX0, 0x3C, 0, 0x7D); + GXSetTexCoordGen2(GX_TEXCOORD1, GX_TG_MTX2x4, GX_TG_TEX1, 0x1E, 0, 0x7D); + GXSetTexCoordGen2(GX_TEXCOORD2, GX_TG_MTX2x4, GX_TG_TEX0, 0x21, 0, 0x7D); + GXSetNumTevStages(2); + GXSetTevColor(GX_TEVREG1, var_r31->unk7C); + GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD1, GX_TEXMAP1, GX_COLOR_NULL); + GXSetTevColorIn(GX_TEVSTAGE0, GX_CC_ZERO, GX_CC_C1, GX_CC_TEXA, GX_CC_ZERO); + GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVREG0); + GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_KONST, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO); + GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVREG0); + GXSetTevOrder(GX_TEVSTAGE1, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR_NULL); + GXSetTevColorIn(GX_TEVSTAGE1, GX_CC_ZERO, GX_CC_C0, GX_CC_TEXA, GX_CC_ZERO); + GXSetTevColorOp(GX_TEVSTAGE1, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV); + GXSetTevAlphaIn(GX_TEVSTAGE1, GX_CA_A1, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO); + GXSetTevAlphaOp(GX_TEVSTAGE1, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV); + GXSetNumIndStages(1); + GXSetIndTexOrder(GX_INDTEXSTAGE0, GX_TEXCOORD2, GX_TEXMAP2); + GXSetTevIndWarp(0, 0, 1, 0, 1); + MTXScale(sp88, 0.1f, 0.10000000149011612 * -sind(model->rot.y), 1.0f); + GXSetIndTexMtx(GX_ITM_0, (float(*)[3])sp88, 0); + GXSetNumChans(0); + GXSetZMode(0, GX_LEQUAL, 0); + GXSetAlphaCompare(GX_GEQUAL, 1, GX_AOP_AND, GX_GEQUAL, 1); + GXSetZCompLoc(0); + GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_ONE, GX_LO_NOOP); + GXCallDisplayList(var_r31->unk80, var_r31->unk84); + GXSetNumIndStages(0); + GXSetTevDirect(GX_TEVSTAGE0); + GXSetTevDirect(GX_TEVSTAGE1); + } +} + +void fn_1_A148(ModelData *model, Mtx matrix) +{ + M427DllMapSubstruct3Sub *var_r31; + + var_r31 = model->unk_120; + if (var_r31->unk0 == 0) { + GXSetTexCopySrc(0, 0, 0x140, 0x1E0); + GXSetTexCopyDst(0x140, 0x1E0, GX_TF_RGB5A3, 0); + } + else { + GXSetTexCopySrc(0x140, 0, 0x140, 0x1E0); + GXSetTexCopyDst(0x140, 0x1E0, GX_TF_RGB5A3, 0); + } + GXCopyTex(var_r31->unk4, 1); + DCFlushRange(var_r31->unk4, var_r31->unk8); +} + +s16 fn_1_A1F4(s32 arg0, s16 arg1, s16 arg2, s16 arg3, float arg8, Vec *arg4, Vec *arg5) +{ + float var_f31; + float var_f30; + float var_f29; + float var_f28; + M427DllMapStruct6 *var_r31; + M427DllMapSubstruct5 *var_r30; + ModelData *var_r29; + s16 var_r28; + s16 var_r27; + Vec2f *var_r26; + void *var_r25; + M427DllMapStruct3 *var_r22; + u16 var_r21; + s16 var_r19; + void *var_r18; + + var_r22 = &lbl_1_bss_158; + var_r28 = Hu3DHookFuncCreate(fn_1_B3CC); + var_r19 = var_r28; + Hu3DModelCameraSet(var_r28, arg3 ? 2 : 1); + Hu3DModelLayerSet(var_r28, 5); + var_r29 = &Hu3DData[var_r28]; + var_r31 = HuMemDirectMallocNum(HEAP_DATA, sizeof(M427DllMapStruct6), var_r29->unk_48); + var_r29->unk_120 = var_r31; + var_r22->unk4[arg3].unkAC = var_r31; + var_r31->unk_00 = arg3; + var_r31->unk_0C = 0.0f; + var_r31->unk_10 = arg8; + var_r31->unk_04 = arg4; + var_r31->unk_08 = arg5; + var_r31->unk_14 = var_r31->unk_18 = 0.0f; + var_r31->unk_1C = var_r31->unk_20 = 0.0f; + var_r31->unk_4C = var_r31->unk_50 = 0.0f; + var_r31->unk_54 = 120.0f; + var_r31->unk_58 = 72.0f; + var_r31->unk_5C = 10.0f; + var_r31->unk_60 = 10.0f; + var_r31->unk_28 = HuSprAnimRead(HuDataReadNum(arg0, MEMORY_DEFAULT_NUM)); + var_r31->unk_3A = arg1 + 1; + var_r31->unk_3C = arg2 + 1; + var_r31->unk_38 = var_r31->unk_3A * var_r31->unk_3C; + var_r31->unk_2C = HuMemDirectMallocNum(HEAP_DATA, var_r31->unk_38 * sizeof(Vec), var_r29->unk_48); + var_r26 = HuMemDirectMallocNum(HEAP_DATA, var_r31->unk_38 * sizeof(Vec2f), var_r29->unk_48); + var_r31->unk_30 = var_r26; + var_r31->unk_34 = HuMemDirectMallocNum(HEAP_DATA, var_r31->unk_38 * sizeof(Vec), var_r29->unk_48); + var_r30 = HuMemDirectMallocNum(HEAP_DATA, arg2 * (arg1 * sizeof(M427DllMapSubstruct5)), var_r29->unk_48); + var_r31->unk_48 = var_r30; + var_r25 = HuMemDirectMallocNum(HEAP_DATA, 0x20000, var_r29->unk_48); + var_r18 = var_r25; + DCFlushRange(var_r25, 0x20000); + GXBeginDisplayList(var_r18, 0x20000); + GXBegin(GX_QUADS, GX_VTXFMT0, arg1 * arg2 * 4); + for (var_r28 = 0; var_r28 < arg2; var_r28++) { + for (var_r27 = 0; var_r27 < arg1; var_r27++) { + var_r30->unk0 = var_r27 + (var_r28 * var_r31->unk_3A); + var_r30->unk2 = var_r27 + var_r28 * var_r31->unk_3A + 1; + var_r30->unk4 = var_r27 + ((var_r28 + 1) * var_r31->unk_3A) + 1; + var_r30->unk6 = var_r27 + ((var_r28 + 1) * var_r31->unk_3A); + GXPosition1x16(var_r30->unk0); + GXPosition1x16(var_r30->unk0); + GXPosition1x16(var_r30->unk0); + GXPosition1x16(var_r30->unk2); + GXPosition1x16(var_r30->unk2); + GXPosition1x16(var_r30->unk2); + GXPosition1x16(var_r30->unk4); + GXPosition1x16(var_r30->unk4); + GXPosition1x16(var_r30->unk4); + GXPosition1x16(var_r30->unk6); + GXPosition1x16(var_r30->unk6); + GXPosition1x16(var_r30->unk6); + fn_1_C2C8(&var_r31->unk_2C[var_r30->unk0], &var_r31->unk_2C[var_r30->unk2], &var_r31->unk_2C[var_r30->unk4], &var_r30->unk8); + var_r30++; + } + } + var_r31->unk_44 = GXEndDisplayList(); + var_r31->unk_40 = HuMemDirectMallocNum(HEAP_DATA, var_r31->unk_44, var_r29->unk_48); + memcpy(var_r31->unk_40, var_r25, var_r31->unk_44); + DCFlushRange(var_r31->unk_40, var_r31->unk_44); + HuMemDirectFree(var_r25); + fn_1_A7F8(var_r31); + var_f29 = 3.0f / (var_r31->unk_3A - 1); + var_f28 = 5.0f / (var_r31->unk_3C - 1); + var_f30 = 0.0f; + for (var_r28 = 0; var_r28 < var_r31->unk_3C; var_r28++) { + var_f31 = 0.0f; + for (var_r27 = 0; var_r27 < var_r31->unk_3A; var_r27++) { + var_r26->x = var_f31; + var_r26->y = var_f30; + var_f31 += var_f29; + var_r26++; + } + var_f30 += var_f28; + } + DCFlushRangeNoSync(var_r31->unk_30, var_r31->unk_38 * 8); + PPCSync(); + return var_r19; +} + +void fn_1_A7F8(M427DllMapStruct6 *var_r31) +{ + Vec sp1C; + float sp14[2]; + float spC[2]; + float var_f29; + float var_f28; + float var_f27; + M427DllMapSubstruct5 *var_r30; + Vec *var_r29; + s16 var_r28; + Vec *var_r27; + s16 var_r26; + s16 var_r25; + + if (omPauseChk() == 0) { + var_r31->unk_4C += 1.0f; + var_r31->unk_50 += 1.5f; + } + if (var_r31->unk_4C >= 360.0f) { + var_r31->unk_4C -= 360.0f; + } + if (var_r31->unk_50 >= 360.0f) { + var_r31->unk_50 -= 360.0f; + } + var_r27 = var_r31->unk_2C; + var_r29 = var_r31->unk_34; + spC[0] = var_r31->unk_0C - var_r31->unk_10; + spC[1] = var_r31->unk_10 / (var_r31->unk_3C - 1); + var_f28 = var_r31->unk_50; + for (var_r28 = 0; var_r28 < var_r31->unk_3C; var_r28++) { + fn_1_B194(var_r31, spC[0], &sp1C); + sp14[0] = sp1C.x; + sp14[1] = (sp1C.y - sp1C.x) / (var_r31->unk_3A - 1); + var_f29 = var_r31->unk_4C; + for (var_r26 = 0; var_r26 < var_r31->unk_3A; var_r26++) { + var_r27->x = sp14[0]; + var_r27->y = sp1C.z + (var_r31->unk_5C * sind(var_f29)) + var_r31->unk_60 * sind(var_f28); + var_r27->z = spC[0]; + sp14[0] += sp14[1]; + var_r27++; + var_r29->x = var_r29->y = var_r29->z = 0.0f; + var_r29++; + var_f29 += var_r31->unk_54; + if (var_f29 >= 360.0f) { + var_f29 -= 360.0f; + } + } + spC[0] += spC[1]; + var_f28 += var_r31->unk_58; + if (var_f28 >= 360.0f) { + var_f28 -= 360.0f; + } + } + var_r30 = var_r31->unk_48; + var_r25 = (var_r31->unk_3A - 1) * (var_r31->unk_3C - 1); + for (var_r28 = 0; var_r28 < var_r25; var_r28++) { + fn_1_C2C8(&var_r31->unk_2C[var_r30->unk0], &var_r31->unk_2C[var_r30->unk2], &var_r31->unk_2C[var_r30->unk4], &var_r30->unk8); + var_r31->unk_34[var_r30->unk0].x += var_r30->unk8.x; + var_r31->unk_34[var_r30->unk0].y += var_r30->unk8.y; + var_r31->unk_34[var_r30->unk0].z += var_r30->unk8.z; + + var_r31->unk_34[var_r30->unk2].x += var_r30->unk8.x; + var_r31->unk_34[var_r30->unk2].y += var_r30->unk8.y; + var_r31->unk_34[var_r30->unk2].z += var_r30->unk8.z; + + var_r31->unk_34[var_r30->unk4].x += var_r30->unk8.x; + var_r31->unk_34[var_r30->unk4].y += var_r30->unk8.y; + var_r31->unk_34[var_r30->unk4].z += var_r30->unk8.z; + + var_r31->unk_34[var_r30->unk6].x += var_r30->unk8.x; + var_r31->unk_34[var_r30->unk6].y += var_r30->unk8.y; + var_r31->unk_34[var_r30->unk6].z += var_r30->unk8.z; + var_r30++; + } + var_r29 = var_r31->unk_34; + for (var_r28 = 0; var_r28 < var_r31->unk_38; var_r28++) { + var_f27 = sqrtf((var_r29->z * var_r29->z) + ((var_r29->x * var_r29->x) + (var_r29->y * var_r29->y))); + var_r29->x /= var_f27; + var_r29->y /= var_f27; + var_r29->z /= var_f27; + var_r29++; + } + DCFlushRangeNoSync(var_r31->unk_2C, var_r31->unk_38 * sizeof(Vec)); + DCFlushRangeNoSync(var_r31->unk_34, var_r31->unk_38 * sizeof(Vec)); + PPCSync(); +} + +s16 lbl_1_data_1EC[2] = { 0, 0 }; + +float fn_1_AE78(s16 arg0, float arg8, float arg9) +{ + float sp8[2]; + float var_f31; + float var_f30; + Vec *var_r31; + s16 var_r30; + M427DllMapSubstruct3 *var_r29; + Vec *var_r28; + s16 var_r27; + s16 var_r26; + + var_r29 = &lbl_1_bss_158.unk4[arg0]; + if (lbl_1_bss_158.unk0 != 0) { + if (lbl_1_bss_158.unk0 == 1) { + lbl_1_data_1EC[arg0] = 0; + lbl_1_bss_158.unk0 = 2; + } + if (!lbl_1_bss_98.unk4) { + return 0.0f; + } + var_r28 = lbl_1_bss_98.unk4; + var_r31 = &lbl_1_bss_98.unk4[lbl_1_data_1EC[arg0]]; + var_r27 = lbl_1_bss_98.unk14; + var_r26 = lbl_1_bss_98.unk16; + for (var_r30 = lbl_1_data_1EC[arg0]; var_r30 < var_r27; var_r30++, var_r31++) { + if (arg9 >= var_r31->z && arg8 >= var_r31->x) { + break; + } + } + if (var_r30 == var_r27) { + return 0.0f; + } + } + else { + if (!var_r29->unkAC) { + return 0.0f; + } + var_r28 = var_r29->unkAC->unk_2C; + var_r31 = &var_r29->unkAC->unk_2C[lbl_1_data_1EC[arg0]]; + var_r27 = var_r29->unkAC->unk_38; + var_r26 = var_r29->unkAC->unk_3A; + for (var_r30 = lbl_1_data_1EC[arg0]; var_r30 < var_r27; var_r30++, var_r31++) { + if (arg9 <= var_r31->z && arg8 <= var_r31->x) { + break; + } + } + if (var_r30 == var_r27) { + return 0.0f; + } + } + sp8[0] = var_r31->x - var_r28[var_r30 - 1].x; + sp8[1] = arg8 - var_r28[var_r30 - 1].x; + var_f30 = sp8[1] / sp8[0]; + var_f31 = var_r31->y - var_r28[var_r30 - 1].y; + var_f31 = var_r28[var_r30 - 1].y + (var_f31 * var_f30); + lbl_1_data_1EC[arg0] = var_r30 - (var_r26 * 2); + return 20.0f + var_f31; +} + +void fn_1_B194(M427DllMapStruct6 *arg0, float arg8, Vec *arg1) +{ + float sp10[2]; + float sp8[2]; + float var_f31; + s16 var_r31; + + for (var_r31 = lbl_1_bss_580; var_r31 != 0;) { + var_r31--; + if (arg0->unk_04[var_r31].z >= arg8) { + if (var_r31 == (lbl_1_bss_580 - 1)) { + arg1->x = arg0->unk_08[var_r31].x; + arg1->y = arg0->unk_04[var_r31].x; + arg1->z = arg0->unk_04[var_r31].y; + } + else { + var_f31 = (arg0->unk_04[var_r31].z - arg8) / (arg0->unk_04[var_r31].z - arg0->unk_04[var_r31 + 1].z); + sp10[0] = arg0->unk_08[var_r31].x - 100.0f; + sp10[1] = arg0->unk_08[var_r31 + 1].x - 100.0f; + sp8[0] = 100.0f + arg0->unk_04[var_r31].x; + sp8[1] = 100.0f + arg0->unk_04[var_r31 + 1].x; + arg1->x = sp10[0] + (var_f31 * (sp10[1] - sp10[0])); + arg1->y = sp8[0] + (var_f31 * (sp8[1] - sp8[0])); + arg1->z = arg0->unk_04[var_r31].y + (var_f31 * (arg0->unk_04[var_r31 + 1].y - arg0->unk_04[var_r31].y)); + } + return; + } + } +} + +void fn_1_B3CC(ModelData *model, Mtx matrix) +{ + Mtx sp154; + Mtx sp124; + Mtx spF4; + Mtx spC4; + GXTexObj sp44; + Vec2f sp18; + GXColor sp14; + float var_f31; + M427DllMapStruct6 *var_r31; + M427DllMapSubstruct3 *var_r30; + M427DllMapSubstruct3Sub *var_r27; + M427DllMapStruct3Sub *var_r24; + s16 var_r21; + + var_r31 = model->unk_120; + var_r30 = &lbl_1_bss_158.unk4[var_r31->unk_00]; + var_r27 = &var_r30->unk94; + var_r24 = &lbl_1_bss_158.unk334; + fn_1_A7F8(var_r31); + GXLoadPosMtxImm(matrix, 0); + MTXInvXpose(matrix, spF4); + GXLoadNrmMtxImm(spF4, 0); + GXClearVtxDesc(); + GXSetVtxDesc(GX_VA_POS, GX_INDEX16); + GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XYZ, GX_F32, 0); + GXSetArray(GX_VA_POS, var_r31->unk_2C, sizeof(Vec)); + GXSetVtxDesc(GX_VA_NRM, GX_INDEX16); + GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_NRM, GX_NRM_XYZ, GX_F32, 0); + GXSetArray(GX_VA_NRM, var_r31->unk_34, sizeof(Vec)); + GXSetVtxDesc(GX_VA_TEX0, GX_INDEX16); + GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX0, GX_TEX_ST, GX_F32, 0); + GXSetArray(GX_VA_TEX0, var_r31->unk_30, 8); + if (var_r31->unk_00 == 0) { + GXInitTexObj(&sp44, var_r27->unk4, 0x140, 0x1E0, GX_TF_RGB5A3, GX_CLAMP, GX_CLAMP, 0); + } + else { + GXInitTexObj(&sp44, var_r27->unk4, 0x140, 0x1E0, GX_TF_RGB5A3, GX_CLAMP, GX_CLAMP, 0); + } + GXInitTexObjLOD(&sp44, GX_LINEAR, GX_LINEAR, 0.0f, 0.0f, 0.0f, 0, 0, GX_ANISO_1); + GXLoadTexObj(&sp44, GX_TEXMAP0); + HuSprTexLoad(var_r31->unk_28, 0, 1, GX_REPEAT, GX_REPEAT, GX_LINEAR); + HuSprTexLoad(var_r24->unk_00, 0, 2, GX_REPEAT, GX_REPEAT, GX_LINEAR); + GXSetNumTevStages(3); + sp14.r = 0; + sp14.g = 0xB6; + sp14.b = 0xCC; + sp14.a = 0x40; + GXSetTevColor(GX_TEVREG2, sp14); + GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR0A0); + GXSetTevColorIn(GX_TEVSTAGE0, GX_CC_ZERO, GX_CC_TEXC, GX_CC_RASC, GX_CC_ZERO); + GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_4, GX_TRUE, GX_TEVREG0); + GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_KONST, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO); + GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVREG0); + GXSetTevOrder(GX_TEVSTAGE1, GX_TEXCOORD1, GX_TEXMAP1, GX_COLOR_NULL); + GXSetTevColorIn(GX_TEVSTAGE1, GX_CC_ZERO, GX_CC_TEXA, GX_CC_C2, GX_CC_ZERO); + GXSetTevColorOp(GX_TEVSTAGE1, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVREG1); + GXSetTevAlphaIn(GX_TEVSTAGE1, GX_CA_KONST, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO); + GXSetTevAlphaOp(GX_TEVSTAGE1, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVREG1); + GXSetTevOrder(GX_TEVSTAGE2, GX_TEXCOORD_NULL, GX_TEXMAP_NULL, GX_COLOR0A0); + GXSetTevColorIn(GX_TEVSTAGE2, GX_CC_ZERO, GX_CC_C1, GX_CC_RASC, GX_CC_C0); + GXSetTevColorOp(GX_TEVSTAGE2, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV); + GXSetTevAlphaIn(GX_TEVSTAGE2, GX_CA_KONST, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO); + GXSetTevAlphaOp(GX_TEVSTAGE2, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV); + GXSetNumIndStages(1); + GXSetIndTexOrder(GX_INDTEXSTAGE0, GX_TEXCOORD2, GX_TEXMAP2); + GXSetTevIndWarp(1, 0, 1, 0, 1); + MTXScale(spF4, -0.1f, 0.1f, 1.0f); + GXSetIndTexMtx(GX_ITM_0, (float(*)[3])spF4, 0); + GXSetNumTexGens(3); + C_MTXLightPerspective(sp154, 45.0f, 0.6f, 0.5f, -0.5f, 0.5f, 0.5f); + MTXCopy(matrix, sp124); + MTXInverse(Hu3DCameraMtx, spF4); + MTXConcat(spF4, sp124, spF4); + MTXConcat(sp154, Hu3DCameraMtx, spC4); + MTXConcat(spC4, spF4, spF4); + GXLoadTexMtxImm(spF4, 0x1E, GX_MTX3x4); + { + Vec sp38 = { 1.0f, 1.0f, 1.0f }; + var_f31 = 0.0f; + fn_1_94BC(&var_r30->unk78, &var_r30->unk84, var_r31->unk_2C, &sp38, var_f31, &sp18, 1); + } + if (omPauseChk() == 0) { + var_r31->unk_20 = var_r31->unk_20 - 0.001f; + } + MTXScale(spF4, 1.0f, 1.0f, 1.0f); + mtxTransCat(spF4, 0.0f, var_r31->unk_20 + (0.3f * sp18.y), 0.0f); + GXLoadTexMtxImm(spF4, 0x21, GX_MTX2x4); + if (omPauseChk() == 0) { + var_r31->unk_24 += 0.05f; + } + if (var_r31->unk_24 >= 360.0f) { + var_r31->unk_24 -= 360.0f; + } + var_r31->unk_14 = sind(var_r31->unk_24); + if (omPauseChk() == 0) { + var_r31->unk_1C += 0.0005f; + } + MTXScale(spF4, 0.5f, 0.5f, 0.5f); + mtxTransCat(spF4, var_r31->unk_14, var_r31->unk_1C, 0.0f); + GXLoadTexMtxImm(spF4, 0x24, GX_MTX2x4); + GXSetTexCoordGen2(GX_TEXCOORD0, GX_TG_MTX3x4, GX_TG_POS, 0x1E, GX_FALSE, 0x7D); + GXSetTexCoordGen2(GX_TEXCOORD1, GX_TG_MTX2x4, GX_TG_TEX0, 0x21, GX_FALSE, 0x7D); + GXSetTexCoordGen2(GX_TEXCOORD2, GX_TG_MTX2x4, GX_TG_TEX0, 0x24, GX_FALSE, 0x7D); + GXSetNumChans(1); + var_r21 = Hu3DLightSet(model, &Hu3DCameraMtx, &Hu3DCameraMtxXPose, 0.0f); + GXSetChanCtrl(GX_COLOR0A0, GX_TRUE, GX_SRC_REG, GX_SRC_REG, var_r21, GX_DF_CLAMP, GX_AF_SPOT); + sp14.r = sp14.g = sp14.b = 0x10; + sp14.a = 0xFF; + GXSetChanAmbColor(GX_COLOR0A0, sp14); + sp14.r = sp14.g = sp14.b = 0xFF; + sp14.a = 0xFF; + GXSetChanMatColor(GX_COLOR0A0, sp14); + GXSetZMode(1, GX_LEQUAL, GX_TRUE); + GXSetAlphaCompare(GX_GEQUAL, 1, GX_AOP_AND, GX_GEQUAL, 1); + GXSetZCompLoc(0); + GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_ONE, GX_LO_NOOP); + GXCallDisplayList(var_r31->unk_40, var_r31->unk_44); + GXSetNumIndStages(0); + GXSetTevDirect(GX_TEVSTAGE0); + GXSetTevDirect(GX_TEVSTAGE1); +} + +void fn_1_BD2C(ModelData *model, Mtx matrix) +{ + GXColor sp14 = { 0, 0, 0, 0xFF }; + GXSetFog(GX_FOG_EXP, 10000.0f, 20000.0f, 300.0f, 50000.0f, sp14); + GXLoadPosMtxImm(matrix, 0); + GXClearVtxDesc(); + GXSetVtxDesc(GX_VA_POS, GX_DIRECT); + GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XYZ, GX_F32, 0); + GXSetVtxDesc(GX_VA_TEX0, GX_DIRECT); + GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX0, GX_TEX_ST, GX_F32, 0); + HuSprTexLoad(lbl_1_bss_F4, 0, 0, GX_REPEAT, GX_REPEAT, GX_LINEAR); + GXSetNumTevStages(1); + GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR_NULL); + GXSetTevColorIn(GX_TEVSTAGE0, GX_CC_TEXC, GX_CC_ZERO, GX_CC_ZERO, GX_CC_ZERO); + GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV); + GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_KONST, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO); + GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV); + GXSetNumTexGens(1); + GXSetTexCoordGen2(GX_TEXCOORD0, GX_TG_MTX2x4, GX_TG_TEX0, 0x3C, GX_FALSE, 0x7D); + GXSetNumChans(0); + GXSetZMode(GX_TRUE, GX_LEQUAL, GX_TRUE); + GXSetAlphaCompare(GX_GEQUAL, 1, GX_AOP_AND, GX_GEQUAL, 1); + GXSetZCompLoc(GX_FALSE); + GXSetBlendMode(GX_BM_NONE, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_NOOP); + GXBegin(GX_QUADS, GX_VTXFMT0, 4); + GXPosition3f32(-1000.0f, 1000.0f, -24000.0f); + GXTexCoord2f32(0.0f, 0.0f); + + GXPosition3f32(1000.0f, 1000.0f, -24000.0f); + GXTexCoord2f32(1.0f, 0.0f); + + GXPosition3f32(1000.0f, -1000.0f, -24000.0f); + GXTexCoord2f32(1.0f, 1.0f); + + GXPosition3f32(-1000.0f, -1000.0f, -24000.0f); + GXTexCoord2f32(0.0f, 1.0f); + + GXSetFog(GX_FOG_EXP, 3500.0f, 20000.0f, 300.0f, 50000.0f, sp14); +} + +void fn_1_C154(ModelData *model, Mtx matrix) +{ + GXColor spC = { 0, 0, 0, 255 }; + GXSetFog(GX_FOG_EXP, 10000.0f, 20000.0f, 300.0f, 50000.0f, spC); +} + +void fn_1_C200(ModelData *model, Mtx matrix) +{ + GXColor spC = { 0, 0, 0, 255 }; + GXSetFog(GX_FOG_EXP, 3500.0f, 20000.0f, 300.0f, 50000.0f, spC); +} + +void fn_1_C2AC(Vec *arg0, float arg8, float arg9, float argA) +{ + arg0->x = arg8; + arg0->y = arg9; + arg0->z = argA; +} + +void fn_1_C2BC(Vec2f *arg0, float arg8, float arg9) +{ + arg0->x = arg8; + arg0->y = arg9; +} + +void fn_1_C2C8(Vec *arg0, Vec *arg1, Vec *arg2, Vec *arg3) +{ + Vec sp14; + Vec sp8; + + sp14.x = arg1->x - arg0->x; + sp14.y = arg1->y - arg0->y; + sp14.z = arg1->z - arg0->z; + sp8.x = arg2->x - arg1->x; + sp8.y = arg2->y - arg1->y; + sp8.z = arg2->z - arg1->z; + arg3->x = -((sp14.y * sp8.z) - (sp14.z * sp8.y)); + arg3->y = -((sp14.z * sp8.x) - (sp14.x * sp8.z)); + arg3->z = -((sp14.x * sp8.y) - (sp14.y * sp8.x)); +} + +// is this one of the structs? +void fn_1_C3A0(float *arg0, float *arg1) +{ + arg1[0] = arg0[0]; + arg1[4] = arg0[1]; + arg1[8] = arg0[2]; + arg1[1] = arg0[4]; + arg1[5] = arg0[5]; + arg1[9] = arg0[6]; + arg1[2] = arg0[8]; + arg1[6] = arg0[9]; + arg1[10] = arg0[10]; + arg1[3] = 0.0f; + arg1[7] = 0.0f; + arg1[11] = 0.0f; +} + +s16 fn_1_C41C(float x1, float y1, float z1, float x2, float y2, float z2, u8 r, u8 g, u8 b) +{ + Vec sp34; + Vec sp28; + GXColor sp23; + LightData *var_r31; + s16 var_r30; + + sp34.x = x1; + sp34.y = y1; + sp34.z = z1; + sp28.x = x2; + sp28.y = y2; + sp28.z = z2; + sp23.r = r; + sp23.g = g; + sp23.b = b; + sp23.a = 0xFF; + for (var_r31 = Hu3DLocalLight, var_r30 = 0; var_r30 < 0x20; var_r30++, var_r31++) { + if (var_r31->unk_00 == -1) { + break; + } + } + if (var_r30 == 0x20) { + return -1; + } + fn_1_C68C(var_r31, &sp34, &sp28, &sp23); + var_r31->unk_00 |= 0x8000; + return var_r30; +} + +void fn_1_C528(s16 sp8, s16 var_r28, float x1, float y1, float z1, float x2, float y2, float z2, u8 r, u8 g, u8 b) +{ + Vec sp38; + Vec sp2C; + GXColor sp27; + ModelData *var_r31; + LightData *var_r30; + s16 var_r29; + + var_r31 = &Hu3DData[sp8]; + sp38.x = x1; + sp38.y = y1; + sp38.z = z1; + sp2C.x = x2; + sp2C.y = y2; + sp2C.z = z2; + sp27.r = r; + sp27.g = g; + sp27.b = b; + sp27.a = 0xFF; + for (var_r30 = Hu3DLocalLight, var_r29 = 0; var_r29 < 0x20; var_r29++, var_r30++) { + if (var_r30->unk_00 == -1) { + break; + } + } + if (var_r29 == 0x20) { + OSReport("Light Entry Over!\n"); + return; + } + fn_1_C68C(var_r30, &sp38, &sp2C, &sp27); + if (var_r31->unk_38[var_r28] == -1) { + var_r31->unk_38[var_r28] = var_r29; + var_r31->attr |= 0x1000; + } +} + +void fn_1_C68C(LightData *arg0, Vec *arg1, Vec *arg2, GXColor *arg3) +{ + arg0->unk_00 = 0; + arg0->unk_1C = *arg1; + arg0->unk_28 = *arg2; + arg0->unk_34.x = arg0->unk_34.y = arg0->unk_34.z = 0.0f; + arg0->unk_04 = 30.0f; + arg0->unk_02 = 2; + VECNormalize(&arg0->unk_28, &arg0->unk_28); + arg0->color.r = arg3->r; + arg0->color.g = arg3->g; + arg0->color.b = arg3->b; + arg0->color.a = arg3->a; +} + +void fn_1_C76C(u8 arg0, float arg8, float arg9, float argA, s16 arg1, float argB, float argC, s16 arg2) +{ + Vec sp24; + Vec sp18; + float sp10[2]; + GXColor spC; + M427DllMapSubstruct6 *var_r31; + s16 var_r30; + + if (arg0 != 0) { + argB += (((rand8() << 8) | rand8()) % 21) - 0xA; + } + else { + argB += (((rand8() << 8) | rand8()) % 61) - 0x1E; + } + sp10[0] = sind(argB); + sp10[1] = cosd(argB); + for (var_r30 = 0; var_r30 < arg1; var_r30++) { + if (arg0 != 0) { + sp24.x = arg8 + ((((rand8() << 8) | rand8()) % 21) - 0xA); + sp24.y = arg9 + ((((rand8() << 8) | rand8()) % 21) - 0xA); + sp24.z = argA + ((((rand8() << 8) | rand8()) % 21) - 0xA); + } + else { + sp24.x = arg8 + ((((rand8() << 8) | rand8()) % 41) - 0x14); + sp24.y = arg9 + ((((rand8() << 8) | rand8()) % 41) - 0x14); + sp24.z = argA + ((((rand8() << 8) | rand8()) % 41) - 0x14); + } + sp18.x = sp18.y = sp18.z = 0.0f; + spC.r = spC.g = spC.b = spC.a = 0xFF; + var_r31 = fn_1_D4FC(arg2, &sp24, &sp18, 0.0f, &spC); + if (!var_r31) { + break; + } + var_r31->unk_38 = arg0; + if (arg0 != 0) { + var_r31->unk_34 = 0; + var_r31->unk_36 = 3; + var_r31->unk_00 = argC * (sp10[0] * (0.1f * ((((rand8() << 8) | rand8()) % 151) + 0x96))); + var_r31->unk_04 = 0.1f * ((((rand8() << 8) | rand8()) % 31) - 0x14); + var_r31->unk_08 = argC * (sp10[1] * (0.1f * ((((rand8() << 8) | rand8()) % 151) + 0x96))); + var_r31->unk_18 = 0.01f * var_r31->unk_00; + var_r31->unk_1C = 0.1f; + var_r31->unk_20 = 0.01f * var_r31->unk_08; + var_r31->unk_24 = argC * (0.1f * ((((rand8() << 8) | rand8()) % 11) + 0xA)); + var_r31->unk_28 = argC * (0.01f * ((((rand8() << 8) | rand8()) % 101) + 0x32) / (var_r31->unk_36 * 0xE)); + } + else { + var_r31->unk_34 = 0; + var_r31->unk_36 = 2; + var_r31->unk_00 = sp10[0] * (0.1f * ((((rand8() << 8) | rand8()) % 31) + 0x32)); + var_r31->unk_04 = 0.1f * ((((rand8() << 8) | rand8()) % 31) - 0x14); + var_r31->unk_08 = sp10[1] * (0.1f * (((((rand8() << 8) | rand8()) % 31)) + 0x32)); + var_r31->unk_18 = 0.0f; + var_r31->unk_1C = 0.1f; + var_r31->unk_20 = 0.0f; + var_r31->unk_24 = 0.3f * (0.1f * ((((rand8() << 8) | rand8()) % 11) + 0xA)); + var_r31->unk_28 = 0.4f * ((0.01f * ((((rand8() << 8) | rand8()) % 51) + 0x32)) / (var_r31->unk_36 * 0xE)); + } + var_r31->unk_2C = 1024.0f * argC; + var_r31->unk_30 = var_r31->unk_2C / (var_r31->unk_36 * 0xE); + } +} + +void fn_1_D22C(ModelData *model, M427DllMapStruct7 *arg1, Mtx matrix) +{ + M427DllMapSubstruct6 *var_r31; + GXColor *var_r30; + s16 var_r29; + u8 var_r28; + + var_r31 = arg1->unk_18; + var_r30 = arg1->unk_24; + for (var_r29 = 0; var_r29 < arg1->unk_00; var_r29++, var_r31++, var_r30++) { + if (var_r31->unk_62 != 0) { + var_r31->unk_54.x += var_r31->unk_00; + var_r31->unk_54.y += var_r31->unk_04; + var_r31->unk_54.z += var_r31->unk_08; + if (var_r31->unk_38 != 0) { + var_r31->unk_00 -= var_r31->unk_18; + var_r31->unk_04 += var_r31->unk_1C; + var_r31->unk_08 -= var_r31->unk_20; + var_r31->unk_18 = 0.01f * var_r31->unk_00; + var_r31->unk_1C *= 1.04f; + var_r31->unk_20 = 0.01f * var_r31->unk_08; + } + else { + var_r31->unk_04 += var_r31->unk_1C; + var_r31->unk_1C *= 1.1f; + } + var_r31->unk_24 += var_r31->unk_28; + var_r31->unk_48.x = var_r31->unk_48.y = var_r31->unk_48.z = var_r31->unk_24; + var_r31->unk_2C -= var_r31->unk_30; + if (var_r31->unk_2C > 255.0f) { + var_r28 = 0xFF; + } + else { + var_r28 = (s32)var_r31->unk_2C; + } + var_r30->a = (s32)var_r28; + var_r31->unk_34++; + if (var_r31->unk_34 >= var_r31->unk_36) { + var_r31->unk_34 = 0; + var_r31->unk_60++; + } + if (var_r31->unk_60 >= arg1->unk_14) { + var_r31->unk_62 = 0; + } + } + } +} + +s16 fn_1_D430(float arg8, float arg9, float argA, s16 arg0) +{ + Vec sp28; + Vec sp1C; + GXColor sp16; + M427DllMapSubstruct6 *var_r31; + + sp28.x = arg8; + sp28.y = arg9; + sp28.z = argA; + sp1C.x = sp1C.y = sp1C.z = 1.0f; + sp16.r = 0xFF; + sp16.g = 0xA0; + sp16.b = 0x60; + sp16.a = 0xFF; + var_r31 = fn_1_D4FC(arg0, &sp28, &sp1C, 0.0f, &sp16); + if (!var_r31) { + return -1; + } + var_r31->unk_24 = 0.0f; + return var_r31->unk_40; +} + +M427DllMapSubstruct6 *fn_1_D4FC(s16 arg0, Vec *arg1, Vec *arg2, float arg8, GXColor *arg3) +{ + M427DllMapSubstruct6 *var_r31; + M427DllMapStruct7 *var_r30; + s16 var_r29; + ModelData *var_r28; + + var_r28 = &Hu3DData[arg0]; + var_r30 = var_r28->unk_120; + for (var_r29 = 0, var_r31 = var_r30->unk_18; var_r29 < var_r30->unk_00; var_r29++, var_r31++) { + if (var_r31->unk_62 == 0) { + break; + } + } + if (var_r29 == var_r30->unk_00) { + return NULL; + } + var_r30->unk_24[var_r29].r = arg3->r; + var_r30->unk_24[var_r29].g = arg3->g; + var_r30->unk_24[var_r29].b = arg3->b; + var_r30->unk_24[var_r29].a = arg3->a; + var_r31->unk_40 = var_r29; + var_r31->unk_44 = arg8; + var_r31->unk_48 = *arg2; + var_r31->unk_54 = *arg1; + var_r31->unk_60 = 0; + var_r31->unk_3C = 0; + var_r31->unk_62 = 1; + return var_r31; +} + +s16 fn_1_D63C(AnimData *arg0, s16 arg1, float arg8, s16 arg2, s16 arg3) +{ + float temp_f0; + M427DllMapStruct7 *var_r31; + s16 var_r30; + Vec2f *var_r29; + ModelData *var_r28; + GXColor *var_r27; + Vec *var_r25; + M427DllMapSubstruct6 *var_r24; + s16 var_r22; + void *var_r21; + s16 var_r20; + s16 var_r19; + void *var_r18; + + var_r20 = Hu3DHookFuncCreate(fn_1_DCD4); + var_r28 = &Hu3DData[var_r20]; + var_r31 = HuMemDirectMallocNum(HEAP_DATA, sizeof(M427DllMapStruct7), var_r28->unk_48); + var_r28->unk_120 = var_r31; + arg0->useNum++; + var_r31->unk_10 = arg0; + var_r31->unk_00 = arg1; + var_r31->unk_08 = 0; + var_r31->unk_0C = 0; + var_r24 = HuMemDirectMallocNum(HEAP_DATA, arg1 * sizeof(M427DllMapSubstruct6), var_r28->unk_48); + var_r31->unk_18 = var_r24; + for (var_r30 = 0; var_r30 < arg1; var_r30++, var_r24++) { + var_r24->unk_60 = -1; + var_r24->unk_62 = 0; + } + var_r25 = HuMemDirectMallocNum(HEAP_DATA, arg1 * sizeof(Vec) * 4, var_r28->unk_48); + var_r31->unk_1C = var_r25; + for (var_r30 = 0; var_r30 < (arg1 * 4); var_r30++, var_r25++) { + var_r25->x = var_r25->y = var_r25->z = 0.0f; + } + var_r27 = HuMemDirectMallocNum(HEAP_DATA, arg1 * sizeof(GXColor), var_r28->unk_48); + var_r31->unk_24 = var_r27; + for (var_r30 = 0; var_r30 < arg1; var_r30++, var_r27++) { + var_r27->r = var_r27->g = var_r27->b = var_r27->a = 0xFF; + } + var_r29 = HuMemDirectMallocNum(HEAP_DATA, arg1 * sizeof(Vec2f) * 4, var_r28->unk_48); + var_r31->unk_20 = var_r29; + for (var_r30 = 0; var_r30 < arg1; var_r30++) { + var_r29->x = 0.0f; + var_r29->y = 0.0f; + var_r29++; + var_r29->x = 1.0f; + var_r29->y = 0.0f; + var_r29++; + var_r29->x = 1.0f; + var_r29->y = 1.0f; + var_r29++; + var_r29->x = 0.0f; + var_r29->y = 1.0f; + var_r29++; + } + if ((arg2 != 0) || (arg3 != 0)) { + var_r22 = arg0->bmp->sizeX / arg2; + var_r19 = arg0->bmp->sizeY / arg3; + var_r31->unk_14 = var_r22 * var_r19; + var_r31->unk_60 = 1.0f / var_r22; + var_r31->unk_64 = 1.0f / var_r19; + } + else { + var_r22 = 1; + var_r31->unk_14 = 1; + var_r31->unk_60 = 1.0f; + var_r31->unk_64 = 1.0f; + } + var_r31->unk_5C = HuMemDirectMallocNum(HEAP_DATA, var_r31->unk_14 * sizeof(Vec2f), var_r28->unk_48); + fn_1_E2B0(var_r31->unk_5C, var_r31->unk_14, var_r22, var_r31->unk_60, var_r31->unk_64); + var_r31->unk_2C.x = var_r31->unk_50 = var_r31->unk_48 = var_r31->unk_54 = -arg8; + var_r31->unk_38 = var_r31->unk_44 = var_r31->unk_2C.y = var_r31->unk_3C = arg8; + var_r31->unk_2C.z = var_r31->unk_40 = var_r31->unk_4C = var_r31->unk_58 = 0.0f; + var_r21 = HuMemDirectMallocNum(HEAP_DATA, 0x20000, var_r28->unk_48); + var_r18 = var_r21; + DCFlushRange(var_r21, 0x20000); + GXBeginDisplayList(var_r18, 0x20000); + GXBegin(GX_QUADS, GX_VTXFMT0, arg1 * 4); + for (var_r30 = 0; var_r30 < arg1; var_r30++) { + GXPosition1x16(var_r30 * 4); + GXPosition1x16(var_r30); + GXPosition1x16(var_r30 * 4); + GXPosition1x16(var_r30 * 4 + 1); + GXPosition1x16(var_r30); + GXPosition1x16(var_r30 * 4 + 1); + GXPosition1x16(var_r30 * 4 + 2); + GXPosition1x16(var_r30); + GXPosition1x16(var_r30 * 4 + 2); + GXPosition1x16(var_r30 * 4 + 3); + GXPosition1x16(var_r30); + GXPosition1x16(var_r30 * 4 + 3); + } + var_r31->unk_04 = GXEndDisplayList(); + var_r31->unk_28 = HuMemDirectMallocNum(HEAP_DATA, var_r31->unk_04, var_r28->unk_48); + memcpy(var_r31->unk_28, var_r21, var_r31->unk_04); + DCFlushRange(var_r31->unk_28, var_r31->unk_04); + HuMemDirectFree(var_r21); + return var_r20; +} + +void fn_1_DB80(s16 arg0) +{ + ModelData *var_r31; + M427DllMapStruct7 *var_r30; + + var_r31 = &Hu3DData[arg0]; + var_r30 = var_r31->unk_120; + HuSprAnimKill(var_r30->unk_10); + Hu3DModelKill(arg0); +} + +void *fn_1_DBE0(s16 arg0) +{ + ModelData *var_r31; + + var_r31 = &Hu3DData[arg0]; + return var_r31->unk_120; +} + +M427DllMapSubstruct6 *fn_1_DC0C(s16 arg0, s16 arg1) +{ + ModelData *var_r31; + M427DllMapStruct7 *var_r30; + + var_r31 = &Hu3DData[arg0]; + var_r30 = var_r31->unk_120; + if (arg1 == -1) { + return NULL; + } + return &var_r30->unk_18[arg1]; +} + +void fn_1_DC64(s16 arg0, M427DllHook arg1) +{ + ModelData *var_r31; + M427DllMapStruct7 *var_r30; + + var_r31 = &Hu3DData[arg0]; + var_r30 = var_r31->unk_120; + var_r30->unk_0C = arg1; +} + +void fn_1_DC9C(s16 arg0, u8 arg1) +{ + ModelData *var_r31; + M427DllMapStruct7 *var_r30; + + var_r31 = &Hu3DData[arg0]; + var_r30 = var_r31->unk_120; + var_r30->unk_08 = arg1; +} + +void fn_1_DCD4(ModelData *model, Mtx matrix) +{ + Mtx sp128; + ROMtx spF8; + Mtx spC8; + Mtx sp98; + Vec sp68[4]; + Vec sp5C; + Vec sp50; + Vec sp44; + Vec sp38; + Vec sp2C; + Vec sp20; + Vec sp14; + Vec sp8; + Vec *var_r31; + M427DllMapStruct7 *var_r30; + M427DllMapSubstruct6 *var_r29; + Vec2f *var_r26; + s16 var_r25; + s16 var_r24; + M427DllHook var_r23; + + var_r30 = model->unk_120; + GXLoadPosMtxImm(matrix, 0); + GXSetNumTevStages(1); + GXSetNumTexGens(1); + GXSetTexCoordGen2(GX_TEXCOORD0, GX_TG_MTX2x4, GX_TG_TEX0, 0x3C, GX_FALSE, 0x7D); + GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR0A0); + var_r24 = var_r30->unk_10->bmp->dataFmt & 0xF; + if ((var_r24 == 7) || (var_r24 == 8)) { + GXSetTevColorIn(GX_TEVSTAGE0, GX_CC_ZERO, GX_CC_TEXA, GX_CC_RASC, GX_CC_ZERO); + } + else { + GXSetTevColorIn(GX_TEVSTAGE0, GX_CC_ZERO, GX_CC_TEXC, GX_CC_RASC, GX_CC_ZERO); + } + GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV); + GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_TEXA, GX_CA_RASA, GX_CA_ZERO); + GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV); + GXSetNumChans(1); + GXSetChanCtrl(GX_COLOR0A0, GX_FALSE, GX_SRC_REG, GX_SRC_VTX, 0, GX_DF_CLAMP, GX_AF_NONE); + if ((model->attr & 2) != 0) { + GXSetZMode(GX_TRUE, GX_LEQUAL, GX_TRUE); + } + else { + GXSetZMode(GX_TRUE, GX_LEQUAL, GX_FALSE); + } + HuSprTexLoad(var_r30->unk_10, 0, 0, GX_REPEAT, GX_REPEAT, GX_LINEAR); + GXSetAlphaCompare(GX_GEQUAL, 1, GX_AOP_AND, GX_GEQUAL, 1); + GXSetZCompLoc(0); + switch (var_r30->unk_08) { + case 0: + GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_NOOP); + break; + case 1: + GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_ONE, GX_LO_NOOP); + break; + case 2: + GXSetBlendMode(GX_BM_BLEND, GX_BL_ZERO, GX_BL_INVDSTCLR, GX_LO_NOOP); + break; + } + GXClearVtxDesc(); + GXSetVtxDesc(GX_VA_POS, GX_INDEX16); + GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XYZ, GX_F32, 0); + GXSetArray(GX_VA_POS, var_r30->unk_1C, 0xC); + GXSetVtxDesc(GX_VA_CLR0, GX_INDEX16); + GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_CLR0, GX_CLR_RGBA, GX_RGBA8, 0); + GXSetArray(GX_VA_CLR0, var_r30->unk_24, 4); + GXSetVtxDesc(GX_VA_TEX0, GX_INDEX16); + GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX0, GX_TEX_ST, GX_F32, 0); + GXSetArray(GX_VA_TEX0, var_r30->unk_20, 8); + sp128[0][0] = matrix[0][0]; + sp128[1][0] = matrix[0][1]; + sp128[2][0] = matrix[0][2]; + sp128[0][1] = matrix[1][0]; + sp128[1][1] = matrix[1][1]; + sp128[2][1] = matrix[1][2]; + sp128[0][2] = matrix[2][0]; + sp128[1][2] = matrix[2][1]; + sp128[2][2] = matrix[2][2]; + sp128[0][3] = 0.0f; + sp128[1][3] = 0.0f; + sp128[2][3] = 0.0f; + PSMTXReorder(sp128, spF8); + if ((omPauseChk() == 0) && (var_r30->unk_0C)) { + var_r23 = var_r30->unk_0C; + var_r23(model, var_r30, matrix); + } + var_r29 = var_r30->unk_18; + var_r31 = var_r30->unk_1C; + var_r26 = var_r30->unk_20; + PSMTXROMultVecArray(spF8, &var_r30->unk_2C, sp68, 4); + for (var_r25 = 0; var_r25 < var_r30->unk_00; var_r25++, var_r29++, var_r26 += 4) { + if (var_r29->unk_62 == 0) { + var_r31->x = var_r31->y = var_r31->z = 0.0f; + var_r31++; + var_r31->x = var_r31->y = var_r31->z = 0.0f; + var_r31++; + var_r31->x = var_r31->y = var_r31->z = 0.0f; + var_r31++; + var_r31->x = var_r31->y = var_r31->z = 0.0f; + var_r31++; + } + else { + if (var_r29->unk_44 == 0.0f) { + fn_1_E420(sp68, &sp38, &var_r29->unk_48, 4); + PSVECAdd(&sp38, &var_r29->unk_54, var_r31++); + PSVECAdd(&sp44, &var_r29->unk_54, var_r31++); + PSVECAdd(&sp50, &var_r29->unk_54, var_r31++); + PSVECAdd(&sp5C, &var_r29->unk_54, var_r31++); + } + else { + fn_1_E420(&var_r30->unk_2C, &sp38, &var_r29->unk_48, 4); + PSMTXRotRad(spC8, 0x5A, MTXDegToRad(var_r29->unk_44)); + PSMTXConcat(sp128, spC8, sp98); + PSMTXMultVecArray(sp98, &sp38, &sp8, 4); + PSVECAdd(&sp8, &var_r29->unk_54, var_r31++); + PSVECAdd(&sp14, &var_r29->unk_54, var_r31++); + PSVECAdd(&sp20, &var_r29->unk_54, var_r31++); + PSVECAdd(&sp2C, &var_r29->unk_54, var_r31++); + } + if (var_r29->unk_60 != -1) { + fn_1_E37C(var_r26, var_r30->unk_5C, var_r29->unk_60, var_r30->unk_60, var_r30->unk_64); + } + } + } + DCFlushRangeNoSync(var_r30->unk_1C, var_r30->unk_00 * sizeof(Vec) * 4); + DCFlushRangeNoSync(var_r30->unk_20, var_r30->unk_00 * sizeof(Vec2f) * 4); + PPCSync(); + GXCallDisplayList(var_r30->unk_28, var_r30->unk_04); +} + +void fn_1_E2B0(Vec2f *arg0, s16 arg1, s16 arg2, float arg8, float arg9) +{ + s16 var_r31; + s16 var_r30; + s16 var_r29; + + for (var_r31 = 0; var_r31 < arg1; var_r31++, arg0++) { + var_r30 = var_r31 % arg2; + var_r29 = var_r31 / arg2; + arg0->x = var_r30 * arg8; + arg0->y = var_r29 * arg9; + } +} + +void fn_1_E37C(Vec2f *arg0, Vec2f *arg1, s16 arg2, float arg8, float arg9) +{ + arg0[0].x = arg1[arg2].x; + arg0[0].y = arg1[arg2].y; + arg0[1].x = arg8 + arg1[arg2].x; + arg0[1].y = arg1[arg2].y; + arg0[2].x = arg8 + arg1[arg2].x; + arg0[2].y = arg9 + arg1[arg2].y; + arg0[3].x = arg1[arg2].x; + arg0[3].y = arg9 + arg1[arg2].y; +} + +void fn_1_E420(Vec *arg0, Vec *arg1, Vec *arg2, s16 arg3) +{ + s16 var_r31; + + for (var_r31 = 0; var_r31 < arg3; var_r31++, arg0++, arg1++) { + arg1->x = arg0->x * arg2->x; + arg1->y = arg0->y * arg2->y; + arg1->z = arg0->z * arg2->z; + } +} + +void fn_1_E488(void) +{ + if ((HuPadBtnDown[0] & PAD_TRIGGER_L) != 0) { + lbl_1_bss_91 ^= 1; + } + if (lbl_1_bss_91 != 0) { + if ((HuPadBtnDown[0] & PAD_TRIGGER_Z) != 0) { + lbl_1_bss_90 = lbl_1_bss_90 ^ 1; + } + if ((HuPadBtn[0] & PAD_BUTTON_LEFT) != 0) { + CRotM[lbl_1_bss_90].y += 1.0f; + } + if ((HuPadBtn[0] & PAD_BUTTON_RIGHT) != 0) { + CRotM[lbl_1_bss_90].y -= 1.0f; + } + if ((HuPadBtn[0] & PAD_BUTTON_UP) != 0) { + CRotM[lbl_1_bss_90].x -= 1.0f; + } + if ((HuPadBtn[0] & PAD_BUTTON_DOWN) != 0) { + CRotM[lbl_1_bss_90].x += 1.0f; + } + CenterM[lbl_1_bss_90].x += HuPadSubStkX[0]; + if ((HuPadBtn[0] & PAD_TRIGGER_R) != 0) { + CenterM[lbl_1_bss_90].y += HuPadSubStkY[0]; + } + else { + CenterM[lbl_1_bss_90].z += HuPadSubStkY[0]; + } + if ((HuPadBtn[0] & PAD_BUTTON_X) != 0) { + CZoomM[lbl_1_bss_90] += 10.0f; + } + if ((HuPadBtn[0] & PAD_BUTTON_Y) != 0) { + CZoomM[lbl_1_bss_90] -= 10.0f; + } + if ((HuPadBtnDown[0] & PAD_BUTTON_A) != 0) { + OSReport("\nCZoom = %.2f \n", CZoomM[lbl_1_bss_90]); + OSReport("Center x = %.2f: y = %.2f: z = %.2f \n", CenterM[lbl_1_bss_90].x, CenterM[lbl_1_bss_90].y, CenterM[lbl_1_bss_90].z); + OSReport("CRot x = %.2f: y = %.2f: z = %.2f \n", CRotM[lbl_1_bss_90].x, CRotM[lbl_1_bss_90].y, CRotM[lbl_1_bss_90].z); + } + } +} diff --git a/src/REL/m427Dll/player.c b/src/REL/m427Dll/player.c index b27e5584..fe097531 100644 --- a/src/REL/m427Dll/player.c +++ b/src/REL/m427Dll/player.c @@ -1967,7 +1967,7 @@ block_18: return 0; } -s32 fn_1_15F10(Vec *arg0, Vec *arg1, s32 arg2, s32 arg3, s32 arg4) +s32 fn_1_15F10(Vec arg0, Vec arg1, s32 arg2, s32 arg3, s32 arg4) { M427DllBss57CStruct *var_r31; s32 var_r30; @@ -1986,12 +1986,12 @@ s32 fn_1_15F10(Vec *arg0, Vec *arg1, s32 arg2, s32 arg3, s32 arg4) var_r31->unk_10 = arg4; var_r31->unk_18 = arg3; var_r31->unk_14 = 0; - var_r31->unk_1C = *arg0; - var_r31->unk_28 = *arg1; + var_r31->unk_1C = arg0; + var_r31->unk_28 = arg1; return var_r30; } -s32 fn_1_15FD0(Vec *arg0, s32 arg1, s32 arg2, s32 arg3, float arg8) +s32 fn_1_15FD0(Vec arg0, float arg8, s32 arg1, s32 arg2, s32 arg3) { M427DllBss57CStruct *var_r31; s32 var_r30; @@ -2010,7 +2010,7 @@ s32 fn_1_15FD0(Vec *arg0, s32 arg1, s32 arg2, s32 arg3, float arg8) var_r31->unk_10 = arg3; var_r31->unk_18 = arg2; var_r31->unk_14 = 0; - var_r31->unk_1C = *arg0; + var_r31->unk_1C = arg0; var_r31->unk_34 = arg8; return var_r30; } From 721c0d4e412f46215a77d7981dd3f3c5b46f2811 Mon Sep 17 00:00:00 2001 From: dbalatoni13 <40299962+dbalatoni13@users.noreply.github.com> Date: Wed, 5 Feb 2025 17:25:23 +0100 Subject: [PATCH 3/6] Fix m435Dll linking (#559) --- configure.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/configure.py b/configure.py index 1a3c04d9..bd9561f0 100644 --- a/configure.py +++ b/configure.py @@ -1144,7 +1144,7 @@ config.libs = [ "m435Dll", # Darts of Doom objects={ Object(MatchingFor("GMPE01_00", "GMPE01_01", "GMPJ01_00"), "REL/m435Dll/main.c"), - Object(MatchingFor("GMPE01_00", "GMPE01_01" "GMPJ01_00"), "REL/m435Dll/sequence.c"), + Object(MatchingFor("GMPE01_00", "GMPE01_01", "GMPJ01_00"), "REL/m435Dll/sequence.c"), }, ), Rel( From da072c209a2998d4fb39c178ccb29c9bbdd3f729 Mon Sep 17 00:00:00 2001 From: Liam Coleman Date: Wed, 5 Feb 2025 18:07:12 -0600 Subject: [PATCH 4/6] Label most of w01Dll (#560) --- config/GMPE01_00/rels/w01Dll/splits.txt | 4 +- config/GMPE01_00/rels/w01Dll/symbols.txt | 488 ++-- config/GMPP01_00/rels/w01Dll/splits.txt | 4 +- include/REL/w01Dll.h | 52 +- src/REL/w01Dll/main.c | 3258 +++++++++++----------- src/REL/w01Dll/mg_coin.c | 1302 +++++---- src/REL/w01Dll/mg_item.c | 1216 ++++---- 7 files changed, 3152 insertions(+), 3172 deletions(-) diff --git a/config/GMPE01_00/rels/w01Dll/splits.txt b/config/GMPE01_00/rels/w01Dll/splits.txt index 7baca9d9..8e0a4285 100644 --- a/config/GMPE01_00/rels/w01Dll/splits.txt +++ b/config/GMPE01_00/rels/w01Dll/splits.txt @@ -11,13 +11,13 @@ REL/board_executor.c: .rodata start:0x00000000 end:0x00000010 REL/w01Dll/main.c: - .text start:0x000000E0 end:0x00009D00 + .text start:0x000000E0 end:0x00009DD8 .rodata start:0x00000010 end:0x00000198 .data start:0x00000000 end:0x00000658 .bss start:0x00000000 end:0x00000708 REL/w01Dll/mg_coin.c: - .text start:0x00009D00 end:0x0000D740 + .text start:0x00009DD8 end:0x0000D740 .rodata start:0x00000198 end:0x000002C8 .data start:0x00000658 end:0x00000F08 .bss start:0x00000708 end:0x000007A0 diff --git a/config/GMPE01_00/rels/w01Dll/symbols.txt b/config/GMPE01_00/rels/w01Dll/symbols.txt index ad0e3d24..66542f00 100644 --- a/config/GMPE01_00/rels/w01Dll/symbols.txt +++ b/config/GMPE01_00/rels/w01Dll/symbols.txt @@ -3,137 +3,137 @@ _prolog = .text:0x00000030; // type:function size:0x64 scope:global _epilog = .text:0x00000094; // type:function size:0x4C scope:global BoardCreate = .text:0x000000E0; // type:function size:0x4BC BoardDestroy = .text:0x0000059C; // type:function size:0x194 -fn_1_730 = .text:0x00000730; // type:function size:0x44 scope:local -fn_1_774 = .text:0x00000774; // type:function size:0x4 scope:local -fn_1_778 = .text:0x00000778; // type:function size:0x9C scope:local -fn_1_814 = .text:0x00000814; // type:function size:0x1D4 scope:local -fn_1_9E8 = .text:0x000009E8; // type:function size:0x318 scope:local +LightSetHook = .text:0x00000730; // type:function size:0x44 scope:local +LightResetHook = .text:0x00000774; // type:function size:0x4 scope:local +LandEvent = .text:0x00000778; // type:function size:0x9C scope:local +WalkEvent = .text:0x00000814; // type:function size:0x1D4 scope:local +MapObjDispSet = .text:0x000009E8; // type:function size:0x318 scope:local fn_1_D00 = .text:0x00000D00; // type:function size:0x4 scope:local -fn_1_D04 = .text:0x00000D04; // type:function size:0x550 scope:local -fn_1_1254 = .text:0x00001254; // type:function size:0x38 scope:local -fn_1_128C = .text:0x0000128C; // type:function size:0x80 scope:local -fn_1_130C = .text:0x0000130C; // type:function size:0x270 scope:local -fn_1_157C = .text:0x0000157C; // type:function size:0xF4 scope:local -fn_1_1670 = .text:0x00001670; // type:function size:0x90 scope:local -fn_1_1700 = .text:0x00001700; // type:function size:0x290 scope:local -fn_1_1990 = .text:0x00001990; // type:function size:0x148 scope:local -fn_1_1AD8 = .text:0x00001AD8; // type:function size:0x64 scope:local -fn_1_1B3C = .text:0x00001B3C; // type:function size:0x3A8 scope:local -fn_1_1EE4 = .text:0x00001EE4; // type:function size:0x48 scope:local -fn_1_1F2C = .text:0x00001F2C; // type:function size:0x78 scope:local -fn_1_1FA4 = .text:0x00001FA4; // type:function size:0x580 scope:local -fn_1_2524 = .text:0x00002524; // type:function size:0x248 scope:local -fn_1_276C = .text:0x0000276C; // type:function size:0x7AC scope:local -fn_1_2F18 = .text:0x00002F18; // type:function size:0x438 scope:local -fn_1_3350 = .text:0x00003350; // type:function size:0x1C4 scope:local -fn_1_3514 = .text:0x00003514; // type:function size:0xA0 scope:local -fn_1_35B4 = .text:0x000035B4; // type:function size:0x70 scope:local -fn_1_3624 = .text:0x00003624; // type:function size:0xFD0 scope:local -fn_1_45F4 = .text:0x000045F4; // type:function size:0x180 scope:local -fn_1_4774 = .text:0x00004774; // type:function size:0xF0 scope:local -fn_1_4864 = .text:0x00004864; // type:function size:0x50 scope:local -fn_1_48B4 = .text:0x000048B4; // type:function size:0x560 scope:local -fn_1_4E14 = .text:0x00004E14; // type:function size:0x194 scope:local -fn_1_4FA8 = .text:0x00004FA8; // type:function size:0x30 scope:local -fn_1_4FD8 = .text:0x00004FD8; // type:function size:0xFC scope:local -fn_1_50D4 = .text:0x000050D4; // type:function size:0x2E4 scope:local -fn_1_53B8 = .text:0x000053B8; // type:function size:0x84 scope:local -fn_1_543C = .text:0x0000543C; // type:function size:0x258 scope:local -fn_1_5694 = .text:0x00005694; // type:function size:0x1D8 scope:local -fn_1_586C = .text:0x0000586C; // type:function size:0xC0 scope:local -fn_1_592C = .text:0x0000592C; // type:function size:0x200 scope:local -fn_1_5B2C = .text:0x00005B2C; // type:function size:0x14 scope:local -fn_1_5B40 = .text:0x00005B40; // type:function size:0x190 scope:local -fn_1_5CD0 = .text:0x00005CD0; // type:function size:0x38 scope:local -fn_1_5D08 = .text:0x00005D08; // type:function size:0x390 scope:local -fn_1_6098 = .text:0x00006098; // type:function size:0xFC scope:local -fn_1_6194 = .text:0x00006194; // type:function size:0x25C scope:local -fn_1_63F0 = .text:0x000063F0; // type:function size:0x624 scope:local -fn_1_6A14 = .text:0x00006A14; // type:function size:0x1AC scope:local -fn_1_6BC0 = .text:0x00006BC0; // type:function size:0x3F4 scope:local -fn_1_6FB4 = .text:0x00006FB4; // type:function size:0x574 scope:local -fn_1_7528 = .text:0x00007528; // type:function size:0x2C4 scope:local -fn_1_77EC = .text:0x000077EC; // type:function size:0xA8 scope:local -fn_1_7894 = .text:0x00007894; // type:function size:0x1D0 scope:local -fn_1_7A64 = .text:0x00007A64; // type:function size:0xAC8 scope:local -fn_1_852C = .text:0x0000852C; // type:function size:0x280 scope:local -fn_1_87AC = .text:0x000087AC; // type:function size:0x34 scope:local -fn_1_87E0 = .text:0x000087E0; // type:function size:0x1A8 scope:local -fn_1_8988 = .text:0x00008988; // type:function size:0xC8 scope:local -fn_1_8A50 = .text:0x00008A50; // type:function size:0x11C scope:local -fn_1_8B6C = .text:0x00008B6C; // type:function size:0x270 scope:local -fn_1_8DDC = .text:0x00008DDC; // type:function size:0x3B0 scope:local -fn_1_918C = .text:0x0000918C; // type:function size:0xF0 scope:local -fn_1_927C = .text:0x0000927C; // type:function size:0xB0 scope:local -fn_1_932C = .text:0x0000932C; // type:function size:0x17C scope:local -fn_1_94A8 = .text:0x000094A8; // type:function size:0x14C scope:local -fn_1_95F4 = .text:0x000095F4; // type:function size:0x200 scope:local -fn_1_97F4 = .text:0x000097F4; // type:function size:0xF8 scope:local -fn_1_98EC = .text:0x000098EC; // type:function size:0x34 scope:local -fn_1_9920 = .text:0x00009920; // type:function size:0x104 scope:local -fn_1_9A24 = .text:0x00009A24; // type:function size:0x198 scope:local -fn_1_9BBC = .text:0x00009BBC; // type:function size:0x144 scope:local -fn_1_9D00 = .text:0x00009D00; // type:function size:0xD8 -fn_1_9DD8 = .text:0x00009DD8; // type:function size:0x6E0 -fn_1_A4B8 = .text:0x0000A4B8; // type:function size:0x9C scope:local -fn_1_A554 = .text:0x0000A554; // type:function size:0xA8 scope:local -fn_1_A5FC = .text:0x0000A5FC; // type:function size:0xE4 scope:local -fn_1_A6E0 = .text:0x0000A6E0; // type:function size:0x938 scope:local -fn_1_B018 = .text:0x0000B018; // type:function size:0x70 scope:local -fn_1_B088 = .text:0x0000B088; // type:function size:0x144 scope:local -fn_1_B1CC = .text:0x0000B1CC; // type:function size:0x1EC scope:local -fn_1_B3B8 = .text:0x0000B3B8; // type:function size:0xC0 scope:local -fn_1_B478 = .text:0x0000B478; // type:function size:0x680 scope:local -fn_1_BAF8 = .text:0x0000BAF8; // type:function size:0x1E4 scope:local -fn_1_BCDC = .text:0x0000BCDC; // type:function size:0x224 scope:local -fn_1_BF00 = .text:0x0000BF00; // type:function size:0x68 scope:local -fn_1_BF68 = .text:0x0000BF68; // type:function size:0x98 scope:local -fn_1_C000 = .text:0x0000C000; // type:function size:0xFC scope:local -fn_1_C0FC = .text:0x0000C0FC; // type:function size:0x160 scope:local -fn_1_C25C = .text:0x0000C25C; // type:function size:0x5E8 scope:local -fn_1_C844 = .text:0x0000C844; // type:function size:0x50 scope:local -fn_1_C894 = .text:0x0000C894; // type:function size:0xB8 scope:local -fn_1_C94C = .text:0x0000C94C; // type:function size:0x4C scope:local -fn_1_C998 = .text:0x0000C998; // type:function size:0x1AC scope:local -fn_1_CB44 = .text:0x0000CB44; // type:function size:0x380 scope:local -fn_1_CEC4 = .text:0x0000CEC4; // type:function size:0x170 scope:local -fn_1_D034 = .text:0x0000D034; // type:function size:0x48 scope:local -fn_1_D07C = .text:0x0000D07C; // type:function size:0x98 scope:local -fn_1_D114 = .text:0x0000D114; // type:function size:0x62C scope:local -fn_1_D740 = .text:0x0000D740; // type:function size:0x644 -fn_1_DD84 = .text:0x0000DD84; // type:function size:0x110 -fn_1_DE94 = .text:0x0000DE94; // type:function size:0x26C -fn_1_E100 = .text:0x0000E100; // type:function size:0x54 scope:local -fn_1_E154 = .text:0x0000E154; // type:function size:0x164 scope:local -fn_1_E2B8 = .text:0x0000E2B8; // type:function size:0x194 scope:local -fn_1_E44C = .text:0x0000E44C; // type:function size:0x4C8 scope:local -fn_1_E914 = .text:0x0000E914; // type:function size:0x3C0 scope:local -fn_1_ECD4 = .text:0x0000ECD4; // type:function size:0x1CC scope:local -fn_1_EEA0 = .text:0x0000EEA0; // type:function size:0x38 scope:local -fn_1_EED8 = .text:0x0000EED8; // type:function size:0x1C4 scope:local -fn_1_F09C = .text:0x0000F09C; // type:function size:0x2AC scope:local -fn_1_F348 = .text:0x0000F348; // type:function size:0xB0 scope:local -fn_1_F3F8 = .text:0x0000F3F8; // type:function size:0x2F0 scope:local -fn_1_F6E8 = .text:0x0000F6E8; // type:function size:0x1A8 scope:local -fn_1_F890 = .text:0x0000F890; // type:function size:0x18C scope:local -fn_1_FA1C = .text:0x0000FA1C; // type:function size:0xA0 scope:local -fn_1_FABC = .text:0x0000FABC; // type:function size:0x9C scope:local -fn_1_FB58 = .text:0x0000FB58; // type:function size:0xE4 scope:local -fn_1_FC3C = .text:0x0000FC3C; // type:function size:0xB0 scope:local -fn_1_FCEC = .text:0x0000FCEC; // type:function size:0x50 scope:local -fn_1_FD3C = .text:0x0000FD3C; // type:function size:0x108 scope:local -fn_1_FE44 = .text:0x0000FE44; // type:function size:0x8C scope:local -fn_1_FED0 = .text:0x0000FED0; // type:function size:0x14C scope:local -fn_1_1001C = .text:0x0001001C; // type:function size:0x19C scope:local -fn_1_101B8 = .text:0x000101B8; // type:function size:0x4AC scope:local -fn_1_10664 = .text:0x00010664; // type:function size:0x1BC scope:local -fn_1_10820 = .text:0x00010820; // type:function size:0x2C8 scope:local -fn_1_10AE8 = .text:0x00010AE8; // type:function size:0xC8 scope:local -fn_1_10BB0 = .text:0x00010BB0; // type:function size:0x140 scope:local -fn_1_10CF0 = .text:0x00010CF0; // type:function size:0x1C8 scope:local -fn_1_10EB8 = .text:0x00010EB8; // type:function size:0x1AC scope:local -fn_1_11064 = .text:0x00011064; // type:function size:0x420 scope:local -fn_1_11484 = .text:0x00011484; // type:function size:0x56C scope:local +RoundItemMain = .text:0x00000D04; // type:function size:0x550 scope:local +RoundItemDestroy = .text:0x00001254; // type:function size:0x38 scope:local +RoundItemEvent = .text:0x0000128C; // type:function size:0x80 scope:local +SpaceAmidaEvent = .text:0x0000130C; // type:function size:0x270 scope:local +WalkMiniEvent = .text:0x0000157C; // type:function size:0xF4 scope:local +UpdateHostDisp = .text:0x00001670; // type:function size:0x90 scope:local +CoasterInit = .text:0x00001700; // type:function size:0x290 scope:local +CoasterPathUpdate = .text:0x00001990; // type:function size:0x148 scope:local +CoasterPosCalc = .text:0x00001AD8; // type:function size:0x64 scope:local +CoasterCameraUpdate = .text:0x00001B3C; // type:function size:0x3A8 scope:local +CoasterCameraObjKill = .text:0x00001EE4; // type:function size:0x48 scope:local +CoasterCameraObjMain = .text:0x00001F2C; // type:function size:0x78 scope:local +CoasterCameraObjUpdate = .text:0x00001FA4; // type:function size:0x580 scope:local +CoasterStickRotGet = .text:0x00002524; // type:function size:0x248 scope:local +CoasterRotUpdate = .text:0x0000276C; // type:function size:0x7AC scope:local +CoasterCoinCheck = .text:0x00002F18; // type:function size:0x438 scope:local +CoasterPathMotUpdate = .text:0x00003350; // type:function size:0x1C4 scope:local +CoasterMotCreate = .text:0x00003514; // type:function size:0xA0 scope:local +CoasterMotKill = .text:0x000035B4; // type:function size:0x70 scope:local +CoasterExec = .text:0x00003624; // type:function size:0xFD0 scope:local +CoasterExit = .text:0x000045F4; // type:function size:0x180 scope:local +CoasterWinCreate = .text:0x00004774; // type:function size:0xF0 scope:local +CoasterWinKill = .text:0x00004864; // type:function size:0x50 scope:local +CoasterHostExec = .text:0x000048B4; // type:function size:0x560 scope:local +CoasterMain = .text:0x00004E14; // type:function size:0x194 scope:local +CoasterDestroy = .text:0x00004FA8; // type:function size:0x30 scope:local +CoasterEvent = .text:0x00004FD8; // type:function size:0xFC scope:local +CoasterCoinCreate = .text:0x000050D4; // type:function size:0x2E4 scope:local +CoasterCoinKill = .text:0x000053B8; // type:function size:0x84 scope:local +CupInit = .text:0x0000543C; // type:function size:0x258 scope:local +CupMotOnSet = .text:0x00005694; // type:function size:0x1D8 scope:local +CupEvent = .text:0x0000586C; // type:function size:0xC0 scope:local +CupMain = .text:0x0000592C; // type:function size:0x200 scope:local +CupDestroy = .text:0x00005B2C; // type:function size:0x14 scope:local +CupExec = .text:0x00005B40; // type:function size:0x190 scope:local +CupObjCheck = .text:0x00005CD0; // type:function size:0x38 scope:local +CupObjCreate = .text:0x00005D08; // type:function size:0x390 scope:local +CupObjMain = .text:0x00006098; // type:function size:0xFC scope:local +CupObjInit = .text:0x00006194; // type:function size:0x25C scope:local +CupObjJumpWait = .text:0x000063F0; // type:function size:0x624 scope:local +CupObjHookReset = .text:0x00006A14; // type:function size:0x1AC scope:local +CupObjStop = .text:0x00006BC0; // type:function size:0x3F4 scope:local +CupObjRotate = .text:0x00006FB4; // type:function size:0x574 scope:local +CupLandEvent = .text:0x00007528; // type:function size:0x2C4 scope:local +CoasterLandEvent = .text:0x000077EC; // type:function size:0xA8 scope:local +CoasterLandMain = .text:0x00007894; // type:function size:0x1D0 scope:local +CoasterLandExec = .text:0x00007A64; // type:function size:0xAC8 scope:local +CoasterPlayerManCreate = .text:0x0000852C; // type:function size:0x280 scope:local +CoasterPlayerManKill = .text:0x000087AC; // type:function size:0x34 scope:local +CoasterPlayerManUpdate = .text:0x000087E0; // type:function size:0x1A8 scope:local +CoasterPlayerWait = .text:0x00008988; // type:function size:0xC8 scope:local +CoasterPlayerChaseBegin = .text:0x00008A50; // type:function size:0x11C scope:local +CoasterPlayerChasePathSet = .text:0x00008B6C; // type:function size:0x270 scope:local +CoasterPlayerChase = .text:0x00008DDC; // type:function size:0x3B0 scope:local +CoasterPlayerStop = .text:0x0000918C; // type:function size:0xF0 scope:local +CoasterPlayerEnd = .text:0x0000927C; // type:function size:0xB0 scope:local +CoasterPlayerEndSet = .text:0x0000932C; // type:function size:0x17C scope:local +CoasterPlayerLoopCheck = .text:0x000094A8; // type:function size:0x14C scope:local +CoasterPlayerTimeInit = .text:0x000095F4; // type:function size:0x200 scope:local +CoasterEffCreate = .text:0x000097F4; // type:function size:0xF8 scope:local +CoasterEffKill = .text:0x000098EC; // type:function size:0x34 scope:local +CoasterEffUpdate = .text:0x00009920; // type:function size:0x104 scope:local +CoasterEffAdd = .text:0x00009A24; // type:function size:0x198 scope:local +CoasterEffModelUpdate = .text:0x00009BBC; // type:function size:0x144 scope:local +CoasterHostComKeySet = .text:0x00009D00; // type:function size:0xD8 scope:local +SpaceAmidaExec = .text:0x00009DD8; // type:function size:0x6E0 +SpaceAmidaMainUpdate = .text:0x0000A4B8; // type:function size:0x9C scope:local +SpaceAmidaStop = .text:0x0000A554; // type:function size:0xA8 scope:local +SpaceAmidaKill = .text:0x0000A5FC; // type:function size:0xE4 scope:local +SpaceAmidaRocketObjUpdate = .text:0x0000A6E0; // type:function size:0x938 scope:local +SpaceAmidaMapLenGet = .text:0x0000B018; // type:function size:0x70 scope:local +SpaceAmidaComChoiceSet = .text:0x0000B088; // type:function size:0x144 scope:local +SpaceAmidaComInputGet = .text:0x0000B1CC; // type:function size:0x1EC scope:local +SpaceAmidaGameOpen = .text:0x0000B3B8; // type:function size:0xC0 scope:local +SpaceAmidaGameUpdate = .text:0x0000B478; // type:function size:0x680 scope:local +SpaceAmidaRocketJump = .text:0x0000BAF8; // type:function size:0x1E4 scope:local +SpaceAmidaRocketKemuriExec = .text:0x0000BCDC; // type:function size:0x224 scope:local +SpaceAmidaRocketWait = .text:0x0000BF00; // type:function size:0x68 scope:local +SpaceAmidaRocketUp = .text:0x0000BF68; // type:function size:0x98 scope:local +SpaceAmidaCoinWin = .text:0x0000C000; // type:function size:0xFC scope:local +SpaceAmidaJumpDown = .text:0x0000C0FC; // type:function size:0x160 scope:local +SpaceAmidaCoinRainMain = .text:0x0000C25C; // type:function size:0x5E8 scope:local +SpaceAmidaReturnWinMain = .text:0x0000C844; // type:function size:0x50 scope:local +SpaceAmidaGameStop = .text:0x0000C894; // type:function size:0xB8 scope:local +SpaceAmidaDirGet = .text:0x0000C94C; // type:function size:0x4C scope:local +SpaceAmidaAngleGet = .text:0x0000C998; // type:function size:0x1AC scope:local +SpaceAmidaPlayerRotAdd = .text:0x0000CB44; // type:function size:0x380 scope:local +SpaceAmidaEffCreate = .text:0x0000CEC4; // type:function size:0x170 scope:local +SpaceAmidaEffKill = .text:0x0000D034; // type:function size:0x48 scope:local +SpaceAmidaEffUpdate = .text:0x0000D07C; // type:function size:0x98 scope:local +SpaceAmidaEffParticleHook = .text:0x0000D114; // type:function size:0x62C scope:local +RoundItemInit = .text:0x0000D740; // type:function size:0x644 +RoundItemKill = .text:0x0000DD84; // type:function size:0x110 +RoundItemEventStart = .text:0x0000DE94; // type:function size:0x26C +RoundItemEnd = .text:0x0000E100; // type:function size:0x54 scope:local +RoundItemClose = .text:0x0000E154; // type:function size:0x164 scope:local +RoundItemMainUpdate = .text:0x0000E2B8; // type:function size:0x194 scope:local +RoundItemUmaStop = .text:0x0000E44C; // type:function size:0x4C8 scope:local +RoundItemPlayerJump = .text:0x0000E914; // type:function size:0x3C0 scope:local +RoundItemStartWait = .text:0x0000ECD4; // type:function size:0x1CC scope:local +RoundItemComInputGet = .text:0x0000EEA0; // type:function size:0x38 scope:local +RoundItemInputWait = .text:0x0000EED8; // type:function size:0x1C4 scope:local +RoundItemStop = .text:0x0000F09C; // type:function size:0x2AC scope:local +RoundItemLightFlicker = .text:0x0000F348; // type:function size:0xB0 scope:local +RoundItemUmaJumpWait = .text:0x0000F3F8; // type:function size:0x2F0 scope:local +RoundItemUmaJump = .text:0x0000F6E8; // type:function size:0x1A8 scope:local +RoundItemRotatePlayer = .text:0x0000F890; // type:function size:0x18C scope:local +RoundItemStreamWait = .text:0x0000FA1C; // type:function size:0xA0 scope:local +RoundItemWinWait = .text:0x0000FABC; // type:function size:0x9C scope:local +ItemGetWinExec = .text:0x0000FB58; // type:function size:0xE4 scope:local +ItemGetShrinkWait = .text:0x0000FC3C; // type:function size:0xB0 scope:local +ItemGetReturnWinExec = .text:0x0000FCEC; // type:function size:0x50 scope:local +RoundItemGameClose = .text:0x0000FD3C; // type:function size:0x108 scope:local +RoundItemGameEnd = .text:0x0000FE44; // type:function size:0x8C scope:local +RoundItemItemUpdate = .text:0x0000FED0; // type:function size:0x14C scope:local +RoundItemItemGet = .text:0x0001001C; // type:function size:0x19C scope:local +ItemGetCreate = .text:0x000101B8; // type:function size:0x4AC scope:local +ItemGetObjUpdate = .text:0x00010664; // type:function size:0x1BC scope:local +ItemGetPlayerMove = .text:0x00010820; // type:function size:0x2C8 scope:local +ItemGetShrink = .text:0x00010AE8; // type:function size:0xC8 scope:local +RoundItemUmaRotYGet = .text:0x00010BB0; // type:function size:0x140 scope:local +RoundItemUmaPlayerSet = .text:0x00010CF0; // type:function size:0x1C8 scope:local +RoundItemAngleGet = .text:0x00010EB8; // type:function size:0x1AC scope:local +ItemGetEff1Hook = .text:0x00011064; // type:function size:0x420 scope:local +ItemGetEff2Hook = .text:0x00011484; // type:function size:0x56C scope:local _ctors = .ctors:0x00000000; // type:label scope:global data:4byte _dtors = .dtors:0x00000000; // type:label scope:global data:4byte lbl_1_rodata_10 = .rodata:0x00000010; // type:object size:0x4 scope:local data:float @@ -334,136 +334,136 @@ lbl_1_rodata_3B4 = .rodata:0x000003B4; // type:object size:0x4 scope:local data: lbl_1_rodata_3B8 = .rodata:0x000003B8; // type:object size:0x4 scope:local data:float lbl_1_rodata_3BC = .rodata:0x000003BC; // type:object size:0x4 scope:local data:float lbl_1_rodata_3C0 = .rodata:0x000003C0; // type:object size:0x4 scope:local data:float -lbl_1_data_0 = .data:0x00000000; // type:object size:0x528 scope:local -lbl_1_data_528 = .data:0x00000528; // type:object size:0x2 scope:local data:2byte -lbl_1_data_52A = .data:0x0000052A; // type:object size:0x2 scope:local data:2byte -lbl_1_data_52C = .data:0x0000052C; // type:object size:0x2 scope:local data:2byte -lbl_1_data_52E = .data:0x0000052E; // type:object size:0x2 scope:local data:2byte -lbl_1_data_530 = .data:0x00000530; // type:object size:0x2 scope:local data:2byte -lbl_1_data_534 = .data:0x00000534; // type:object size:0x8 scope:local -lbl_1_data_53C = .data:0x0000053C; // type:object size:0x8 scope:local +mapObjData = .data:0x00000000; // type:object size:0x528 scope:local +bgMdl = .data:0x00000528; // type:object size:0x2 scope:local data:2byte +fgMdl = .data:0x0000052A; // type:object size:0x2 scope:local data:2byte +starHostMdl = .data:0x0000052C; // type:object size:0x2 scope:local data:2byte +hostMdl = .data:0x0000052E; // type:object size:0x2 scope:local data:2byte +syuppouMdl = .data:0x00000530; // type:object size:0x2 scope:local data:2byte +starHostMotTbl = .data:0x00000534; // type:object size:0x8 scope:local +hostMotTbl = .data:0x0000053C; // type:object size:0x8 scope:local lbl_1_data_544 = .data:0x00000544; // type:object size:0x14 scope:local data:string lbl_1_data_558 = .data:0x00000558; // type:object size:0x14 scope:local data:string lbl_1_data_56C = .data:0x0000056C; // type:object size:0x13 scope:local data:string -lbl_1_data_580 = .data:0x00000580; // type:object size:0x2 scope:local data:2byte +coasterWinId = .data:0x00000580; // type:object size:0x2 scope:local data:2byte lbl_1_data_582 = .data:0x00000582; // type:object size:0x12 scope:local -lbl_1_data_594 = .data:0x00000594; // type:object size:0x40 scope:local -lbl_1_data_5D4 = .data:0x000005D4; // type:object size:0x4 scope:local data:4byte -lbl_1_data_5D8 = .data:0x000005D8; // type:object size:0x4 scope:local data:4byte -lbl_1_data_5DC = .data:0x000005DC; // type:object size:0x10 scope:local data:2byte +coasterMotTbl = .data:0x00000594; // type:object size:0x40 scope:local +cupMoveSeNo = .data:0x000005D4; // type:object size:0x4 scope:local data:4byte +decaStompSeNo = .data:0x000005D8; // type:object size:0x4 scope:local data:4byte +cupMapObj = .data:0x000005DC; // type:object size:0x10 scope:local data:2byte lbl_1_data_5EC = .data:0x000005EC; // type:object size:0x7 scope:local data:string lbl_1_data_5F3 = .data:0x000005F3; // type:object size:0x7 scope:local data:string lbl_1_data_5FA = .data:0x000005FA; // type:object size:0x7 scope:local data:string -lbl_1_data_604 = .data:0x00000604; // type:object size:0xC scope:local -lbl_1_data_610 = .data:0x00000610; // type:object size:0x10 scope:local +cupHookTbl = .data:0x00000604; // type:object size:0xC scope:local +cupArrowRot = .data:0x00000610; // type:object size:0x10 scope:local lbl_1_data_620 = .data:0x00000620; // type:object size:0x5 scope:local data:string lbl_1_data_625 = .data:0x00000625; // type:object size:0x5 scope:local data:string lbl_1_data_62A = .data:0x0000062A; // type:object size:0x5 scope:local data:string lbl_1_data_62F = .data:0x0000062F; // type:object size:0x4 scope:local data:string -lbl_1_data_633 = .data:0x00000633; // type:object size:0x1 scope:local data:byte -lbl_1_data_634 = .data:0x00000634; // type:object size:0x24 scope:local -lbl_1_data_658 = .data:0x00000658; // type:object size:0x24 scope:local -lbl_1_data_67C = .data:0x0000067C; // type:object size:0x12 scope:local data:2byte -lbl_1_data_690 = .data:0x00000690; // type:object size:0x2D0 scope:local -lbl_1_data_960 = .data:0x00000960; // type:object size:0x2D0 scope:local -lbl_1_data_C30 = .data:0x00000C30; // type:object size:0x2D0 scope:local +coasterChasePlayer = .data:0x00000633; // type:object size:0x1 scope:local data:byte +coasterChaseSe = .data:0x00000634; // type:object size:0x24 scope:local +effPosTbl = .data:0x00000658; // type:object size:0x24 scope:local +spaceAmidaCoinNumTbl = .data:0x0000067C; // type:object size:0x12 scope:local data:2byte +spaceAmidaMap1 = .data:0x00000690; // type:object size:0x2D0 scope:local +spaceAmidaMap2 = .data:0x00000960; // type:object size:0x2D0 scope:local +spaceAmidaMap3 = .data:0x00000C30; // type:object size:0x2D0 scope:local lbl_1_data_F00 = .data:0x00000F00; // type:object size:0x3 scope:local data:string -lbl_1_data_F08 = .data:0x00000F08; // type:object size:0x38 scope:local -lbl_1_data_F40 = .data:0x00000F40; // type:object size:0x20 scope:local -lbl_1_data_F60 = .data:0x00000F60; // type:object size:0x20 scope:local +itemMdlTbl = .data:0x00000F08; // type:object size:0x38 scope:local +itemGetMotTbl = .data:0x00000F40; // type:object size:0x20 scope:local +jumpMotTbl = .data:0x00000F60; // type:object size:0x20 scope:local lbl_1_data_F80 = .data:0x00000F80; // type:object size:0x7 scope:local data:string lbl_1_data_F87 = .data:0x00000F87; // type:object size:0x5 scope:local data:string lbl_1_data_F8C = .data:0x00000F8C; // type:object size:0x5 scope:local data:string lbl_1_data_F91 = .data:0x00000F91; // type:object size:0x5 scope:local data:string lbl_1_data_F96 = .data:0x00000F96; // type:object size:0x5 scope:local data:string -lbl_1_data_F9C = .data:0x00000F9C; // type:object size:0x10 scope:local data:4byte -lbl_1_bss_0 = .bss:0x00000000; // type:object size:0x4 data:4byte -lbl_1_bss_4 = .bss:0x00000004; // type:object size:0x4 scope:local data:4byte -lbl_1_bss_8 = .bss:0x00000008; // type:object size:0x4 scope:local data:4byte -lbl_1_bss_C = .bss:0x0000000C; // type:object size:0x4 scope:local data:4byte -lbl_1_bss_10 = .bss:0x00000010; // type:object size:0x4 scope:local data:4byte -lbl_1_bss_14 = .bss:0x00000014; // type:object size:0x4 scope:local data:4byte -lbl_1_bss_18 = .bss:0x00000018; // type:object size:0x4 scope:local data:4byte -lbl_1_bss_1C = .bss:0x0000001C; // type:object size:0x1 scope:local data:byte -lbl_1_bss_20 = .bss:0x00000020; // type:object size:0x4 scope:local data:4byte -lbl_1_bss_24 = .bss:0x00000024; // type:object size:0x2 scope:local data:2byte -lbl_1_bss_26 = .bss:0x00000026; // type:object size:0x2 scope:local data:2byte -lbl_1_bss_28 = .bss:0x00000028; // type:object size:0x1 scope:local data:byte -lbl_1_bss_29 = .bss:0x00000029; // type:object size:0x1 scope:local data:byte +umaHookTbl = .data:0x00000F9C; // type:object size:0x10 scope:local data:4byte +boardWork = .bss:0x00000000; // type:object size:0x4 data:4byte +roundItemProc = .bss:0x00000004; // type:object size:0x4 scope:local data:4byte +coasterProc = .bss:0x00000008; // type:object size:0x4 scope:local data:4byte +coasterPlayerManObj = .bss:0x0000000C; // type:object size:0x4 scope:local data:4byte +coasterCameraObj = .bss:0x00000010; // type:object size:0x4 scope:local data:4byte +cupProc = .bss:0x00000014; // type:object size:0x4 scope:local data:4byte +cupObj = .bss:0x00000018; // type:object size:0x4 scope:local data:4byte +coasterPlayerChaseNum = .bss:0x0000001C; // type:object size:0x1 scope:local data:byte +coasterEffObj = .bss:0x00000020; // type:object size:0x4 scope:local data:4byte +cupSpaceEnd = .bss:0x00000024; // type:object size:0x2 scope:local data:2byte +cupSpaceStart = .bss:0x00000026; // type:object size:0x2 scope:local data:2byte +cupHookNo = .bss:0x00000028; // type:object size:0x1 scope:local data:byte +cupSide = .bss:0x00000029; // type:object size:0x1 scope:local data:byte lbl_1_bss_2C = .bss:0x0000002C; // type:object size:0x5A0 scope:local -lbl_1_bss_5CC = .bss:0x000005CC; // type:object size:0x4 scope:local data:2byte -lbl_1_bss_5D0 = .bss:0x000005D0; // type:object size:0x30 scope:local -lbl_1_bss_600 = .bss:0x00000600; // type:object size:0x18 scope:local -lbl_1_bss_618 = .bss:0x00000618; // type:object size:0xC scope:local data:4byte -lbl_1_bss_624 = .bss:0x00000624; // type:object size:0xC scope:local data:float -lbl_1_bss_630 = .bss:0x00000630; // type:object size:0xC scope:local data:4byte -lbl_1_bss_63C = .bss:0x0000063C; // type:object size:0x4 scope:local data:float -lbl_1_bss_640 = .bss:0x00000640; // type:object size:0x4 scope:local data:float -lbl_1_bss_644 = .bss:0x00000644; // type:object size:0x4 scope:local data:float -lbl_1_bss_648 = .bss:0x00000648; // type:object size:0xC scope:local data:4byte -lbl_1_bss_654 = .bss:0x00000654; // type:object size:0xC scope:local data:float -lbl_1_bss_660 = .bss:0x00000660; // type:object size:0xC scope:local data:float -lbl_1_bss_66C = .bss:0x0000066C; // type:object size:0x4 scope:local data:float -lbl_1_bss_670 = .bss:0x00000670; // type:object size:0x4 scope:local data:float -lbl_1_bss_674 = .bss:0x00000674; // type:object size:0x4 scope:local data:float -lbl_1_bss_678 = .bss:0x00000678; // type:object size:0x30 scope:local +coasterMotId = .bss:0x000005CC; // type:object size:0x4 scope:local data:2byte +coasterCoinMdlId = .bss:0x000005D0; // type:object size:0x30 scope:local +coasterCoinF = .bss:0x00000600; // type:object size:0x18 scope:local +coasterCameraTarget = .bss:0x00000618; // type:object size:0xC scope:local data:4byte +coasterCameraUp = .bss:0x00000624; // type:object size:0xC scope:local data:float +coasterCameraPos = .bss:0x00000630; // type:object size:0xC scope:local data:4byte +coasterBaseRotY = .bss:0x0000063C; // type:object size:0x4 scope:local data:float +coasterTime = .bss:0x00000640; // type:object size:0x4 scope:local data:float +coasterMaxTime = .bss:0x00000644; // type:object size:0x4 scope:local data:float +coasterPosOld = .bss:0x00000648; // type:object size:0xC scope:local data:4byte +coasterPos = .bss:0x00000654; // type:object size:0xC scope:local data:float +coasterRot = .bss:0x00000660; // type:object size:0xC scope:local data:float +coasterCamSpeed = .bss:0x0000066C; // type:object size:0x4 scope:local data:float +coasterSpeed = .bss:0x00000670; // type:object size:0x4 scope:local data:float +coasterAccel = .bss:0x00000674; // type:object size:0x4 scope:local data:float +coasterMtx = .bss:0x00000678; // type:object size:0x30 scope:local lbl_1_bss_6A8 = .bss:0x000006A8; // type:object size:0x4 scope:local data:float -lbl_1_bss_6AC = .bss:0x000006AC; // type:object size:0x2 scope:local data:2byte -lbl_1_bss_6AE = .bss:0x000006AE; // type:object size:0x2 scope:local data:2byte -lbl_1_bss_6B0 = .bss:0x000006B0; // type:object size:0x1 scope:local data:byte -lbl_1_bss_6B1 = .bss:0x000006B1; // type:object size:0x1 scope:local data:byte -lbl_1_bss_6B2 = .bss:0x000006B2; // type:object size:0x1 scope:local data:byte -lbl_1_bss_6B3 = .bss:0x000006B3; // type:object size:0x1 scope:local data:byte -lbl_1_bss_6B4 = .bss:0x000006B4; // type:object size:0x1 scope:local data:byte -lbl_1_bss_6B6 = .bss:0x000006B6; // type:object size:0xA scope:local data:2byte -lbl_1_bss_6C0 = .bss:0x000006C0; // type:object size:0x4 scope:local data:4byte -lbl_1_bss_6C4 = .bss:0x000006C4; // type:object size:0x42 data:2byte -lbl_1_bss_708 = .bss:0x00000708; // type:object size:0x2 scope:local data:2byte -lbl_1_bss_70C = .bss:0x0000070C; // type:object size:0x4 scope:local data:4byte -lbl_1_bss_710 = .bss:0x00000710; // type:object size:0x4 scope:local data:4byte -lbl_1_bss_714 = .bss:0x00000714; // type:object size:0xC scope:local -lbl_1_bss_720 = .bss:0x00000720; // type:object size:0x4 scope:local data:4byte -lbl_1_bss_724 = .bss:0x00000724; // type:object size:0x4 scope:local data:4byte -lbl_1_bss_728 = .bss:0x00000728; // type:object size:0x2 scope:local data:2byte -lbl_1_bss_72A = .bss:0x0000072A; // type:object size:0x2 scope:local data:2byte -lbl_1_bss_72C = .bss:0x0000072C; // type:object size:0x4 scope:local data:4byte -lbl_1_bss_730 = .bss:0x00000730; // type:object size:0x4 scope:local data:4byte -lbl_1_bss_734 = .bss:0x00000734; // type:object size:0x4 scope:local data:4byte -lbl_1_bss_738 = .bss:0x00000738; // type:object size:0xC scope:local data:float -lbl_1_bss_744 = .bss:0x00000744; // type:object size:0x2 scope:local data:2byte -lbl_1_bss_748 = .bss:0x00000748; // type:object size:0x4 scope:local data:4byte -lbl_1_bss_74C = .bss:0x0000074C; // type:object size:0x4 scope:local data:4byte -lbl_1_bss_750 = .bss:0x00000750; // type:object size:0x2 scope:local data:2byte -lbl_1_bss_754 = .bss:0x00000754; // type:object size:0x4 scope:local data:float -lbl_1_bss_758 = .bss:0x00000758; // type:object size:0x4 scope:local data:4byte -lbl_1_bss_75C = .bss:0x0000075C; // type:object size:0x4 scope:local data:4byte -lbl_1_bss_760 = .bss:0x00000760; // type:object size:0x28 scope:local -lbl_1_bss_788 = .bss:0x00000788; // type:object size:0x2 scope:local data:2byte -lbl_1_bss_78A = .bss:0x0000078A; // type:object size:0x6 scope:local data:2byte -lbl_1_bss_790 = .bss:0x00000790; // type:object size:0x6 scope:local data:2byte -lbl_1_bss_796 = .bss:0x00000796; // type:object size:0x2 scope:local data:2byte -lbl_1_bss_798 = .bss:0x00000798; // type:object size:0x4 scope:local data:4byte -lbl_1_bss_79C = .bss:0x0000079C; // type:object size:0x4 scope:local data:4byte -lbl_1_bss_7A0 = .bss:0x000007A0; // type:object size:0x4 scope:local data:4byte -lbl_1_bss_7A4 = .bss:0x000007A4; // type:object size:0x4 scope:local data:4byte -lbl_1_bss_7A8 = .bss:0x000007A8; // type:object size:0x2 scope:local data:2byte -lbl_1_bss_7AA = .bss:0x000007AA; // type:object size:0x2 scope:local data:2byte -lbl_1_bss_7AC = .bss:0x000007AC; // type:object size:0x8 scope:local data:4byte -lbl_1_bss_7B4 = .bss:0x000007B4; // type:object size:0x2 scope:local data:2byte -lbl_1_bss_7B8 = .bss:0x000007B8; // type:object size:0x4 scope:local data:4byte -lbl_1_bss_7BC = .bss:0x000007BC; // type:object size:0x8 scope:local data:4byte -lbl_1_bss_7C4 = .bss:0x000007C4; // type:object size:0xC scope:local data:float -lbl_1_bss_7D0 = .bss:0x000007D0; // type:object size:0x2 scope:local data:2byte -lbl_1_bss_7D2 = .bss:0x000007D2; // type:object size:0x2 scope:local data:2byte -lbl_1_bss_7D4 = .bss:0x000007D4; // type:object size:0x2 scope:local data:2byte -lbl_1_bss_7D6 = .bss:0x000007D6; // type:object size:0x2 scope:local data:2byte -lbl_1_bss_7D8 = .bss:0x000007D8; // type:object size:0xC scope:local data:4byte -lbl_1_bss_7E4 = .bss:0x000007E4; // type:object size:0x4 scope:local data:4byte -lbl_1_bss_7E8 = .bss:0x000007E8; // type:object size:0x4 scope:local data:float -lbl_1_bss_7EC = .bss:0x000007EC; // type:object size:0x4 scope:local data:float -lbl_1_bss_7F0 = .bss:0x000007F0; // type:object size:0x4 scope:local data:4byte -lbl_1_bss_7F4 = .bss:0x000007F4; // type:object size:0x4 scope:local data:4byte -lbl_1_bss_7F8 = .bss:0x000007F8; // type:object size:0x4 scope:local data:4byte -lbl_1_bss_7FC = .bss:0x000007FC; // type:object size:0x10 scope:local data:4byte -lbl_1_bss_80C = .bss:0x0000080C; // type:object size:0xC scope:local data:float -lbl_1_bss_818 = .bss:0x00000818; // type:object size:0x4 scope:local data:4byte +coasterStartSpace = .bss:0x000006AC; // type:object size:0x2 scope:local data:2byte +coasterPathMdlId = .bss:0x000006AE; // type:object size:0x2 scope:local data:2byte +coasterType = .bss:0x000006B0; // type:object size:0x1 scope:local data:byte +coasterLandF = .bss:0x000006B1; // type:object size:0x1 scope:local data:byte +coasterDoneF = .bss:0x000006B2; // type:object size:0x1 scope:local data:byte +coasterLoopF = .bss:0x000006B3; // type:object size:0x1 scope:local data:byte +eventPlayer = .bss:0x000006B4; // type:object size:0x1 scope:local data:byte +roundItemTbl = .bss:0x000006B6; // type:object size:0xA scope:local data:2byte +mapObjMotTbl = .bss:0x000006C0; // type:object size:0x4 scope:local data:4byte +mapObjMdlId = .bss:0x000006C4; // type:object size:0x42 data:2byte +spaceAmidaSeqStopF = .bss:0x00000708; // type:object size:0x2 scope:local data:2byte +spaceAmidaEffAnim = .bss:0x0000070C; // type:object size:0x4 scope:local data:4byte +spaceAmidaEffObj = .bss:0x00000710; // type:object size:0x4 scope:local data:4byte +rocketObj = .bss:0x00000714; // type:object size:0xC scope:local +spaceAmidaGameObj = .bss:0x00000720; // type:object size:0x4 scope:local data:4byte +spaceAmidaSeNo = .bss:0x00000724; // type:object size:0x4 scope:local data:4byte +spaceAmidaCoinNum = .bss:0x00000728; // type:object size:0x2 scope:local data:2byte +spaceAmidaStopF = .bss:0x0000072A; // type:object size:0x2 scope:local data:2byte +rocketWarpF = .bss:0x0000072C; // type:object size:0x4 scope:local data:4byte +spaceAmidaPath = .bss:0x00000730; // type:object size:0x4 scope:local data:4byte +spaceAmidaMapNo = .bss:0x00000734; // type:object size:0x4 scope:local data:4byte +spaceAmidaPos = .bss:0x00000738; // type:object size:0xC scope:local data:float +timerSeqId = .bss:0x00000744; // type:object size:0x2 scope:local data:2byte +timerFrame = .bss:0x00000748; // type:object size:0x4 scope:local data:4byte +timerSec = .bss:0x0000074C; // type:object size:0x4 scope:local data:4byte +kemuriMdlId = .bss:0x00000750; // type:object size:0x2 scope:local data:2byte +spaceAmidaTime = .bss:0x00000754; // type:object size:0x4 scope:local data:float +spaceAmidaMainObj = .bss:0x00000758; // type:object size:0x4 scope:local data:4byte +coinWinProc = .bss:0x0000075C; // type:object size:0x4 scope:local data:4byte +coinMdlId = .bss:0x00000760; // type:object size:0x28 scope:local +spaceAmidaEffMdlId = .bss:0x00000788; // type:object size:0x2 scope:local data:2byte +rocketMdlId = .bss:0x0000078A; // type:object size:0x6 scope:local data:2byte +mapMdlId = .bss:0x00000790; // type:object size:0x6 scope:local data:2byte +spaceAmidaMdlId = .bss:0x00000796; // type:object size:0x2 scope:local data:2byte +spaceAmidaPlayerNo = .bss:0x00000798; // type:object size:0x4 scope:local data:4byte +spaceAmidaPadNo = .bss:0x0000079C; // type:object size:0x4 scope:local data:4byte +roundItemEffAnim = .bss:0x000007A0; // type:object size:0x4 scope:local data:4byte +roundItemStreamId = .bss:0x000007A4; // type:object size:0x4 scope:local data:4byte +umaStopTimer = .bss:0x000007A8; // type:object size:0x2 scope:local data:2byte +roundItemStopF = .bss:0x000007AA; // type:object size:0x2 scope:local data:2byte +itemGetSeNo = .bss:0x000007AC; // type:object size:0x4 scope:local data:4byte +umaStopF = .bss:0x000007B4; // type:object size:0x2 scope:local data:2byte +jumpMotId = .bss:0x000007B8; // type:object size:0x4 scope:local data:4byte +itemGetMotId = .bss:0x000007BC; // type:object size:0x8 scope:local data:4byte +playerPos = .bss:0x000007C4; // type:object size:0xC scope:local data:float +timerFrame = .bss:0x000007D0; // type:object size:0x2 scope:local data:2byte +timerSec = .bss:0x000007D2; // type:object size:0x2 scope:local data:2byte +timerSeqId = .bss:0x000007D4; // type:object size:0x2 scope:local data:2byte +seqStartId = .bss:0x000007D6; // type:object size:0x2 scope:local data:2byte +umaPos = .bss:0x000007D8; // type:object size:0xC scope:local data:4byte +roundItemPlayer = .bss:0x000007E4; // type:object size:0x4 scope:local data:4byte +borderSpeed = .bss:0x000007E8; // type:object size:0x4 scope:local data:float +umaSpeed = .bss:0x000007EC; // type:object size:0x4 scope:local data:float +itemGetObj = .bss:0x000007F0; // type:object size:0x4 scope:local data:4byte +roundItemMainObj = .bss:0x000007F4; // type:object size:0x4 scope:local data:4byte +roundItemUmaObj = .bss:0x000007F8; // type:object size:0x4 scope:local data:4byte +itemObj = .bss:0x000007FC; // type:object size:0x10 scope:local data:4byte +roundItemPos = .bss:0x0000080C; // type:object size:0xC scope:local data:float +itemAnim = .bss:0x00000818; // type:object size:0x4 scope:local data:4byte diff --git a/config/GMPP01_00/rels/w01Dll/splits.txt b/config/GMPP01_00/rels/w01Dll/splits.txt index 7baca9d9..8e0a4285 100644 --- a/config/GMPP01_00/rels/w01Dll/splits.txt +++ b/config/GMPP01_00/rels/w01Dll/splits.txt @@ -11,13 +11,13 @@ REL/board_executor.c: .rodata start:0x00000000 end:0x00000010 REL/w01Dll/main.c: - .text start:0x000000E0 end:0x00009D00 + .text start:0x000000E0 end:0x00009DD8 .rodata start:0x00000010 end:0x00000198 .data start:0x00000000 end:0x00000658 .bss start:0x00000000 end:0x00000708 REL/w01Dll/mg_coin.c: - .text start:0x00009D00 end:0x0000D740 + .text start:0x00009DD8 end:0x0000D740 .rodata start:0x00000198 end:0x000002C8 .data start:0x00000658 end:0x00000F08 .bss start:0x00000708 end:0x000007A0 diff --git a/include/REL/w01Dll.h b/include/REL/w01Dll.h index f3e1e5d6..c8c44f3b 100755 --- a/include/REL/w01Dll.h +++ b/include/REL/w01Dll.h @@ -4,24 +4,56 @@ #include "dolphin/types.h" enum { + MAPOBJ_COASTER, + MAPOBJ_COASTER_RAIL, + MAPOBJ_HOST1, + MAPOBJ_HOST2, + MAPOBJ_HOST3, + MAPOBJ_HOST4, + MAPOBJ_SPACEAMIDA, + MAPOBJ_SPACEAMIDA_MAP1, + MAPOBJ_SPACEAMIDA_MAP2, + MAPOBJ_SPACEAMIDA_MAP3, + MAPOBJ_SPACEAMIDA_ROCKET1, + MAPOBJ_SPACEAMIDA_ROCKET2, + MAPOBJ_SPACEAMIDA_ROCKET3, + MAPOBJ_SPACEAMIDA_LIGHTEFF, + MAPOBJ_SPACEAMIDA_LAMP1, + MAPOBJ_SPACEAMIDA_LAMP2, + MAPOBJ_ROUNDITEM, + MAPOBJ_ROUNDITEM_UMA, + MAPOBJ_ROUNDITEM_BORDER, + MAPOBJ_ROUNDITEM_ITEM, + MAPOBJ_ROUNDITEM_ITEM_LIGHT, + MAPOBJ_ROUNDITEM_ITEM_UP, + MAPOBJ_ROUNDITEM_ITEM_DENSYOKU, + MAPOBJ_CUPR_DISH, + MAPOBJ_CUPR1, + MAPOBJ_CUPR2, + MAPOBJ_CUPR3, + MAPOBJ_CUPR_ARROW, + MAPOBJ_CUPL_DISH, + MAPOBJ_CUPL1, + MAPOBJ_CUPL2, + MAPOBJ_CUPL3, + MAPOBJ_CUPL_ARROW, MAPOBJ_MAX = 33 }; typedef struct { /* 0x00 */ struct { - u8 unk00_field0 : 1; + u8 hostSide : 1; }; - /* 0x01 */ s8 unk01[2]; -} UnkBoardDataStruct; // Size unknown + /* 0x01 */ s8 cupDir[2]; +} W01BoardWork; -extern void fn_1_9D00(s32 arg0); -extern void fn_1_9DD8(void); +extern void SpaceAmidaExec(void); -extern void fn_1_D740(s16 *arg0); -extern void fn_1_DD84(void); -extern void fn_1_DE94(void); +extern void RoundItemInit(s16 *itemTbl); +extern void RoundItemKill(void); +extern void RoundItemEventStart(void); -extern s16 lbl_1_bss_6C4[MAPOBJ_MAX]; -extern UnkBoardDataStruct *lbl_1_bss_0; +extern s16 mapObjMdlId[MAPOBJ_MAX]; +extern W01BoardWork *boardWork; #endif diff --git a/src/REL/w01Dll/main.c b/src/REL/w01Dll/main.c index 6cf2beb7..f1d1e39f 100755 --- a/src/REL/w01Dll/main.c +++ b/src/REL/w01Dll/main.c @@ -33,136 +33,133 @@ typedef struct { struct { - u8 unk00_field0 : 1; + u8 killF : 1; }; -} Bss10Work; +} CoasterCameraWork; typedef struct { struct { - u8 unk00_field0 : 1; - u8 unk00_field1 : 3; - u8 unk00_field2 : 1; - u8 unk00_field3 : 1; + u8 killF : 1; + u8 mode : 3; + u8 stopF : 1; + u8 decaF : 1; }; - u8 unk01; - u8 unk02; - char unk03[1]; - s16 unk04; - char unk06[2]; - float unk08; -} Bss18Work; + u8 time; + u8 delay; + s16 dishMdlId; + float dishSpeed; +} CupObjWork; typedef struct { - /* 0x00 */ s8 unk00; - /* 0x01 */ s8 unk01; - /* 0x02 */ s16 unk02; - /* 0x04 */ s16 unk04; - /* 0x06 */ s16 unk06; - /* 0x08 */ float unk08; - /* 0x0C */ char unk0C[4]; - /* 0x10 */ float unk10; - /* 0x14 */ Vec unk14; - /* 0x20 */ Mtx unk20; -} BssCData; // Size 0x50 + s8 mode; + s8 playerNo; + s16 delay; + s16 pathMdlId; + s16 endSpace; + float speed; + float unk0C; + float time; + Vec pos; + Mtx matrix; +} CoasterPlayerWork; // Size 0x50 typedef struct { struct { - u8 unk00_field0 : 1; + u8 killF : 1; }; - s8 unk01; - char unk02[2]; - BssCData *unk04; -} BssCWork; + s8 playerNum; + CoasterPlayerWork *player; +} CoasterPlayerManWork; typedef struct { - /* 0x00 */ s16 unk00; - /* 0x02 */ s16 unk02; - /* 0x04 */ float unk04; - /* 0x08 */ Vec unk08; - /* 0x14 */ Vec unk14; -} Bss20Data; // Size 0x20 + /* 0x00 */ s16 time; + /* 0x02 */ s16 mdlId; + /* 0x04 */ float scale; + /* 0x08 */ Vec pos; + /* 0x14 */ Vec vel; +} CoasterEffData; // Size 0x20 typedef struct { struct { - u8 unk00_field0 : 1; + u8 killF : 1; }; - u8 unk01; - char unk02[2]; - Bss20Data *unk04; -} Bss20Work; + u8 delay; + CoasterEffData *data; +} CoasterEffWork; -static void fn_1_730(void); -static void fn_1_774(void); -static s32 fn_1_778(void); -static s32 fn_1_814(void); -static void fn_1_9E8(void); +static void LightSetHook(void); +static void LightResetHook(void); +static s32 LandEvent(void); +static s32 WalkEvent(void); +static void MapObjDispSet(void); static void fn_1_D00(void); -static void fn_1_D04(void); -static void fn_1_1254(void); -static void fn_1_128C(void); -static void fn_1_130C(void); -static s32 fn_1_157C(void); -static void fn_1_1670(void); -static void fn_1_1700(void); -static void fn_1_1990(void); -static void fn_1_1AD8(BoardCameraData *camera); -static void fn_1_1B3C(void); -static void fn_1_1EE4(void); -static void fn_1_1F2C(omObjData *arg0); -static void fn_1_1FA4(void); -static float fn_1_2524(void); -static void fn_1_276C(void); -static void fn_1_2F18(void); -static void fn_1_3350(void); -static void fn_1_3514(s32 arg0); -static void fn_1_35B4(s32 arg0); -static void fn_1_3624(void); -static void fn_1_45F4(void); -static void fn_1_4774(void); -static void fn_1_4864(void); -static s32 fn_1_48B4(void); -static void fn_1_4E14(void); -static void fn_1_4FA8(void); -static void fn_1_4FD8(void); -static void fn_1_50D4(void); -static void fn_1_53B8(void); -static void fn_1_543C(void); -static void fn_1_5694(s32 arg0); -static void fn_1_586C(s32 arg0, s32 arg1); -static void fn_1_592C(void); -static void fn_1_5B2C(void); -static void fn_1_5B40(void); -static BOOL fn_1_5CD0(void); -static void fn_1_5D08(void); -static void fn_1_6098(omObjData *arg0); -static void fn_1_6194(Bss18Work *arg0, omObjData *arg1); -static void fn_1_63F0(Bss18Work *arg0, omObjData *arg1); -static void fn_1_6A14(Bss18Work *arg0, omObjData *arg1); -static void fn_1_6BC0(Bss18Work *arg0, omObjData *arg1); -static void fn_1_6FB4(Bss18Work *arg0, omObjData *arg1); -static void fn_1_7528(s32 arg0, s32 arg1); -static void fn_1_77EC(s32 arg0, s32 arg1); -static void fn_1_7894(void); -static void fn_1_7A64(void); -static void fn_1_852C(void); -static void fn_1_87AC(void); -static void fn_1_87E0(omObjData *arg0); -static void fn_1_8988(BssCData *arg0, omObjData *arg1); -static void fn_1_8A50(BssCData *arg0, omObjData *arg1); -static void fn_1_8B6C(BssCData *arg0, omObjData *arg1); -static void fn_1_8DDC(BssCData *arg0, omObjData *arg1); -static void fn_1_918C(BssCData *arg0, omObjData *arg1); -static void fn_1_927C(BssCData *arg0, omObjData *arg1); -static void fn_1_932C(BssCData *arg0); -static s32 fn_1_94A8(BssCData *arg0); -static void fn_1_95F4(BssCData *arg0); -static void fn_1_97F4(void); -static void fn_1_98EC(void); -static void fn_1_9920(omObjData *arg0); -static void fn_1_9A24(Bss20Work *arg0); -static void fn_1_9BBC(Bss20Work *arg0); +static void RoundItemMain(void); +static void RoundItemDestroy(void); +static void RoundItemEvent(void); +static void SpaceAmidaEvent(void); +static s32 WalkMiniEvent(void); +static void UpdateHostDisp(void); +static void CoasterInit(void); +static void CoasterPathUpdate(void); +static void CoasterPosCalc(BoardCameraData *camera); +static void CoasterCameraUpdate(void); +static void CoasterCameraObjKill(void); +static void CoasterCameraObjMain(omObjData *obj); +static void CoasterCameraObjUpdate(void); +static float CoasterStickRotGet(void); +static void CoasterRotUpdate(void); +static void CoasterCoinCheck(void); +static void CoasterPathMotUpdate(void); +static void CoasterMotCreate(s32 playerNo); +static void CoasterMotKill(s32 playerNo); +static void CoasterExec(void); +static void CoasterExit(void); +static void CoasterWinCreate(void); +static void CoasterWinKill(void); +static s32 CoasterHostExec(void); +static void CoasterMain(void); +static void CoasterDestroy(void); +static void CoasterEvent(void); +static void CoasterCoinCreate(void); +static void CoasterCoinKill(void); +static void CupInit(void); +static void CupMotOnSet(s32 stopF); +static void CupEvent(s32 side, s32 spaceStart); +static void CupMain(void); +static void CupDestroy(void); +static void CupExec(void); +static BOOL CupObjCheck(void); +static void CupObjCreate(void); +static void CupObjMain(omObjData *obj); +static void CupObjInit(CupObjWork *work, omObjData *obj); +static void CupObjJumpWait(CupObjWork *work, omObjData *obj); +static void CupObjHookReset(CupObjWork *work, omObjData *obj); +static void CupObjStop(CupObjWork *work, omObjData *obj); +static void CupObjRotate(CupObjWork *work, omObjData *obj); +static void CupLandEvent(s32 playerNo, s32 spaceId); +static void CoasterLandEvent(s32 playerNo, s32 spaceId); +static void CoasterLandMain(void); +static void CoasterLandExec(void); +static void CoasterPlayerManCreate(void); +static void CoasterPlayerManKill(void); +static void CoasterPlayerManUpdate(omObjData *obj); +static void CoasterPlayerWait(CoasterPlayerWork *work, omObjData *obj); +static void CoasterPlayerChaseBegin(CoasterPlayerWork *work, omObjData *obj); +static void CoasterPlayerChasePathSet(CoasterPlayerWork *work, omObjData *obj); +static void CoasterPlayerChase(CoasterPlayerWork *work, omObjData *obj); +static void CoasterPlayerStop(CoasterPlayerWork *work, omObjData *obj); +static void CoasterPlayerEnd(CoasterPlayerWork *work, omObjData *obj); +static void CoasterPlayerEndSet(CoasterPlayerWork *work); +static s32 CoasterPlayerLoopCheck(CoasterPlayerWork *work); +static void CoasterPlayerTimeInit(CoasterPlayerWork *work); +static void CoasterEffCreate(void); +static void CoasterEffKill(void); +static void CoasterEffUpdate(omObjData *obj); +static void CoasterEffAdd(CoasterEffWork *work); +static void CoasterEffModelUpdate(CoasterEffWork *work); +extern void CoasterHostComKeySet(s32 playerNo); -static BoardMapObject lbl_1_data_0[MAPOBJ_MAX] +static BoardMapObject mapObjData[MAPOBJ_MAX] = { { { 0.0f, 0.0f, 0.0f }, { 0.0f, 0.0f, 0.0f }, { 1.0f, 1.0f, 1.0f }, DATA_MAKE_NUM(DATADIR_W01, 8) }, { { 0.0f, 700.0f, 300.0f }, { 0.0f, 0.0f, 0.0f }, { 1.0f, 1.0f, 1.0f }, DATA_MAKE_NUM(DATADIR_W01, 9) }, { { -2025.0f, 100.0f, 1950.0f }, { 0.0f, 0.0f, 0.0f }, { 1.0f, 1.0f, 1.0f }, DATA_MAKE_NUM(DATADIR_BGUEST, 0) }, @@ -197,116 +194,116 @@ static BoardMapObject lbl_1_data_0[MAPOBJ_MAX] { { -1800.0f, 200.0f, -900.0f }, { 0.0f, 0.0f, 0.0f }, { 1.0f, 1.0f, 1.0f }, DATA_MAKE_NUM(DATADIR_W01, 4) }, { { -1800.0f, 200.0f, -900.0f }, { 0.0f, 0.0f, 0.0f }, { 1.0f, 1.0f, 1.0f }, DATA_MAKE_NUM(DATADIR_W01, 5) } }; -s16 lbl_1_bss_6C4[MAPOBJ_MAX]; +s16 mapObjMdlId[MAPOBJ_MAX]; -static s32 *lbl_1_bss_6C0; -static s16 lbl_1_bss_6B6[5]; -static s8 lbl_1_bss_6B4; -static s8 lbl_1_bss_6B3; -static s8 lbl_1_bss_6B2; -static s8 lbl_1_bss_6B1; -static s8 lbl_1_bss_6B0; -static s16 lbl_1_bss_6AE; -static s16 lbl_1_bss_6AC; +static s32 *mapObjMotTbl; +static s16 roundItemTbl[5]; +static s8 eventPlayer; +static s8 coasterLoopF; +static s8 coasterDoneF; +static s8 coasterLandF; +static s8 coasterType; +static s16 coasterPathMdlId; +static s16 coasterStartSpace; static float lbl_1_bss_6A8; -static Mtx lbl_1_bss_678; -static float lbl_1_bss_674; -static float lbl_1_bss_670; -static float lbl_1_bss_66C; -static Vec lbl_1_bss_660; -static Vec lbl_1_bss_654; -static Vec lbl_1_bss_648; -static float lbl_1_bss_644; -static float lbl_1_bss_640; -static float lbl_1_bss_63C; -static Vec lbl_1_bss_630; -static Vec lbl_1_bss_624; -static Vec lbl_1_bss_618; -static s8 lbl_1_bss_600[24]; -static s16 lbl_1_bss_5D0[24]; -static s16 lbl_1_bss_5CC[2]; +static Mtx coasterMtx; +static float coasterAccel; +static float coasterSpeed; +static float coasterCamSpeed; +static Vec coasterRot; +static Vec coasterPos; +static Vec coasterPosOld; +static float coasterMaxTime; +static float coasterTime; +static float coasterBaseRotY; +static Vec coasterCameraPos; +static Vec coasterCameraUp; +static Vec coasterCameraTarget; +static s8 coasterCoinF[24]; +static s16 coasterCoinMdlId[24]; +static s16 coasterMotId[2]; static s8 lbl_1_bss_2C[1440]; static s8 lbl_1_bss_2A[2]; // padding -static s8 lbl_1_bss_29; -static s8 lbl_1_bss_28; -static s16 lbl_1_bss_26; -static s16 lbl_1_bss_24; -static omObjData *lbl_1_bss_20; -static s8 lbl_1_bss_1C; -static omObjData *lbl_1_bss_18; -static Process *lbl_1_bss_14; -static omObjData *lbl_1_bss_10; -static omObjData *lbl_1_bss_C; -static Process *lbl_1_bss_8; -static Process *lbl_1_bss_4; -UnkBoardDataStruct *lbl_1_bss_0; +static s8 cupSide; +static s8 cupHookNo; +static s16 cupSpaceStart; +static s16 cupSpaceEnd; +static omObjData *coasterEffObj; +static s8 coasterPlayerChaseNum; +static omObjData *cupObj; +static Process *cupProc; +static omObjData *coasterCameraObj; +static omObjData *coasterPlayerManObj; +static Process *coasterProc; +static Process *roundItemProc; +W01BoardWork *boardWork; -static s16 lbl_1_data_528 = -1; -static s16 lbl_1_data_52A = -1; -static s16 lbl_1_data_52C = -1; -static s16 lbl_1_data_52E = -1; -static s16 lbl_1_data_530 = -1; +static s16 bgMdl = -1; +static s16 fgMdl = -1; +static s16 starHostMdl = -1; +static s16 hostMdl = -1; +static s16 syuppouMdl = -1; -static s32 lbl_1_data_534[] = { DATA_MAKE_NUM(DATADIR_W01, 30), -1 }; +static s32 starHostMotTbl[] = { DATA_MAKE_NUM(DATADIR_W01, 30), -1 }; -static s32 lbl_1_data_53C[] = { DATA_MAKE_NUM(DATADIR_BGUEST, 1), -1 }; +static s32 hostMotTbl[] = { DATA_MAKE_NUM(DATADIR_BGUEST, 1), -1 }; void BoardCreate(void) { - BoardMapObject *temp_r30; - s32 sp8; + BoardMapObject *mapObj; + s32 boardNo; s32 i; - sp8 = GWBoardGet(); - lbl_1_bss_0 = (UnkBoardDataStruct *)GWSystem.board_data; + boardNo = GWBoardGet(); + boardWork = (W01BoardWork *)GWSystem.board_data; BoardSpaceInit(DATA_MAKE_NUM(DATADIR_W01, 0)); - lbl_1_data_528 = BoardModelCreate(DATA_MAKE_NUM(DATADIR_W01, 1), NULL, 0); - fn_8006DDE8(lbl_1_data_528, -1.0f); - BoardModelPosSet(lbl_1_data_528, 0.0f, 0.0f, 0.0f); - BoardModelMotionStart(lbl_1_data_528, 0, 0x40000001); - lbl_1_data_52A = BoardModelCreate(DATA_MAKE_NUM(DATADIR_W01, 2), NULL, 0); - fn_8006DDE8(lbl_1_data_52A, -1.0f); - BoardModelPosSet(lbl_1_data_52A, 0.0f, 0.0f, 0.0f); - BoardModelMotionStart(lbl_1_data_52A, 0, 0x40000001); - lbl_1_data_52C = BoardModelCreate(DATA_MAKE_NUM(DATADIR_W01, 29), lbl_1_data_534, 0); - BoardModelPosSet(lbl_1_data_52C, 0.0f, 0.0f, 0.0f); - BoardModelMotionStart(lbl_1_data_52C, 1, 0x40000001); - lbl_1_data_52E = BoardModelCreate(DATA_MAKE_NUM(DATADIR_BGUEST, 0), lbl_1_data_53C, 0); - BoardModelPosSet(lbl_1_data_52E, 0.0f, 0.0f, 0.0f); - BoardModelMotionStart(lbl_1_data_52E, 1, 0x40000001); - lbl_1_data_530 = BoardModelCreate(DATA_MAKE_NUM(DATADIR_W01, 11), NULL, 0); - BoardModelMotionStart(lbl_1_data_530, 0, 0x40000001); - BoardLightHookSet(fn_1_730, fn_1_774); + bgMdl = BoardModelCreate(DATA_MAKE_NUM(DATADIR_W01, 1), NULL, 0); + fn_8006DDE8(bgMdl, -1.0f); + BoardModelPosSet(bgMdl, 0.0f, 0.0f, 0.0f); + BoardModelMotionStart(bgMdl, 0, HU3D_MOTATTR_LOOP); + fgMdl = BoardModelCreate(DATA_MAKE_NUM(DATADIR_W01, 2), NULL, 0); + fn_8006DDE8(fgMdl, -1.0f); + BoardModelPosSet(fgMdl, 0.0f, 0.0f, 0.0f); + BoardModelMotionStart(fgMdl, 0, HU3D_MOTATTR_LOOP); + starHostMdl = BoardModelCreate(DATA_MAKE_NUM(DATADIR_W01, 29), starHostMotTbl, 0); + BoardModelPosSet(starHostMdl, 0.0f, 0.0f, 0.0f); + BoardModelMotionStart(starHostMdl, 1, HU3D_MOTATTR_LOOP); + hostMdl = BoardModelCreate(DATA_MAKE_NUM(DATADIR_BGUEST, 0), hostMotTbl, 0); + BoardModelPosSet(hostMdl, 0.0f, 0.0f, 0.0f); + BoardModelMotionStart(hostMdl, 1, HU3D_MOTATTR_LOOP); + syuppouMdl = BoardModelCreate(DATA_MAKE_NUM(DATADIR_W01, 11), NULL, 0); + BoardModelMotionStart(syuppouMdl, 0, HU3D_MOTATTR_LOOP); + BoardLightHookSet(LightSetHook, LightResetHook); for (i = 0; i < MAPOBJ_MAX; i++) { - temp_r30 = &lbl_1_data_0[i]; - if (temp_r30->data_num != -1) { - if (i == 2 || i == 3 || i == 4 || i == 5) { - lbl_1_bss_6C0 = lbl_1_data_53C; + mapObj = &mapObjData[i]; + if (mapObj->data_num != -1) { + if (i == MAPOBJ_HOST1 || i == MAPOBJ_HOST2 || i == MAPOBJ_HOST3 || i == MAPOBJ_HOST4) { + mapObjMotTbl = hostMotTbl; } else { - lbl_1_bss_6C0 = NULL; + mapObjMotTbl = NULL; } - lbl_1_bss_6C4[i] = BoardModelCreate(temp_r30->data_num, lbl_1_bss_6C0, 0); - BoardModelPosSetV(lbl_1_bss_6C4[i], &temp_r30->pos); - BoardModelRotSetV(lbl_1_bss_6C4[i], &temp_r30->rot); - BoardModelScaleSetV(lbl_1_bss_6C4[i], &temp_r30->scale); - BoardModelVisibilitySet(lbl_1_bss_6C4[i], 1); + mapObjMdlId[i] = BoardModelCreate(mapObj->data_num, mapObjMotTbl, 0); + BoardModelPosSetV(mapObjMdlId[i], &mapObj->pos); + BoardModelRotSetV(mapObjMdlId[i], &mapObj->rot); + BoardModelScaleSetV(mapObjMdlId[i], &mapObj->scale); + BoardModelVisibilitySet(mapObjMdlId[i], 1); } } - BoardModelMotionStart(lbl_1_bss_6C4[2], 1, 0x40000001); - BoardModelMotionStart(lbl_1_bss_6C4[3], 1, 0x40000001); - BoardModelMotionStart(lbl_1_bss_6C4[4], 1, 0x40000001); - BoardModelMotionStart(lbl_1_bss_6C4[5], 1, 0x40000001); - fn_1_543C(); - fn_1_9E8(); - fn_1_1700(); - BoardSpaceWalkEventFuncSet(fn_1_814); - BoardSpaceWalkMiniEventFuncSet(fn_1_157C); - BoardSpaceLandEventFuncSet(fn_1_778); - BoardStarHostSet(lbl_1_data_52C); - BoardBooHouseHostSet(lbl_1_data_52E); - BoardLotteryHostSet(lbl_1_data_52E); - BoardShopHostSet(lbl_1_data_52E); + BoardModelMotionStart(mapObjMdlId[MAPOBJ_HOST1], 1, HU3D_MOTATTR_LOOP); + BoardModelMotionStart(mapObjMdlId[MAPOBJ_HOST2], 1, HU3D_MOTATTR_LOOP); + BoardModelMotionStart(mapObjMdlId[MAPOBJ_HOST3], 1, HU3D_MOTATTR_LOOP); + BoardModelMotionStart(mapObjMdlId[MAPOBJ_HOST4], 1, HU3D_MOTATTR_LOOP); + CupInit(); + MapObjDispSet(); + CoasterInit(); + BoardSpaceWalkEventFuncSet(WalkEvent); + BoardSpaceWalkMiniEventFuncSet(WalkMiniEvent); + BoardSpaceLandEventFuncSet(LandEvent); + BoardStarHostSet(starHostMdl); + BoardBooHouseHostSet(hostMdl); + BoardLotteryHostSet(hostMdl); + BoardShopHostSet(hostMdl); BoardJunctionMaskSet(0xC000); BoardJunctionMaskSet(0x3000); } @@ -315,217 +312,217 @@ void BoardDestroy(void) { s32 i; - fn_1_4864(); + CoasterWinKill(); fn_1_D00(); - for (i = 0; i < 33; i++) { - if (lbl_1_bss_6C4[i] != 0) { - BoardModelKill(lbl_1_bss_6C4[i]); - lbl_1_bss_6C4[i] = 0; + for (i = 0; i < MAPOBJ_MAX; i++) { + if (mapObjMdlId[i] != 0) { + BoardModelKill(mapObjMdlId[i]); + mapObjMdlId[i] = 0; } } - if (lbl_1_data_530 != -1) { - BoardModelKill(lbl_1_data_530); - lbl_1_data_530 = -1; + if (syuppouMdl != -1) { + BoardModelKill(syuppouMdl); + syuppouMdl = -1; } - if (lbl_1_data_52E != -1) { - BoardModelKill(lbl_1_data_52E); - lbl_1_data_52E = -1; + if (hostMdl != -1) { + BoardModelKill(hostMdl); + hostMdl = -1; } - if (lbl_1_data_52C != -1) { - BoardModelKill(lbl_1_data_52C); - lbl_1_data_52C = -1; + if (starHostMdl != -1) { + BoardModelKill(starHostMdl); + starHostMdl = -1; } - if (lbl_1_data_528 != -1) { - BoardModelKill(lbl_1_data_528); - lbl_1_data_528 = -1; + if (bgMdl != -1) { + BoardModelKill(bgMdl); + bgMdl = -1; } - if (lbl_1_data_52A != -1) { - BoardModelKill(lbl_1_data_52A); - lbl_1_data_52A = -1; + if (fgMdl != -1) { + BoardModelKill(fgMdl); + fgMdl = -1; } BoardSpaceDestroy(); } -static void fn_1_730(void) +static void LightSetHook(void) { - s16 var_r31; + s16 modelId; - var_r31 = BoardModelIDGet(lbl_1_data_528); - Hu3DModelLightInfoSet(var_r31, 1); + modelId = BoardModelIDGet(bgMdl); + Hu3DModelLightInfoSet(modelId, 1); } -static void fn_1_774(void) { } +static void LightResetHook(void) { } -static s32 fn_1_778(void) +static s32 LandEvent(void) { - s32 temp_r31; - s32 temp_r30; - u32 temp_r29; + s32 playerNo; + s32 spaceId; + u32 flag; - temp_r31 = GWSystem.player_curr; - temp_r30 = GWPlayer[temp_r31].space_curr; - temp_r29 = BoardSpaceFlagGet(0, temp_r30); - if (temp_r29 & 0x800) { - fn_1_77EC(temp_r31, temp_r30); + playerNo = GWSystem.player_curr; + spaceId = GWPlayer[playerNo].space_curr; + flag = BoardSpaceFlagGet(0, spaceId); + if (flag & 0x800) { + CoasterLandEvent(playerNo, spaceId); } - else if (temp_r29 & 0x400) { - fn_1_7528(temp_r31, temp_r30); + else if (flag & 0x400) { + CupLandEvent(playerNo, spaceId); } } -static s32 fn_1_814(void) +static s32 WalkEvent(void) { - s32 temp_r27; - s32 var_r30; - s32 var_r29; - s32 var_r26; - BoardSpace *temp_r31; - BoardSpace *temp_r28; + s32 playerNo; + s32 i; + s32 type; + s32 spaceLinkId; + BoardSpace *space; + BoardSpace *spaceLink; - temp_r27 = GWSystem.player_curr; - temp_r31 = BoardSpaceGet(0, GWPlayer[temp_r27].space_curr); - if (temp_r31->flag & 0x3000) { - if (BoardPlayerSizeGet(temp_r27) == 2 || GWPlayer[temp_r27].bowser_suit) { + playerNo = GWSystem.player_curr; + space = BoardSpaceGet(0, GWPlayer[playerNo].space_curr); + if (space->flag & 0x3000) { + if (BoardPlayerSizeGet(playerNo) == 2 || GWPlayer[playerNo].bowser_suit) { return 0; } - if (temp_r31->flag & 0x2000) { - if (lbl_1_bss_0->unk00_field0 != 0) { + if (space->flag & 0x2000) { + if (boardWork->hostSide != 0) { return 0; } } - else if (temp_r31->flag & 0x1000) { - if (lbl_1_bss_0->unk00_field0 != 1) { + else if (space->flag & 0x1000) { + if (boardWork->hostSide != 1) { return 0; } } - fn_1_4FD8(); + CoasterEvent(); return 1; } - var_r29 = -1; - for (var_r30 = 0; var_r30 < temp_r31->link_cnt; var_r30++) { - if (temp_r31->link[var_r30] != -1) { - temp_r28 = BoardSpaceGet(0, temp_r31->link[var_r30]); - if (temp_r28->flag & 0x8000) { - var_r29 = 0; - var_r26 = temp_r31->link[var_r30]; + type = -1; + for (i = 0; i < space->link_cnt; i++) { + if (space->link[i] != -1) { + spaceLink = BoardSpaceGet(0, space->link[i]); + if (spaceLink->flag & 0x8000) { + type = 0; + spaceLinkId = space->link[i]; break; } - else if (temp_r28->flag & 0x4000) { - var_r29 = 1; - var_r26 = temp_r31->link[var_r30]; + else if (spaceLink->flag & 0x4000) { + type = 1; + spaceLinkId = space->link[i]; break; } } } - if (var_r29 != -1) { - fn_1_586C(var_r29, var_r26); + if (type != -1) { + CupEvent(type, spaceLinkId); return 1; } return 0; } -static void fn_1_9E8(void) +static void MapObjDispSet(void) { - BoardModelVisibilitySet(lbl_1_bss_6C4[6], 1); - BoardModelVisibilitySet(lbl_1_bss_6C4[7], 0); - BoardModelVisibilitySet(lbl_1_bss_6C4[8], 0); - BoardModelVisibilitySet(lbl_1_bss_6C4[9], 0); - BoardModelVisibilitySet(lbl_1_bss_6C4[10], 0); - BoardModelVisibilitySet(lbl_1_bss_6C4[11], 0); - BoardModelVisibilitySet(lbl_1_bss_6C4[12], 0); - BoardModelVisibilitySet(lbl_1_bss_6C4[13], 0); - BoardModelVisibilitySet(lbl_1_bss_6C4[14], 1); - BoardModelVisibilitySet(lbl_1_bss_6C4[15], 1); - BoardModelMotionStart(lbl_1_bss_6C4[6], 0, 0); - BoardModelMotionSpeedSet(lbl_1_bss_6C4[6], 0.0f); - BoardModelMotionStart(lbl_1_bss_6C4[14], 0, 0x40000001); - BoardModelMotionStart(lbl_1_bss_6C4[15], 0, 0x40000001); - BoardModelHookSet(lbl_1_bss_6C4[6], "amida_ban_07-sirenr", lbl_1_bss_6C4[14]); - BoardModelHookSet(lbl_1_bss_6C4[6], "amida_ban_07-sirenl", lbl_1_bss_6C4[15]); - BoardModelVisibilitySet(lbl_1_bss_6C4[16], 1); - BoardModelVisibilitySet(lbl_1_bss_6C4[17], 1); - BoardModelVisibilitySet(lbl_1_bss_6C4[18], 1); - BoardModelVisibilitySet(lbl_1_bss_6C4[19], 0); - BoardModelVisibilitySet(lbl_1_bss_6C4[20], 0); - BoardModelVisibilitySet(lbl_1_bss_6C4[21], 1); - BoardModelVisibilitySet(lbl_1_bss_6C4[22], 1); - BoardModelMotionStart(lbl_1_bss_6C4[21], 0, 0); - BoardModelMotionSpeedSet(lbl_1_bss_6C4[21], 0.0f); - BoardModelMotionStart(lbl_1_bss_6C4[18], 0, 0); - BoardModelMotionSpeedSet(lbl_1_bss_6C4[18], 0.0f); - BoardModelExistDupe(lbl_1_bss_6C4[16], 0); - BoardModelMotionStart(lbl_1_bss_6C4[16], 0, 0x40000001); - BoardModelMotionStart(lbl_1_bss_6C4[17], 0, 0x40000001); - BoardModelMotionStart(lbl_1_bss_6C4[22], 0, 0x40000001); - BoardModelHookSet(lbl_1_bss_6C4[21], "m_goraund_01-flag1", lbl_1_bss_6C4[22]); + BoardModelVisibilitySet(mapObjMdlId[MAPOBJ_SPACEAMIDA], 1); + BoardModelVisibilitySet(mapObjMdlId[MAPOBJ_SPACEAMIDA_MAP1], 0); + BoardModelVisibilitySet(mapObjMdlId[MAPOBJ_SPACEAMIDA_MAP2], 0); + BoardModelVisibilitySet(mapObjMdlId[MAPOBJ_SPACEAMIDA_MAP3], 0); + BoardModelVisibilitySet(mapObjMdlId[MAPOBJ_SPACEAMIDA_ROCKET1], 0); + BoardModelVisibilitySet(mapObjMdlId[MAPOBJ_SPACEAMIDA_ROCKET2], 0); + BoardModelVisibilitySet(mapObjMdlId[MAPOBJ_SPACEAMIDA_ROCKET3], 0); + BoardModelVisibilitySet(mapObjMdlId[MAPOBJ_SPACEAMIDA_LIGHTEFF], 0); + BoardModelVisibilitySet(mapObjMdlId[MAPOBJ_SPACEAMIDA_LAMP1], 1); + BoardModelVisibilitySet(mapObjMdlId[MAPOBJ_SPACEAMIDA_LAMP2], 1); + BoardModelMotionStart(mapObjMdlId[MAPOBJ_SPACEAMIDA], 0, 0); + BoardModelMotionSpeedSet(mapObjMdlId[MAPOBJ_SPACEAMIDA], 0.0f); + BoardModelMotionStart(mapObjMdlId[MAPOBJ_SPACEAMIDA_LAMP1], 0, HU3D_MOTATTR_LOOP); + BoardModelMotionStart(mapObjMdlId[MAPOBJ_SPACEAMIDA_LAMP2], 0, HU3D_MOTATTR_LOOP); + BoardModelHookSet(mapObjMdlId[MAPOBJ_SPACEAMIDA], "amida_ban_07-sirenr", mapObjMdlId[MAPOBJ_SPACEAMIDA_LAMP1]); + BoardModelHookSet(mapObjMdlId[MAPOBJ_SPACEAMIDA], "amida_ban_07-sirenl", mapObjMdlId[MAPOBJ_SPACEAMIDA_LAMP2]); + BoardModelVisibilitySet(mapObjMdlId[MAPOBJ_ROUNDITEM], 1); + BoardModelVisibilitySet(mapObjMdlId[MAPOBJ_ROUNDITEM_UMA], 1); + BoardModelVisibilitySet(mapObjMdlId[MAPOBJ_ROUNDITEM_BORDER], 1); + BoardModelVisibilitySet(mapObjMdlId[MAPOBJ_ROUNDITEM_ITEM], 0); + BoardModelVisibilitySet(mapObjMdlId[MAPOBJ_ROUNDITEM_ITEM_LIGHT], 0); + BoardModelVisibilitySet(mapObjMdlId[MAPOBJ_ROUNDITEM_ITEM_UP], 1); + BoardModelVisibilitySet(mapObjMdlId[MAPOBJ_ROUNDITEM_ITEM_DENSYOKU], 1); + BoardModelMotionStart(mapObjMdlId[MAPOBJ_ROUNDITEM_ITEM_UP], 0, 0); + BoardModelMotionSpeedSet(mapObjMdlId[MAPOBJ_ROUNDITEM_ITEM_UP], 0.0f); + BoardModelMotionStart(mapObjMdlId[MAPOBJ_ROUNDITEM_BORDER], 0, 0); + BoardModelMotionSpeedSet(mapObjMdlId[MAPOBJ_ROUNDITEM_BORDER], 0.0f); + BoardModelExistDupe(mapObjMdlId[MAPOBJ_ROUNDITEM], 0); + BoardModelMotionStart(mapObjMdlId[MAPOBJ_ROUNDITEM], 0, HU3D_MOTATTR_LOOP); + BoardModelMotionStart(mapObjMdlId[MAPOBJ_ROUNDITEM_UMA], 0, HU3D_MOTATTR_LOOP); + BoardModelMotionStart(mapObjMdlId[MAPOBJ_ROUNDITEM_ITEM_DENSYOKU], 0, HU3D_MOTATTR_LOOP); + BoardModelHookSet(mapObjMdlId[MAPOBJ_ROUNDITEM_ITEM_UP], "m_goraund_01-flag1", mapObjMdlId[MAPOBJ_ROUNDITEM_ITEM_DENSYOKU]); } static void fn_1_D00(void) { } -static void fn_1_D04(void) +static void RoundItemMain(void) { - Vec sp3C; - Vec sp30; - Vec sp24; - Vec sp18; - Vec spC; - s8 sp8[4]; - s32 temp_r28; - s32 temp_r3; - s32 var_r26; - s32 var_r25; - s32 temp_r30; + Vec spacePos; + s8 comItem[4]; + s32 spaceStart; + s32 spaceEnd; + s32 comPlayF; + s32 choice; + s32 playerNo; s32 i; s32 j; - temp_r30 = GWSystem.player_curr; - var_r26 = 0; - if (BoardPlayerItemCount(temp_r30) == 3) { + playerNo = GWSystem.player_curr; + comPlayF = FALSE; + if (BoardPlayerItemCount(playerNo) == 3) { BoardWinCreate(0, MAKE_MESSID(10, 9), 0); BoardWinWait(); BoardWinKill(); HuPrcEnd(); } - lbl_1_bss_6B6[0] = 0; + roundItemTbl[0] = 0; i = 1; while (i < 4) { - lbl_1_bss_6B6[i] = frandmod(14); - if (lbl_1_bss_6B6[i] != 10 && lbl_1_bss_6B6[i] != 13) { + roundItemTbl[i] = frandmod(14); + if (roundItemTbl[i] != 10 && roundItemTbl[i] != 13) { for (j = 0; j < i; j++) { - if (lbl_1_bss_6B6[i] == lbl_1_bss_6B6[j]) { - lbl_1_bss_6B6[i] = -1; + if (roundItemTbl[i] == roundItemTbl[j]) { + roundItemTbl[i] = -1; } } - if (lbl_1_bss_6B6[i] != -1) { + if (roundItemTbl[i] != -1) { i++; } } } - fn_1_D740(lbl_1_bss_6B6); + RoundItemInit(roundItemTbl); for (i = 0; i < 4; i++) { - sp8[i] = lbl_1_bss_6B6[i]; + comItem[i] = roundItemTbl[i]; } - if (BoardComPreferItemGet(temp_r30, sp8, 4) != -1) { - var_r26 = 1; + if (BoardComPreferItemGet(playerNo, comItem, 4) != -1) { + comPlayF = TRUE; } HuAudFXPlay(0x40D); HuAudFXPlay(0x40E); - BoardModelAttrReset(lbl_1_bss_6C4[21], 0x40000004); - BoardModelMotionStart(lbl_1_bss_6C4[21], 0, 0); - temp_r28 = GWPlayer[temp_r30].space_curr; - temp_r3 = BoardSpaceLinkFlagSearch(0, temp_r28, 0x02000000); - BoardSpacePosGet(0, temp_r3, &sp3C); - sp30.x = 150.0f; - sp30.y = 0.0f; - sp30.z = 0.0f; - sp24.x = -45.0f; - sp24.y = 0.0f; - sp24.z = 0.0f; - BoardCameraMotionStartEx(lbl_1_bss_6C4[4], &sp24, &sp30, 1880.0f, -1.0f, 21); + BoardModelAttrReset(mapObjMdlId[MAPOBJ_ROUNDITEM_ITEM_UP], HU3D_MOTATTR_REV); + BoardModelMotionStart(mapObjMdlId[MAPOBJ_ROUNDITEM_ITEM_UP], 0, 0); + spaceStart = GWPlayer[playerNo].space_curr; + spaceEnd = BoardSpaceLinkFlagSearch(0, spaceStart, 0x02000000); + BoardSpacePosGet(0, spaceEnd, &spacePos); + { + Vec cameraOfs; + Vec cameraRot; + cameraOfs.x = 150.0f; + cameraOfs.y = 0.0f; + cameraOfs.z = 0.0f; + cameraRot.x = -45.0f; + cameraRot.y = 0.0f; + cameraRot.z = 0.0f; + BoardCameraMotionStartEx(mapObjMdlId[MAPOBJ_HOST3], &cameraRot, &cameraOfs, 1880.0f, -1.0f, 21); + } BoardCameraMotionWait(); BoardWinCreateChoice(2, MAKE_MESSID(10, 0), 0, 0); - if (GWPlayer[temp_r30].com) { - if (var_r26 != 0) { + if (GWPlayer[playerNo].com) { + if (comPlayF != 0) { BoardComKeySetLeft(); } else { @@ -534,369 +531,376 @@ static void fn_1_D04(void) } BoardWinWait(); BoardWinKill(); - var_r25 = BoardWinChoiceGet(); - if (var_r25 != 0) { + choice = BoardWinChoiceGet(); + if (choice != 0) { BoardWinCreate(2, MAKE_MESSID(10, 4), 0); BoardWinWait(); BoardWinKill(); BoardMGExit(); HuAudFXPlay(0x40F); - BoardModelMotionStart(lbl_1_bss_6C4[21], 0, 0x40000004); - while (!BoardModelMotionEndCheck(lbl_1_bss_6C4[21])) { + BoardModelMotionStart(mapObjMdlId[MAPOBJ_ROUNDITEM_ITEM_UP], 0, HU3D_MOTATTR_REV); + while (!BoardModelMotionEndCheck(mapObjMdlId[MAPOBJ_ROUNDITEM_ITEM_UP])) { HuPrcVSleep(); } - BoardModelMotionSpeedSet(lbl_1_bss_6C4[21], 0.0f); - BoardModelAttrReset(lbl_1_bss_6C4[21], 0x40000004); + BoardModelMotionSpeedSet(mapObjMdlId[MAPOBJ_ROUNDITEM_ITEM_UP], 0.0f); + BoardModelAttrReset(mapObjMdlId[MAPOBJ_ROUNDITEM_ITEM_UP], HU3D_MOTATTR_REV); while (BoardMGDoneFlagGet() != 1) { HuPrcVSleep(); } BoardMGDoneFlagSet(0); - fn_1_DD84(); + RoundItemKill(); HuPrcEnd(); } - BoardPlayerMoveBetween(temp_r30, temp_r28, temp_r3); - while (GWPlayer[temp_r30].moving) { + BoardPlayerMoveBetween(playerNo, spaceStart, spaceEnd); + while (GWPlayer[playerNo].moving) { HuPrcVSleep(); } - BoardPlayerMotionStart(temp_r30, 1, 0x40000001); - sp18.x = 0.0f; - sp18.y = 0.0f; - sp18.z = 0.0f; - spC.x = -45.0f; - spC.y = 0.0f; - spC.z = 0.0f; - BoardCameraMotionStartEx(lbl_1_bss_6C4[21], &spC, &sp18, 1200.0f, -1.0f, 21); + BoardPlayerMotionStart(playerNo, 1, HU3D_MOTATTR_LOOP); + { + Vec cameraOfs; + Vec cameraRot; + cameraOfs.x = 0.0f; + cameraOfs.y = 0.0f; + cameraOfs.z = 0.0f; + cameraRot.x = -45.0f; + cameraRot.y = 0.0f; + cameraRot.z = 0.0f; + BoardCameraMotionStartEx(mapObjMdlId[MAPOBJ_ROUNDITEM_ITEM_UP], &cameraRot, &cameraOfs, 1200.0f, -1.0f, 21); + } BoardCameraMotionWait(); - fn_1_DE94(); + RoundItemEventStart(); while (BoardEventFlagGet() != 0) { HuPrcVSleep(); } BoardCameraMotionWait(); BoardAudSeqPause(0, 0, 1000); - while (GWPlayer[temp_r30].moving) { + while (GWPlayer[playerNo].moving) { HuPrcVSleep(); } - BoardPlayerMotionStart(temp_r30, 1, 0x40000001); + BoardPlayerMotionStart(playerNo, 1, HU3D_MOTATTR_LOOP); HuPrcEnd(); } -static void fn_1_1254(void) +static void RoundItemDestroy(void) { BoardWinKill(); CharModelDataClose(-1); - lbl_1_bss_4 = NULL; + roundItemProc = NULL; } -static void fn_1_128C(void) +static void RoundItemEvent(void) { - lbl_1_bss_4 = HuPrcChildCreate(fn_1_D04, 0x2003, 0x2000, 0, boardMainProc); - HuPrcDestructorSet2(lbl_1_bss_4, fn_1_1254); - while (lbl_1_bss_4) { + roundItemProc = HuPrcChildCreate(RoundItemMain, 0x2003, 0x2000, 0, boardMainProc); + HuPrcDestructorSet2(roundItemProc, RoundItemDestroy); + while (roundItemProc) { HuPrcVSleep(); } } -static void fn_1_130C(void) +static void SpaceAmidaEvent(void) { - Vec sp20; - Vec sp14; - Vec sp8; - s32 temp_r31; - s32 var_r28; - s32 temp_r30; - s32 temp_r3; + Vec spacePos; + s32 playerNo; + s32 choice; + s32 spaceStart; + s32 spaceEnd; - temp_r31 = GWSystem.player_curr; + playerNo = GWSystem.player_curr; BoardWinCreateChoice(2, MAKE_MESSID(11, 0), 0, 0); - if (GWPlayer[temp_r31].com) { + if (GWPlayer[playerNo].com) { BoardComKeySetLeft(); } BoardWinWait(); BoardWinKill(); - var_r28 = BoardWinChoiceGet(); - if (var_r28 != 0) { + choice = BoardWinChoiceGet(); + if (choice != 0) { BoardWinCreate(2, MAKE_MESSID(11, 4), 0); BoardWinWait(); BoardWinKill(); BoardMGExit(); return; } - BoardModelMotionStart(lbl_1_bss_6C4[6], 0, 0); - sp14.x = 0.0f; - sp14.y = 0.0f; - sp14.z = 0.0f; - sp8.x = 0.0f; - sp8.y = 170.0f; - sp8.z = 0.0f; - BoardCameraMotionStartEx(lbl_1_bss_6C4[6], &sp14, &sp8, 1200.0f, 25.0f, 21); - temp_r30 = GWPlayer[temp_r31].space_curr; - temp_r3 = BoardSpaceLinkFlagSearch(0, temp_r30, 0x02000000); - BoardSpacePosGet(0, temp_r3, &sp20); - BoardPlayerMoveBetween(temp_r31, temp_r30, temp_r3); - BoardPlayerMotionStart(temp_r31, 1, 0x40000001); + BoardModelMotionStart(mapObjMdlId[MAPOBJ_SPACEAMIDA], 0, 0); + { + Vec cameraOfs; + Vec cameraRot; + cameraOfs.x = 0.0f; + cameraOfs.y = 0.0f; + cameraOfs.z = 0.0f; + cameraRot.x = 0.0f; + cameraRot.y = 170.0f; + cameraRot.z = 0.0f; + BoardCameraMotionStartEx(mapObjMdlId[MAPOBJ_SPACEAMIDA], &cameraOfs, &cameraRot, 1200.0f, 25.0f, 21); + } + + spaceStart = GWPlayer[playerNo].space_curr; + spaceEnd = BoardSpaceLinkFlagSearch(0, spaceStart, 0x02000000); + BoardSpacePosGet(0, spaceEnd, &spacePos); + BoardPlayerMoveBetween(playerNo, spaceStart, spaceEnd); + BoardPlayerMotionStart(playerNo, 1, HU3D_MOTATTR_LOOP); BoardAudSeqPause(0, 1, 1000); - fn_1_9DD8(); - while (GWPlayer[temp_r31].moving) { + SpaceAmidaExec(); + while (GWPlayer[playerNo].moving) { HuPrcVSleep(); } while (BoardEventFlagGet() != 0) { HuPrcVSleep(); } BoardAudSeqPause(0, 0, 1000); - while (GWPlayer[temp_r31].moving) { + while (GWPlayer[playerNo].moving) { HuPrcVSleep(); } - BoardPlayerMotionStart(temp_r31, 1, 0x40000001); + BoardPlayerMotionStart(playerNo, 1, HU3D_MOTATTR_LOOP); } -static s32 fn_1_157C(void) +static s32 WalkMiniEvent(void) { - s32 temp_r31; - s16 temp_curr; + s32 flag; + s16 spaceId; - temp_curr = GWPlayer[GWSystem.player_curr].space_curr; - temp_r31 = BoardSpaceFlagGet(0, temp_curr) & 0x600000; + spaceId = GWPlayer[GWSystem.player_curr].space_curr; + flag = BoardSpaceFlagGet(0, spaceId) & 0x600000; BoardRollDispSet(0); - if (temp_r31 == 0x200000) { - fn_1_130C(); + if (flag == 0x200000) { + SpaceAmidaEvent(); } - else if (temp_r31 == 0x400000) { - fn_1_128C(); + else if (flag == 0x400000) { + RoundItemEvent(); } BoardRollDispSet(1); } -static void fn_1_1670(void) +static void UpdateHostDisp(void) { - if (lbl_1_bss_0->unk00_field0 == 0) { - BoardModelVisibilitySet(lbl_1_bss_6C4[2], 1); - BoardModelVisibilitySet(lbl_1_bss_6C4[3], 0); + if (boardWork->hostSide == 0) { + BoardModelVisibilitySet(mapObjMdlId[MAPOBJ_HOST1], 1); + BoardModelVisibilitySet(mapObjMdlId[MAPOBJ_HOST2], 0); } else { - BoardModelVisibilitySet(lbl_1_bss_6C4[2], 0); - BoardModelVisibilitySet(lbl_1_bss_6C4[3], 1); + BoardModelVisibilitySet(mapObjMdlId[MAPOBJ_HOST1], 0); + BoardModelVisibilitySet(mapObjMdlId[MAPOBJ_HOST2], 1); } } -static void fn_1_1700(void) +static void CoasterInit(void) { - Vec sp8; - Mtx sp14; + Vec pos; + Mtx matrix; - lbl_1_bss_6B1 = 0; - lbl_1_bss_6AE = BoardModelCreate(DATA_MAKE_NUM(DATADIR_W01, 10), NULL, 0); - lbl_1_bss_644 = BoardModelMotionMaxTimeGet(lbl_1_bss_6AE); - BoardModelVisibilitySet(lbl_1_bss_6AE, 0); + coasterLandF = 0; + coasterPathMdlId = BoardModelCreate(DATA_MAKE_NUM(DATADIR_W01, 10), NULL, 0); + coasterMaxTime = BoardModelMotionMaxTimeGet(coasterPathMdlId); + BoardModelVisibilitySet(coasterPathMdlId, 0); memset(lbl_1_bss_2C, 0, sizeof(lbl_1_bss_2C)); if (BoardSpaceRead(1, DATA_MAKE_NUM(DATADIR_W01, 6)) == 0) { - if (lbl_1_bss_0->unk00_field0 == 0) { - BoardSpaceFlagPosGet(1, 0x2000, &sp8); - BoardModelMotionTimeSet(lbl_1_bss_6AE, lbl_1_bss_644); - lbl_1_bss_63C = -90.0f; + if (boardWork->hostSide == 0) { + BoardSpaceFlagPosGet(1, 0x2000, &pos); + BoardModelMotionTimeSet(coasterPathMdlId, coasterMaxTime); + coasterBaseRotY = -90.0f; } else { - BoardSpaceFlagPosGet(1, 0x1000, &sp8); - BoardModelMotionTimeSet(lbl_1_bss_6AE, 0.0f); - lbl_1_bss_63C = 90.0f; + BoardSpaceFlagPosGet(1, 0x1000, &pos); + BoardModelMotionTimeSet(coasterPathMdlId, 0.0f); + coasterBaseRotY = 90.0f; } - lbl_1_bss_654 = sp8; - BoardModelPosSetV(lbl_1_bss_6C4[0], &sp8); - BoardModelRotSet(lbl_1_bss_6C4[0], 0.0f, lbl_1_bss_63C, 0.0f); - BoardModelExistDupe(lbl_1_bss_6C4[0], 1); - BoardModelExistDupe(lbl_1_bss_6C4[1], 1); - fn_8006DDE8(lbl_1_bss_6C4[1], 500.0f); - MTXIdentity(sp14); - BoardModelMtxSet(lbl_1_bss_6C4[0], &sp14); - fn_1_1670(); + coasterPos = pos; + BoardModelPosSetV(mapObjMdlId[MAPOBJ_COASTER], &pos); + BoardModelRotSet(mapObjMdlId[MAPOBJ_COASTER], 0.0f, coasterBaseRotY, 0.0f); + BoardModelExistDupe(mapObjMdlId[MAPOBJ_COASTER], 1); + BoardModelExistDupe(mapObjMdlId[MAPOBJ_COASTER_RAIL], 1); + fn_8006DDE8(mapObjMdlId[MAPOBJ_COASTER_RAIL], 500.0f); + MTXIdentity(matrix); + BoardModelMtxSet(mapObjMdlId[MAPOBJ_COASTER], &matrix); + UpdateHostDisp(); } } -static void fn_1_1990(void) +static void CoasterPathUpdate(void) { - Vec sp10; - float var_f31; - s32 var_r29; - s32 var_r30; - s16 sp8[3]; - BoardSpace *temp_r31; - BoardSpace *temp_r3; + Vec diff; + float time; + s32 spaceId; + s32 spaceIdLink; + s16 linkTbl[3]; + BoardSpace *space; + BoardSpace *spaceLink; - var_r29 = lbl_1_bss_6AC; - var_f31 = 0.0f; + spaceId = coasterStartSpace; + time = 0.0f; while (TRUE) { - temp_r31 = BoardSpaceGet(1, var_r29); - if (lbl_1_bss_0->unk00_field0 == 0) { - var_r30 = temp_r31->link[0]; + space = BoardSpaceGet(1, spaceId); + if (boardWork->hostSide == 0) { + spaceIdLink = space->link[0]; } else { - BoardSpaceLinkTargetListGet(1, var_r29, sp8); - var_r30 = sp8[0]; + BoardSpaceLinkTargetListGet(1, spaceId, linkTbl); + spaceIdLink = linkTbl[0]; } - if (var_r30 == 0) { + if (spaceIdLink == 0) { break; } - temp_r3 = BoardSpaceGet(1, var_r30); - if (!temp_r3) { - temp_r3 = temp_r31; + spaceLink = BoardSpaceGet(1, spaceIdLink); + if (!spaceLink) { + spaceLink = space; break; } - VECSubtract(&temp_r3->pos, &temp_r31->pos, &sp10); - var_f31 += VECMag(&sp10); - if (var_f31 >= lbl_1_bss_640) { + VECSubtract(&spaceLink->pos, &space->pos, &diff); + time += VECMag(&diff); + if (time >= coasterTime) { break; } - var_r29 = var_r30; + spaceId = spaceIdLink; } - if (temp_r31->flag & 8) { - lbl_1_bss_6B3 = 1; + if (space->flag & 8) { + coasterLoopF = 1; } else { - lbl_1_bss_6B3 = 0; + coasterLoopF = 0; } } -static void fn_1_1AD8(BoardCameraData *camera) +static void CoasterPosCalc(BoardCameraData *camera) { - camera->pos = lbl_1_bss_630; - camera->up = lbl_1_bss_624; - camera->target = lbl_1_bss_618; + camera->pos = coasterCameraPos; + camera->up = coasterCameraUp; + camera->target = coasterCameraTarget; } -static void fn_1_1B3C(void) +static void CoasterCameraUpdate(void) { - Vec sp3C; - Vec sp30; - Vec sp24; - Vec sp18; - Vec spC; - Mtx sp48; + Vec modelPos; + Vec diff; + Vec target; + Vec up; + Vec pos; + Mtx matrix; - VECSubtract(&lbl_1_bss_654, &lbl_1_bss_648, &sp30); - if (lbl_1_bss_6B3 != 0) { - BoardModelPosGet(lbl_1_bss_6C4[1], &sp3C); - VECSubtract(&sp3C, &lbl_1_bss_654, &sp18); - VECNormalize(&sp18, &sp18); - sp24 = lbl_1_bss_648; - spC = lbl_1_bss_654; - BoardMTXCalcLookAt(sp48, &spC, &sp18, &sp24); - MTXTranspose(sp48, lbl_1_bss_678); - MTXRotRad(sp48, 'z', MTXDegToRad(lbl_1_bss_660.z)); - MTXConcat(lbl_1_bss_678, sp48, lbl_1_bss_678); + VECSubtract(&coasterPos, &coasterPosOld, &diff); + if (coasterLoopF != 0) { + BoardModelPosGet(mapObjMdlId[MAPOBJ_COASTER_RAIL], &modelPos); + VECSubtract(&modelPos, &coasterPos, &up); + VECNormalize(&up, &up); + target = coasterPosOld; + pos = coasterPos; + BoardMTXCalcLookAt(matrix, &pos, &up, &target); + MTXTranspose(matrix, coasterMtx); + MTXRotRad(matrix, 'z', MTXDegToRad(coasterRot.z)); + MTXConcat(coasterMtx, matrix, coasterMtx); } else { - if (sp30.z != 0.0f || sp30.x != 0.0f) { - lbl_1_bss_660.y = atan2d(sp30.x, sp30.z); - lbl_1_bss_660.x = -atan2d(sp30.y, VECMagXZ(&sp30)); + if (diff.z != 0.0f || diff.x != 0.0f) { + coasterRot.y = atan2d(diff.x, diff.z); + coasterRot.x = -atan2d(diff.y, VECMagXZ(&diff)); } else { - lbl_1_bss_660.x = lbl_1_bss_660.y = 0.0f; + coasterRot.x = coasterRot.y = 0.0f; } - MTXRotRad(lbl_1_bss_678, 'z', MTXDegToRad(lbl_1_bss_660.z)); - MTXRotRad(sp48, 'x', MTXDegToRad(lbl_1_bss_660.x)); - MTXConcat(sp48, lbl_1_bss_678, lbl_1_bss_678); - MTXRotRad(sp48, 'y', MTXDegToRad(lbl_1_bss_660.y)); - MTXConcat(sp48, lbl_1_bss_678, lbl_1_bss_678); + MTXRotRad(coasterMtx, 'z', MTXDegToRad(coasterRot.z)); + MTXRotRad(matrix, 'x', MTXDegToRad(coasterRot.x)); + MTXConcat(matrix, coasterMtx, coasterMtx); + MTXRotRad(matrix, 'y', MTXDegToRad(coasterRot.y)); + MTXConcat(matrix, coasterMtx, coasterMtx); } } -static void fn_1_1EE4(void) +static void CoasterCameraObjKill(void) { - Bss10Work *temp_r31; + CoasterCameraWork *work; - if (lbl_1_bss_10) { - temp_r31 = OM_GET_WORK_PTR(lbl_1_bss_10, Bss10Work); - temp_r31->unk00_field0 = 1; + if (coasterCameraObj) { + work = OM_GET_WORK_PTR(coasterCameraObj, CoasterCameraWork); + work->killF = TRUE; } } -static void fn_1_1F2C(omObjData *arg0) +static void CoasterCameraObjMain(omObjData *obj) { - Bss10Work *temp_r31 = OM_GET_WORK_PTR(arg0, Bss10Work); + CoasterCameraWork *work = OM_GET_WORK_PTR(obj, CoasterCameraWork); - if (temp_r31->unk00_field0 != 0 || BoardIsKill()) { - omDelObjEx(HuPrcCurrentGet(), arg0); - lbl_1_bss_10 = NULL; + if (work->killF != 0 || BoardIsKill()) { + omDelObjEx(HuPrcCurrentGet(), obj); + coasterCameraObj = NULL; return; } - fn_1_1FA4(); + CoasterCameraObjUpdate(); } -static void fn_1_1FA4(void) +static void CoasterCameraObjUpdate(void) { - Vec sp18; - Vec spC; - float temp_f28; - float temp_f29; - float var_f27; + Vec modelPos; + Vec pos; + float angleY; + float angleX; + float radius; - spC.x = lbl_1_bss_648.x; - spC.y = lbl_1_bss_648.y + 200.0f; - spC.z = lbl_1_bss_648.z; - VECSubtract(&spC, &lbl_1_bss_618, &spC); - VECScale(&spC, &spC, 0.08f); - VECAdd(&spC, &lbl_1_bss_618, &lbl_1_bss_618); - VECSubtract(&lbl_1_bss_654, &lbl_1_bss_648, &spC); - if (spC.x != 0.0f || spC.z != 0.0f) { - temp_f29 = atan2f(spC.y, VECMagXZ(&spC)); - temp_f28 = atan2f(-spC.x, -spC.z); + pos.x = coasterPosOld.x; + pos.y = coasterPosOld.y + 200.0f; + pos.z = coasterPosOld.z; + VECSubtract(&pos, &coasterCameraTarget, &pos); + VECScale(&pos, &pos, 0.08f); + VECAdd(&pos, &coasterCameraTarget, &coasterCameraTarget); + VECSubtract(&coasterPos, &coasterPosOld, &pos); + if (pos.x != 0.0f || pos.z != 0.0f) { + angleX = atan2f(pos.y, VECMagXZ(&pos)); + angleY = atan2f(-pos.x, -pos.z); } else { - temp_f29 = temp_f28 = 0.0f; + angleX = angleY = 0.0f; return; } - temp_f29 += -0.27925268f; - if (lbl_1_bss_6B3 != 0) { - if (lbl_1_bss_66C < 0.08f) { - lbl_1_bss_66C -= 0.00033333333f; + angleX += -0.27925268f; + if (coasterLoopF != 0) { + if (coasterCamSpeed < 0.08f) { + coasterCamSpeed -= 0.00033333333f; } - BoardModelPosGet(lbl_1_bss_6C4[1], &sp18); - if (lbl_1_bss_0->unk00_field0 == 0) { - var_f27 = -2500.0f; + BoardModelPosGet(mapObjMdlId[MAPOBJ_COASTER_RAIL], &modelPos); + if (boardWork->hostSide == 0) { + radius = -2500.0f; } else { - var_f27 = 2500.0f; + radius = 2500.0f; } - sp18.x = sp18.x + var_f27 * sin(1.4137166738510132); // TODO: should be sind(81) - sp18.y = sp18.y + -150.0f; - sp18.z = sp18.z + var_f27 * cos(1.4137166738510132); // TODO: should be cosd(81) - VECSubtract(&sp18, &lbl_1_bss_630, &spC); - VECScale(&spC, &spC, lbl_1_bss_66C); - VECAdd(&spC, &lbl_1_bss_630, &lbl_1_bss_630); + modelPos.x = modelPos.x + radius * sin(1.4137166738510132); // TODO: should be sind(81) + modelPos.y = modelPos.y + -150.0f; + modelPos.z = modelPos.z + radius * cos(1.4137166738510132); // TODO: should be cosd(81) + VECSubtract(&modelPos, &coasterCameraPos, &pos); + VECScale(&pos, &pos, coasterCamSpeed); + VECAdd(&pos, &coasterCameraPos, &coasterCameraPos); } else { - if (lbl_1_bss_66C < 0.08f) { - lbl_1_bss_66C += 0.00066666666f; + if (coasterCamSpeed < 0.08f) { + coasterCamSpeed += 0.00066666666f; } - spC.x = 400.0 * (sin(temp_f28) * cos(temp_f29)); - spC.y = 400.0 * -sin(temp_f29); - spC.z = 400.0 * (cos(temp_f28) * cos(temp_f29)); - VECAdd(&lbl_1_bss_618, &spC, &spC); - VECSubtract(&spC, &lbl_1_bss_630, &spC); - VECScale(&spC, &spC, lbl_1_bss_66C); - VECAdd(&spC, &lbl_1_bss_630, &lbl_1_bss_630); + pos.x = 400.0 * (sin(angleY) * cos(angleX)); + pos.y = 400.0 * -sin(angleX); + pos.z = 400.0 * (cos(angleY) * cos(angleX)); + VECAdd(&coasterCameraTarget, &pos, &pos); + VECSubtract(&pos, &coasterCameraPos, &pos); + VECScale(&pos, &pos, coasterCamSpeed); + VECAdd(&pos, &coasterCameraPos, &coasterCameraPos); } } -static float fn_1_2524(void) +static float CoasterStickRotGet(void) { - Vec sp24; - Vec sp18; - Vec spC; - float var_f30; - s16 sp8; - s32 var_r29; + Vec basePos; + Vec modelPos; + Vec diff; + float stickRot; + s16 stkX; + s32 padNo; s32 i; - sp24 = lbl_1_bss_654; - if (GWPlayer[lbl_1_bss_6B4].com) { - if (lbl_1_bss_6B3 != 0) { + basePos = coasterPos; + if (GWPlayer[eventPlayer].com) { + if (coasterLoopF != 0) { return 0.0f; } for (i = 0; i < 24; i++) { - if (lbl_1_bss_600[i] == 0) { - BoardModelPosGet(lbl_1_bss_5D0[i], &sp18); - VECSubtract(&sp18, &sp24, &spC); - if (!(VECMag(&spC) > 400.0f)) { + if (coasterCoinF[i] == 0) { + BoardModelPosGet(coasterCoinMdlId[i], &modelPos); + VECSubtract(&modelPos, &basePos, &diff); + if (!(VECMag(&diff) > 400.0f)) { break; } } @@ -904,109 +908,104 @@ static float fn_1_2524(void) if (i == 24) { return 0.0f; } - VECSubtract(&sp18, &sp24, &spC); - var_f30 = atan2d(spC.x, spC.z); - if (var_f30 > 0.0f) { - var_f30 = 45.0f; + VECSubtract(&modelPos, &basePos, &diff); + stickRot = atan2d(diff.x, diff.z); + if (stickRot > 0.0f) { + stickRot = 45.0f; } else { - var_f30 = -45.0f; + stickRot = -45.0f; } } else { - var_r29 = GWPlayer[lbl_1_bss_6B4].port; - sp8 = HuPadStkX[var_r29]; - OSs16tof32(&sp8, &var_f30); - var_f30 = var_f30 * 0.625f; + padNo = GWPlayer[eventPlayer].port; + stkX = HuPadStkX[padNo]; + OSs16tof32(&stkX, &stickRot); + stickRot = stickRot * 0.625f; } - return var_f30; + return stickRot; } -static void fn_1_276C(void) +static void CoasterRotUpdate(void) { - Vec sp58; - Vec sp40; - Vec sp34; - Vec sp28; - Vec sp1C; - float temp_f26; - float var_f27; + float motTime; + float stickRot; Mtx sp70; - fn_1_1B3C(); - if (lbl_1_bss_6B1 != 0) { - lbl_1_bss_660.z = 0.0f; + CoasterCameraUpdate(); + if (coasterLandF != 0) { + coasterRot.z = 0.0f; return; } - var_f27 = fn_1_2524(); - BoardDAngleCalcRange(&lbl_1_bss_660.z, var_f27, 5.0f); - temp_f26 = 6.0f + 6.0f * (lbl_1_bss_660.z / 45.0f) - 1.0f; - if (lbl_1_bss_660.z > 22.5f) { - BoardPlayerMotionStart(lbl_1_bss_6B4, lbl_1_bss_5CC[1], 0); - BoardPlayerMotionTimeSet(lbl_1_bss_6B4, temp_f26); + stickRot = CoasterStickRotGet(); + BoardDAngleCalcRange(&coasterRot.z, stickRot, 5.0f); + motTime = 6.0f + 6.0f * (coasterRot.z / 45.0f) - 1.0f; + if (coasterRot.z > 22.5f) { + BoardPlayerMotionStart(eventPlayer, coasterMotId[1], 0); + BoardPlayerMotionTimeSet(eventPlayer, motTime); } - else if (lbl_1_bss_660.z < -22.5f) { - BoardPlayerMotionStart(lbl_1_bss_6B4, lbl_1_bss_5CC[1], 0); - BoardPlayerMotionTimeSet(lbl_1_bss_6B4, temp_f26); + else if (coasterRot.z < -22.5f) { + BoardPlayerMotionStart(eventPlayer, coasterMotId[1], 0); + BoardPlayerMotionTimeSet(eventPlayer, motTime); } else { - BoardPlayerMotionShiftSet(lbl_1_bss_6B4, lbl_1_bss_5CC[0], 0.0f, 10.0f, HU3D_MOTATTR_LOOP); + BoardPlayerMotionShiftSet(eventPlayer, coasterMotId[0], 0.0f, 10.0f, HU3D_MOTATTR_LOOP); } - fn_1_2F18(); + CoasterCoinCheck(); } -static void fn_1_2F18(void) +static void CoasterCoinCheck(void) { - Vec sp3C; - Vec sp30; - Vec sp24; - Vec sp18; - Vec spC; - float var_f29; - Mtx spD8; - Mtx spA8; - Mtx sp78; - Mtx sp48; + Vec coinPos; + Vec ofs; + Vec angle; + Vec diff; + Vec mdlCoasterPos; + float rotZ; + Mtx matrix; + Mtx mtxRotX; + Mtx mtxRotY; + Mtx mtxRotZ; s32 i; - if (lbl_1_bss_6B3 == 0) { - var_f29 = lbl_1_bss_660.z; - if (var_f29 > 180.0f) { - var_f29 -= 360.0f; + if (coasterLoopF == 0) { + rotZ = coasterRot.z; + if (rotZ > 180.0f) { + rotZ -= 360.0f; } - BoardModelPosGet(lbl_1_bss_6C4[0], &spC); - VECSubtract(&lbl_1_bss_654, &lbl_1_bss_648, &sp18); - if (sp18.z != 0.0f || sp18.x != 0.0f) { - sp24.y = atan2d(sp18.x, sp18.z); - sp24.x = -atan2d(sp18.y, VECMagXZ(&sp18)); + BoardModelPosGet(mapObjMdlId[MAPOBJ_COASTER], &mdlCoasterPos); + VECSubtract(&coasterPos, &coasterPosOld, &diff); + if (diff.z != 0.0f || diff.x != 0.0f) { + angle.y = atan2d(diff.x, diff.z); + angle.x = -atan2d(diff.y, VECMagXZ(&diff)); } else { - sp24.x = sp24.y = 0.0f; + angle.x = angle.y = 0.0f; } - MTXTrans(spD8, 0.0f, 180.0f, 0.0f); - MTXRotRad(spA8, 'x', MTXDegToRad(sp24.x)); - MTXRotRad(sp78, 'y', MTXDegToRad(sp24.y)); - MTXRotRad(sp48, 'z', MTXDegToRad(var_f29)); - MTXConcat(spA8, sp48, sp48); - MTXConcat(sp78, sp48, sp48); - MTXConcat(sp48, spD8, spD8); - sp30.x = spD8[0][3]; - sp30.y = spD8[1][3]; - sp30.z = spD8[2][3]; - VECAdd(&sp30, &spC, &sp30); - if (var_f29 < 27.000002f && var_f29 > -27.000002f) { + MTXTrans(matrix, 0.0f, 180.0f, 0.0f); + MTXRotRad(mtxRotX, 'x', MTXDegToRad(angle.x)); + MTXRotRad(mtxRotY, 'y', MTXDegToRad(angle.y)); + MTXRotRad(mtxRotZ, 'z', MTXDegToRad(rotZ)); + MTXConcat(mtxRotX, mtxRotZ, mtxRotZ); + MTXConcat(mtxRotY, mtxRotZ, mtxRotZ); + MTXConcat(mtxRotZ, matrix, matrix); + ofs.x = matrix[0][3]; + ofs.y = matrix[1][3]; + ofs.z = matrix[2][3]; + VECAdd(&ofs, &mdlCoasterPos, &ofs); + if (rotZ < 27.000002f && rotZ > -27.000002f) { return; } for (i = 0; i < 24; i++) { - if (lbl_1_bss_600[i] == 0) { - BoardModelPosGet(lbl_1_bss_5D0[i], &sp3C); - if (BoardVecMaxDistXZCheck(&sp3C, &sp30, 180.0f)) { + if (coasterCoinF[i] == 0) { + BoardModelPosGet(coasterCoinMdlId[i], &coinPos); + if (BoardVecMaxDistXZCheck(&coinPos, &ofs, 180.0f)) { CharModelLayerSetAll(2); - CharModelCoinEffectCreate(1, &sp3C); - BoardModelVisibilitySet(lbl_1_bss_5D0[i], 0); - BoardPlayerCoinsAdd(lbl_1_bss_6B4, 1); + CharModelCoinEffectCreate(1, &coinPos); + BoardModelVisibilitySet(coasterCoinMdlId[i], 0); + BoardPlayerCoinsAdd(eventPlayer, 1); HuAudFXPlay(7); - lbl_1_bss_600[i] = 1; + coasterCoinF[i] = 1; break; } } @@ -1014,239 +1013,236 @@ static void fn_1_2F18(void) } } -static s16 lbl_1_data_580 = -1; +static s16 coasterWinId = -1; -static void fn_1_3350(void) +static void CoasterPathMotUpdate(void) { - Vec sp8; - s16 temp_r3; - ModelData *temp_r30; - HsfObject *temp_r31; + Vec diff; + s16 modelId; + ModelData *modelP; + HsfObject *obj; - lbl_1_bss_674 += 0.002f; - if (lbl_1_bss_670 > 0.18f) { - lbl_1_bss_670 = 0.18f; + coasterAccel += 0.002f; + if (coasterSpeed > 0.18f) { + coasterSpeed = 0.18f; } - else if (lbl_1_bss_670 < 0.18f) { - lbl_1_bss_670 += lbl_1_bss_674; + else if (coasterSpeed < 0.18f) { + coasterSpeed += coasterAccel; } - temp_r3 = BoardModelIDGet(lbl_1_bss_6AE); - temp_r30 = &Hu3DData[temp_r3]; - Hu3DMotionExec(temp_r3, temp_r30->unk_08, temp_r30->unk_64, 0); - temp_r31 = Hu3DModelObjPtrGet(temp_r3, "looppath-cube1"); - lbl_1_bss_648 = lbl_1_bss_654; - lbl_1_bss_654.x = temp_r31->data.curr.pos.x; - lbl_1_bss_654.y = temp_r31->data.curr.pos.y; - lbl_1_bss_654.z = temp_r31->data.curr.pos.z; - VECSubtract(&lbl_1_bss_648, &lbl_1_bss_654, &sp8); - lbl_1_bss_640 += VECMag(&sp8); + modelId = BoardModelIDGet(coasterPathMdlId); + modelP = &Hu3DData[modelId]; + Hu3DMotionExec(modelId, modelP->unk_08, modelP->unk_64, 0); + obj = Hu3DModelObjPtrGet(modelId, "looppath-cube1"); + coasterPosOld = coasterPos; + coasterPos.x = obj->data.curr.pos.x; + coasterPos.y = obj->data.curr.pos.y; + coasterPos.z = obj->data.curr.pos.z; + VECSubtract(&coasterPosOld, &coasterPos, &diff); + coasterTime += VECMag(&diff); } -static s32 lbl_1_data_594[8][2] +static s32 coasterMotTbl[8][2] = { { DATA_MAKE_NUM(DATADIR_W01, 34), DATA_MAKE_NUM(DATADIR_W01, 42) }, { DATA_MAKE_NUM(DATADIR_W01, 35), DATA_MAKE_NUM(DATADIR_W01, 43) }, { DATA_MAKE_NUM(DATADIR_W01, 36), DATA_MAKE_NUM(DATADIR_W01, 44) }, { DATA_MAKE_NUM(DATADIR_W01, 37), DATA_MAKE_NUM(DATADIR_W01, 45) }, { DATA_MAKE_NUM(DATADIR_W01, 38), DATA_MAKE_NUM(DATADIR_W01, 46) }, { DATA_MAKE_NUM(DATADIR_W01, 39), DATA_MAKE_NUM(DATADIR_W01, 47) }, { DATA_MAKE_NUM(DATADIR_W01, 40), DATA_MAKE_NUM(DATADIR_W01, 48) }, { DATA_MAKE_NUM(DATADIR_W01, 41), DATA_MAKE_NUM(DATADIR_W01, 49) } }; -static void fn_1_3514(s32 arg0) +static void CoasterMotCreate(s32 playerNo) { - s32 temp_r30; + s32 charNo; s32 i; - temp_r30 = GWPlayer[arg0].character; + charNo = GWPlayer[playerNo].character; for (i = 0; i < 2; i++) { - lbl_1_bss_5CC[i] = BoardPlayerMotionCreate(arg0, lbl_1_data_594[temp_r30][i]); + coasterMotId[i] = BoardPlayerMotionCreate(playerNo, coasterMotTbl[charNo][i]); } } -static void fn_1_35B4(s32 arg0) +static void CoasterMotKill(s32 playerNo) { s32 i; for (i = 0; i < 2; i++) { - BoardPlayerMotionKill(arg0, lbl_1_bss_5CC[i]); - lbl_1_bss_5CC[i] = -1; + BoardPlayerMotionKill(playerNo, coasterMotId[i]); + coasterMotId[i] = -1; } } -static void fn_1_3624(void) +static void CoasterExec(void) { - Mtx sp48; - Vec sp3C; - Vec sp30; - Vec sp24; - Vec sp18; - float temp_f28; - float var_f30; - float var_f29; - s32 temp_r19; - Bss10Work *temp_r18; - s16 sp10; - s16 var_r25; + Mtx playerMtx; + Vec spacePos; + Vec cameraRot; + float coasterRotSpeed; + float coasterRotDir; + float coasterMotSpeed; + s32 seNo; + CoasterCameraWork *camWork; + s16 endSpace; s16 i; - lbl_1_bss_674 = lbl_1_bss_670 = 0.0f; - lbl_1_bss_640 = 0.0f; - lbl_1_bss_660.x = 0.0f; - lbl_1_bss_660.y = 0.0f; - lbl_1_bss_660.z = 0.0f; + coasterAccel = coasterSpeed = 0.0f; + coasterTime = 0.0f; + coasterRot.x = 0.0f; + coasterRot.y = 0.0f; + coasterRot.z = 0.0f; lbl_1_bss_6A8 = 0.0f; - lbl_1_bss_6B3 = 0; - lbl_1_bss_624.x = 0.0f; - lbl_1_bss_624.z = 0.0f; - lbl_1_bss_624.y = 1.0f; - lbl_1_bss_66C = 0.08f; - fn_1_3514(lbl_1_bss_6B4); - BoardPlayerMotionStart(lbl_1_bss_6B4, lbl_1_bss_5CC[0], 0x40000001); + coasterLoopF = 0; + coasterCameraUp.x = 0.0f; + coasterCameraUp.z = 0.0f; + coasterCameraUp.y = 1.0f; + coasterCamSpeed = 0.08f; + CoasterMotCreate(eventPlayer); + BoardPlayerMotionStart(eventPlayer, coasterMotId[0], HU3D_MOTATTR_LOOP); BoardSpaceAttrSet(0, 1); - fn_1_97F4(); - BoardModelMotionStart(lbl_1_bss_6AE, 0, 0); - if (lbl_1_bss_0->unk00_field0 == 0) { - BoardModelMotionTimeSet(lbl_1_bss_6AE, lbl_1_bss_644); - lbl_1_bss_63C = -90.0f; - lbl_1_bss_6AC = BoardSpaceFlagPosGet(1, 0x2000, &sp3C); - var_r25 = BoardSpaceFlagSearch(0, 0x1000); - var_f30 = -1.0f; + CoasterEffCreate(); + BoardModelMotionStart(coasterPathMdlId, 0, 0); + if (boardWork->hostSide == 0) { + BoardModelMotionTimeSet(coasterPathMdlId, coasterMaxTime); + coasterBaseRotY = -90.0f; + coasterStartSpace = BoardSpaceFlagPosGet(1, 0x2000, &spacePos); + endSpace = BoardSpaceFlagSearch(0, 0x1000); + coasterRotDir = -1.0f; } else { - BoardModelMotionTimeSet(lbl_1_bss_6AE, 0.0f); - lbl_1_bss_63C = 90.0f; - lbl_1_bss_6AC = BoardSpaceFlagPosGet(1, 0x1000, &sp3C); - var_r25 = BoardSpaceFlagSearch(0, 0x2000); - var_f30 = 1.0f; + BoardModelMotionTimeSet(coasterPathMdlId, 0.0f); + coasterBaseRotY = 90.0f; + coasterStartSpace = BoardSpaceFlagPosGet(1, 0x1000, &spacePos); + endSpace = BoardSpaceFlagSearch(0, 0x2000); + coasterRotDir = 1.0f; } - lbl_1_bss_654 = sp3C; - lbl_1_bss_648 = lbl_1_bss_654; - BoardModelMotionSpeedSet(lbl_1_bss_6AE, lbl_1_bss_670); - BoardPlayerPosSetV(lbl_1_bss_6B4, &lbl_1_bss_654); - BoardCameraPosCalcFuncSet(fn_1_1AD8); - lbl_1_bss_10 = omAddObjEx(boardObjMan, 0x7E02, 0, 0, -1, fn_1_1F2C); - temp_r18 = OM_GET_WORK_PTR(lbl_1_bss_10, Bss10Work); - temp_r18->unk00_field0 = 0; - sp30.x = -40.0f; - sp30.z = 0.0f; - sp30.y = -lbl_1_bss_63C; - BoardCameraMotionStartEx(lbl_1_bss_6C4[0], &sp30, NULL, 150.0f, -1.0f, 2); + coasterPos = spacePos; + coasterPosOld = coasterPos; + BoardModelMotionSpeedSet(coasterPathMdlId, coasterSpeed); + BoardPlayerPosSetV(eventPlayer, &coasterPos); + BoardCameraPosCalcFuncSet(CoasterPosCalc); + coasterCameraObj = omAddObjEx(boardObjMan, 0x7E02, 0, 0, -1, CoasterCameraObjMain); + camWork = OM_GET_WORK_PTR(coasterCameraObj, CoasterCameraWork); + camWork->killF = FALSE; + cameraRot.x = -40.0f; + cameraRot.z = 0.0f; + cameraRot.y = -coasterBaseRotY; + BoardCameraMotionStartEx(mapObjMdlId[MAPOBJ_COASTER], &cameraRot, NULL, 150.0f, -1.0f, 2); BoardCameraMotionWait(); - BoardModelPosGet(lbl_1_bss_6C4[0], &lbl_1_bss_618); - lbl_1_bss_630.x = lbl_1_bss_618.x + 1000.0 * (sind(sp30.y) * cosd(sp30.x)); - lbl_1_bss_630.y = lbl_1_bss_618.y + 1000.0 * -sind(sp30.x); - lbl_1_bss_630.z = lbl_1_bss_618.z + 1000.0 * (cosd(sp30.y) * cosd(sp30.x)); - MTXRotRad(lbl_1_bss_678, 'y', MTXDegToRad(lbl_1_bss_63C)); - BoardModelMtxSet(lbl_1_bss_6C4[0], &lbl_1_bss_678); - BoardPlayerMtxSet(lbl_1_bss_6B4, &lbl_1_bss_678); - BoardModelRotSet(lbl_1_bss_6C4[0], 0.0f, 0.0f, 0.0f); - BoardPlayerRotSet(lbl_1_bss_6B4, 0.0f, 0.0f, 0.0f); - BoardPlayerExistCheck(lbl_1_bss_6B4, 0); + BoardModelPosGet(mapObjMdlId[MAPOBJ_COASTER], &coasterCameraTarget); + coasterCameraPos.x = coasterCameraTarget.x + 1000.0 * (sind(cameraRot.y) * cosd(cameraRot.x)); + coasterCameraPos.y = coasterCameraTarget.y + 1000.0 * -sind(cameraRot.x); + coasterCameraPos.z = coasterCameraTarget.z + 1000.0 * (cosd(cameraRot.y) * cosd(cameraRot.x)); + MTXRotRad(coasterMtx, 'y', MTXDegToRad(coasterBaseRotY)); + BoardModelMtxSet(mapObjMdlId[MAPOBJ_COASTER], &coasterMtx); + BoardPlayerMtxSet(eventPlayer, &coasterMtx); + BoardModelRotSet(mapObjMdlId[MAPOBJ_COASTER], 0.0f, 0.0f, 0.0f); + BoardPlayerRotSet(eventPlayer, 0.0f, 0.0f, 0.0f); + BoardPlayerExistCheck(eventPlayer, 0); BoardMusStart(1, 0x10, 0x7F, 0); - fn_1_50D4(); - BoardStatusShowSetForce(lbl_1_bss_6B4); - BoardStatusShowSet(lbl_1_bss_6B4, 1); - while (!BoardStatusStopCheck(lbl_1_bss_6B4)) { + CoasterCoinCreate(); + BoardStatusShowSetForce(eventPlayer); + BoardStatusShowSet(eventPlayer, 1); + while (!BoardStatusStopCheck(eventPlayer)) { HuPrcVSleep(); } - temp_r19 = HuAudFXPlay(0x40C); - fn_1_4774(); + seNo = HuAudFXPlay(0x40C); + CoasterWinCreate(); WipeCreate(WIPE_MODE_IN, WIPE_TYPE_NORMAL, -1); - lbl_1_bss_6B0 = 1; + coasterType = 1; HuAudFXPlay(0x413); while (TRUE) { - fn_1_1990(); - fn_1_3350(); - fn_1_276C(); - BoardModelPosSetV(lbl_1_bss_6C4[0], &lbl_1_bss_654); - BoardPlayerPosSetV(lbl_1_bss_6B4, &lbl_1_bss_654); - if (BoardPlayerSizeGet(lbl_1_bss_6B4) != 1) { - MTXTrans(sp48, 0.0f, 30.0f, 0.0f); + CoasterPathUpdate(); + CoasterPathMotUpdate(); + CoasterRotUpdate(); + BoardModelPosSetV(mapObjMdlId[MAPOBJ_COASTER], &coasterPos); + BoardPlayerPosSetV(eventPlayer, &coasterPos); + if (BoardPlayerSizeGet(eventPlayer) != 1) { + MTXTrans(playerMtx, 0.0f, 30.0f, 0.0f); } else { - MTXTrans(sp48, 0.0f, 400.0f, 250.0f); + MTXTrans(playerMtx, 0.0f, 400.0f, 250.0f); } - BoardModelMtxSet(lbl_1_bss_6C4[0], &lbl_1_bss_678); - MTXConcat(lbl_1_bss_678, sp48, sp48); - BoardPlayerMtxSet(lbl_1_bss_6B4, &sp48); - if (lbl_1_bss_0->unk00_field0 == 0) { - var_f29 = -lbl_1_bss_670; + BoardModelMtxSet(mapObjMdlId[MAPOBJ_COASTER], &coasterMtx); + MTXConcat(coasterMtx, playerMtx, playerMtx); + BoardPlayerMtxSet(eventPlayer, &playerMtx); + if (boardWork->hostSide == 0) { + coasterMotSpeed = -coasterSpeed; } else { - var_f29 = lbl_1_bss_670; + coasterMotSpeed = coasterSpeed; } - BoardModelMotionSpeedSet(lbl_1_bss_6AE, var_f29); - if (lbl_1_bss_0->unk00_field0 == 0) { - if (BoardModelMotionTimeGet(lbl_1_bss_6AE) <= 0.0f) { + BoardModelMotionSpeedSet(coasterPathMdlId, coasterMotSpeed); + if (boardWork->hostSide == 0) { + if (BoardModelMotionTimeGet(coasterPathMdlId) <= 0.0f) { break; } } else { - if (BoardModelMotionTimeGet(lbl_1_bss_6AE) >= lbl_1_bss_644) { + if (BoardModelMotionTimeGet(coasterPathMdlId) >= coasterMaxTime) { break; } } HuPrcVSleep(); } - MTXIdentity(lbl_1_bss_678); - fn_1_4864(); - HuAudFXStop(temp_r19); - fn_1_1EE4(); - fn_1_98EC(); - if (BoardPlayerSizeGet(lbl_1_bss_6B4) == 1) { - MTXTrans(sp48, 0.0f, 400.0f, 250.0f); + MTXIdentity(coasterMtx); + CoasterWinKill(); + HuAudFXStop(seNo); + CoasterCameraObjKill(); + CoasterEffKill(); + if (BoardPlayerSizeGet(eventPlayer) == 1) { + MTXTrans(playerMtx, 0.0f, 400.0f, 250.0f); } else { - MTXTrans(sp48, 0.0f, 30.0f, 0.0f); + MTXTrans(playerMtx, 0.0f, 30.0f, 0.0f); } - BoardModelMtxSet(lbl_1_bss_6C4[0], &lbl_1_bss_678); - BoardPlayerMtxSet(lbl_1_bss_6B4, &sp48); - lbl_1_bss_660.x = lbl_1_bss_660.z = 0.0f; + BoardModelMtxSet(mapObjMdlId[MAPOBJ_COASTER], &coasterMtx); + BoardPlayerMtxSet(eventPlayer, &playerMtx); + coasterRot.x = coasterRot.z = 0.0f; BoardAudSeqFadeOut(1, 1000); WipeColorSet(0, 0, 0); WipeCreate(WIPE_MODE_OUT, WIPE_TYPE_NORMAL, -1); HuAudFXPlay(0x401); - temp_f28 = (-lbl_1_bss_63C - lbl_1_bss_660.y) / 30.0f; + coasterRotSpeed = (-coasterBaseRotY - coasterRot.y) / 30.0f; for (i = 0; i < 30; i++) { - BoardModelRotSetV(lbl_1_bss_6C4[0], &lbl_1_bss_660); - BoardPlayerRotSetV(lbl_1_bss_6B4, &lbl_1_bss_660); - lbl_1_bss_660.y += temp_f28 * var_f30; + BoardModelRotSetV(mapObjMdlId[MAPOBJ_COASTER], &coasterRot); + BoardPlayerRotSetV(eventPlayer, &coasterRot); + coasterRot.y += coasterRotSpeed * coasterRotDir; HuPrcVSleep(); } - lbl_1_bss_660.y = -lbl_1_bss_63C; - BoardModelRotSetV(lbl_1_bss_6C4[0], &lbl_1_bss_660); - BoardPlayerRotSetV(lbl_1_bss_6B4, &lbl_1_bss_660); - BoardStatusShowSet(lbl_1_bss_6B4, 0); + coasterRot.y = -coasterBaseRotY; + BoardModelRotSetV(mapObjMdlId[MAPOBJ_COASTER], &coasterRot); + BoardPlayerRotSetV(eventPlayer, &coasterRot); + BoardStatusShowSet(eventPlayer, 0); BoardSpaceAttrReset(0, 1); - fn_1_53B8(); + CoasterCoinKill(); BoardCameraMoveSet(0); - BoardCameraTargetPlayerSet(lbl_1_bss_6B4); + BoardCameraTargetPlayerSet(eventPlayer); BoardCameraViewSet(1); BoardCameraMotionWait(); do { HuPrcVSleep(); } while (WipeStatGet() != 0); - BoardPlayerIdleSet(lbl_1_bss_6B4); - BoardPlayerMtxSet(lbl_1_bss_6B4, &lbl_1_bss_678); + BoardPlayerIdleSet(eventPlayer); + BoardPlayerMtxSet(eventPlayer, &coasterMtx); BoardCameraPosCalcFuncSet(NULL); - BoardPlayerExistCheck(lbl_1_bss_6B4, 1); - BoardSpacePosGet(0, var_r25, &sp3C); - GWPlayer[lbl_1_bss_6B4].space_curr = var_r25; - BoardPlayerPosSetV(lbl_1_bss_6B4, &sp3C); - fn_1_35B4(lbl_1_bss_6B4); - lbl_1_bss_6B2 = 1; + BoardPlayerExistCheck(eventPlayer, 1); + BoardSpacePosGet(0, endSpace, &spacePos); + GWPlayer[eventPlayer].space_curr = endSpace; + BoardPlayerPosSetV(eventPlayer, &spacePos); + CoasterMotKill(eventPlayer); + coasterDoneF = 1; } -static void fn_1_45F4(void) +static void CoasterExit(void) { - if (lbl_1_bss_6B2 != 0) { - if (lbl_1_bss_0->unk00_field0 == 0) { - lbl_1_bss_0->unk00_field0 = 1; + if (coasterDoneF != 0) { + if (boardWork->hostSide == 0) { + boardWork->hostSide = 1; } else { - lbl_1_bss_0->unk00_field0 = 0; + boardWork->hostSide = 0; } - lbl_1_bss_6B2 = 0; - fn_1_1670(); + coasterDoneF = 0; + UpdateHostDisp(); } - fn_1_87AC(); - while (lbl_1_bss_C) { + CoasterPlayerManKill(); + while (coasterPlayerManObj) { HuPrcVSleep(); } BoardAudSeqPause(0, 0, 1000); @@ -1259,50 +1255,50 @@ static void fn_1_45F4(void) BoardStatusShowSetAll(1); } -static void fn_1_4774(void) +static void CoasterWinCreate(void) { - float sp8[2]; - float var_f31; - float var_f30; + float winSize[2]; + float winX; + float winY; - HuWinMesMaxSizeGet(1, sp8, MAKE_MESSID(13, 5)); - var_f31 = -10000.0f; - var_f30 = 352.0f; - lbl_1_data_580 = HuWinCreate(var_f31, var_f30, sp8[0], sp8[1], 0); - HuWinBGTPLvlSet(lbl_1_data_580, 0.0f); - HuWinMesSpeedSet(lbl_1_data_580, 0); - HuWinMesSet(lbl_1_data_580, MAKE_MESSID(13, 5)); + HuWinMesMaxSizeGet(1, winSize, MAKE_MESSID(13, 5)); + winX = -10000.0f; + winY = 352.0f; + coasterWinId = HuWinCreate(winX, winY, winSize[0], winSize[1], 0); + HuWinBGTPLvlSet(coasterWinId, 0.0f); + HuWinMesSpeedSet(coasterWinId, 0); + HuWinMesSet(coasterWinId, MAKE_MESSID(13, 5)); } -static void fn_1_4864(void) +static void CoasterWinKill(void) { - if (lbl_1_data_580 != -1) { - HuWinKill(lbl_1_data_580); - lbl_1_data_580 = -1; + if (coasterWinId != -1) { + HuWinKill(coasterWinId); + coasterWinId = -1; } } -static s32 fn_1_48B4(void) +static s32 CoasterHostExec(void) { - Vec sp20; - Vec sp14; - Vec sp8; - float var_f31; - u32 var_r31; + Vec startPos; + Vec endPos; + Vec dir; + float angle; + u32 mess; s32 i; - s32 temp_r28; - s32 temp_r30; + s32 spaceEnd; + s32 spaceStart; - var_r31 = 0; - lbl_1_bss_6B0 = 0; - lbl_1_bss_6B1 = 0; - lbl_1_bss_6B2 = 0; - lbl_1_bss_6B4 = GWSystem.player_curr; - temp_r30 = GWPlayer[lbl_1_bss_6B4].space_curr; - BoardPlayerMotionShiftSet(lbl_1_bss_6B4, 1, 0.0f, 14.0f, HU3D_MOTATTR_LOOP); + mess = 0; + coasterType = 0; + coasterLandF = 0; + coasterDoneF = 0; + eventPlayer = GWSystem.player_curr; + spaceStart = GWPlayer[eventPlayer].space_curr; + BoardPlayerMotionShiftSet(eventPlayer, 1, 0.0f, 14.0f, HU3D_MOTATTR_LOOP); BoardWinCreateChoice(0, MAKE_MESSID(13, 0), -1, 0); - if (GWPlayer[lbl_1_bss_6B4].com) { - fn_1_9D00(lbl_1_bss_6B4); + if (GWPlayer[eventPlayer].com) { + CoasterHostComKeySet(eventPlayer); } BoardWinWait(); if (BoardWinChoiceGet() != 0) { @@ -1310,23 +1306,23 @@ static s32 fn_1_48B4(void) } BoardWinCreate(2, 0xD0006, 0); BoardWinWait(); - temp_r28 = BoardSpaceLinkFlagSearch(0, temp_r30, 0x02000000); - BoardSpacePosGet(0, temp_r30, &sp20); - BoardSpacePosGet(0, temp_r28, &sp14); - VECSubtract(&sp14, &sp20, &sp8); - VECNormalize(&sp8, &sp8); - var_f31 = atan2d(-sp8.x, -sp8.z); - BoardPlayerRotSet(lbl_1_bss_6B4, 0.0f, var_f31, 0.0f); - BoardPlayerMoveBetween(lbl_1_bss_6B4, temp_r30, temp_r28); - while (GWPlayer[lbl_1_bss_6B4].moving) { + spaceEnd = BoardSpaceLinkFlagSearch(0, spaceStart, 0x02000000); + BoardSpacePosGet(0, spaceStart, &startPos); + BoardSpacePosGet(0, spaceEnd, &endPos); + VECSubtract(&endPos, &startPos, &dir); + VECNormalize(&dir, &dir); + angle = atan2d(-dir.x, -dir.z); + BoardPlayerRotSet(eventPlayer, 0.0f, angle, 0.0f); + BoardPlayerMoveBetween(eventPlayer, spaceStart, spaceEnd); + while (GWPlayer[eventPlayer].moving) { HuPrcVSleep(); } - BoardPlayerIdleSet(lbl_1_bss_6B4); + BoardPlayerIdleSet(eventPlayer); while (TRUE) { BoardWinCreateChoice(1, MAKE_MESSID(13, 1), 0, 0); BoardWinAttrSet(0x10); - if (GWPlayer[lbl_1_bss_6B4].com) { - if (BoardPlayerCoinsGet(lbl_1_bss_6B4) >= 5) { + if (GWPlayer[eventPlayer].com) { + if (BoardPlayerCoinsGet(eventPlayer) >= 5) { BoardComKeySetUp(); } else { @@ -1335,19 +1331,19 @@ static s32 fn_1_48B4(void) } BoardWinWait(); if (BoardWinChoiceGet() == 1) { - var_r31 = MAKE_MESSID(13, 3); + mess = MAKE_MESSID(13, 3); break; } if (BoardWinChoiceGet() == 2) { - BoardViewMapExec(lbl_1_bss_6B4); + BoardViewMapExec(eventPlayer); continue; } - if (BoardPlayerCoinsGet(lbl_1_bss_6B4) < 5) { - var_r31 = MAKE_MESSID(13, 4); + if (BoardPlayerCoinsGet(eventPlayer) < 5) { + mess = MAKE_MESSID(13, 4); break; } for (i = 0; i < 5; i++) { - BoardPlayerCoinsAdd(lbl_1_bss_6B4, -1); + BoardPlayerCoinsAdd(eventPlayer, -1); HuAudFXPlay(0xE); HuPrcSleep(6); } @@ -1363,1122 +1359,1118 @@ static s32 fn_1_48B4(void) while (WipeStatGet() != 0) { HuPrcVSleep(); } - fn_1_852C(); - return 1; + CoasterPlayerManCreate(); + return TRUE; } - if (var_r31 != 0) { - BoardWinCreate(1, var_r31, 0); + if (mess != 0) { + BoardWinCreate(1, mess, 0); BoardWinWait(); BoardWinKill(); } - BoardCameraTargetPlayerSet(lbl_1_bss_6B4); - VECSubtract(&sp20, &sp14, &sp8); - VECNormalize(&sp8, &sp8); - var_f31 = atan2d(-sp8.x, -sp8.z); - BoardPlayerRotSet(lbl_1_bss_6B4, 0.0f, var_f31, 0.0f); - BoardPlayerMoveBetween(lbl_1_bss_6B4, temp_r28, temp_r30); - while (GWPlayer[lbl_1_bss_6B4].moving) { + BoardCameraTargetPlayerSet(eventPlayer); + VECSubtract(&startPos, &endPos, &dir); + VECNormalize(&dir, &dir); + angle = atan2d(-dir.x, -dir.z); + BoardPlayerRotSet(eventPlayer, 0.0f, angle, 0.0f); + BoardPlayerMoveBetween(eventPlayer, spaceEnd, spaceStart); + while (GWPlayer[eventPlayer].moving) { HuPrcVSleep(); } - return 0; + return FALSE; } -static void fn_1_4E14(void) +static void CoasterMain(void) { - if (fn_1_48B4() != 0) { - fn_1_3624(); - fn_1_45F4(); + if (CoasterHostExec() != 0) { + CoasterExec(); + CoasterExit(); } HuPrcEnd(); } -static void fn_1_4FA8(void) +static void CoasterDestroy(void) { BoardWinKill(); - lbl_1_bss_8 = NULL; + coasterProc = NULL; } -static void fn_1_4FD8(void) +static void CoasterEvent(void) { - lbl_1_bss_6B4 = GWSystem.player_curr; + eventPlayer = GWSystem.player_curr; BoardRollDispSet(0); - if (BoardPlayerSizeGet(lbl_1_bss_6B4) == 2 || GWPlayer[lbl_1_bss_6B4].bowser_suit) { + if (BoardPlayerSizeGet(eventPlayer) == 2 || GWPlayer[eventPlayer].bowser_suit) { return; } - lbl_1_bss_8 = HuPrcChildCreate(fn_1_4E14, 0x2003, 0x2000, 0, boardMainProc); - HuPrcDestructorSet2(lbl_1_bss_8, fn_1_4FA8); - while (lbl_1_bss_8) { + coasterProc = HuPrcChildCreate(CoasterMain, 0x2003, 0x2000, 0, boardMainProc); + HuPrcDestructorSet2(coasterProc, CoasterDestroy); + while (coasterProc) { HuPrcVSleep(); } BoardRollDispSet(1); } -static void fn_1_50D4(void) +static void CoasterCoinCreate(void) { - Vec sp20; - Vec sp14; - Vec sp8; - float temp_f30; - float var_f31; - BoardSpace *temp_r31; - s32 var_r27; - s32 var_r26; - s32 var_r29; - s32 var_r28; + Vec pos; + Vec posSpace; + Vec dir; + float radius; + float angle; + BoardSpace *space; + s32 side; + s32 newSide; + s32 coinNum; + s32 spaceId; s32 i; for (i = 0; i < 24; i++) { - lbl_1_bss_5D0[i] = BoardModelCreate(DATA_MAKE_NUM(DATADIR_BOARD, 9), NULL, 0); - BoardModelVisibilitySet(lbl_1_bss_5D0[i], 0); - BoardModelMotionStart(lbl_1_bss_5D0[i], 0, 0x40000001); - lbl_1_bss_600[i] = 0; + coasterCoinMdlId[i] = BoardModelCreate(DATA_MAKE_NUM(DATADIR_BOARD, 9), NULL, 0); + BoardModelVisibilitySet(coasterCoinMdlId[i], 0); + BoardModelMotionStart(coasterCoinMdlId[i], 0, HU3D_MOTATTR_LOOP); + coasterCoinF[i] = 0; } - temp_f30 = 180.0f; - var_r28 = BoardSpaceFlagPosGet(1, 0x2000, &sp20); - var_r27 = BoardRand() & 1; - var_r29 = i = 0; + radius = 180.0f; + spaceId = BoardSpaceFlagPosGet(1, 0x2000, &pos); + side = BoardRand() & 1; + coinNum = i = 0; while (i < 24) { - temp_r31 = BoardSpaceGet(1, var_r28); - var_r28 = temp_r31->link[0]; - if (var_r28 == -1 || temp_r31->link_cnt == 0) { + space = BoardSpaceGet(1, spaceId); + spaceId = space->link[0]; + if (spaceId == -1 || space->link_cnt == 0) { break; } - if (!(temp_r31->flag & 0x80)) { - sp14 = temp_r31->pos; + if (!(space->flag & 0x80)) { + posSpace = space->pos; } else { - if (var_r29 >= 3) { + if (coinNum >= 3) { if (BoardRandFloat() < 0.5f) { - var_r26 = 1; + newSide = 1; } else { - var_r26 = 0; + newSide = 0; } - var_r27 = var_r26; - var_r29 = 0; + side = newSide; + coinNum = 0; } - VECSubtract(&sp14, &temp_r31->pos, &sp8); - VECNormalize(&sp8, &sp8); - var_f31 = atan2d(sp8.z, sp8.x); - if (var_r27 != 0) { - var_f31 += 180.0f; + VECSubtract(&posSpace, &space->pos, &dir); + VECNormalize(&dir, &dir); + angle = atan2d(dir.z, dir.x); + if (side != 0) { + angle += 180.0f; } - sp20.x = temp_r31->pos.x + temp_f30 * sind(var_f31); - sp20.y = temp_r31->pos.y + 80.0f; - sp20.z = temp_r31->pos.z + temp_f30 * cosd(var_f31); - BoardModelPosSetV(lbl_1_bss_5D0[i], &sp20); - BoardModelVisibilitySet(lbl_1_bss_5D0[i], 1); - sp14 = temp_r31->pos; + pos.x = space->pos.x + radius * sind(angle); + pos.y = space->pos.y + 80.0f; + pos.z = space->pos.z + radius * cosd(angle); + BoardModelPosSetV(coasterCoinMdlId[i], &pos); + BoardModelVisibilitySet(coasterCoinMdlId[i], 1); + posSpace = space->pos; i++; - var_r29++; + coinNum++; } } } -static void fn_1_53B8(void) +static void CoasterCoinKill(void) { s32 i; for (i = 0; i < 24; i++) { - if (lbl_1_bss_5D0[i] != -1) { - BoardModelKill(lbl_1_bss_5D0[i]); - lbl_1_bss_5D0[i] = -1; + if (coasterCoinMdlId[i] != -1) { + BoardModelKill(coasterCoinMdlId[i]); + coasterCoinMdlId[i] = -1; } } } -static s32 lbl_1_data_5D4 = -1; -static s32 lbl_1_data_5D8 = -1; +static s32 cupMoveSeNo = -1; +static s32 decaStompSeNo = -1; -static s16 lbl_1_data_5DC[2][4] = { { 24, 25, 26, 27 }, { 29, 30, 31, 32 } }; +static s16 cupMapObj[2][4] = { + { MAPOBJ_CUPR1, MAPOBJ_CUPR2, MAPOBJ_CUPR3, MAPOBJ_CUPR_ARROW }, + { MAPOBJ_CUPL1, MAPOBJ_CUPL2, MAPOBJ_CUPL3, MAPOBJ_CUPL_ARROW } +}; -static char *lbl_1_data_604[] = { "chara1", "chara2", "chara3" }; +static char *cupHookTbl[] = { "chara1", "chara2", "chara3" }; -static float lbl_1_data_610[2][2] = { { 90.0f, 0.0f }, { 0.0f, 270.0f } }; +static float cupArrowRot[2][2] = { { 90.0f, 0.0f }, { 0.0f, 270.0f } }; -static void fn_1_543C(void) +static void CupInit(void) { - float var_f31; - s16 temp_r28; - s16 temp_r29; + float rotY; + s16 mdlIdDish; + s16 mdlId; s32 i; s32 j; - char *sp10[] = { "cup1", "cup2", "cup3", "ya1" }; - s32 sp8[] = { 23, 28 }; + char *hookName[] = { "cup1", "cup2", "cup3", "ya1" }; + s32 dishMapObj[] = { MAPOBJ_CUPR_DISH, MAPOBJ_CUPL_DISH }; for (i = 0; i < 2; i++) { - temp_r28 = lbl_1_bss_6C4[sp8[i]]; - BoardModelMotionStart(temp_r28, 0, 0x40000001); - BoardModelExistDupe(temp_r28, 0); + mdlIdDish = mapObjMdlId[dishMapObj[i]]; + BoardModelMotionStart(mdlIdDish, 0, HU3D_MOTATTR_LOOP); + BoardModelExistDupe(mdlIdDish, 0); for (j = 0; j < 4; j++) { - temp_r29 = lbl_1_bss_6C4[lbl_1_data_5DC[i][j]]; - BoardModelExistDupe(temp_r29, 1); - BoardModelHookSet(temp_r28, sp10[j], temp_r29); - BoardModelMotionStart(temp_r29, 0, 0x40000001); - BoardModelRotSet(temp_r29, 0.0f, 360.0f * BoardRandFloat(), 0.0f); + mdlId = mapObjMdlId[cupMapObj[i][j]]; + BoardModelExistDupe(mdlId, 1); + BoardModelHookSet(mdlIdDish, hookName[j], mdlId); + BoardModelMotionStart(mdlId, 0, HU3D_MOTATTR_LOOP); + BoardModelRotSet(mdlId, 0.0f, 360.0f * BoardRandFloat(), 0.0f); } } - if (lbl_1_bss_0->unk01[0] != 0) { - var_f31 = 0.0f; + if (boardWork->cupDir[0] != 0) { + rotY = 0.0f; } else { - var_f31 = 90.0f; + rotY = 90.0f; } - BoardModelRotSet(lbl_1_bss_6C4[27], 0.0f, var_f31, 0.0f); - if (lbl_1_bss_0->unk01[1] != 0) { - var_f31 = -90.0f; + BoardModelRotSet(mapObjMdlId[MAPOBJ_CUPR_ARROW], 0.0f, rotY, 0.0f); + if (boardWork->cupDir[1] != 0) { + rotY = -90.0f; } else { - var_f31 = 0.0f; + rotY = 0.0f; } - BoardModelRotSet(lbl_1_bss_6C4[32], 0.0f, var_f31, 0.0f); + BoardModelRotSet(mapObjMdlId[MAPOBJ_CUPL_ARROW], 0.0f, rotY, 0.0f); } -static void fn_1_5694(s32 arg0) +static void CupMotOnSet(s32 stopF) { - s16 temp_r29; - s16 temp_r30; + s16 dishMdlId; + s16 cupMdlId; s16 i; - s32 spC[] = { 23, 28 }; + s32 dishMapObj[] = { MAPOBJ_CUPR_DISH, MAPOBJ_CUPL_DISH }; - temp_r29 = lbl_1_bss_6C4[spC[lbl_1_bss_29]]; - if (arg0 != 0) { - BoardModelMotionSpeedSet(temp_r29, 1.0f); - BoardModelAttrReset(temp_r29, 0x40000002); + dishMdlId = mapObjMdlId[dishMapObj[cupSide]]; + if (stopF != 0) { + BoardModelMotionSpeedSet(dishMdlId, 1.0f); + BoardModelAttrReset(dishMdlId, HU3D_MOTATTR_PAUSE); for (i = 0; i < 3; i++) { - temp_r30 = lbl_1_bss_6C4[lbl_1_data_5DC[lbl_1_bss_29][i]]; - BoardModelMotionSpeedSet(temp_r30, 1.0f); - BoardModelAttrReset(temp_r30, 0x40000002); + cupMdlId = mapObjMdlId[cupMapObj[cupSide][i]]; + BoardModelMotionSpeedSet(cupMdlId, 1.0f); + BoardModelAttrReset(cupMdlId, HU3D_MOTATTR_PAUSE); } } else { - BoardModelMotionSpeedSet(temp_r29, 0.0f); - BoardModelAttrSet(temp_r29, 0x40000002); + BoardModelMotionSpeedSet(dishMdlId, 0.0f); + BoardModelAttrSet(dishMdlId, HU3D_MOTATTR_PAUSE); for (i = 0; i < 3; i++) { - temp_r30 = lbl_1_bss_6C4[lbl_1_data_5DC[lbl_1_bss_29][i]]; - BoardModelMotionSpeedSet(temp_r30, 0.0f); - BoardModelAttrSet(temp_r30, 0x40000002); + cupMdlId = mapObjMdlId[cupMapObj[cupSide][i]]; + BoardModelMotionSpeedSet(cupMdlId, 0.0f); + BoardModelAttrSet(cupMdlId, HU3D_MOTATTR_PAUSE); } } } -static void fn_1_586C(s32 arg0, s32 arg1) +static void CupEvent(s32 side, s32 spaceStart) { - lbl_1_bss_29 = arg0; - lbl_1_bss_26 = arg1; + cupSide = side; + cupSpaceStart = spaceStart; BoardRollDispSet(0); - lbl_1_bss_14 = HuPrcChildCreate(fn_1_592C, 0x2003, 0x2000, 0, boardMainProc); - HuPrcDestructorSet2(lbl_1_bss_14, fn_1_5B2C); - while (lbl_1_bss_14) { + cupProc = HuPrcChildCreate(CupMain, 0x2003, 0x2000, 0, boardMainProc); + HuPrcDestructorSet2(cupProc, CupDestroy); + while (cupProc) { HuPrcVSleep(); } BoardRollDispSet(1); } -static void fn_1_592C(void) +static void CupMain(void) { - s16 temp_r30; - s16 var_r28; + s16 dishMdlId; - lbl_1_data_5D4 = -1; - lbl_1_data_5D8 = -1; + cupMoveSeNo = -1; + decaStompSeNo = -1; BoardPlayerIdleSet(GWSystem.player_curr); - if (lbl_1_bss_29 == 0) { - var_r28 = lbl_1_bss_6C4[23]; + if (cupSide == 0) { + dishMdlId = mapObjMdlId[MAPOBJ_CUPR_DISH]; } else { - var_r28 = lbl_1_bss_6C4[28]; + dishMdlId = mapObjMdlId[MAPOBJ_CUPL_DISH]; } - BoardCameraTargetModelSet(var_r28); + BoardCameraTargetModelSet(dishMdlId); BoardCameraOffsetSet(0.0f, 0.0f, 0.0f); - fn_1_5D08(); - while (!fn_1_5CD0()) { + CupObjCreate(); + while (!CupObjCheck()) { HuPrcVSleep(); } - fn_1_5B40(); - fn_1_5694(1); + CupExec(); + CupMotOnSet(1); BoardCameraTargetPlayerSet(GWSystem.player_curr); BoardCameraViewSet(1); BoardCameraMotionWait(); HuPrcEnd(); } -static void fn_1_5B2C(void) +static void CupDestroy(void) { - lbl_1_bss_14 = NULL; + cupProc = NULL; } -static void fn_1_5B40(void) +static void CupExec(void) { - s16 spC[] = { 27, 32 }; - s16 temp_r30; - s32 temp_r31; - float sp8; - float temp_f31; + s16 cupArrowMapObj[] = { MAPOBJ_CUPR_ARROW, MAPOBJ_CUPL_ARROW }; + s16 cupArrowMdlId; + s32 cupDir; + float rotY; + float rotYNew; - temp_r31 = lbl_1_bss_0->unk01[lbl_1_bss_29]; - lbl_1_bss_0->unk01[lbl_1_bss_29] ^= 1; - temp_r30 = lbl_1_bss_6C4[spC[lbl_1_bss_29]]; - sp8 = lbl_1_data_610[lbl_1_bss_29][temp_r31]; - temp_f31 = lbl_1_data_610[lbl_1_bss_29][temp_r31 ^ 1]; + cupDir = boardWork->cupDir[cupSide]; + boardWork->cupDir[cupSide] ^= 1; + cupArrowMdlId = mapObjMdlId[cupArrowMapObj[cupSide]]; + rotY = cupArrowRot[cupSide][cupDir]; + rotYNew = cupArrowRot[cupSide][cupDir ^ 1]; HuAudFXPlay(0x403); while (TRUE) { HuPrcVSleep(); - if (BoardDAngleCalcRange(&sp8, temp_f31, 3.0f) != 0) { + if (BoardDAngleCalcRange(&rotY, rotYNew, 3.0f) != 0) { break; } - BoardModelRotSet(temp_r30, 0.0f, sp8, 0.0f); + BoardModelRotSet(cupArrowMdlId, 0.0f, rotY, 0.0f); } } -static BOOL fn_1_5CD0(void) +static BOOL CupObjCheck(void) { - return lbl_1_bss_18 ? FALSE : TRUE; + return cupObj ? FALSE : TRUE; } -static void fn_1_5D08(void) +static void CupObjCreate(void) { - Bss18Work *temp_r31; - float var_f30; - float var_f31; - s16 var_r28; - s16 var_r25; + CupObjWork *work; + float time; + float speed; + s16 dishMdlId; + s16 cupMdlId; s32 i; - if (lbl_1_bss_29 == 0) { - var_r28 = lbl_1_bss_6C4[23]; + if (cupSide == 0) { + dishMdlId = mapObjMdlId[MAPOBJ_CUPR_DISH]; } else { - var_r28 = lbl_1_bss_6C4[28]; + dishMdlId = mapObjMdlId[MAPOBJ_CUPL_DISH]; } while (TRUE) { - var_f30 = BoardModelMotionTimeGet(var_r28); - if (var_f30 >= 209.0f && var_f30 <= 211.0f) { + time = BoardModelMotionTimeGet(dishMdlId); + if (time >= 209.0f && time <= 211.0f) { break; } - if (var_f30 >= 129.0f && var_f30 <= 131.0f) { + if (time >= 129.0f && time <= 131.0f) { break; } - if (var_f30 >= 49.0f && var_f30 <= 51.0f) { + if (time >= 49.0f && time <= 51.0f) { break; } HuPrcVSleep(); } - var_f31 = 1.0f; - while (var_f31 > 0.01f) { - var_f31 *= 0.9f; - if (var_f31 <= 0.01f) { - var_f31 = 0.0f; + speed = 1.0f; + while (speed > 0.01f) { + speed *= 0.9f; + if (speed <= 0.01f) { + speed = 0.0f; } - BoardModelMotionSpeedSet(var_r28, var_f31); + BoardModelMotionSpeedSet(dishMdlId, speed); for (i = 0; i < 3; i++) { - var_r25 = lbl_1_bss_6C4[lbl_1_data_5DC[lbl_1_bss_29][i]]; - BoardModelMotionSpeedSet(var_r25, var_f31); + cupMdlId = mapObjMdlId[cupMapObj[cupSide][i]]; + BoardModelMotionSpeedSet(cupMdlId, speed); } HuPrcVSleep(); } - fn_1_5694(0); - lbl_1_bss_18 = omAddObjEx(boardObjMan, 0x103, 0, 0, -1, fn_1_6098); - temp_r31 = OM_GET_WORK_PTR(lbl_1_bss_18, Bss18Work); - temp_r31->unk00_field0 = 0; - temp_r31->unk01 = 0; - temp_r31->unk02 = 0; - temp_r31->unk00_field2 = 0; - temp_r31->unk04 = var_r28; + CupMotOnSet(0); + cupObj = omAddObjEx(boardObjMan, 0x103, 0, 0, -1, CupObjMain); + work = OM_GET_WORK_PTR(cupObj, CupObjWork); + work->killF = 0; + work->time = 0; + work->delay = 0; + work->stopF = 0; + work->dishMdlId = dishMdlId; if (BoardPlayerSizeGet(GWSystem.player_curr) == 2) { - temp_r31->unk00_field3 = 1; + work->decaF = TRUE; } else { - temp_r31->unk00_field3 = 0; + work->decaF = FALSE; } } -static void fn_1_6098(omObjData *arg0) +static void CupObjMain(omObjData *obj) { - Bss18Work *temp_r31 = OM_GET_WORK_PTR(arg0, Bss18Work); - s32 temp_r0; + CupObjWork *work = OM_GET_WORK_PTR(obj, CupObjWork); - if (temp_r31->unk00_field0 != 0 || BoardIsKill()) { - lbl_1_bss_18 = NULL; - omDelObjEx(HuPrcCurrentGet(), arg0); + if (work->killF != 0 || BoardIsKill()) { + cupObj = NULL; + omDelObjEx(HuPrcCurrentGet(), obj); return; } - if (temp_r31->unk02 != 0) { - temp_r31->unk02--; + if (work->delay != 0) { + work->delay--; return; } - switch (temp_r31->unk00_field1) { + switch (work->mode) { case 0: - fn_1_6194(temp_r31, arg0); + CupObjInit(work, obj); break; case 2: - fn_1_63F0(temp_r31, arg0); + CupObjJumpWait(work, obj); break; case 3: - fn_1_6BC0(temp_r31, arg0); + CupObjStop(work, obj); break; case 1: - fn_1_6FB4(temp_r31, arg0); + CupObjRotate(work, obj); break; } } -static void fn_1_6194(Bss18Work *arg0, omObjData *arg1) +static void CupObjInit(CupObjWork *work, omObjData *obj) { - Mtx sp38; - Vec sp2C; - Vec sp20; - Vec sp14; - Vec sp8; + Mtx objMtx; + Vec objPosPrev; + Vec playerPos; + Vec objRot; + Vec objPos; float temp_f31; float var_f30; s32 var_r28; s32 i; - BoardPlayerPosGet(GWSystem.player_curr, &sp20); + BoardPlayerPosGet(GWSystem.player_curr, &playerPos); var_f30 = 1000000.0f; for (i = 0; i < 3; i++) { - Hu3DModelObjPosGet(BoardModelIDGet(arg0->unk04), lbl_1_data_604[i], &sp8); - temp_f31 = VECSquareDistance(&sp8, &sp20); + Hu3DModelObjPosGet(BoardModelIDGet(work->dishMdlId), cupHookTbl[i], &objPos); + temp_f31 = VECSquareDistance(&objPos, &playerPos); if (temp_f31 < var_f30) { var_f30 = temp_f31; - lbl_1_bss_28 = i; - sp2C = sp8; + cupHookNo = i; + objPosPrev = objPos; } } - Hu3DModelObjMtxGet(BoardModelIDGet(arg0->unk04), lbl_1_data_604[lbl_1_bss_28], sp38); - Hu3DMtxRotGet(&sp38, &sp14); - sp14.y = 180.0f; - VECSubtract(&sp2C, &sp20, &sp8); - arg1->trans.x = sp8.x / 25.0f; - arg1->trans.z = sp8.z / 25.0f; + Hu3DModelObjMtxGet(BoardModelIDGet(work->dishMdlId), cupHookTbl[cupHookNo], objMtx); + Hu3DMtxRotGet(&objMtx, &objRot); + objRot.y = 180.0f; + VECSubtract(&objPosPrev, &playerPos, &objPos); + obj->trans.x = objPos.x / 25.0f; + obj->trans.z = objPos.z / 25.0f; var_r28 = BoardPlayerRotYGet(GWSystem.player_curr); - arg1->trans.y = BoardDAngleCalc(sp14.y - var_r28) / 25.0f; - arg1->scale.x = sp2C.x; - arg1->scale.y = sp2C.y; - arg1->scale.z = sp2C.z; + obj->trans.y = BoardDAngleCalc(objRot.y - var_r28) / 25.0f; + obj->scale.x = objPosPrev.x; + obj->scale.y = objPosPrev.y; + obj->scale.z = objPosPrev.z; BoardPlayerMotionShiftSet(GWSystem.player_curr, 4, 15.0f, 5.0f, HU3D_MOTATTR_NONE); - arg0->unk00_field1 = 2; - arg0->unk01 = 0; + work->mode = 2; + work->time = 0; } -static void fn_1_63F0(Bss18Work *arg0, omObjData *arg1) +static void CupObjJumpWait(CupObjWork *work, omObjData *obj) { - Vec sp10; - float temp_f29; - float var_f27; - float var_f28; + Vec pos; + float time; + float rotY; + float scaleY; s16 var_r24; - if (arg0->unk01 >= 55) { + if (work->time >= 55) { BoardPlayerRotSet(GWSystem.player_curr, 0.0f, 0.0f, 0.0f); BoardPlayerIdleSet(GWSystem.player_curr); if (GWPlayer[GWSystem.player_curr].bowser_suit) { - BoardModelHookSet(arg0->unk04, lbl_1_data_604[lbl_1_bss_28], BoardBowserSuitModelGet()); + BoardModelHookSet(work->dishMdlId, cupHookTbl[cupHookNo], BoardBowserSuitModelGet()); } else { - BoardModelHookSet(arg0->unk04, lbl_1_data_604[lbl_1_bss_28], BoardPlayerModelGet(GWSystem.player_curr)); + BoardModelHookSet(work->dishMdlId, cupHookTbl[cupHookNo], BoardPlayerModelGet(GWSystem.player_curr)); } - var_r24 = lbl_1_bss_6C4[lbl_1_data_5DC[lbl_1_bss_29][lbl_1_bss_28]]; - if (arg0->unk00_field3 != 0) { + var_r24 = mapObjMdlId[cupMapObj[cupSide][cupHookNo]]; + if (work->decaF != 0) { BoardModelScaleSet(var_r24, 1.0f, 0.1f, 1.0f); } - fn_1_5694(1); - lbl_1_data_5D4 = HuAudFXPlay(0x410); - arg0->unk01 = 0; - arg0->unk00_field1 = 1; + CupMotOnSet(1); + cupMoveSeNo = HuAudFXPlay(0x410); + work->time = 0; + work->mode = 1; return; } - if (arg0->unk01 == 25) { - BoardPlayerPosSet(GWSystem.player_curr, arg1->scale.x, arg1->scale.y, arg1->scale.z); + if (work->time == 25) { + BoardPlayerPosSet(GWSystem.player_curr, obj->scale.x, obj->scale.y, obj->scale.z); BoardPlayerMotionShiftSet(GWSystem.player_curr, 5, 0.0f, 8.0f, HU3D_MOTATTR_NONE); } - if (arg0->unk01 < 25) { - OSu8tof32(&arg0->unk01, &temp_f29); - BoardPlayerPosGet(GWSystem.player_curr, &sp10); - sp10.x += arg1->trans.x; - sp10.z += arg1->trans.z; - sp10.y += 15.0f + -0.08166667f * temp_f29 * temp_f29; - if (sp10.y <= arg1->scale.y) { - sp10.y = arg1->scale.y; + if (work->time < 25) { + OSu8tof32(&work->time, &time); + BoardPlayerPosGet(GWSystem.player_curr, &pos); + pos.x += obj->trans.x; + pos.z += obj->trans.z; + pos.y += 15.0f + -0.08166667f * time * time; + if (pos.y <= obj->scale.y) { + pos.y = obj->scale.y; } - var_f27 = arg1->trans.y + BoardPlayerRotYGet(GWSystem.player_curr); - BoardPlayerRotYSet(GWSystem.player_curr, var_f27); - BoardPlayerPosSetV(GWSystem.player_curr, &sp10); - if (arg0->unk01 > 12 && arg0->unk00_field3 != 0) { - if (lbl_1_data_5D8 == -1) { - lbl_1_data_5D8 = HuAudFXPlay(0x411); + rotY = obj->trans.y + BoardPlayerRotYGet(GWSystem.player_curr); + BoardPlayerRotYSet(GWSystem.player_curr, rotY); + BoardPlayerPosSetV(GWSystem.player_curr, &pos); + if (work->time > 12 && work->decaF != 0) { + if (decaStompSeNo == -1) { + decaStompSeNo = HuAudFXPlay(0x411); } - OSu8tof32(&arg0->unk01, &temp_f29); - temp_f29 -= 12.0f; - temp_f29 = 90.0f * (temp_f29 / 12.5f); - var_f28 = cosd(temp_f29); - if (var_f28 < 0.1f) { - var_f28 = 0.1f; + OSu8tof32(&work->time, &time); + time -= 12.0f; + time = 90.0f * (time / 12.5f); + scaleY = cosd(time); + if (scaleY < 0.1f) { + scaleY = 0.1f; } - var_r24 = lbl_1_bss_6C4[lbl_1_data_5DC[lbl_1_bss_29][lbl_1_bss_28]]; - BoardModelScaleSet(var_r24, 1.0f, var_f28, 1.0f); + var_r24 = mapObjMdlId[cupMapObj[cupSide][cupHookNo]]; + BoardModelScaleSet(var_r24, 1.0f, scaleY, 1.0f); } } - arg0->unk01++; + work->time++; } -static void fn_1_6A14(Bss18Work *arg0, omObjData *arg1) +static void CupObjHookReset(CupObjWork *work, omObjData *obj) { - Vec sp20; - Vec sp14; - Vec sp8; + Vec endPos; + Vec startPos; + Vec diff; - BoardModelHookObjReset(arg0->unk04, lbl_1_data_604[lbl_1_bss_28]); - Hu3DModelObjPosGet(BoardModelIDGet(arg0->unk04), lbl_1_data_604[lbl_1_bss_28], &sp14); - BoardPlayerPosSetV(GWSystem.player_curr, &sp14); - BoardSpacePosGet(0, lbl_1_bss_24, &sp20); - VECSubtract(&sp20, &sp14, &sp8); - arg1->trans.x = sp8.x / 25.0f; - arg1->trans.z = sp8.z / 25.0f; - arg1->scale.x = sp20.x; - arg1->scale.y = sp20.y; - arg1->scale.z = sp20.z; + BoardModelHookObjReset(work->dishMdlId, cupHookTbl[cupHookNo]); + Hu3DModelObjPosGet(BoardModelIDGet(work->dishMdlId), cupHookTbl[cupHookNo], &startPos); + BoardPlayerPosSetV(GWSystem.player_curr, &startPos); + BoardSpacePosGet(0, cupSpaceEnd, &endPos); + VECSubtract(&endPos, &startPos, &diff); + obj->trans.x = diff.x / 25.0f; + obj->trans.z = diff.z / 25.0f; + obj->scale.x = endPos.x; + obj->scale.y = endPos.y; + obj->scale.z = endPos.z; BoardPlayerMotionShiftSet(GWSystem.player_curr, 4, 15.0f, 5.0f, HU3D_MOTATTR_NONE); - BoardPlayerRotYSet(GWSystem.player_curr, atan2d(sp8.x, sp8.z)); - arg0->unk00_field1 = 3; - arg0->unk01 = 0; + BoardPlayerRotYSet(GWSystem.player_curr, atan2d(diff.x, diff.z)); + work->mode = 3; + work->time = 0; } -static void fn_1_6BC0(Bss18Work *arg0, omObjData *arg1) +static void CupObjStop(CupObjWork *work, omObjData *obj) { - Vec sp14; - Vec sp8; - float var_f28; - float temp_f29; - s16 var_r27; + Vec pos; + Vec spacePos; + float angle; + float time; + s16 mdlId; - if (arg0->unk01 >= 55) { - BoardSpacePosGet(0, lbl_1_bss_24, &sp8); - GWPlayer[GWSystem.player_curr].space_curr = lbl_1_bss_24; - BoardPlayerPosSetV(GWSystem.player_curr, &sp8); + if (work->time >= 55) { + BoardSpacePosGet(0, cupSpaceEnd, &spacePos); + GWPlayer[GWSystem.player_curr].space_curr = cupSpaceEnd; + BoardPlayerPosSetV(GWSystem.player_curr, &spacePos); BoardPlayerIdleSet(GWSystem.player_curr); - var_r27 = lbl_1_bss_6C4[lbl_1_data_5DC[lbl_1_bss_29][lbl_1_bss_28]]; - if (arg0->unk00_field3 != 0) { - BoardModelScaleSet(var_r27, 1.0f, 1.0f, 1.0f); + mdlId = mapObjMdlId[cupMapObj[cupSide][cupHookNo]]; + if (work->decaF != 0) { + BoardModelScaleSet(mdlId, 1.0f, 1.0f, 1.0f); } - arg0->unk00_field0 = 1; + work->killF = 1; } - if (arg0->unk01 == 25) { - BoardPlayerPosSet(GWSystem.player_curr, arg1->scale.x, arg1->scale.y, arg1->scale.z); + if (work->time == 25) { + BoardPlayerPosSet(GWSystem.player_curr, obj->scale.x, obj->scale.y, obj->scale.z); BoardPlayerMotionShiftSet(GWSystem.player_curr, 5, 0.0f, 8.0f, HU3D_MOTATTR_NONE); } - if (arg0->unk01 < 25) { - OSu8tof32(&arg0->unk01, &temp_f29); - BoardPlayerPosGet(GWSystem.player_curr, &sp14); - sp14.x += arg1->trans.x; - sp14.z += arg1->trans.z; - sp14.y += 15.0f + -0.08166667f * temp_f29 * temp_f29; - if (sp14.y <= arg1->scale.y) { - sp14.y = arg1->scale.y; + if (work->time < 25) { + OSu8tof32(&work->time, &time); + BoardPlayerPosGet(GWSystem.player_curr, &pos); + pos.x += obj->trans.x; + pos.z += obj->trans.z; + pos.y += 15.0f + -0.08166667f * time * time; + if (pos.y <= obj->scale.y) { + pos.y = obj->scale.y; } - BoardPlayerPosSetV(GWSystem.player_curr, &sp14); - if (arg0->unk01 > 12 && arg0->unk00_field3 != 0) { - OSu8tof32(&arg0->unk01, &temp_f29); - temp_f29 -= 12.0f; - temp_f29 = 90.0f * (temp_f29 / 12.5f); - var_f28 = sind(temp_f29); - if (var_f28 < 0.1f) { - var_f28 = 0.1f; + BoardPlayerPosSetV(GWSystem.player_curr, &pos); + if (work->time > 12 && work->decaF != 0) { + OSu8tof32(&work->time, &time); + time -= 12.0f; + time = 90.0f * (time / 12.5f); + angle = sind(time); + if (angle < 0.1f) { + angle = 0.1f; } - var_r27 = lbl_1_bss_6C4[lbl_1_data_5DC[lbl_1_bss_29][lbl_1_bss_28]]; - BoardModelScaleSet(var_r27, 1.0f, var_f28, 1.0f); + mdlId = mapObjMdlId[cupMapObj[cupSide][cupHookNo]]; + BoardModelScaleSet(mdlId, 1.0f, angle, 1.0f); } } - arg0->unk01++; + work->time++; } -static void fn_1_6FB4(Bss18Work *arg0, omObjData *arg1) +static void CupObjRotate(CupObjWork *work, omObjData *obj) { - Vec sp40; - Vec sp34; - Vec sp28; - Vec sp1C; - Vec sp10; - float var_f31; - BoardSpace *temp_r29; - s16 var_r22; - u32 temp_r3; - s32 var_r24; + Vec spacePos; + Vec objPos; + + float dist; + BoardSpace *space; + s16 mdlId; + u32 flag; + s32 cupDir; s32 i; - if (arg0->unk00_field2 != 0) { - arg0->unk08 *= 0.9f; - if (arg0->unk08 <= 0.01f) { - arg0->unk08 = 0.0f; - fn_1_5694(0); - if (lbl_1_data_5D4 != -1) { - HuAudFXStop(lbl_1_data_5D4); - lbl_1_data_5D4 = -1; + if (work->stopF != 0) { + work->dishSpeed *= 0.9f; + if (work->dishSpeed <= 0.01f) { + work->dishSpeed = 0.0f; + CupMotOnSet(0); + if (cupMoveSeNo != -1) { + HuAudFXStop(cupMoveSeNo); + cupMoveSeNo = -1; } - fn_1_6A14(arg0, arg1); + CupObjHookReset(work, obj); } - BoardModelMotionSpeedSet(arg0->unk04, arg0->unk08); + BoardModelMotionSpeedSet(work->dishMdlId, work->dishSpeed); for (i = 0; i < 3; i++) { - var_r22 = lbl_1_bss_6C4[lbl_1_data_5DC[lbl_1_bss_29][i]]; - BoardModelMotionSpeedSet(var_r22, arg0->unk08); + mdlId = mapObjMdlId[cupMapObj[cupSide][i]]; + BoardModelMotionSpeedSet(mdlId, work->dishSpeed); } return; } - if (lbl_1_bss_29 == 0) { - var_r24 = lbl_1_bss_0->unk01[lbl_1_bss_29] ^ 1; + if (cupSide == 0) { + cupDir = boardWork->cupDir[cupSide] ^ 1; } else { - var_r24 = lbl_1_bss_0->unk01[lbl_1_bss_29]; + cupDir = boardWork->cupDir[cupSide]; } - temp_r29 = BoardSpaceGet(0, lbl_1_bss_26); - lbl_1_bss_24 = -1; - for (i = 0; i < temp_r29->link_cnt; i++) { - if (temp_r29->link[i] != -1) { - temp_r3 = BoardSpaceFlagGet(0, temp_r29->link[i]); - if ((temp_r3 & 0x200) && var_r24 == 0) { - lbl_1_bss_24 = temp_r29->link[i]; + space = BoardSpaceGet(0, cupSpaceStart); + cupSpaceEnd = -1; + for (i = 0; i < space->link_cnt; i++) { + if (space->link[i] != -1) { + flag = BoardSpaceFlagGet(0, space->link[i]); + if ((flag & 0x200) && cupDir == 0) { + cupSpaceEnd = space->link[i]; } - if ((temp_r3 & 0x100) && var_r24 != 0) { - lbl_1_bss_24 = temp_r29->link[i]; + if ((flag & 0x100) && cupDir != 0) { + cupSpaceEnd = space->link[i]; } } } - BoardSpacePosGet(0, lbl_1_bss_24, &sp40); - Hu3DModelObjPosGet(BoardModelIDGet(arg0->unk04), lbl_1_data_604[lbl_1_bss_28], &sp34); - var_f31 = BoardVecDistXZCalc(&sp40, &sp34); - if (var_f31 <= 300.0f) { - arg0->unk00_field2 = 1; - arg0->unk08 = 1.0f; + BoardSpacePosGet(0, cupSpaceEnd, &spacePos); + Hu3DModelObjPosGet(BoardModelIDGet(work->dishMdlId), cupHookTbl[cupHookNo], &objPos); + dist = BoardVecDistXZCalc(&spacePos, &objPos); + if (dist <= 300.0f) { + work->stopF = TRUE; + work->dishSpeed = 1.0f; } } -static void fn_1_7528(s32 arg0, s32 arg1) +static void CupLandEvent(s32 playerNo, s32 spaceId) { - Vec sp30; - Vec sp24; - Vec sp18; - float temp_f31; - float temp_f30; - s16 sp14[] = { 23, 28 }; + Vec spacePos; + Vec cupRPos; + Vec cupLPos; + float cupRDist; + float cupLDist; + s16 sp14[] = { MAPOBJ_CUPR_DISH, MAPOBJ_CUPL_DISH }; BoardPlayerIdleSet(GWSystem.player_curr); - BoardSpacePosGet(0, arg1, &sp30); - BoardModelPosGet(lbl_1_bss_6C4[23], &sp24); - BoardModelPosGet(lbl_1_bss_6C4[28], &sp18); - temp_f31 = VECDistance(&sp24, &sp30); - temp_f30 = VECDistance(&sp18, &sp30); - if (temp_f31 < temp_f30) { - lbl_1_bss_29 = 0; + BoardSpacePosGet(0, spaceId, &spacePos); + BoardModelPosGet(mapObjMdlId[MAPOBJ_CUPR_DISH], &cupRPos); + BoardModelPosGet(mapObjMdlId[MAPOBJ_CUPL_DISH], &cupLPos); + cupRDist = VECDistance(&cupRPos, &spacePos); + cupLDist = VECDistance(&cupLPos, &spacePos); + if (cupRDist < cupLDist) { + cupSide = 0; } else { - lbl_1_bss_29 = 1; + cupSide = 1; } - BoardCameraTargetModelSet(lbl_1_bss_6C4[sp14[lbl_1_bss_29]]); + BoardCameraTargetModelSet(mapObjMdlId[sp14[cupSide]]); BoardCameraMotionWait(); HuPrcSleep(42); - fn_1_5B40(); + CupExec(); BoardCameraTargetPlayerSet(GWSystem.player_curr); BoardCameraMotionWait(); HuPrcSleep(12); } -static void fn_1_77EC(s32 arg0, s32 arg1) +static void CoasterLandEvent(s32 playerNo, s32 spaceId) { - lbl_1_bss_6B4 = arg0; - lbl_1_bss_6B0 = 0; - lbl_1_bss_8 = HuPrcChildCreate(fn_1_7894, 0x2003, 0x2000, 0, boardMainProc); - HuPrcDestructorSet2(lbl_1_bss_8, fn_1_4FA8); - while (lbl_1_bss_8) { + eventPlayer = playerNo; + coasterType = 0; + coasterProc = HuPrcChildCreate(CoasterLandMain, 0x2003, 0x2000, 0, boardMainProc); + HuPrcDestructorSet2(coasterProc, CoasterDestroy); + while (coasterProc) { HuPrcVSleep(); } } -static void fn_1_7894(void) +static void CoasterLandMain(void) { - lbl_1_bss_6B1 = 1; + coasterLandF = 1; WipeColorSet(0, 0, 0); WipeCreate(WIPE_MODE_OUT, WIPE_TYPE_NORMAL, 21); while (WipeStatGet() != 0) { HuPrcVSleep(); } - fn_1_7A64(); - fn_1_45F4(); + CoasterLandExec(); + CoasterExit(); HuPrcEnd(); } -static void fn_1_7A64(void) +static void CoasterLandExec(void) { - Vec sp34; - Vec sp28; - Vec sp1C; - Vec sp10; - float var_f30; - s16 var_r20; - s32 temp_r19; - s32 var_r28; + Vec spacePos; + float motSpeed; + s16 spaceId; + s32 seNo; + s32 endF; - var_r28 = 0; - lbl_1_bss_674 = lbl_1_bss_670 = 0.18f; - lbl_1_bss_640 = 0.0f; - lbl_1_bss_660.x = 0.0f; - lbl_1_bss_660.y = 0.0f; - lbl_1_bss_660.z = 0.0f; + endF = 0; + coasterAccel = coasterSpeed = 0.18f; + coasterTime = 0.0f; + coasterRot.x = 0.0f; + coasterRot.y = 0.0f; + coasterRot.z = 0.0f; lbl_1_bss_6A8 = 0.0f; - lbl_1_bss_6B3 = 0; - lbl_1_bss_624.x = 0.0f; - lbl_1_bss_624.z = 0.0f; - lbl_1_bss_624.y = 1.0f; - lbl_1_bss_66C = 0.04f; + coasterLoopF = 0; + coasterCameraUp.x = 0.0f; + coasterCameraUp.z = 0.0f; + coasterCameraUp.y = 1.0f; + coasterCamSpeed = 0.04f; BoardSpaceAttrSet(0, 1); - fn_1_97F4(); - BoardModelMotionStart(lbl_1_bss_6AE, 0, 0); - if (lbl_1_bss_0->unk00_field0 == 0) { - BoardModelMotionTimeSet(lbl_1_bss_6AE, lbl_1_bss_644); - lbl_1_bss_63C = -90.0f; - lbl_1_bss_6AC = BoardSpaceFlagPosGet(1, 0x2000, &sp34); - var_r20 = BoardSpaceFlagSearch(1, 0x1000); + CoasterEffCreate(); + BoardModelMotionStart(coasterPathMdlId, 0, 0); + if (boardWork->hostSide == 0) { + BoardModelMotionTimeSet(coasterPathMdlId, coasterMaxTime); + coasterBaseRotY = -90.0f; + coasterStartSpace = BoardSpaceFlagPosGet(1, 0x2000, &spacePos); + spaceId = BoardSpaceFlagSearch(1, 0x1000); } else { - BoardModelMotionTimeSet(lbl_1_bss_6AE, 0.0f); - lbl_1_bss_63C = 90.0f; - lbl_1_bss_6AC = BoardSpaceFlagPosGet(1, 0x1000, &sp34); - var_r20 = BoardSpaceFlagSearch(1, 0x2000); + BoardModelMotionTimeSet(coasterPathMdlId, 0.0f); + coasterBaseRotY = 90.0f; + coasterStartSpace = BoardSpaceFlagPosGet(1, 0x1000, &spacePos); + spaceId = BoardSpaceFlagSearch(1, 0x2000); } - lbl_1_bss_654 = sp34; - BoardCameraMotionStartEx(lbl_1_bss_6C4[0], NULL, NULL, 2400.0f, -1.0f, 2); - MTXRotRad(lbl_1_bss_678, 'y', MTXDegToRad(lbl_1_bss_63C)); - BoardModelMtxSet(lbl_1_bss_6C4[0], &lbl_1_bss_678); - BoardModelRotSet(lbl_1_bss_6C4[0], 0.0f, 0.0f, 0.0f); - fn_1_3350(); - lbl_1_bss_648 = lbl_1_bss_654; - lbl_1_bss_618 = lbl_1_bss_654; - lbl_1_bss_630 = lbl_1_bss_654; - fn_1_852C(); - BoardModelMotionSpeedSet(lbl_1_bss_6AE, lbl_1_bss_670); + coasterPos = spacePos; + BoardCameraMotionStartEx(mapObjMdlId[MAPOBJ_COASTER], NULL, NULL, 2400.0f, -1.0f, 2); + MTXRotRad(coasterMtx, 'y', MTXDegToRad(coasterBaseRotY)); + BoardModelMtxSet(mapObjMdlId[MAPOBJ_COASTER], &coasterMtx); + BoardModelRotSet(mapObjMdlId[MAPOBJ_COASTER], 0.0f, 0.0f, 0.0f); + CoasterPathMotUpdate(); + coasterPosOld = coasterPos; + coasterCameraTarget = coasterPos; + coasterCameraPos = coasterPos; + CoasterPlayerManCreate(); + BoardModelMotionSpeedSet(coasterPathMdlId, coasterSpeed); BoardCameraMotionWait(); WipeCreate(WIPE_MODE_IN, WIPE_TYPE_NORMAL, -1); - lbl_1_bss_6B0 = 1; - temp_r19 = HuAudFXPlay(0x412); + coasterType = 1; + seNo = HuAudFXPlay(0x412); while (TRUE) { - fn_1_1990(); - fn_1_3350(); - fn_1_276C(); - BoardModelPosSetV(lbl_1_bss_6C4[0], &lbl_1_bss_654); - BoardModelMtxSet(lbl_1_bss_6C4[0], &lbl_1_bss_678); - if (lbl_1_bss_0->unk00_field0 == 0) { - var_f30 = -lbl_1_bss_670; + CoasterPathUpdate(); + CoasterPathMotUpdate(); + CoasterRotUpdate(); + BoardModelPosSetV(mapObjMdlId[MAPOBJ_COASTER], &coasterPos); + BoardModelMtxSet(mapObjMdlId[MAPOBJ_COASTER], &coasterMtx); + if (boardWork->hostSide == 0) { + motSpeed = -coasterSpeed; } else { - var_f30 = lbl_1_bss_670; + motSpeed = coasterSpeed; } - BoardModelMotionSpeedSet(lbl_1_bss_6AE, var_f30); - if (lbl_1_bss_0->unk00_field0 == 0) { - if (BoardModelMotionTimeGet(lbl_1_bss_6AE) <= 20.0f && var_r28 == 0) { + BoardModelMotionSpeedSet(coasterPathMdlId, motSpeed); + if (boardWork->hostSide == 0) { + if (BoardModelMotionTimeGet(coasterPathMdlId) <= 20.0f && endF == 0) { WipeColorSet(0, 0, 0); WipeCreate(WIPE_MODE_OUT, WIPE_TYPE_NORMAL, -1); - var_r28 = 1; + endF = 1; } } else { - if (BoardModelMotionTimeGet(lbl_1_bss_6AE) >= lbl_1_bss_644 - 20.0f && var_r28 == 0) { + if (BoardModelMotionTimeGet(coasterPathMdlId) >= coasterMaxTime - 20.0f && endF == 0) { WipeColorSet(0, 0, 0); WipeCreate(WIPE_MODE_OUT, WIPE_TYPE_NORMAL, -1); - var_r28 = 1; + endF = 1; } } - if (var_r28 != 0 && WipeStatGet() == 0) { + if (endF != 0 && WipeStatGet() == 0) { break; } HuPrcVSleep(); } - HuAudFXStop(temp_r19); - fn_1_98EC(); - fn_1_87AC(); - while (lbl_1_bss_C) { + HuAudFXStop(seNo); + CoasterEffKill(); + CoasterPlayerManKill(); + while (coasterPlayerManObj) { HuPrcVSleep(); } - MTXIdentity(lbl_1_bss_678); - BoardModelMtxSet(lbl_1_bss_6C4[0], &lbl_1_bss_678); - lbl_1_bss_660.x = 0.0f; - lbl_1_bss_660.z = 0.0f; - lbl_1_bss_660.y = -lbl_1_bss_63C; - BoardModelRotSetV(lbl_1_bss_6C4[0], &lbl_1_bss_660); - BoardSpacePosGet(1, var_r20, &sp34); - BoardModelPosSetV(lbl_1_bss_6C4[0], &sp34); + MTXIdentity(coasterMtx); + BoardModelMtxSet(mapObjMdlId[MAPOBJ_COASTER], &coasterMtx); + coasterRot.x = 0.0f; + coasterRot.z = 0.0f; + coasterRot.y = -coasterBaseRotY; + BoardModelRotSetV(mapObjMdlId[MAPOBJ_COASTER], &coasterRot); + BoardSpacePosGet(1, spaceId, &spacePos); + BoardModelPosSetV(mapObjMdlId[MAPOBJ_COASTER], &spacePos); BoardSpaceAttrReset(0, 1); BoardCameraMoveSet(0); - BoardCameraTargetPlayerSet(lbl_1_bss_6B4); + BoardCameraTargetPlayerSet(eventPlayer); BoardCameraViewSet(1); BoardCameraMotionWait(); - lbl_1_bss_6B2 = 1; + coasterDoneF = 1; } -static s8 lbl_1_data_633 = -1; +static s8 coasterChasePlayer = -1; -static void fn_1_852C(void) +static void CoasterPlayerManCreate(void) { - BssCWork *temp_r30; - BssCData *temp_r31; - Vec spC; - float temp_f31; - s16 sp8; - s16 var_r28; + CoasterPlayerManWork *work; + CoasterPlayerWork *workPlayer; + Vec playerPos; + float motTime; + s16 charNo; + s16 spaceId; s16 i; - u32 var_r27; + u32 spaceFlag; - lbl_1_bss_C = omAddObjEx(boardObjMan, 0x103, 0, 0, -1, fn_1_87E0); - temp_r30 = OM_GET_WORK_PTR(lbl_1_bss_C, BssCWork); - temp_r30->unk00_field0 = 0; - temp_r30->unk04 = HuMemDirectMallocNum(HEAP_SYSTEM, 4 * sizeof(BssCData), MEMORY_DEFAULT_NUM); - memset(temp_r30->unk04, 0, 4 * sizeof(BssCData)); - lbl_1_data_633 = -1; - lbl_1_bss_1C = 0; - for (temp_r30->unk01 = i = 0; i < 4; i++) { - temp_r31 = &temp_r30->unk04[temp_r30->unk01]; - var_r28 = GWPlayer[i].space_curr; - sp8 = GWPlayer[i].character; - var_r27 = BoardSpaceFlagGet(0, var_r28); - if (!(var_r27 & 1)) { - temp_r31->unk00 = -1; + coasterPlayerManObj = omAddObjEx(boardObjMan, 0x103, 0, 0, -1, CoasterPlayerManUpdate); + work = OM_GET_WORK_PTR(coasterPlayerManObj, CoasterPlayerManWork); + work->killF = 0; + work->player = HuMemDirectMallocNum(HEAP_SYSTEM, 4 * sizeof(CoasterPlayerWork), MEMORY_DEFAULT_NUM); + memset(work->player, 0, 4 * sizeof(CoasterPlayerWork)); + coasterChasePlayer = -1; + coasterPlayerChaseNum = 0; + for (work->playerNum = i = 0; i < 4; i++) { + workPlayer = &work->player[work->playerNum]; + spaceId = GWPlayer[i].space_curr; + charNo = GWPlayer[i].character; + spaceFlag = BoardSpaceFlagGet(0, spaceId); + if (!(spaceFlag & 1)) { + workPlayer->mode = -1; continue; } - temp_r31->unk00 = 0; - temp_r31->unk01 = i; - temp_r31->unk02 = 0; - BoardPlayerPosGet(temp_r31->unk01, &spC); - temp_r31->unk04 = BoardModelCreate(DATA_MAKE_NUM(DATADIR_W01, 10), NULL, 0); - temp_f31 = BoardModelMotionMaxTimeGet(temp_r31->unk04); - BoardModelVisibilitySet(temp_r31->unk04, 0); - fn_1_95F4(temp_r31); - BoardModelMotionStart(temp_r31->unk04, 0, 0); - BoardModelMotionSpeedSet(temp_r31->unk04, 0.0f); - if (lbl_1_bss_0->unk00_field0 == 0) { - temp_r31->unk08 = -0.18f; - BoardModelMotionTimeSet(temp_r31->unk04, temp_f31); + workPlayer->mode = 0; + workPlayer->playerNo = i; + workPlayer->delay = 0; + BoardPlayerPosGet(workPlayer->playerNo, &playerPos); + workPlayer->pathMdlId = BoardModelCreate(DATA_MAKE_NUM(DATADIR_W01, 10), NULL, 0); + motTime = BoardModelMotionMaxTimeGet(workPlayer->pathMdlId); + BoardModelVisibilitySet(workPlayer->pathMdlId, 0); + CoasterPlayerTimeInit(workPlayer); + BoardModelMotionStart(workPlayer->pathMdlId, 0, 0); + BoardModelMotionSpeedSet(workPlayer->pathMdlId, 0.0f); + if (boardWork->hostSide == 0) { + workPlayer->speed = -0.18f; + BoardModelMotionTimeSet(workPlayer->pathMdlId, motTime); } else { - temp_r31->unk08 = 0.18f; - BoardModelMotionTimeSet(temp_r31->unk04, 0.0f); + workPlayer->speed = 0.18f; + BoardModelMotionTimeSet(workPlayer->pathMdlId, 0.0f); } - fn_1_932C(temp_r31); - temp_r30->unk01++; + CoasterPlayerEndSet(workPlayer); + work->playerNum++; } BoardCameraMoveSet(1); - BoardCameraTargetModelSet(lbl_1_bss_6C4[0]); + BoardCameraTargetModelSet(mapObjMdlId[MAPOBJ_COASTER]); } -static void fn_1_87AC(void) +static void CoasterPlayerManKill(void) { - if (lbl_1_bss_C) { - OM_GET_WORK_PTR(lbl_1_bss_C, BssCWork)->unk00_field0 = 1; + if (coasterPlayerManObj) { + OM_GET_WORK_PTR(coasterPlayerManObj, CoasterPlayerManWork)->killF = 1; } } -static void fn_1_87E0(omObjData *arg0) +static void CoasterPlayerManUpdate(omObjData *obj) { - BssCWork *temp_r30 = OM_GET_WORK_PTR(arg0, BssCWork); - BssCData *temp_r31; + CoasterPlayerManWork *work = OM_GET_WORK_PTR(obj, CoasterPlayerManWork); + CoasterPlayerWork *workPlayer; s32 i; - if (temp_r30->unk00_field0 != 0 || BoardIsKill()) { - for (i = 0; i < temp_r30->unk01; i++) { - temp_r31 = &temp_r30->unk04[i]; + if (work->killF != 0 || BoardIsKill()) { + for (i = 0; i < work->playerNum; i++) { + workPlayer = &work->player[i]; } - HuMemDirectFree(temp_r30->unk04); - lbl_1_bss_C = NULL; - omDelObjEx(HuPrcCurrentGet(), arg0); + HuMemDirectFree(work->player); + coasterPlayerManObj = NULL; + omDelObjEx(HuPrcCurrentGet(), obj); return; } - if (lbl_1_bss_6B0 == 0) { + if (coasterType == 0) { return; } - for (i = 0; i < temp_r30->unk01; i++) { - temp_r31 = &temp_r30->unk04[i]; - if (temp_r31->unk02 != 0) { - temp_r31->unk02--; + for (i = 0; i < work->playerNum; i++) { + workPlayer = &work->player[i]; + if (workPlayer->delay != 0) { + workPlayer->delay--; } else { - switch (temp_r31->unk00) { + switch (workPlayer->mode) { case 0: - fn_1_8988(temp_r31, arg0); + CoasterPlayerWait(workPlayer, obj); break; case 1: - fn_1_8A50(temp_r31, arg0); + CoasterPlayerChaseBegin(workPlayer, obj); break; case 2: - fn_1_8B6C(temp_r31, arg0); + CoasterPlayerChasePathSet(workPlayer, obj); break; case 3: - fn_1_8DDC(temp_r31, arg0); + CoasterPlayerChase(workPlayer, obj); break; case 4: - fn_1_918C(temp_r31, arg0); + CoasterPlayerStop(workPlayer, obj); break; case 5: - fn_1_927C(temp_r31, arg0); + CoasterPlayerEnd(workPlayer, obj); break; } } } } -static void fn_1_8988(BssCData *arg0, omObjData *arg1) +static void CoasterPlayerWait(CoasterPlayerWork *work, omObjData *obj) { - Vec sp20; - Vec sp14; - Vec sp8; + Vec mdlCoasterPos; + Vec playerPos; + Vec dir; - if (arg0->unk10 - lbl_1_bss_640 > 900.0f) { + if (work->time - coasterTime > 900.0f) { return; } - BoardModelPosGet(*lbl_1_bss_6C4, &sp20); - BoardPlayerPosGet(arg0->unk01, &sp14); - VECSubtract(&sp20, &sp14, &sp8); - BoardPlayerRotYSet(arg0->unk01, atan2d(sp8.x, sp8.z)); - arg0->unk00 = 1; + BoardModelPosGet(mapObjMdlId[MAPOBJ_COASTER], &mdlCoasterPos); + BoardPlayerPosGet(work->playerNo, &playerPos); + VECSubtract(&mdlCoasterPos, &playerPos, &dir); + BoardPlayerRotYSet(work->playerNo, atan2d(dir.x, dir.z)); + work->mode = 1; } -static s32 lbl_1_data_634[8] = { 0x00000123, 0x00000163, 0x000001A3, 0x000001E3, 0x00000223, 0x00000263, 0x000002A3, 0x000002E3 }; +static s32 coasterChaseSe[8] = { 0x00000123, 0x00000163, 0x000001A3, 0x000001E3, 0x00000223, 0x00000263, 0x000002A3, 0x000002E3 }; -static void fn_1_8A50(BssCData *arg0, omObjData *arg1) +static void CoasterPlayerChaseBegin(CoasterPlayerWork *work, omObjData *obj) { - if (lbl_1_data_633 == -1) { - BoardCameraTargetPlayerSet(arg0->unk01); - lbl_1_data_633 = arg0->unk01; + if (coasterChasePlayer == -1) { + BoardCameraTargetPlayerSet(work->playerNo); + coasterChasePlayer = work->playerNo; } - HuAudFXPlay(lbl_1_data_634[GWPlayer[arg0->unk01].character]); - BoardPlayerMotionStart(arg0->unk01, 9, 0); - BoardPlayerMotionSpeedSet(arg0->unk01, 2.0f); - arg0->unk02 = lbl_1_bss_1C * 3 + 9; - arg0->unk00 = 2; - lbl_1_bss_1C++; - omVibrate(arg0->unk01, 12, 4, 2); + HuAudFXPlay(coasterChaseSe[GWPlayer[work->playerNo].character]); + BoardPlayerMotionStart(work->playerNo, 9, 0); + BoardPlayerMotionSpeedSet(work->playerNo, 2.0f); + work->delay = coasterPlayerChaseNum * 3 + 9; + work->mode = 2; + coasterPlayerChaseNum++; + omVibrate(work->playerNo, 12, 4, 2); } -static void fn_1_8B6C(BssCData *arg0, omObjData *arg1) +static void CoasterPlayerChasePathSet(CoasterPlayerWork *work, omObjData *obj) { - ModelData *temp_r29; - HsfObject *var_r30; - Vec sp20; - Vec sp14; - Vec sp8; - float temp_f30; - float var_f31; - s16 var_r28; + ModelData *modelP; + HsfObject *modelObj; + Vec mdlCoasterPos; + Vec dir; + Vec objPos; + float motTime; + float time; + s16 modelId; - BoardPlayerPosGet(arg0->unk01, &arg0->unk14); - BoardModelPosGet(lbl_1_bss_6C4[0], &sp20); - VECSubtract(&sp20, &arg0->unk14, &sp14); - BoardPlayerRotYSet(arg0->unk01, -atan2d(sp14.x, sp14.z)); - BoardPlayerMotionStart(arg0->unk01, 3, 0x40000001); - BoardPlayerMotionSpeedSet(arg0->unk01, 2.0f); - temp_f30 = BoardModelMotionTimeGet(lbl_1_bss_6AE); - var_r28 = BoardModelIDGet(lbl_1_bss_6AE); - temp_r29 = &Hu3DData[var_r28]; - Hu3DMotionExec(var_r28, temp_r29->unk_08, temp_r29->unk_64, 0); - var_r30 = Hu3DModelObjPtrGet(var_r28, "looppath-cube1"); - sp8.x = var_r30->data.curr.pos.x; - sp8.y = var_r30->data.curr.pos.y; - sp8.z = var_r30->data.curr.pos.z; - var_f31 = lbl_1_bss_640; + BoardPlayerPosGet(work->playerNo, &work->pos); + BoardModelPosGet(mapObjMdlId[MAPOBJ_COASTER], &mdlCoasterPos); + VECSubtract(&mdlCoasterPos, &work->pos, &dir); + BoardPlayerRotYSet(work->playerNo, -atan2d(dir.x, dir.z)); + BoardPlayerMotionStart(work->playerNo, 3, HU3D_MOTATTR_LOOP); + BoardPlayerMotionSpeedSet(work->playerNo, 2.0f); + motTime = BoardModelMotionTimeGet(coasterPathMdlId); + modelId = BoardModelIDGet(coasterPathMdlId); + modelP = &Hu3DData[modelId]; + Hu3DMotionExec(modelId, modelP->unk_08, modelP->unk_64, 0); + modelObj = Hu3DModelObjPtrGet(modelId, "looppath-cube1"); + objPos.x = modelObj->data.curr.pos.x; + objPos.y = modelObj->data.curr.pos.y; + objPos.z = modelObj->data.curr.pos.z; + time = coasterTime; while (TRUE) { - Hu3DMotionExec(var_r28, temp_r29->unk_08, temp_r29->unk_64, 0); - var_r30 = Hu3DModelObjPtrGet(var_r28, "looppath-cube1"); - sp14.x = sp8.x - var_r30->data.curr.pos.x; - sp14.y = sp8.y - var_r30->data.curr.pos.y; - sp14.z = sp8.z - var_r30->data.curr.pos.z; - var_f31 += VECMag(&sp14); - if (var_f31 >= arg0->unk10) { + Hu3DMotionExec(modelId, modelP->unk_08, modelP->unk_64, 0); + modelObj = Hu3DModelObjPtrGet(modelId, "looppath-cube1"); + dir.x = objPos.x - modelObj->data.curr.pos.x; + dir.y = objPos.y - modelObj->data.curr.pos.y; + dir.z = objPos.z - modelObj->data.curr.pos.z; + time += VECMag(&dir); + if (time >= work->time) { break; } - sp8.x = var_r30->data.curr.pos.x; - sp8.y = var_r30->data.curr.pos.y; - sp8.z = var_r30->data.curr.pos.z; - temp_r29->unk_64 += arg0->unk08; + objPos.x = modelObj->data.curr.pos.x; + objPos.y = modelObj->data.curr.pos.y; + objPos.z = modelObj->data.curr.pos.z; + modelP->unk_64 += work->speed; } - BoardModelMotionStart(arg0->unk04, 0, 0); - BoardModelMotionTimeSet(arg0->unk04, temp_r29->unk_64); - BoardModelMotionSpeedSet(arg0->unk04, temp_r29->unk_68); - arg0->unk00 = 3; - BoardModelMotionTimeSet(lbl_1_bss_6AE, temp_f30); + BoardModelMotionStart(work->pathMdlId, 0, 0); + BoardModelMotionTimeSet(work->pathMdlId, modelP->unk_64); + BoardModelMotionSpeedSet(work->pathMdlId, modelP->unk_68); + work->mode = 3; + BoardModelMotionTimeSet(coasterPathMdlId, motTime); } -static void fn_1_8DDC(BssCData *arg0, omObjData *arg1) +static void CoasterPlayerChase(CoasterPlayerWork *work, omObjData *obj) { - ModelData *temp_r29; - HsfObject *var_r30; - Vec *var_r27; - Vec *var_r26; - Vec sp48; - Vec sp3C; - Vec sp30; - Vec sp24; - Vec sp18; - Vec spC; - Mtx sp54; - s16 var_r28; + ModelData *modelP; + HsfObject *modelObj; + Vec *pos; + Vec *target; + Vec up; + Vec rot; + Vec objPos; + Vec diff; + Vec railPos; + Vec spacePos; + Mtx matrix; + s16 modelId; - var_r28 = BoardModelIDGet(arg0->unk04); - temp_r29 = &Hu3DData[var_r28]; - Hu3DMotionExec(var_r28, temp_r29->unk_08, temp_r29->unk_64, 0); - var_r30 = Hu3DModelObjPtrGet(var_r28, "looppath-cube1"); - sp30.x = var_r30->data.curr.pos.x; - sp30.y = var_r30->data.curr.pos.y; - sp30.z = var_r30->data.curr.pos.z; - VECSubtract(&sp30, &arg0->unk14, &sp24); - if (fn_1_94A8(arg0) != 0) { - BoardModelPosGet(lbl_1_bss_6C4[1], &sp18); - VECSubtract(&sp18, &sp30, &sp48); - VECNormalize(&sp48, &sp48); - var_r27 = &arg0->unk14; - var_r26 = &sp30; - BoardMTXCalcLookAt(sp54, var_r26, &sp48, var_r27); - MTXTranspose(sp54, arg0->unk20); + modelId = BoardModelIDGet(work->pathMdlId); + modelP = &Hu3DData[modelId]; + Hu3DMotionExec(modelId, modelP->unk_08, modelP->unk_64, 0); + modelObj = Hu3DModelObjPtrGet(modelId, "looppath-cube1"); + objPos.x = modelObj->data.curr.pos.x; + objPos.y = modelObj->data.curr.pos.y; + objPos.z = modelObj->data.curr.pos.z; + VECSubtract(&objPos, &work->pos, &diff); + if (CoasterPlayerLoopCheck(work) != 0) { + BoardModelPosGet(mapObjMdlId[MAPOBJ_COASTER_RAIL], &railPos); + VECSubtract(&railPos, &objPos, &up); + VECNormalize(&up, &up); + pos = &work->pos; + target = &objPos; + BoardMTXCalcLookAt(matrix, target, &up, pos); + MTXTranspose(matrix, work->matrix); } else { - if (sp24.z != 0.0f || sp24.x != 0.0f) { - sp3C.y = atan2d(sp24.x, sp24.z); - sp3C.x = -atan2d(sp24.y, VECMagXZ(&sp24)); + if (diff.z != 0.0f || diff.x != 0.0f) { + rot.y = atan2d(diff.x, diff.z); + rot.x = -atan2d(diff.y, VECMagXZ(&diff)); } else { - sp3C.x = sp3C.y = 0.0f; + rot.x = rot.y = 0.0f; } - MTXRotRad(sp54, 'x', MTXDegToRad(sp3C.x)); - MTXRotRad(arg0->unk20, 'y', MTXDegToRad(sp3C.y)); - MTXConcat(arg0->unk20, sp54, arg0->unk20); + MTXRotRad(matrix, 'x', MTXDegToRad(rot.x)); + MTXRotRad(work->matrix, 'y', MTXDegToRad(rot.y)); + MTXConcat(work->matrix, matrix, work->matrix); } - BoardPlayerPosSetV(arg0->unk01, &sp30); - BoardPlayerRotSet(arg0->unk01, 0.0f, 0.0f, 0.0f); - BoardPlayerMtxSet(arg0->unk01, &arg0->unk20); - arg0->unk14 = sp30; - BoardSpacePosGet(0, arg0->unk06, &spC); - if (BoardVecMaxDistXZCheck(&spC, &sp30, 200.0f)) { - arg0->unk00 = 4; + BoardPlayerPosSetV(work->playerNo, &objPos); + BoardPlayerRotSet(work->playerNo, 0.0f, 0.0f, 0.0f); + BoardPlayerMtxSet(work->playerNo, &work->matrix); + work->pos = objPos; + BoardSpacePosGet(0, work->endSpace, &spacePos); + if (BoardVecMaxDistXZCheck(&spacePos, &objPos, 200.0f)) { + work->mode = 4; } } -static void fn_1_918C(BssCData *arg0, omObjData *arg1) +static void CoasterPlayerStop(CoasterPlayerWork *work, omObjData *obj) { - Vec sp20; - Vec sp14; - Vec sp8; - s32 var_r30; + Vec spacePos; + Vec playerPos; + Vec dir; + s32 spaceEnd; - MTXIdentity(arg0->unk20); - var_r30 = BoardSpaceLinkFlagSearch(0, arg0->unk06, 0x40); - BoardSpacePosGet(0, var_r30, &sp20); - BoardPlayerPosGet(arg0->unk01, &sp14); - BoardPlayerMtxSet(arg0->unk01, &arg0->unk20); - VECSubtract(&sp20, &sp14, &sp8); - BoardPlayerRotYSet(arg0->unk01, atan2d(-sp8.z, -sp8.x)); - BoardPlayerPosLerpStart(arg0->unk01, &sp14, &sp20, 20); - arg0->unk00 = 5; + MTXIdentity(work->matrix); + spaceEnd = BoardSpaceLinkFlagSearch(0, work->endSpace, 0x40); + BoardSpacePosGet(0, spaceEnd, &spacePos); + BoardPlayerPosGet(work->playerNo, &playerPos); + BoardPlayerMtxSet(work->playerNo, &work->matrix); + VECSubtract(&spacePos, &playerPos, &dir); + BoardPlayerRotYSet(work->playerNo, atan2d(-dir.z, -dir.x)); + BoardPlayerPosLerpStart(work->playerNo, &playerPos, &spacePos, 20); + work->mode = 5; } -static void fn_1_927C(BssCData *arg0, omObjData *arg1) +static void CoasterPlayerEnd(CoasterPlayerWork *work, omObjData *obj) { - s32 temp_r3; + s32 spaceEnd; - if (!GWPlayer[arg0->unk01].moving) { - BoardPlayerIdleSet(arg0->unk01); - temp_r3 = BoardSpaceLinkFlagSearch(0, arg0->unk06, 0x40); - GWPlayer[arg0->unk01].space_curr = temp_r3; - arg0->unk00 = -1; - BoardPlayerMoveAwayStartCurr(temp_r3, 0); + if (!GWPlayer[work->playerNo].moving) { + BoardPlayerIdleSet(work->playerNo); + spaceEnd = BoardSpaceLinkFlagSearch(0, work->endSpace, 0x40); + GWPlayer[work->playerNo].space_curr = spaceEnd; + work->mode = -1; + BoardPlayerMoveAwayStartCurr(spaceEnd, 0); } } -static void fn_1_932C(BssCData *arg0) +static void CoasterPlayerEndSet(CoasterPlayerWork *work) { - BoardSpace *temp_r30; - BoardSpace *var_r26; - Vec sp20[2]; - Vec sp14; - float spC[2]; - s16 sp8[2]; - s32 var_r29; - s32 var_r28; + BoardSpace *space; + BoardSpace *linkSpace; + Vec spacePos[2]; + Vec beginPos; + float spaceDist[2]; + s16 spaceId[2]; + s32 j; + s32 no; s32 i; - for (var_r28 = i = 0; i < BoardSpaceCountGet(0); i++) { - temp_r30 = BoardSpaceGet(0, i + 1); - for (var_r29 = 0; var_r29 < temp_r30->link_cnt; var_r29++) { - var_r26 = BoardSpaceGet(0, temp_r30->link[var_r29]); - if (var_r26->flag & 0x40) { - sp8[var_r28] = i + 1; - BoardSpacePosGet(0, temp_r30->link[var_r29], &sp20[var_r28]); - var_r28++; + for (no = i = 0; i < BoardSpaceCountGet(0); i++) { + space = BoardSpaceGet(0, i + 1); + for (j = 0; j < space->link_cnt; j++) { + linkSpace = BoardSpaceGet(0, space->link[j]); + if (linkSpace->flag & 0x40) { + spaceId[no] = i + 1; + BoardSpacePosGet(0, space->link[j], &spacePos[no]); + no++; } } - if (var_r28 >= 2) { + if (no >= 2) { break; } } - if (lbl_1_bss_0->unk00_field0 == 0) { - BoardSpaceFlagPosGet(0, 0x1000, &sp14); + if (boardWork->hostSide == 0) { + BoardSpaceFlagPosGet(0, 0x1000, &beginPos); } else { - BoardSpaceFlagPosGet(0, 0x2000, &sp14); + BoardSpaceFlagPosGet(0, 0x2000, &beginPos); } for (i = 0; i < 2; i++) { - spC[i] = VECSquareDistance(&sp14, &sp20[i]); + spaceDist[i] = VECSquareDistance(&beginPos, &spacePos[i]); } - if (spC[0] < spC[1]) { - arg0->unk06 = sp8[0]; + if (spaceDist[0] < spaceDist[1]) { + work->endSpace = spaceId[0]; } else { - arg0->unk06 = sp8[1]; + work->endSpace = spaceId[1]; } } -static s32 fn_1_94A8(BssCData *arg0) +static s32 CoasterPlayerLoopCheck(CoasterPlayerWork *arg0) { - Vec sp14; - s16 spC[4]; + Vec playerPos; + s16 linkTbl[4]; float sp8; - s32 var_r30; - s32 var_r29; - s32 var_r26; - BoardSpace *var_r31; - BoardSpace *var_r27; - BoardSpace *var_r28; + s32 spaceId; + s32 spaceIdLink; + s32 spaceIdPrev; + BoardSpace *space; + BoardSpace *spaceLink; + BoardSpace *spacePrev; - BoardPlayerPosGet(arg0->unk01, &sp14); - var_r28 = NULL; - var_r26 = -1; - var_r30 = lbl_1_bss_6AC; + BoardPlayerPosGet(arg0->playerNo, &playerPos); + spacePrev = NULL; + spaceIdPrev = -1; + spaceId = coasterStartSpace; sp8 = 0.0f; while (TRUE) { - var_r31 = BoardSpaceGet(1, var_r30); - if (lbl_1_bss_0->unk00_field0 == 0) { - var_r29 = var_r31->link[0]; + space = BoardSpaceGet(1, spaceId); + if (boardWork->hostSide == 0) { + spaceIdLink = space->link[0]; } else { - BoardSpaceLinkTargetListGet(1, var_r30, spC); - var_r29 = spC[0]; + BoardSpaceLinkTargetListGet(1, spaceId, linkTbl); + spaceIdLink = linkTbl[0]; } - var_r27 = BoardSpaceGet(1, var_r29); - if (!var_r27) { - var_r27 = var_r31; + spaceLink = BoardSpaceGet(1, spaceIdLink); + if (!spaceLink) { + spaceLink = space; break; } - if (BoardVecMaxDistXZCheck(&var_r31->pos, &sp14, 200.0f)) { - if (BoardVecMaxDistXZCheck(&var_r31->pos, &sp14, 100.0f)) { + if (BoardVecMaxDistXZCheck(&space->pos, &playerPos, 200.0f)) { + if (BoardVecMaxDistXZCheck(&space->pos, &playerPos, 100.0f)) { break; } - if (var_r28) { - var_r31 = var_r28; + if (spacePrev) { + space = spacePrev; break; } else { - var_r28 = var_r31; + spacePrev = space; } } - var_r26 = var_r30; - var_r30 = var_r29; + spaceIdPrev = spaceId; + spaceId = spaceIdLink; } - if (var_r31->flag & 8) { + if (space->flag & 8) { return 1; } else { @@ -2486,166 +2478,198 @@ static s32 fn_1_94A8(BssCData *arg0) } } -static void fn_1_95F4(BssCData *arg0) +static void CoasterPlayerTimeInit(CoasterPlayerWork *work) { - HsfObject *var_r30; - ModelData *temp_r29; - Vec sp2C; - Vec sp20; - Vec sp14; - Vec sp8; - float temp_f30; - float var_f31; - s16 var_r28; + HsfObject *modelObj; + ModelData *modelP; + Vec pos; + Vec prevPos; + Vec playerPos; + Vec diff; + float maxTime; + float time; + s16 modelId; - temp_f30 = BoardModelMotionMaxTimeGet(arg0->unk04); - if (lbl_1_bss_0->unk00_field0 == 0) { - BoardModelMotionTimeSet(arg0->unk04, temp_f30); - BoardModelMotionSpeedSet(arg0->unk04, -0.18f); + maxTime = BoardModelMotionMaxTimeGet(work->pathMdlId); + if (boardWork->hostSide == 0) { + BoardModelMotionTimeSet(work->pathMdlId, maxTime); + BoardModelMotionSpeedSet(work->pathMdlId, -0.18f); } else { - BoardModelMotionTimeSet(arg0->unk04, 0.0f); - BoardModelMotionSpeedSet(arg0->unk04, 0.18f); + BoardModelMotionTimeSet(work->pathMdlId, 0.0f); + BoardModelMotionSpeedSet(work->pathMdlId, 0.18f); } - BoardPlayerPosGet(arg0->unk01, &sp14); - var_r28 = BoardModelIDGet(arg0->unk04); - temp_r29 = &Hu3DData[var_r28]; - Hu3DMotionExec(var_r28, temp_r29->unk_08, temp_r29->unk_64, 0); - var_r30 = Hu3DModelObjPtrGet(var_r28, "looppath-cube1"); - sp20.x = var_r30->data.curr.pos.x; - sp20.y = var_r30->data.curr.pos.y; - sp20.z = var_r30->data.curr.pos.z; - var_f31 = 0.0f; + BoardPlayerPosGet(work->playerNo, &playerPos); + modelId = BoardModelIDGet(work->pathMdlId); + modelP = &Hu3DData[modelId]; + Hu3DMotionExec(modelId, modelP->unk_08, modelP->unk_64, 0); + modelObj = Hu3DModelObjPtrGet(modelId, "looppath-cube1"); + prevPos.x = modelObj->data.curr.pos.x; + prevPos.y = modelObj->data.curr.pos.y; + prevPos.z = modelObj->data.curr.pos.z; + time = 0.0f; while (TRUE) { - Hu3DMotionExec(var_r28, temp_r29->unk_08, temp_r29->unk_64, 0); - var_r30 = Hu3DModelObjPtrGet(var_r28, "looppath-cube1"); - sp2C.x = var_r30->data.curr.pos.x; - sp2C.y = var_r30->data.curr.pos.y; - sp2C.z = var_r30->data.curr.pos.z; - VECSubtract(&sp2C, &sp20, &sp8); - var_f31 += VECMag(&sp8); - if (BoardVecMinDistCheck(&sp14, &sp2C, 150.0f)) { + Hu3DMotionExec(modelId, modelP->unk_08, modelP->unk_64, 0); + modelObj = Hu3DModelObjPtrGet(modelId, "looppath-cube1"); + pos.x = modelObj->data.curr.pos.x; + pos.y = modelObj->data.curr.pos.y; + pos.z = modelObj->data.curr.pos.z; + VECSubtract(&pos, &prevPos, &diff); + time += VECMag(&diff); + if (BoardVecMinDistCheck(&playerPos, &pos, 150.0f)) { break; } - sp20 = sp2C; - temp_r29->unk_64 += temp_r29->unk_68; + prevPos = pos; + modelP->unk_64 += modelP->unk_68; } - arg0->unk10 = var_f31; + work->time = time; } -static void fn_1_97F4(void) +static void CoasterEffCreate(void) { - Bss20Work *temp_r30; - Bss20Data *var_r31; + CoasterEffWork *work; + CoasterEffData *data; s32 i; - if (lbl_1_bss_20) { + if (coasterEffObj) { return; } - lbl_1_bss_20 = omAddObjEx(boardObjMan, 0x101, 1, 0, -1, fn_1_9920); - temp_r30 = OM_GET_WORK_PTR(lbl_1_bss_20, Bss20Work); - temp_r30->unk00_field0 = 0; - temp_r30->unk04 = HuMemDirectMallocNum(HEAP_SYSTEM, 20 * sizeof(Bss20Data), MEMORY_DEFAULT_NUM); - var_r31 = temp_r30->unk04; - for (i = 0; i < 20; var_r31++, i++) { - var_r31->unk00 = -1; - var_r31->unk02 = BoardModelCreate(DATA_MAKE_NUM(DATADIR_W01, 7), NULL, 0); - BoardModelVisibilitySet(var_r31->unk02, 0); + coasterEffObj = omAddObjEx(boardObjMan, 0x101, 1, 0, -1, CoasterEffUpdate); + work = OM_GET_WORK_PTR(coasterEffObj, CoasterEffWork); + work->killF = 0; + work->data = HuMemDirectMallocNum(HEAP_SYSTEM, 20 * sizeof(CoasterEffData), MEMORY_DEFAULT_NUM); + data = work->data; + for (i = 0; i < 20; data++, i++) { + data->time = -1; + data->mdlId = BoardModelCreate(DATA_MAKE_NUM(DATADIR_W01, 7), NULL, 0); + BoardModelVisibilitySet(data->mdlId, 0); } } -static void fn_1_98EC(void) +static void CoasterEffKill(void) { - if (lbl_1_bss_20) { - OM_GET_WORK_PTR(lbl_1_bss_20, Bss20Work)->unk00_field0 = 1; + if (coasterEffObj) { + OM_GET_WORK_PTR(coasterEffObj, CoasterEffWork)->killF = TRUE; } } -static void fn_1_9920(omObjData *arg0) +static void CoasterEffUpdate(omObjData *obj) { - Bss20Work *temp_r31; + CoasterEffWork *work; s32 i; - temp_r31 = OM_GET_WORK_PTR(lbl_1_bss_20, Bss20Work); - if (temp_r31->unk00_field0 != 0 || BoardIsKill()) { + work = OM_GET_WORK_PTR(coasterEffObj, CoasterEffWork); + if (work->killF != 0 || BoardIsKill()) { for (i = 0; i < 20; i++) { - BoardModelKill(temp_r31->unk04[i].unk02); + BoardModelKill(work->data[i].mdlId); } - HuMemDirectFree(temp_r31->unk04); - lbl_1_bss_20 = 0; - omDelObjEx(HuPrcCurrentGet(), arg0); + HuMemDirectFree(work->data); + coasterEffObj = 0; + omDelObjEx(HuPrcCurrentGet(), obj); return; } - if (lbl_1_bss_640 < 10.0f) { + if (coasterTime < 10.0f) { return; } - if (temp_r31->unk01 != 0) { - temp_r31->unk01--; + if (work->delay != 0) { + work->delay--; } else { - temp_r31->unk01 = 2; - fn_1_9A24(temp_r31); + work->delay = 2; + CoasterEffAdd(work); } - fn_1_9BBC(temp_r31); + CoasterEffModelUpdate(work); } -static void fn_1_9A24(Bss20Work *arg0) +static void CoasterEffAdd(CoasterEffWork *work) { - Bss20Data *temp_r31; - Mtx sp8; + CoasterEffData *data; + Mtx matrix; s32 i; s32 j; - if (lbl_1_bss_6B1 != 0) { - MTXTrans(sp8, 0.0f, 50.0f, -100.0f); + if (coasterLandF != 0) { + MTXTrans(matrix, 0.0f, 50.0f, -100.0f); } else { - MTXTrans(sp8, 0.0f, 70.0f, -100.0f); + MTXTrans(matrix, 0.0f, 70.0f, -100.0f); } - MTXConcat(lbl_1_bss_678, sp8, sp8); + MTXConcat(coasterMtx, matrix, matrix); for (i = 0; i < 4; i++) { for (j = 0; j < 20; j++) { - temp_r31 = &arg0->unk04[j]; - if (temp_r31->unk00 == -1) { - temp_r31->unk00 = 10; - Hu3DMtxTransGet(sp8, &temp_r31->unk08); - VECAdd(&lbl_1_bss_654, &temp_r31->unk08, &temp_r31->unk08); - temp_r31->unk14.x = 0.0f; - temp_r31->unk14.y = 0.0f; - temp_r31->unk14.z = 0.001f; - temp_r31->unk04 = 1.0f; - BoardModelVisibilitySet(temp_r31->unk02, 1); - BoardModelLayerSet(temp_r31->unk02, 2); - BoardModelPosSetV(temp_r31->unk02, &temp_r31->unk08); + data = &work->data[j]; + if (data->time == -1) { + data->time = 10; + Hu3DMtxTransGet(matrix, &data->pos); + VECAdd(&coasterPos, &data->pos, &data->pos); + data->vel.x = 0.0f; + data->vel.y = 0.0f; + data->vel.z = 0.001f; + data->scale = 1.0f; + BoardModelVisibilitySet(data->mdlId, 1); + BoardModelLayerSet(data->mdlId, 2); + BoardModelPosSetV(data->mdlId, &data->pos); break; } } } } -static void fn_1_9BBC(Bss20Work *arg0) +static void CoasterEffModelUpdate(CoasterEffWork *work) { - Bss20Data *temp_r31; + CoasterEffData *data; s32 i; for (i = 0; i < 20; i++) { - temp_r31 = &arg0->unk04[i]; - if (temp_r31->unk00 == -1) { + data = &work->data[i]; + if (data->time == -1) { continue; } - temp_r31->unk00--; - if (temp_r31->unk00 == 0) { - temp_r31->unk00 = -1; - BoardModelVisibilitySet(temp_r31->unk02, 0); + data->time--; + if (data->time == 0) { + data->time = -1; + BoardModelVisibilitySet(data->mdlId, 0); } else { - if (temp_r31->unk00 <= 3) { - temp_r31->unk04 = sind(30.0f * temp_r31->unk00); + if (data->time <= 3) { + data->scale = sind(30.0f * data->time); } - VECAdd(&temp_r31->unk08, &temp_r31->unk14, &temp_r31->unk08); - BoardModelMtxSet(temp_r31->unk02, &lbl_1_bss_678); - BoardModelPosSetV(temp_r31->unk02, &temp_r31->unk08); - BoardModelScaleSet(temp_r31->unk02, temp_r31->unk04, temp_r31->unk04, temp_r31->unk04); + VECAdd(&data->pos, &data->vel, &data->pos); + BoardModelMtxSet(data->mdlId, &coasterMtx); + BoardModelPosSetV(data->mdlId, &data->pos); + BoardModelScaleSet(data->mdlId, data->scale, data->scale, data->scale); } } } + +static void CoasterHostComKeySet(s32 playerNo) +{ + s32 starPos; + s32 yesF; + + starPos = GWSystem.star_pos; + yesF = 0; + if (boardWork->hostSide != 0) { + if (starPos == 0 || starPos == 1 || starPos == 7) { + yesF = 0; + } + else { + yesF = 1; + } + } + else if (starPos == 0 || starPos == 1 || starPos == 7) { + yesF = 1; + } + else { + yesF = 0; + } + if (BoardPlayerCoinsGet(playerNo) < 5) { + yesF = 0; + } + if (yesF != 0) { + BoardComKeySetLeft(); + } + else { + BoardComKeySetRight(); + } +} \ No newline at end of file diff --git a/src/REL/w01Dll/mg_coin.c b/src/REL/w01Dll/mg_coin.c index c24ee595..f07a4b3b 100755 --- a/src/REL/w01Dll/mg_coin.c +++ b/src/REL/w01Dll/mg_coin.c @@ -25,102 +25,98 @@ #include "ext_math.h" typedef struct { - /* 0x00 */ Vec unk00; - /* 0x0C */ float unk0C; -} Data690InnerStruct; // Size 0x10 + /* 0x00 */ Vec pos; + /* 0x0C */ float len; +} SpaceAmidaPathPoint; // Size 0x10 -typedef Data690InnerStruct Data690Block[15]; +typedef SpaceAmidaPathPoint SpaceAmidaMap[15]; typedef struct { /* 0x00 */ s16 unk00; /* 0x02 */ s16 unk02; - /* 0x04 */ Vec unk04; - /* 0x10 */ Vec unk10; - /* 0x1C */ u16 unk1C; - /* 0x1E */ char unk1E[2]; - /* 0x20 */ float unk20; - /* 0x24 */ u16 unk24; - /* 0x26 */ s16 unk26; - /* 0x28 */ s16 unk28; - /* 0x2A */ char unk2A[2]; -} Bss720Data; // Size 0x2C + /* 0x04 */ Vec rocketPos; + /* 0x10 */ Vec jumpDir; + /* 0x1C */ u16 waitTime; + /* 0x20 */ float jumpTime; + /* 0x24 */ u16 comDelay; + /* 0x26 */ s16 comChoice; + /* 0x28 */ s16 comInputTimer; +} SpaceAmidaGameWork; // Size 0x2C typedef struct { /* 0x00 */ char unk00[4]; - /* 0x04 */ Data690Block *unk04; - /* 0x08 */ u16 unk08; - /* 0x0A */ char unk0A[2]; - /* 0x0C */ float unk0C; - /* 0x10 */ float unk10; - /* 0x14 */ float unk14; - /* 0x18 */ float unk18; - /* 0x1C */ float unk1C; - /* 0x20 */ Vec unk20; - /* 0x2C */ Vec unk2C; - /* 0x38 */ float unk38; + /* 0x04 */ SpaceAmidaMap *map; + /* 0x08 */ u16 mapCursor; + /* 0x0C */ float len; + /* 0x10 */ float speed; + /* 0x14 */ float maxSpeed; + /* 0x18 */ float rocketXOfs; + /* 0x1C */ float kemuriSize; + /* 0x20 */ Vec kemuriScale; + /* 0x2C */ Vec kemuriScaleVel; + /* 0x38 */ float kemuriTPLvl; /* 0x3C */ float unk3C; - /* 0x40 */ s16 unk40; - /* 0x42 */ char unk42[2]; -} Bss714Data; // Size 0x44 + /* 0x40 */ s16 targetNo; +} RocketWork; // Size 0x44 -static void fn_1_A4B8(omObjData *arg0); -static void fn_1_A554(void); -static void fn_1_A5FC(void); -static void fn_1_A6E0(omObjData *arg0); -static float fn_1_B018(Data690Block *arg0); -static void fn_1_B088(omObjData *arg0); -static void fn_1_B1CC(omObjData *arg0, u16 *arg1, u16 *arg2); -static void fn_1_B3B8(omObjData *arg0); -static void fn_1_B478(omObjData *arg0); -static void fn_1_BAF8(omObjData *arg0); -static void fn_1_BCDC(omObjData *arg0); -static void fn_1_BF00(omObjData *arg0); -static void fn_1_BF68(omObjData *arg0); -static void fn_1_C000(void); -static void fn_1_C0FC(omObjData *arg0); -static void fn_1_C25C(void); -static void fn_1_C844(void); -static void fn_1_C894(omObjData *arg0); -static void fn_1_C94C(Vec *arg0, Vec *arg1, Vec *arg2); -static float fn_1_C998(Vec *arg0); -static u32 fn_1_CB44(Vec *arg0, float arg1); -static void fn_1_CEC4(void); -static void fn_1_D034(void); -static void fn_1_D07C(omObjData *arg0); -static void fn_1_D114(ModelData *model, ParticleData *particle, Mtx matrix); +static void SpaceAmidaMainUpdate(omObjData *obj); +static void SpaceAmidaStop(void); +static void SpaceAmidaKill(void); +static void SpaceAmidaRocketObjUpdate(omObjData *obj); +static float SpaceAmidaMapLenGet(SpaceAmidaMap *obj); +static void SpaceAmidaComChoiceSet(omObjData *obj); +static void SpaceAmidaComInputGet(omObjData *obj, u16 *stkBtn, u16 *btn); +static void SpaceAmidaGameOpen(omObjData *obj); +static void SpaceAmidaGameUpdate(omObjData *obj); +static void SpaceAmidaRocketJump(omObjData *obj); +static void SpaceAmidaRocketKemuriExec(omObjData *obj); +static void SpaceAmidaRocketWait(omObjData *obj); +static void SpaceAmidaRocketUp(omObjData *obj); +static void SpaceAmidaCoinWin(void); +static void SpaceAmidaJumpDown(omObjData *obj); +static void SpaceAmidaCoinRainMain(void); +static void SpaceAmidaReturnWinMain(void); +static void SpaceAmidaGameStop(omObjData *obj); +static void SpaceAmidaDirGet(Vec *a, Vec *b, Vec *result); +static float SpaceAmidaAngleGet(Vec *dir); +static u32 SpaceAmidaPlayerRotAdd(Vec *rocketPos, float delta); +static void SpaceAmidaEffCreate(void); +static void SpaceAmidaEffKill(void); +static void SpaceAmidaEffUpdate(omObjData *arg0); +static void SpaceAmidaEffParticleHook(ModelData *model, ParticleData *particle, Mtx matrix); -static s32 lbl_1_bss_79C; -static s32 lbl_1_bss_798; -static s16 lbl_1_bss_796; -static s16 lbl_1_bss_790[3]; -static s16 lbl_1_bss_78A[3]; -static s16 lbl_1_bss_788; -static s16 lbl_1_bss_760[20]; -static Process *lbl_1_bss_75C; -static omObjData *lbl_1_bss_758; -static float lbl_1_bss_754; -static s16 lbl_1_bss_750; -static s32 lbl_1_bss_74C; -static s32 lbl_1_bss_748; -static s16 lbl_1_bss_744; -static Vec lbl_1_bss_738; -static s32 lbl_1_bss_734; -static s32 lbl_1_bss_730; -static s32 lbl_1_bss_72C; -static u16 lbl_1_bss_72A; -static u16 lbl_1_bss_728; -static s32 lbl_1_bss_724; -static omObjData *lbl_1_bss_720; -static omObjData *lbl_1_bss_714[3]; -static omObjData *lbl_1_bss_710; -static AnimData *lbl_1_bss_70C; -static s16 lbl_1_bss_708; +static s32 spaceAmidaPadNo; +static s32 spaceAmidaPlayerNo; +static s16 spaceAmidaMdlId; +static s16 mapMdlId[3]; +static s16 rocketMdlId[3]; +static s16 spaceAmidaEffMdlId; +static s16 coinMdlId[20]; +static Process *coinWinProc; +static omObjData *spaceAmidaMainObj; +static float spaceAmidaTime; +static s16 kemuriMdlId; +static s32 timerSec; +static s32 timerFrame; +static s16 timerSeqId; +static Vec spaceAmidaPos; +static s32 spaceAmidaMapNo; +static s32 spaceAmidaPath; +static s32 rocketWarpF; +static u16 spaceAmidaStopF; +static u16 spaceAmidaCoinNum; +static s32 spaceAmidaSeNo; +static omObjData *spaceAmidaGameObj; +static omObjData *rocketObj[3]; +static omObjData *spaceAmidaEffObj; +static AnimData *spaceAmidaEffAnim; +static s16 spaceAmidaSeqStopF; -static Vec lbl_1_data_658[3] = { { -50.0f, 238.0f, 0.0f }, { 0.0f, 275.5f, 0.0f }, { 50.0f, 238.0f, 0.0f } }; +static Vec effPosTbl[3] = { { -50.0f, 238.0f, 0.0f }, { 0.0f, 275.5f, 0.0f }, { 50.0f, 238.0f, 0.0f } }; -static u16 lbl_1_data_67C[3][3] = { { 10, 5, 20 }, { 10, 5, 20 }, { 5, 20, 10 } }; +static u16 spaceAmidaCoinNumTbl[3][3] = { { 10, 5, 20 }, { 10, 5, 20 }, { 5, 20, 10 } }; -static Data690Block lbl_1_data_690[3] +static SpaceAmidaMap spaceAmidaMap1[3] = { { { { -50.0f, -12.0f, 0.0f }, 75.0f }, { { -50.0f, 63.0f, 0.0f }, 50.0f }, { { 0.0f, 63.0f, 0.0f }, 25.0f }, { { 0.0f, 88.0f, 0.0f }, 50.0f }, { { 50.0f, 88.0f, 0.0f }, 87.5f }, { { 50.0f, 175.5f, 0.0f }, 0.0f } }, { { { 0.0f, -12.0f, 0.0f }, 75.0f }, { { 0.0f, 63.0f, 0.0f }, 50.0f }, { { -50.0f, 63.0f, 0.0f }, 50.0f }, @@ -130,7 +126,7 @@ static Data690Block lbl_1_data_690[3] { { 0.0f, 113.0f, 0.0f }, 50.0f }, { { -50.0f, 113.0f, 0.0f }, 50.0f }, { { -50.0f, 163.0f, 0.0f }, 50.0f }, { { 0.0f, 163.0f, 0.0f }, 50.0f }, { { 0.0f, 213.0f, 0.0f }, 0.0f } } }; -static Data690Block lbl_1_data_960[3] +static SpaceAmidaMap spaceAmidaMap2[3] = { { { { -50.0f, -12.0f, 0.0f }, 125.0f }, { { -50.0f, 113.0f, 0.0f }, 50.0f }, { { 0.0f, 113.0f, 0.0f }, 25.0f }, { { 0.0f, 138.0f, 0.0f }, 50.0f }, { { 50.0f, 138.0f, 0.0f }, 37.5f }, { { 50.0f, 175.5f, 0.0f }, 0.0f } }, { { { 0.0f, -12.0f, 0.0f }, 75.0f }, { { 0.0f, 63.0f, 0.0f }, 50.0f }, { { 50.0f, 63.0f, 0.0f }, 75.0f }, @@ -140,7 +136,7 @@ static Data690Block lbl_1_data_960[3] { { 0.0f, 113.0f, 0.0f }, 50.0f }, { { -50.0f, 113.0f, 0.0f }, 50.0f }, { { -50.0f, 163.0f, 0.0f }, 50.0f }, { { 0.0f, 163.0f, 0.0f }, 50.0f }, { { 0.0f, 213.0f, 0.0f }, 0.0f } } }; -static Data690Block lbl_1_data_C30[3] +static SpaceAmidaMap spaceAmidaMap3[3] = { { { { -50.0f, -12.0f, 0.0f }, 100.0f }, { { -50.0f, 88.0f, 0.0f }, 50.0f }, { { 0.0f, 88.0f, 0.0f }, 50.0f }, { { 0.0f, 138.0f, 0.0f }, 50.0f }, { { -50.0f, 138.0f, 0.0f }, 37.5f }, { { -50.0f, 175.5f, 0.0f }, 0.0f } }, { { { 0.0f, -12.0f, 0.0f }, 75.0f }, { { 0.0f, 63.0f, 0.0f }, 50.0f }, { { 50.0f, 63.0f, 0.0f }, 100.0f }, @@ -149,911 +145,867 @@ static Data690Block lbl_1_data_C30[3] { { -50.0f, 88.0f, 0.0f }, 50.0f }, { { -50.0f, 138.0f, 0.0f }, 50.0f }, { { 0.0f, 138.0f, 0.0f }, 25.0f }, { { 0.0f, 163.0f, 0.0f }, 50.0f }, { { 50.0f, 163.0f, 0.0f }, 12.5f }, { { 50.0f, 175.5f, 0.0f }, 0.0f } } }; -void fn_1_9D00(s32 arg0) +void SpaceAmidaExec(void) { - s32 temp_r31; - s32 var_r30; - - temp_r31 = GWSystem.star_pos; - var_r30 = 0; - if (lbl_1_bss_0->unk00_field0 != 0) { - if (temp_r31 == 0 || temp_r31 == 1 || temp_r31 == 7) { - var_r30 = 0; - } - else { - var_r30 = 1; - } - } - else if (temp_r31 == 0 || temp_r31 == 1 || temp_r31 == 7) { - var_r30 = 1; - } - else { - var_r30 = 0; - } - if (BoardPlayerCoinsGet(arg0) < 5) { - var_r30 = 0; - } - if (var_r30 != 0) { - BoardComKeySetLeft(); - } - else { - BoardComKeySetRight(); - } -} - -void fn_1_9DD8(void) -{ - Vec sp2C[3]; - Vec sp20; - Vec sp14; - Vec sp8; - Bss720Data *temp_r30; - Bss714Data *temp_r29; + Vec rocketMdlOfs[3]; + Vec pos; + Vec rocketPos; + Vec scale; + SpaceAmidaGameWork *gameObjWork; + RocketWork *rocketWork; s32 i; - lbl_1_bss_79C = GWPlayer[GWSystem.player_curr].port; - lbl_1_bss_796 = lbl_1_bss_6C4[6]; - lbl_1_bss_790[0] = lbl_1_bss_6C4[7]; - lbl_1_bss_790[1] = lbl_1_bss_6C4[8]; - lbl_1_bss_790[2] = lbl_1_bss_6C4[9]; - lbl_1_bss_78A[0] = lbl_1_bss_6C4[10]; - lbl_1_bss_78A[1] = lbl_1_bss_6C4[11]; - lbl_1_bss_78A[2] = lbl_1_bss_6C4[12]; - BoardModelVisibilitySet(lbl_1_bss_790[0], 0); - BoardModelVisibilitySet(lbl_1_bss_790[1], 0); - BoardModelVisibilitySet(lbl_1_bss_790[2], 0); - lbl_1_bss_734 = rand8() % 3; - BoardModelVisibilitySet(lbl_1_bss_790[lbl_1_bss_734], 1); - BoardModelMotionStart(lbl_1_bss_790[lbl_1_bss_734], 0, 0x40000001); - BoardModelPosGet(lbl_1_bss_796, &sp20); - sp8.x = sp8.y = sp8.z = 1.0f; + spaceAmidaPadNo = GWPlayer[GWSystem.player_curr].port; + spaceAmidaMdlId = mapObjMdlId[MAPOBJ_SPACEAMIDA]; + mapMdlId[0] = mapObjMdlId[MAPOBJ_SPACEAMIDA_MAP1]; + mapMdlId[1] = mapObjMdlId[MAPOBJ_SPACEAMIDA_MAP2]; + mapMdlId[2] = mapObjMdlId[MAPOBJ_SPACEAMIDA_MAP3]; + rocketMdlId[0] = mapObjMdlId[MAPOBJ_SPACEAMIDA_ROCKET1]; + rocketMdlId[1] = mapObjMdlId[MAPOBJ_SPACEAMIDA_ROCKET2]; + rocketMdlId[2] = mapObjMdlId[MAPOBJ_SPACEAMIDA_ROCKET3]; + BoardModelVisibilitySet(mapMdlId[0], 0); + BoardModelVisibilitySet(mapMdlId[1], 0); + BoardModelVisibilitySet(mapMdlId[2], 0); + spaceAmidaMapNo = rand8() % 3; + BoardModelVisibilitySet(mapMdlId[spaceAmidaMapNo], 1); + BoardModelMotionStart(mapMdlId[spaceAmidaMapNo], 0, HU3D_MOTATTR_LOOP); + BoardModelPosGet(spaceAmidaMdlId, &pos); + scale.x = scale.y = scale.z = 1.0f; for (i = 0; i < 3; i++) { - sp2C[i] = lbl_1_data_690[i][0].unk00; - sp2C[i].y -= -12.0f; - BoardModelPosSet(lbl_1_bss_78A[i], sp20.x + sp2C[i].x, sp20.y + sp2C[i].y, sp20.z + 30.0f); - BoardModelVisibilitySet(lbl_1_bss_78A[i], 1); - BoardModelScaleSetV(lbl_1_bss_78A[i], &sp8); + rocketMdlOfs[i] = spaceAmidaMap1[i][0].pos; + rocketMdlOfs[i].y -= -12.0f; + BoardModelPosSet(rocketMdlId[i], pos.x + rocketMdlOfs[i].x, pos.y + rocketMdlOfs[i].y, pos.z + 30.0f); + BoardModelVisibilitySet(rocketMdlId[i], 1); + BoardModelScaleSetV(rocketMdlId[i], &scale); } - lbl_1_bss_798 = GWSystem.player_curr; - BoardModelPosGet(lbl_1_bss_796, &lbl_1_bss_738); - lbl_1_bss_730 = 1; - BoardModelPosGet(lbl_1_bss_78A[lbl_1_bss_730], &sp14); - BoardPlayerPosGet(lbl_1_bss_798, &sp20); - lbl_1_bss_758 = omAddObjEx(boardObjMan, 0x101, 0, 0, -1, fn_1_A4B8); - lbl_1_bss_720 = omAddObjEx(boardObjMan, 0x101, 0, 0, -1, fn_1_B3B8); - lbl_1_bss_720->data = HuMemDirectMallocNum(HEAP_SYSTEM, sizeof(Bss720Data), MEMORY_DEFAULT_NUM); - temp_r30 = lbl_1_bss_720->data; - temp_r30->unk02 = 0; - temp_r30->unk04 = sp14; - temp_r30->unk28 = 0; - fn_1_CB44(&sp14, 0.0f); - fn_1_B088(lbl_1_bss_720); - lbl_1_bss_750 = Hu3DModelCreateFile(DATA_MAKE_NUM(DATADIR_W01, 19)); - Hu3DModelAttrSet(lbl_1_bss_750, HU3D_ATTR_DISPOFF); + spaceAmidaPlayerNo = GWSystem.player_curr; + BoardModelPosGet(spaceAmidaMdlId, &spaceAmidaPos); + spaceAmidaPath = 1; + BoardModelPosGet(rocketMdlId[spaceAmidaPath], &rocketPos); + BoardPlayerPosGet(spaceAmidaPlayerNo, &pos); + spaceAmidaMainObj = omAddObjEx(boardObjMan, 0x101, 0, 0, -1, SpaceAmidaMainUpdate); + spaceAmidaGameObj = omAddObjEx(boardObjMan, 0x101, 0, 0, -1, SpaceAmidaGameOpen); + spaceAmidaGameObj->data = HuMemDirectMallocNum(HEAP_SYSTEM, sizeof(SpaceAmidaGameWork), MEMORY_DEFAULT_NUM); + gameObjWork = spaceAmidaGameObj->data; + gameObjWork->unk02 = 0; + gameObjWork->rocketPos = rocketPos; + gameObjWork->comInputTimer = 0; + SpaceAmidaPlayerRotAdd(&rocketPos, 0.0f); + SpaceAmidaComChoiceSet(spaceAmidaGameObj); + kemuriMdlId = Hu3DModelCreateFile(DATA_MAKE_NUM(DATADIR_W01, 19)); + Hu3DModelAttrSet(kemuriMdlId, HU3D_ATTR_DISPOFF); for (i = 0; i < 3; i++) { - lbl_1_bss_714[i] = omAddObjEx(boardObjMan, 0x101, 0, 0, -1, fn_1_A6E0); - lbl_1_bss_714[i]->data = HuMemDirectMallocNum(HEAP_SYSTEM, sizeof(Bss714Data), MEMORY_DEFAULT_NUM); - lbl_1_bss_714[i]->work[0] = lbl_1_bss_78A[i]; - lbl_1_bss_714[i]->work[1] = 0; - lbl_1_bss_714[i]->work[3] = 0; - temp_r29 = lbl_1_bss_714[i]->data; - if (i == lbl_1_bss_730) { - lbl_1_bss_714[i]->work[2] = 1; + rocketObj[i] = omAddObjEx(boardObjMan, 0x101, 0, 0, -1, SpaceAmidaRocketObjUpdate); + rocketObj[i]->data = HuMemDirectMallocNum(HEAP_SYSTEM, sizeof(RocketWork), MEMORY_DEFAULT_NUM); + rocketObj[i]->work[0] = rocketMdlId[i]; + rocketObj[i]->work[1] = 0; + rocketObj[i]->work[3] = 0; + rocketWork = rocketObj[i]->data; + if (i == spaceAmidaPath) { + rocketObj[i]->work[2] = 1; } else { - lbl_1_bss_714[i]->work[2] = 0; + rocketObj[i]->work[2] = 0; } - temp_r29->unk18 = 1.0f; - temp_r29->unk1C = 0.0f; + rocketWork->rocketXOfs = 1.0f; + rocketWork->kemuriSize = 0.0f; } - lbl_1_bss_72C = 0; - lbl_1_bss_74C = 5; - lbl_1_bss_748 = REFRESH_RATE; - lbl_1_bss_72A = 0; - fn_1_CEC4(); - lbl_1_bss_788 = BoardModelCreate(DATA_MAKE_NUM(DATADIR_W01, 17), NULL, 0); - BoardModelMotionUpdateSet(lbl_1_bss_788, 1); - BoardModelVisibilitySet(lbl_1_bss_788, 0); + rocketWarpF = 0; + timerSec = 5; + timerFrame = REFRESH_RATE; + spaceAmidaStopF = 0; + SpaceAmidaEffCreate(); + spaceAmidaEffMdlId = BoardModelCreate(DATA_MAKE_NUM(DATADIR_W01, 17), NULL, 0); + BoardModelMotionUpdateSet(spaceAmidaEffMdlId, 1); + BoardModelVisibilitySet(spaceAmidaEffMdlId, 0); for (i = 0; i < 20; i++) { - lbl_1_bss_760[i] = BoardModelCreate(DATA_MAKE_NUM(DATADIR_BOARD, 10), NULL, 1); - BoardModelVisibilitySet(lbl_1_bss_760[i], 0); + coinMdlId[i] = BoardModelCreate(DATA_MAKE_NUM(DATADIR_BOARD, 10), NULL, 1); + BoardModelVisibilitySet(coinMdlId[i], 0); } } -static void fn_1_A4B8(omObjData *arg0) +static void SpaceAmidaMainUpdate(omObjData *obj) { - if (lbl_1_bss_72A == 0) { + if (spaceAmidaStopF == 0) { return; } if (BoardMGDoneFlagGet() == 1) { - if (lbl_1_bss_754 <= 0.0f) { - fn_1_A5FC(); - omDelObjEx(HuPrcCurrentGet(), arg0); + if (spaceAmidaTime <= 0.0f) { + SpaceAmidaKill(); + omDelObjEx(HuPrcCurrentGet(), obj); } } - lbl_1_bss_754 -= 1.0f; + spaceAmidaTime -= 1.0f; } -static void fn_1_A554(void) +static void SpaceAmidaStop(void) { - float temp_f1; + float time; - lbl_1_bss_72A = 1; + spaceAmidaStopF = 1; BoardMGExit(); - temp_f1 = BoardModelMotionTimeGet(lbl_1_bss_796); - lbl_1_bss_754 = temp_f1; - BoardModelMotionStart(lbl_1_bss_796, 0, 0); - BoardModelMotionTimeSet(lbl_1_bss_796, temp_f1); - BoardModelMotionSpeedSet(lbl_1_bss_796, -1.0f); + time = BoardModelMotionTimeGet(spaceAmidaMdlId); + spaceAmidaTime = time; + BoardModelMotionStart(spaceAmidaMdlId, 0, 0); + BoardModelMotionTimeSet(spaceAmidaMdlId, time); + BoardModelMotionSpeedSet(spaceAmidaMdlId, -1.0f); } -static void fn_1_A5FC(void) +static void SpaceAmidaKill(void) { s32 i; for (i = 0; i < 3; i++) { - BoardModelVisibilitySet(lbl_1_bss_790[i], 0); - BoardModelVisibilitySet(lbl_1_bss_78A[i], 0); - omDelObjEx(HuPrcCurrentGet(), lbl_1_bss_714[i]); + BoardModelVisibilitySet(mapMdlId[i], 0); + BoardModelVisibilitySet(rocketMdlId[i], 0); + omDelObjEx(HuPrcCurrentGet(), rocketObj[i]); } for (i = 0; i < 20; i++) { - BoardModelKill(lbl_1_bss_760[i]); + BoardModelKill(coinMdlId[i]); } - fn_1_D034(); - BoardModelKill(lbl_1_bss_788); + SpaceAmidaEffKill(); + BoardModelKill(spaceAmidaEffMdlId); BoardMGDoneFlagSet(0); - Hu3DModelKill(lbl_1_bss_750); + Hu3DModelKill(kemuriMdlId); } -static void fn_1_A6E0(omObjData *arg0) +static void SpaceAmidaRocketObjUpdate(omObjData *obj) { - Bss714Data *temp_r31; - Vec sp2C; - Vec sp20; - Vec sp14; - Vec sp8; - float var_f31; + RocketWork *work; + Vec scale; + Vec pos; + Vec rocketPos; + Vec dir; + float len; - temp_r31 = arg0->data; - BoardModelScaleGet(arg0->work[0], &sp2C); - switch (arg0->work[2]) { + work = obj->data; + BoardModelScaleGet(obj->work[0], &scale); + switch (obj->work[2]) { case 1: - if ((sp2C.x += 0.08f) >= 1.5f) { - sp2C.x = 1.5f; - sp2C.y = 1.5f; - if (arg0->work[3] == 1) { - arg0->work[2] = 0; + if ((scale.x += 0.08f) >= 1.5f) { + scale.x = 1.5f; + scale.y = 1.5f; + if (obj->work[3] == 1) { + obj->work[2] = 0; } else { - arg0->work[2] = 2; + obj->work[2] = 2; } } else { - sp2C.y += 0.08f; + scale.y += 0.08f; } - BoardModelScaleSetV(arg0->work[0], &sp2C); + BoardModelScaleSetV(obj->work[0], &scale); break; case 2: - if ((sp2C.x -= 0.08f) <= 1.0f) { - sp2C.x = 1.0f; - sp2C.y = 1.0f; - if (arg0->work[1] == 1) { - arg0->work[2] = 0; - arg0->work[1] = 0; + if ((scale.x -= 0.08f) <= 1.0f) { + scale.x = 1.0f; + scale.y = 1.0f; + if (obj->work[1] == 1) { + obj->work[2] = 0; + obj->work[1] = 0; } else { - arg0->work[2] = 1; + obj->work[2] = 1; } } else { - sp2C.y -= 0.08f; + scale.y -= 0.08f; } - BoardModelScaleSetV(arg0->work[0], &sp2C); + BoardModelScaleSetV(obj->work[0], &scale); break; case 3: - switch (lbl_1_bss_734) { + switch (spaceAmidaMapNo) { case 0: - temp_r31->unk04 = &lbl_1_data_690[lbl_1_bss_730]; + work->map = &spaceAmidaMap1[spaceAmidaPath]; break; case 1: - temp_r31->unk04 = &lbl_1_data_960[lbl_1_bss_730]; + work->map = &spaceAmidaMap2[spaceAmidaPath]; break; case 2: - temp_r31->unk04 = &lbl_1_data_C30[lbl_1_bss_730]; + work->map = &spaceAmidaMap3[spaceAmidaPath]; break; } - BoardModelPosGet(arg0->work[0], &sp14); - sp14.x = lbl_1_bss_738.x + ((*temp_r31->unk04)[0].unk00.x + temp_r31->unk18); - temp_r31->unk18 = -temp_r31->unk18; - BoardModelPosSetV(arg0->work[0], &sp14); - sp14.y += 5.0f; - BoardPlayerPosSetV(lbl_1_bss_798, &sp14); - temp_r31->unk1C += 0.022222223f; - temp_r31->unk38 -= 0.011111111f; - if (temp_r31->unk38 < 0.0f) { - temp_r31->unk38 = 0.0f; + BoardModelPosGet(obj->work[0], &rocketPos); + rocketPos.x = spaceAmidaPos.x + ((*work->map)[0].pos.x + work->rocketXOfs); + work->rocketXOfs = -work->rocketXOfs; + BoardModelPosSetV(obj->work[0], &rocketPos); + rocketPos.y += 5.0f; + BoardPlayerPosSetV(spaceAmidaPlayerNo, &rocketPos); + work->kemuriSize += 0.022222223f; + work->kemuriTPLvl -= 0.011111111f; + if (work->kemuriTPLvl < 0.0f) { + work->kemuriTPLvl = 0.0f; } - Hu3DModelTPLvlSet(lbl_1_bss_750, temp_r31->unk38); - if (temp_r31->unk1C > 1.0f) { - temp_r31->unk1C = 1.0f; + Hu3DModelTPLvlSet(kemuriMdlId, work->kemuriTPLvl); + if (work->kemuriSize > 1.0f) { + work->kemuriSize = 1.0f; } - VECAdd(&temp_r31->unk20, &temp_r31->unk2C, &temp_r31->unk20); - if (temp_r31->unk20.y >= 4.0f) { - temp_r31->unk20.y = 4.0f; - temp_r31->unk2C.y = -0.1f; + VECAdd(&work->kemuriScale, &work->kemuriScaleVel, &work->kemuriScale); + if (work->kemuriScale.y >= 4.0f) { + work->kemuriScale.y = 4.0f; + work->kemuriScaleVel.y = -0.1f; } - if (temp_r31->unk20.y < 1.0f) { - temp_r31->unk20.y = 1.0f; + if (work->kemuriScale.y < 1.0f) { + work->kemuriScale.y = 1.0f; } - Hu3DModelScaleSet(lbl_1_bss_750, temp_r31->unk20.x, temp_r31->unk20.y, temp_r31->unk20.z); + Hu3DModelScaleSet(kemuriMdlId, work->kemuriScale.x, work->kemuriScale.y, work->kemuriScale.z); break; case 4: - Hu3DModelAttrSet(lbl_1_bss_750, HU3D_ATTR_DISPOFF); - arg0->work[2] = 5; - temp_r31->unk08 = 0; - temp_r31->unk0C = 12.0f; - temp_r31->unk14 = (fn_1_B018(temp_r31->unk04) - temp_r31->unk0C) / 90.0f; - temp_r31->unk10 = temp_r31->unk14 / 20.0f; + Hu3DModelAttrSet(kemuriMdlId, HU3D_ATTR_DISPOFF); + obj->work[2] = 5; + work->mapCursor = 0; + work->len = 12.0f; + work->maxSpeed = (SpaceAmidaMapLenGet(work->map) - work->len) / 90.0f; + work->speed = work->maxSpeed / 20.0f; HuAudFXPlay(0x406); HuAudFXPlay(0x407); - HuAudFXStop(lbl_1_bss_724); + HuAudFXStop(spaceAmidaSeNo); break; case 5: - var_f31 = temp_r31->unk0C + temp_r31->unk10; - temp_r31->unk0C = var_f31; - temp_r31->unk10 *= 1.04f; - if (temp_r31->unk10 > temp_r31->unk14) { - temp_r31->unk10 = temp_r31->unk14; + len = work->len + work->speed; + work->len = len; + work->speed *= 1.04f; + if (work->speed > work->maxSpeed) { + work->speed = work->maxSpeed; } - BoardModelPosGet(arg0->work[0], &sp20); - while (var_f31 >= (*temp_r31->unk04)[temp_r31->unk08].unk0C) { - var_f31 -= (*temp_r31->unk04)[temp_r31->unk08].unk0C; - temp_r31->unk08++; - if ((*temp_r31->unk04)[temp_r31->unk08].unk0C == 0.0f) { - omVibrate(lbl_1_bss_798, 12, 6, 6); - var_f31 = 0.0f; - lbl_1_bss_72C = 1; - lbl_1_bss_724 = HuAudFXPlay(0x332); - lbl_1_bss_708 = 0; - arg0->work[2] = 6; - if (sp20.x - lbl_1_bss_738.x < -25.0f) { - temp_r31->unk40 = 0; - lbl_1_bss_728 = 5; + BoardModelPosGet(obj->work[0], &pos); + while (len >= (*work->map)[work->mapCursor].len) { + len -= (*work->map)[work->mapCursor].len; + work->mapCursor++; + if ((*work->map)[work->mapCursor].len == 0.0f) { + omVibrate(spaceAmidaPlayerNo, 12, 6, 6); + len = 0.0f; + rocketWarpF = 1; + spaceAmidaSeNo = HuAudFXPlay(0x332); + spaceAmidaSeqStopF = 0; + obj->work[2] = 6; + if (pos.x - spaceAmidaPos.x < -25.0f) { + work->targetNo = 0; + spaceAmidaCoinNum = 5; } - else if (sp20.x - lbl_1_bss_738.x > 25.0f) { - temp_r31->unk40 = 2; - lbl_1_bss_728 = 10; + else if (pos.x - spaceAmidaPos.x > 25.0f) { + work->targetNo = 2; + spaceAmidaCoinNum = 10; } else { - temp_r31->unk40 = 1; - lbl_1_bss_728 = 20; + work->targetNo = 1; + spaceAmidaCoinNum = 20; } break; } } - temp_r31->unk0C = var_f31; - sp14.x = sp14.y = sp14.z = 0.0f; - if (lbl_1_bss_72C == 0) { - fn_1_C94C(&(*temp_r31->unk04)[temp_r31->unk08].unk00, &(*temp_r31->unk04)[temp_r31->unk08 + 1].unk00, &sp8); - sp20.x = lbl_1_bss_738.x + (sp8.x * var_f31 + (*temp_r31->unk04)[temp_r31->unk08].unk00.x); - sp20.y = lbl_1_bss_738.y + (sp8.y * var_f31 + (*temp_r31->unk04)[temp_r31->unk08].unk00.y); + work->len = len; + rocketPos.x = rocketPos.y = rocketPos.z = 0.0f; + if (rocketWarpF == 0) { + SpaceAmidaDirGet(&(*work->map)[work->mapCursor].pos, &(*work->map)[work->mapCursor + 1].pos, &dir); + pos.x = spaceAmidaPos.x + (dir.x * len + (*work->map)[work->mapCursor].pos.x); + pos.y = spaceAmidaPos.y + (dir.y * len + (*work->map)[work->mapCursor].pos.y); } else { - sp20.x = lbl_1_bss_738.x + (*temp_r31->unk04)[temp_r31->unk08].unk00.x; - sp20.y = lbl_1_bss_738.y + (*temp_r31->unk04)[temp_r31->unk08].unk00.y; + pos.x = spaceAmidaPos.x + (*work->map)[work->mapCursor].pos.x; + pos.y = spaceAmidaPos.y + (*work->map)[work->mapCursor].pos.y; } - BoardModelPosSetV(arg0->work[0], &sp20); - sp20.y += 5.0f; - BoardPlayerPosSetV(lbl_1_bss_798, &sp20); - BoardModelRotSetV(arg0->work[0], &sp14); - BoardPlayerRotSetV(lbl_1_bss_798, &sp14); + BoardModelPosSetV(obj->work[0], &pos); + pos.y += 5.0f; + BoardPlayerPosSetV(spaceAmidaPlayerNo, &pos); + BoardModelRotSetV(obj->work[0], &rocketPos); + BoardPlayerRotSetV(spaceAmidaPlayerNo, &rocketPos); break; case 6: - if (lbl_1_bss_708 == 0 && (HuAudFXStatusGet(lbl_1_bss_724) == 1 || HuAudFXStatusGet(lbl_1_bss_724) == 0)) { + if (spaceAmidaSeqStopF == 0 && (HuAudFXStatusGet(spaceAmidaSeNo) == 1 || HuAudFXStatusGet(spaceAmidaSeNo) == 0)) { BoardAudSeqPause(0, 0, 1000); - lbl_1_bss_708 = 1; + spaceAmidaSeqStopF = 1; } - BoardModelVisibilitySet(lbl_1_bss_788, 1); - sp20.x = lbl_1_bss_738.x + lbl_1_data_658[temp_r31->unk40].x; - sp20.y = lbl_1_bss_738.y + lbl_1_data_658[temp_r31->unk40].y; - sp20.z = lbl_1_bss_738.z + lbl_1_data_658[temp_r31->unk40].z; - BoardModelPosSetV(lbl_1_bss_788, &sp20); - temp_r31->unk1C -= 0.05f; - if (temp_r31->unk1C <= 0.0f) { - temp_r31->unk1C = 0.0f; + BoardModelVisibilitySet(spaceAmidaEffMdlId, 1); + pos.x = spaceAmidaPos.x + effPosTbl[work->targetNo].x; + pos.y = spaceAmidaPos.y + effPosTbl[work->targetNo].y; + pos.z = spaceAmidaPos.z + effPosTbl[work->targetNo].z; + BoardModelPosSetV(spaceAmidaEffMdlId, &pos); + work->kemuriSize -= 0.05f; + if (work->kemuriSize <= 0.0f) { + work->kemuriSize = 0.0f; } break; } } -static float fn_1_B018(Data690Block *arg0) +static float SpaceAmidaMapLenGet(SpaceAmidaMap *arg0) { - float var_f31; + float len; s32 i; - var_f31 = 0.0f; + len = 0.0f; i = 0; while (TRUE) { - if ((*arg0)[i].unk0C == 0.0f) { + if ((*arg0)[i].len == 0.0f) { break; } - var_f31 += (*arg0)[i].unk0C; + len += (*arg0)[i].len; i++; } - return var_f31; + return len; } -static void fn_1_B088(omObjData *arg0) +static void SpaceAmidaComChoiceSet(omObjData *obj) { - Bss720Data *temp_r31; - u16 sp8[] = { 20, 60, 120, 190 }; + SpaceAmidaGameWork *work; + u16 chance[] = { 20, 60, 120, 190 }; s32 i; - temp_r31 = arg0->data; - if (rand8() < sp8[GWPlayerCfg[lbl_1_bss_798].diff]) { + work = obj->data; + if (rand8() < chance[GWPlayerCfg[spaceAmidaPlayerNo].diff]) { for (i = 0; i < 3; i++) { - if (lbl_1_data_67C[lbl_1_bss_734][i] == 20) { - temp_r31->unk26 = i; + if (spaceAmidaCoinNumTbl[spaceAmidaMapNo][i] == 20) { + work->comChoice = i; } } } else { - temp_r31->unk26 = rand8() % 3; + work->comChoice = rand8() % 3; } - temp_r31->unk24 = rand8() % 20 + 20; + work->comDelay = rand8() % 20 + 20; } -static void fn_1_B1CC(omObjData *arg0, u16 *arg1, u16 *arg2) +static void SpaceAmidaComInputGet(omObjData *obj, u16 *stkBtn, u16 *btn) { - Bss720Data *temp_r31; + SpaceAmidaGameWork *work; - temp_r31 = arg0->data; - *arg1 = *arg2 = 0; - if (temp_r31->unk24 != 0) { - temp_r31->unk24--; + work = obj->data; + *stkBtn = *btn = 0; + if (work->comDelay != 0) { + work->comDelay--; return; } - if (temp_r31->unk28 >= 4 || (rand8() & 1)) { - if (temp_r31->unk26 == lbl_1_bss_730) { - *arg2 |= 0x100; + if (work->comInputTimer >= 4 || (rand8() & 1)) { + if (work->comChoice == spaceAmidaPath) { + *btn |= PAD_BUTTON_A; } - else if (temp_r31->unk26 < lbl_1_bss_730) { - *arg1 |= 1; + else if (work->comChoice < spaceAmidaPath) { + *stkBtn |= PAD_BUTTON_LEFT; } else { - *arg1 |= 2; + *stkBtn |= PAD_BUTTON_RIGHT; } - temp_r31->unk24 = rand8() % 10 + 10; + work->comDelay = rand8() % 10 + 10; } else { - temp_r31->unk28++; - temp_r31->unk24 = rand8() % 10 + 20; - if (lbl_1_bss_730 == 0) { - *arg1 |= 2; + work->comInputTimer++; + work->comDelay = rand8() % 10 + 20; + if (spaceAmidaPath == 0) { + *stkBtn |= PAD_BUTTON_RIGHT; } - else if (lbl_1_bss_730 == 2) { - *arg1 |= 1; + else if (spaceAmidaPath == 2) { + *stkBtn |= PAD_BUTTON_LEFT; } else if (rand8() & 1) { - *arg1 |= 1; + *stkBtn |= PAD_BUTTON_LEFT; } else { - *arg1 |= 2; + *stkBtn |= PAD_BUTTON_RIGHT; } } } -static void fn_1_B3B8(omObjData *arg0) +static void SpaceAmidaGameOpen(omObjData *obj) { - float temp_f31; - - temp_f31 = BoardModelMotionMaxTimeGet(lbl_1_bss_796); - if (BoardModelMotionTimeGet(lbl_1_bss_796) >= temp_f31) { - lbl_1_bss_744 = MGSeqCreate(1, lbl_1_bss_74C, 0x120, 0x40); - lbl_1_bss_720->func = fn_1_B478; + if (BoardModelMotionTimeGet(spaceAmidaMdlId) >= BoardModelMotionMaxTimeGet(spaceAmidaMdlId)) { + timerSeqId = MGSeqCreate(1, timerSec, 0x120, 0x40); + spaceAmidaGameObj->func = SpaceAmidaGameUpdate; BoardMusStart(1, 0xF, 0x7F, 0); - lbl_1_bss_724 = HuAudFXPlay(0x408); + spaceAmidaSeNo = HuAudFXPlay(0x408); } } -static void fn_1_B478(omObjData *arg0) +static void SpaceAmidaGameUpdate(omObjData *obj) { - Bss720Data *temp_r31; - Vec sp18; - Vec spC; - float var_f28; - u16 var_r27; - u16 var_r29; + SpaceAmidaGameWork *work; + Vec rocketPos; + Vec playerPos; + float jumpDist; + u16 btn; + u16 stkBtn; - temp_r31 = arg0->data; - if ((--lbl_1_bss_748) == 0) { - if ((--lbl_1_bss_74C) >= 0) { - MGSeqParamSet(lbl_1_bss_744, 1, lbl_1_bss_74C); + work = obj->data; + if ((--timerFrame) == 0) { + if ((--timerSec) >= 0) { + MGSeqParamSet(timerSeqId, 1, timerSec); } - lbl_1_bss_748 = REFRESH_RATE; + timerFrame = REFRESH_RATE; } - if (GWPlayerCfg[lbl_1_bss_798].iscom == 1) { - fn_1_B1CC(arg0, &var_r29, &var_r27); + if (GWPlayerCfg[spaceAmidaPlayerNo].iscom == 1) { + SpaceAmidaComInputGet(obj, &stkBtn, &btn); } else { - var_r29 = HuPadDStkRep[lbl_1_bss_79C]; - var_r27 = HuPadBtnDown[lbl_1_bss_79C]; + stkBtn = HuPadDStkRep[spaceAmidaPadNo]; + btn = HuPadBtnDown[spaceAmidaPadNo]; } - if ((var_r29 & 1) && lbl_1_bss_730 != 0) { - lbl_1_bss_714[lbl_1_bss_730]->work[1] = 1; - lbl_1_bss_714[lbl_1_bss_730]->work[2] = 2; - lbl_1_bss_730--; - lbl_1_bss_714[lbl_1_bss_730]->work[2] = 1; + if ((stkBtn & PAD_BUTTON_LEFT) && spaceAmidaPath != 0) { + rocketObj[spaceAmidaPath]->work[1] = 1; + rocketObj[spaceAmidaPath]->work[2] = 2; + spaceAmidaPath--; + rocketObj[spaceAmidaPath]->work[2] = 1; } - if ((var_r29 & 2) && lbl_1_bss_730 != 2) { - lbl_1_bss_714[lbl_1_bss_730]->work[1] = 1; - lbl_1_bss_714[lbl_1_bss_730]->work[2] = 2; - lbl_1_bss_730++; - lbl_1_bss_714[lbl_1_bss_730]->work[2] = 1; + if ((stkBtn & PAD_BUTTON_RIGHT) && spaceAmidaPath != 2) { + rocketObj[spaceAmidaPath]->work[1] = 1; + rocketObj[spaceAmidaPath]->work[2] = 2; + spaceAmidaPath++; + rocketObj[spaceAmidaPath]->work[2] = 1; } - BoardModelPosGet(lbl_1_bss_78A[lbl_1_bss_730], &sp18); - BoardPlayerPosGet(lbl_1_bss_798, &spC); - fn_1_CB44(&sp18, 0.0f); - temp_r31->unk04 = sp18; - if (lbl_1_bss_74C < 0 || (var_r27 & 0x100)) { - MGSeqParamSet(lbl_1_bss_744, 2, -1); - lbl_1_bss_714[lbl_1_bss_730]->work[1] = 1; - BoardPlayerPosGet(lbl_1_bss_798, &spC); - var_f28 = VECDistanceXZ(&temp_r31->unk04, &spC); - fn_1_C94C(&spC, &temp_r31->unk04, &temp_r31->unk10); - temp_r31->unk10.y = 0.0f; - temp_r31->unk10.x *= var_f28 / 30.0f; - temp_r31->unk10.z *= var_f28 / 30.0f; - temp_r31->unk00 = 0; - temp_r31->unk20 = 0.0f; - arg0->func = fn_1_BAF8; + BoardModelPosGet(rocketMdlId[spaceAmidaPath], &rocketPos); + BoardPlayerPosGet(spaceAmidaPlayerNo, &playerPos); + SpaceAmidaPlayerRotAdd(&rocketPos, 0.0f); + work->rocketPos = rocketPos; + if (timerSec < 0 || (btn & PAD_BUTTON_A)) { + MGSeqParamSet(timerSeqId, 2, -1); + rocketObj[spaceAmidaPath]->work[1] = 1; + BoardPlayerPosGet(spaceAmidaPlayerNo, &playerPos); + jumpDist = VECDistanceXZ(&work->rocketPos, &playerPos); + SpaceAmidaDirGet(&playerPos, &work->rocketPos, &work->jumpDir); + work->jumpDir.y = 0.0f; + work->jumpDir.x *= jumpDist / 30.0f; + work->jumpDir.z *= jumpDist / 30.0f; + work->unk00 = 0; + work->jumpTime = 0.0f; + obj->func = SpaceAmidaRocketJump; } } -static void fn_1_BAF8(omObjData *arg0) +static void SpaceAmidaRocketJump(omObjData *obj) { - Bss720Data *temp_r31; - Vec sp14; - Vec sp8; + SpaceAmidaGameWork *work; + Vec playerPos; + Vec rocketPos; - temp_r31 = arg0->data; - if (lbl_1_bss_714[lbl_1_bss_730]->work[2] != 0) { + work = obj->data; + if (rocketObj[spaceAmidaPath]->work[2] != 0) { return; } - BoardPlayerMotionStart(lbl_1_bss_798, 4, 0); - BoardPlayerPosGet(lbl_1_bss_798, &sp14); - sp14.x += temp_r31->unk10.x; - sp14.z += temp_r31->unk10.z; - sp14.y = lbl_1_bss_738.y + 80.0 * sind(6.0f * temp_r31->unk20); - BoardModelPosGet(lbl_1_bss_714[lbl_1_bss_730]->work[0], &sp8); - if ((temp_r31->unk20 += 1.0f) == 30.0f) { - sp14.y = sp8.y + 5.0f; - BoardPlayerPosSetV(lbl_1_bss_798, &sp14); - BoardPlayerMotionShiftSet(lbl_1_bss_798, 2, 0.0f, 10.0f, HU3D_MOTATTR_NONE); - arg0->func = fn_1_BCDC; + BoardPlayerMotionStart(spaceAmidaPlayerNo, 4, 0); + BoardPlayerPosGet(spaceAmidaPlayerNo, &playerPos); + playerPos.x += work->jumpDir.x; + playerPos.z += work->jumpDir.z; + playerPos.y = spaceAmidaPos.y + 80.0 * sind(6.0f * work->jumpTime); + BoardModelPosGet(rocketObj[spaceAmidaPath]->work[0], &rocketPos); + if ((++work->jumpTime) == 30.0f) { + playerPos.y = rocketPos.y + 5.0f; + BoardPlayerPosSetV(spaceAmidaPlayerNo, &playerPos); + BoardPlayerMotionShiftSet(spaceAmidaPlayerNo, 2, 0.0f, 10.0f, HU3D_MOTATTR_NONE); + obj->func = SpaceAmidaRocketKemuriExec; } - BoardPlayerPosSetV(lbl_1_bss_798, &sp14); + BoardPlayerPosSetV(spaceAmidaPlayerNo, &playerPos); } -static void fn_1_BCDC(omObjData *arg0) +static void SpaceAmidaRocketKemuriExec(omObjData *obj) { - Bss720Data *temp_r29; - Bss714Data *temp_r31; - Vec sp14; - Vec sp8; + SpaceAmidaGameWork *work; + RocketWork *rocketWork; + Vec playerPos; + Vec kemuriPos; - temp_r29 = arg0->data; - BoardPlayerPosGet(lbl_1_bss_798, &sp14); - sp8 = sp14; - sp8.z += 100.0f; - if (fn_1_CB44(&sp8, 10.0f) == 1) { - BoardPlayerMotionShiftSet(lbl_1_bss_798, 1, 0.0f, 10.0f, HU3D_MOTATTR_NONE); - temp_r29->unk1C = 90; - lbl_1_bss_710->work[0] = 1; - lbl_1_bss_714[lbl_1_bss_730]->work[2] = 3; - temp_r31 = lbl_1_bss_714[lbl_1_bss_730]->data; - Hu3DModelAttrReset(lbl_1_bss_750, HU3D_ATTR_DISPOFF); - Hu3DModelPosSet(lbl_1_bss_750, sp14.x, sp14.y, sp14.z); - temp_r31->unk20.x = 1.4f; - temp_r31->unk20.y = 1.4f; - temp_r31->unk20.z = 1.4f; - temp_r31->unk2C.x = 0.055999998f; - temp_r31->unk2C.y = 0.08088889f; - temp_r31->unk2C.z = 0.055999998f; - temp_r31->unk38 = 1.0f; - temp_r31->unk3C = 0.0f; - Hu3DModelScaleSet(lbl_1_bss_750, 1.4f, 1.4f, 1.4f); - arg0->func = fn_1_BF00; + work = obj->data; + BoardPlayerPosGet(spaceAmidaPlayerNo, &playerPos); + kemuriPos = playerPos; + kemuriPos.z += 100.0f; + if (SpaceAmidaPlayerRotAdd(&kemuriPos, 10.0f) == 1) { + BoardPlayerMotionShiftSet(spaceAmidaPlayerNo, 1, 0.0f, 10.0f, HU3D_MOTATTR_NONE); + work->waitTime = 90; + spaceAmidaEffObj->work[0] = 1; + rocketObj[spaceAmidaPath]->work[2] = 3; + rocketWork = rocketObj[spaceAmidaPath]->data; + Hu3DModelAttrReset(kemuriMdlId, HU3D_ATTR_DISPOFF); + Hu3DModelPosSet(kemuriMdlId, playerPos.x, playerPos.y, playerPos.z); + rocketWork->kemuriScale.x = 1.4f; + rocketWork->kemuriScale.y = 1.4f; + rocketWork->kemuriScale.z = 1.4f; + rocketWork->kemuriScaleVel.x = 0.055999998f; + rocketWork->kemuriScaleVel.y = 0.08088889f; + rocketWork->kemuriScaleVel.z = 0.055999998f; + rocketWork->kemuriTPLvl = 1.0f; + rocketWork->unk3C = 0.0f; + Hu3DModelScaleSet(kemuriMdlId, 1.4f, 1.4f, 1.4f); + obj->func = SpaceAmidaRocketWait; } } -static void fn_1_BF00(omObjData *arg0) +static void SpaceAmidaRocketWait(omObjData *obj) { - Bss720Data *temp_r31; + SpaceAmidaGameWork *work; - temp_r31 = arg0->data; - if (temp_r31->unk1C == 0) { - lbl_1_bss_714[lbl_1_bss_730]->work[2] = 4; - arg0->func = fn_1_BF68; + work = obj->data; + if (work->waitTime == 0) { + rocketObj[spaceAmidaPath]->work[2] = 4; + obj->func = SpaceAmidaRocketUp; } else { - temp_r31->unk1C--; + work->waitTime--; } } -static void fn_1_BF68(omObjData *arg0) +static void SpaceAmidaRocketUp(omObjData *obj) { - Bss720Data *sp8; + SpaceAmidaGameWork *work; - sp8 = arg0->data; - if (lbl_1_bss_714[lbl_1_bss_730]->work[2] == 6) { - lbl_1_bss_75C = HuPrcCreate(fn_1_C000, 0x2004, 0x1000, 0); - lbl_1_bss_75C->user_data = arg0; - arg0->func = NULL; + work = obj->data; + if (rocketObj[spaceAmidaPath]->work[2] == 6) { + coinWinProc = HuPrcCreate(SpaceAmidaCoinWin, 0x2004, 0x1000, 0); + coinWinProc->user_data = obj; + obj->func = NULL; } } -static void fn_1_C000(void) +static void SpaceAmidaCoinWin(void) { - char sp8[16]; // array size may range between 1 and 16 (inclusive) - omObjData *temp_r30; - Bss720Data *temp_r31; + char mess[16]; // array size may range between 1 and 16 (inclusive) + omObjData *obj; + SpaceAmidaGameWork *work; BoardAudSeqFadeOut(1, 100); - sprintf(&sp8, "%d", lbl_1_bss_728); + sprintf(&mess, "%d", spaceAmidaCoinNum); BoardWinCreate(2, MAKE_MESSID(11, 6), 0); - BoardWinInsertMesSet(MAKE_MESSID_PTR(sp8), 0); + BoardWinInsertMesSet(MAKE_MESSID_PTR(mess), 0); BoardWinWait(); BoardWinKill(); - temp_r30 = HuPrcCurrentGet()->user_data; - temp_r31 = temp_r30->data; - temp_r31->unk10.x = 0.0f; - temp_r31->unk10.y = 10.0f; - temp_r31->unk10.z = 3.0f; - temp_r31->unk20 = 0.0f; - BoardPlayerMotionShiftSet(lbl_1_bss_798, 4, 0.0f, 10.0f, HU3D_MOTATTR_NONE); - temp_r30->func = fn_1_C0FC; + obj = HuPrcCurrentGet()->user_data; + work = obj->data; + work->jumpDir.x = 0.0f; + work->jumpDir.y = 10.0f; + work->jumpDir.z = 3.0f; + work->jumpTime = 0.0f; + BoardPlayerMotionShiftSet(spaceAmidaPlayerNo, 4, 0.0f, 10.0f, HU3D_MOTATTR_NONE); + obj->func = SpaceAmidaJumpDown; HuPrcKill(NULL); while (TRUE) { HuPrcVSleep(); } } -static void fn_1_C0FC(omObjData *arg0) +static void SpaceAmidaJumpDown(omObjData *obj) { - Bss720Data *temp_r31; - Vec sp8; + SpaceAmidaGameWork *work; + Vec pos; - temp_r31 = arg0->data; - BoardPlayerPosGet(lbl_1_bss_798, &sp8); - sp8.x += temp_r31->unk10.x; - sp8.y += temp_r31->unk10.y - 0.029166667f * temp_r31->unk20 * temp_r31->unk20; - sp8.z += temp_r31->unk10.z; - temp_r31->unk20 += 1.0f; - if (sp8.y <= lbl_1_bss_738.y) { - BoardPlayerMotionShiftSet(lbl_1_bss_798, 1, 0.0f, 10.0f, HU3D_MOTATTR_LOOP); - sp8.y = lbl_1_bss_738.y; - lbl_1_bss_75C = HuPrcCreate(fn_1_C25C, 0x2004, 0x1000, 0); - lbl_1_bss_75C->user_data = arg0; - arg0->func = NULL; + work = obj->data; + BoardPlayerPosGet(spaceAmidaPlayerNo, &pos); + pos.x += work->jumpDir.x; + pos.y += work->jumpDir.y - 0.029166667f * work->jumpTime * work->jumpTime; + pos.z += work->jumpDir.z; + work->jumpTime += 1.0f; + if (pos.y <= spaceAmidaPos.y) { + BoardPlayerMotionShiftSet(spaceAmidaPlayerNo, 1, 0.0f, 10.0f, HU3D_MOTATTR_LOOP); + pos.y = spaceAmidaPos.y; + coinWinProc = HuPrcCreate(SpaceAmidaCoinRainMain, 0x2004, 0x1000, 0); + coinWinProc->user_data = obj; + obj->func = NULL; } - BoardPlayerPosSetV(lbl_1_bss_798, &sp8); + BoardPlayerPosSetV(spaceAmidaPlayerNo, &pos); } -static void fn_1_C25C(void) +static void SpaceAmidaCoinRainMain(void) { - Vec sp11C[20]; - Vec sp2C[20]; - Vec sp20; - Vec sp14; - Vec sp8; - float var_f31; - s16 var_r30; + Vec coinPos[20]; + Vec coinRot[20]; + Vec playerPos; + Vec scale; + Vec coinEffPos; + float velY; + s16 coinNum; s16 i; - var_r30 = 0; - BoardPlayerPosGet(lbl_1_bss_798, &sp20); - sp14.x = sp14.y = sp14.z = 1.0f; - for (i = 0; i < lbl_1_bss_728; i++) { - BoardModelVisibilitySet(lbl_1_bss_760[i], 1); - sp11C[i] = sp20; - sp11C[i].y += 600.0f + i * 120; - sp11C[i].x += -25.0f + 50.0f * frand8() * 0.003921569f; - sp11C[i].z += -25.0f + 50.0f * frand8() * 0.003921569f; - sp2C[i].x = sp2C[i].z = 0.0f; - sp2C[i].y = 360.0f * frand8() * 0.003921569f; - BoardModelPosSetV(lbl_1_bss_760[i], &sp11C[i]); - BoardModelScaleSetV(lbl_1_bss_760[i], &sp14); - BoardModelRotSetV(lbl_1_bss_760[i], &sp2C[i]); + coinNum = 0; + BoardPlayerPosGet(spaceAmidaPlayerNo, &playerPos); + scale.x = scale.y = scale.z = 1.0f; + for (i = 0; i < spaceAmidaCoinNum; i++) { + BoardModelVisibilitySet(coinMdlId[i], 1); + coinPos[i] = playerPos; + coinPos[i].y += 600.0f + i * 120; + coinPos[i].x += -25.0f + 50.0f * frand8() * 0.003921569f; + coinPos[i].z += -25.0f + 50.0f * frand8() * 0.003921569f; + coinRot[i].x = coinRot[i].z = 0.0f; + coinRot[i].y = 360.0f * frand8() * 0.003921569f; + BoardModelPosSetV(coinMdlId[i], &coinPos[i]); + BoardModelScaleSetV(coinMdlId[i], &scale); + BoardModelRotSetV(coinMdlId[i], &coinRot[i]); } - var_f31 = -1.0f; + velY = -1.0f; while (TRUE) { - for (i = 0; i < lbl_1_bss_728; i++) { - if (i >= var_r30) { - sp11C[i].y += var_f31; - BoardModelPosSetV(lbl_1_bss_760[i], &sp11C[i]); - sp2C[i].y += 45.0f; - if (sp2C[i].y >= 360.0f) { - sp2C[i].y -= 360.0f; + for (i = 0; i < spaceAmidaCoinNum; i++) { + if (i >= coinNum) { + coinPos[i].y += velY; + BoardModelPosSetV(coinMdlId[i], &coinPos[i]); + coinRot[i].y += 45.0f; + if (coinRot[i].y >= 360.0f) { + coinRot[i].y -= 360.0f; } - BoardModelRotSetV(lbl_1_bss_760[i], &sp2C[i]); - if (sp11C[i].y <= sp20.y + 80.0f) { - sp8 = sp11C[i]; - CharModelCoinEffectCreate(1, &sp8); - BoardModelVisibilitySet(lbl_1_bss_760[i], 0); - var_r30++; - BoardPlayerCoinsAdd(lbl_1_bss_798, 1); + BoardModelRotSetV(coinMdlId[i], &coinRot[i]); + if (coinPos[i].y <= playerPos.y + 80.0f) { + Vec pos = coinPos[i]; + CharModelCoinEffectCreate(1, &pos); + BoardModelVisibilitySet(coinMdlId[i], 0); + coinNum++; + BoardPlayerCoinsAdd(spaceAmidaPlayerNo, 1); HuAudFXPlay(7); - omVibrate(lbl_1_bss_798, 0xC, 6, 6); + omVibrate(spaceAmidaPlayerNo, 0xC, 6, 6); } } } - var_f31 *= 1.05f; - if (var_f31 < -20.0f) { - var_f31 = -20.0f; + velY *= 1.05f; + if (velY < -20.0f) { + velY = -20.0f; } - if (var_r30 == lbl_1_bss_728) { - BoardPlayerMotionShiftSet(lbl_1_bss_798, 7, 0.0f, 10.0f, HU3D_MOTATTR_NONE); + if (coinNum == spaceAmidaCoinNum) { + BoardPlayerMotionShiftSet(spaceAmidaPlayerNo, 7, 0.0f, 10.0f, HU3D_MOTATTR_NONE); break; } HuPrcVSleep(); } - while (!BoardPlayerMotionEndCheck(lbl_1_bss_798)) { + while (!BoardPlayerMotionEndCheck(spaceAmidaPlayerNo)) { HuPrcVSleep(); } - lbl_1_bss_75C = HuPrcCreate(fn_1_C844, 0x2004, 0x1000, 0); - lbl_1_bss_75C->user_data = HuPrcCurrentGet()->user_data; + coinWinProc = HuPrcCreate(SpaceAmidaReturnWinMain, 0x2004, 0x1000, 0); + coinWinProc->user_data = HuPrcCurrentGet()->user_data; HuPrcKill(NULL); while (TRUE) { HuPrcVSleep(); } } -static void fn_1_C844(void) +static void SpaceAmidaReturnWinMain(void) { - omObjData *var_r31; + omObjData *obj; BoardWinCreate(2, MAKE_MESSID(11, 7), 0); BoardWinWait(); BoardWinKill(); - var_r31 = HuPrcCurrentGet()->user_data; - var_r31->func = fn_1_C894; + obj = HuPrcCurrentGet()->user_data; + obj->func = SpaceAmidaGameStop; HuPrcKill(NULL); while (TRUE) { HuPrcVSleep(); } } -static void fn_1_C894(omObjData *arg0) +static void SpaceAmidaGameStop(omObjData *obj) { - float temp_f31; - - lbl_1_bss_72A = 1; - BoardMGExit(); - temp_f31 = BoardModelMotionTimeGet(lbl_1_bss_796); - lbl_1_bss_754 = temp_f31; - BoardModelMotionStart(lbl_1_bss_796, 0, 0); - BoardModelMotionTimeSet(lbl_1_bss_796, temp_f31); - BoardModelMotionSpeedSet(lbl_1_bss_796, -1.0f); - omDelObjEx(HuPrcCurrentGet(), arg0); + SpaceAmidaStop(); + omDelObjEx(HuPrcCurrentGet(), obj); } -static void fn_1_C94C(Vec *arg0, Vec *arg1, Vec *arg2) +static void SpaceAmidaDirGet(Vec *b, Vec *a, Vec *result) { - VECSubtract(arg1, arg0, arg2); - VECNormalize(arg2, arg2); + VECSubtract(a, b, result); + VECNormalize(result, result); } -static float fn_1_C998(Vec *arg0) +static float SpaceAmidaAngleGet(Vec *dir) { - float temp_f31; + float angle; - if (arg0->x || arg0->z) { - if (arg0->x == 0.0f) { - if (arg0->z > 0.0f) { + if (dir->x || dir->z) { + if (dir->x == 0.0f) { + if (dir->z > 0.0f) { return 0.0f; } else { return 180.0f; } } - if (arg0->z == 0.0f) { - if (arg0->x > 0.0f) { + if (dir->z == 0.0f) { + if (dir->x > 0.0f) { return 90.0f; } else { return 270.0f; } } - temp_f31 = atan2d(arg0->z, arg0->x); - if (arg0->z < 0.0f) { - temp_f31 = 90.0f - temp_f31; + angle = atan2d(dir->z, dir->x); + if (dir->z < 0.0f) { + angle = 90.0f - angle; } else { - temp_f31 = 90.0f - temp_f31; - if (temp_f31 < 0.0f) { - temp_f31 += 360.0f; + angle = 90.0f - angle; + if (angle < 0.0f) { + angle += 360.0f; } } - return temp_f31; + return angle; } return -1.0f; } -static u32 fn_1_CB44(Vec *arg0, float arg1) +static u32 SpaceAmidaPlayerRotAdd(Vec *rocketPos, float delta) { - Vec sp24; - Vec sp18; - Vec spC; - float var_f28; - float var_f30; - float var_f31; + Vec dir; + Vec playerPos; + Vec playerRot; + float rocketAngle; + float angleDelta; + float rotY; - BoardPlayerPosGet(lbl_1_bss_798, &sp18); - VECSubtract(arg0, &sp18, &sp24); - VECNormalize(&sp24, &sp24); - var_f28 = fn_1_C998(&sp24); - BoardPlayerRotGet(lbl_1_bss_798, &spC); - var_f31 = spC.y; - var_f30 = var_f28 - var_f31; - if (arg1 == 0.0f) { - var_f31 = var_f28; + BoardPlayerPosGet(spaceAmidaPlayerNo, &playerPos); + SpaceAmidaDirGet(&playerPos, rocketPos, &dir); + rocketAngle = SpaceAmidaAngleGet(&dir); + BoardPlayerRotGet(spaceAmidaPlayerNo, &playerRot); + rotY = playerRot.y; + angleDelta = rocketAngle - rotY; + if (delta == 0.0f) { + rotY = rocketAngle; } - else if (fabs(var_f30) > arg1) { - if (var_f30 < 0.0f) { - var_f30 += 360.0f; + else if (fabs(angleDelta) > delta) { + if (angleDelta < 0.0f) { + angleDelta += 360.0f; } - if (var_f30 < 180.0f) { - if (var_f30 > arg1) { - var_f31 += arg1; + if (angleDelta < 180.0f) { + if (angleDelta > delta) { + rotY += delta; } else { - var_f31 += var_f30; + rotY += angleDelta; } } - else if (360.0f - var_f30 > arg1) { - var_f31 -= arg1; + else if (360.0f - angleDelta > delta) { + rotY -= delta; } else { - var_f31 -= 360.0f - var_f30; + rotY -= 360.0f - angleDelta; } } else { - var_f31 = var_f28; + rotY = rocketAngle; } - if (var_f31 >= 360.0f) { - var_f31 -= 360.0f; + if (rotY >= 360.0f) { + rotY -= 360.0f; } - if (var_f31 < 0.0f) { - var_f31 += 360.0f; + if (rotY < 0.0f) { + rotY += 360.0f; } - BoardPlayerRotYSet(lbl_1_bss_798, var_f31); - if (var_f31 == var_f28) { - return 1; + BoardPlayerRotYSet(spaceAmidaPlayerNo, rotY); + if (rotY == rocketAngle) { + return TRUE; } else { - return 0; + return FALSE; } } -static void fn_1_CEC4(void) +static void SpaceAmidaEffCreate(void) { - lbl_1_bss_70C = HuSprAnimReadFile(DATA_MAKE_NUM(DATADIR_W01, 20)); - lbl_1_bss_710 = omAddObjEx(boardObjMan, 0x101, 1, 0, -1, fn_1_D07C); - lbl_1_bss_710->data = HuMemDirectMallocNum(HEAP_SYSTEM, 12, MEMORY_DEFAULT_NUM); - lbl_1_bss_710->model[0] = Hu3DParticleCreate(lbl_1_bss_70C, 0x320); - Hu3DParticleColSet(lbl_1_bss_710->model[0], 0xFF, 0, 0); - Hu3DParticleScaleSet(lbl_1_bss_710->model[0], 5.0f); - Hu3DParticleHookSet(lbl_1_bss_710->model[0], fn_1_D114); - Hu3DParticleBlendModeSet(lbl_1_bss_710->model[0], 1); - Hu3DModelAttrSet(lbl_1_bss_710->model[0], HU3D_ATTR_DISPOFF); - lbl_1_bss_710->work[0] = 0; + spaceAmidaEffAnim = HuSprAnimReadFile(DATA_MAKE_NUM(DATADIR_W01, 20)); + spaceAmidaEffObj = omAddObjEx(boardObjMan, 0x101, 1, 0, -1, SpaceAmidaEffUpdate); + spaceAmidaEffObj->data = HuMemDirectMallocNum(HEAP_SYSTEM, 12, MEMORY_DEFAULT_NUM); + spaceAmidaEffObj->model[0] = Hu3DParticleCreate(spaceAmidaEffAnim, 0x320); + Hu3DParticleColSet(spaceAmidaEffObj->model[0], 255, 0, 0); + Hu3DParticleScaleSet(spaceAmidaEffObj->model[0], 5.0f); + Hu3DParticleHookSet(spaceAmidaEffObj->model[0], SpaceAmidaEffParticleHook); + Hu3DParticleBlendModeSet(spaceAmidaEffObj->model[0], 1); + Hu3DModelAttrSet(spaceAmidaEffObj->model[0], HU3D_ATTR_DISPOFF); + spaceAmidaEffObj->work[0] = 0; } -static void fn_1_D034(void) +static void SpaceAmidaEffKill(void) { - Hu3DModelKill(lbl_1_bss_710->model[0]); - omDelObjEx(HuPrcCurrentGet(), lbl_1_bss_710); + Hu3DModelKill(spaceAmidaEffObj->model[0]); + omDelObjEx(HuPrcCurrentGet(), spaceAmidaEffObj); } -static void fn_1_D07C(omObjData *arg0) +static void SpaceAmidaEffUpdate(omObjData *obj) { - void *sp8; + void *work; - sp8 = arg0->data; - switch (arg0->work[0]) { + work = obj->data; + switch (obj->work[0]) { case 0: break; case 1: - arg0->work[0] = 2; - Hu3DModelAttrReset(arg0->model[0], HU3D_ATTR_DISPOFF); - Hu3DModelScaleSet(arg0->model[0], 10.0f, 10.0f, 10.0f); + obj->work[0] = 2; + Hu3DModelAttrReset(obj->model[0], HU3D_ATTR_DISPOFF); + Hu3DModelScaleSet(obj->model[0], 10.0f, 10.0f, 10.0f); break; case 2: break; } } -static void fn_1_D114(ModelData *model, ParticleData *particle, Mtx matrix) +static void SpaceAmidaEffParticleHook(ModelData *model, ParticleData *particle, Mtx matrix) { - Bss714Data *temp_r28; - HsfanimStruct01 *var_r31; - Vec sp8; - float temp_f31; + RocketWork *work; + HsfanimStruct01 *particleDataP; + Vec pos; + float size; s32 i; s32 j; - s32 temp_r26; + s32 relSize; - BoardModelPosGet(lbl_1_bss_714[lbl_1_bss_730]->work[0], &sp8); - temp_r28 = lbl_1_bss_714[lbl_1_bss_730]->data; + BoardModelPosGet(rocketObj[spaceAmidaPath]->work[0], &pos); + work = rocketObj[spaceAmidaPath]->data; if (particle->unk_34 == 0) { - var_r31 = particle->unk_48; - for (i = 0; i < particle->unk_30; i++, var_r31++) { - var_r31->unk2C = 0.0f; + particleDataP = particle->unk_48; + for (i = 0; i < particle->unk_30; i++, particleDataP++) { + particleDataP->unk2C = 0.0f; } particle->unk_1C = (void *)1; } - if (temp_r28->unk1C > 0.0f) { - for (i = 0; i < 80.0f * temp_r28->unk1C; i++) { - var_r31 = particle->unk_48; - for (j = 0; j < particle->unk_30; j++, var_r31++) { - if (var_r31->unk2C == 0.0f) { + if (work->kemuriSize > 0.0f) { + for (i = 0; i < 80.0f * work->kemuriSize; i++) { + particleDataP = particle->unk_48; + for (j = 0; j < particle->unk_30; j++, particleDataP++) { + if (particleDataP->unk2C == 0.0f) { break; } } if (j != particle->unk_30) { - temp_r26 = frand16(); - temp_f31 = (-15.0f + 30.0f * (temp_r26 / 65536.0f)) * temp_r28->unk1C; - var_r31->unk08.x = sp8.x + temp_f31; - var_r31->unk08.y = sp8.y; - var_r31->unk08.z = sp8.z; - var_r31->unk14.x = 255.0f; - var_r31->unk14.y = 155.0f; - var_r31->unk14.z = 55.0f; - var_r31->unk40.a = 0xFF; - var_r31->unk20 = 0.0f; - var_r31->unk24 = temp_r28->unk1C * (-3.0 + (2.0 * (fabs(temp_f31) / 15.0))); - var_r31->unk28 = 0.0f; - var_r31->unk2C = 7.3f; + relSize = frand16(); + size = (-15.0f + 30.0f * (relSize / 65536.0f)) * work->kemuriSize; + particleDataP->unk08.x = pos.x + size; + particleDataP->unk08.y = pos.y; + particleDataP->unk08.z = pos.z; + particleDataP->unk14.x = 255.0f; + particleDataP->unk14.y = 155.0f; + particleDataP->unk14.z = 55.0f; + particleDataP->unk40.a = 0xFF; + particleDataP->unk20 = 0.0f; + particleDataP->unk24 = work->kemuriSize * (-3.0 + (2.0 * (fabs(size) / 15.0))); + particleDataP->unk28 = 0.0f; + particleDataP->unk2C = 7.3f; } } } - var_r31 = particle->unk_48; - for (i = 0; i < particle->unk_30; i++, var_r31++) { - if (var_r31->unk2C == 0.0f) { + particleDataP = particle->unk_48; + for (i = 0; i < particle->unk_30; i++, particleDataP++) { + if (particleDataP->unk2C == 0.0f) { continue; } - var_r31->unk34.x = var_r31->unk08.x; - var_r31->unk34.y = var_r31->unk08.y; - var_r31->unk34.z = var_r31->unk08.z; - var_r31->unk08.x += var_r31->unk20; - var_r31->unk08.y += var_r31->unk24; - var_r31->unk08.z += var_r31->unk28; - if (var_r31->unk08.y <= lbl_1_bss_738.y) { - var_r31->unk08.y = lbl_1_bss_738.y; - var_r31->unk24 = -var_r31->unk24 - 0.3f; - if (var_r31->unk24 < 0.0f) { - var_r31->unk24 = 0.0f; + particleDataP->unk34.x = particleDataP->unk08.x; + particleDataP->unk34.y = particleDataP->unk08.y; + particleDataP->unk34.z = particleDataP->unk08.z; + particleDataP->unk08.x += particleDataP->unk20; + particleDataP->unk08.y += particleDataP->unk24; + particleDataP->unk08.z += particleDataP->unk28; + if (particleDataP->unk08.y <= spaceAmidaPos.y) { + particleDataP->unk08.y = spaceAmidaPos.y; + particleDataP->unk24 = -particleDataP->unk24 - 0.3f; + if (particleDataP->unk24 < 0.0f) { + particleDataP->unk24 = 0.0f; } - temp_r26 = 80.0f * (2.0f * ((sp8.x - var_r31->unk08.x) / 15.0f) - rand8() / 255.0f); - var_r31->unk20 = 8.0 * sind(temp_r26); - var_r31->unk28 = 8.0 * cosd(temp_r26); + relSize = 80.0f * (2.0f * ((pos.x - particleDataP->unk08.x) / 15.0f) - rand8() / 255.0f); + particleDataP->unk20 = 8.0 * sind(relSize); + particleDataP->unk28 = 8.0 * cosd(relSize); } - var_r31->unk24 -= 0.35f; - if ((var_r31->unk14.x -= 25.5f) < 0.0f) { - var_r31->unk14.x = 0.0f; + particleDataP->unk24 -= 0.35f; + if ((particleDataP->unk14.x -= 25.5f) < 0.0f) { + particleDataP->unk14.x = 0.0f; } - if ((var_r31->unk14.y -= 36.42857f) < 0.0f) { - var_r31->unk14.y = 0.0f; + if ((particleDataP->unk14.y -= 36.42857f) < 0.0f) { + particleDataP->unk14.y = 0.0f; } - if ((var_r31->unk14.z -= 63.75f) < 0.0f) { - var_r31->unk14.z = 0.0f; + if ((particleDataP->unk14.z -= 63.75f) < 0.0f) { + particleDataP->unk14.z = 0.0f; } - var_r31->unk40.r = var_r31->unk14.x; - var_r31->unk40.g = var_r31->unk14.y; - var_r31->unk40.b = var_r31->unk14.z; - if (var_r31->unk40.r == 0 && var_r31->unk40.g == 0 && var_r31->unk40.b == 0) { - var_r31->unk2C = 0.0f; + particleDataP->unk40.r = particleDataP->unk14.x; + particleDataP->unk40.g = particleDataP->unk14.y; + particleDataP->unk40.b = particleDataP->unk14.z; + if (particleDataP->unk40.r == 0 && particleDataP->unk40.g == 0 && particleDataP->unk40.b == 0) { + particleDataP->unk2C = 0.0f; } } } diff --git a/src/REL/w01Dll/mg_item.c b/src/REL/w01Dll/mg_item.c index 6830c410..6a61927a 100755 --- a/src/REL/w01Dll/mg_item.c +++ b/src/REL/w01Dll/mg_item.c @@ -25,63 +25,63 @@ #include "dolphin.h" #include "ext_math.h" -static void fn_1_E100(void); -static void fn_1_E154(void); -static void fn_1_E2B8(omObjData *arg0); -static void fn_1_E44C(omObjData *arg0); -static void fn_1_E914(omObjData *arg0); -static void fn_1_ECD4(omObjData *arg0); -static void fn_1_EEA0(omObjData *arg0, u16 *arg1); -static void fn_1_EED8(omObjData *arg0); -static void fn_1_F09C(omObjData *arg0); -static void fn_1_F348(omObjData *arg0); -static void fn_1_F3F8(omObjData *arg0); -static void fn_1_F6E8(omObjData *arg0); -static void fn_1_F890(omObjData *arg0); -static void fn_1_FA1C(omObjData *arg0); -static void fn_1_FABC(omObjData *arg0); -static void fn_1_FB58(void); -static void fn_1_FC3C(omObjData *arg0); -static void fn_1_FCEC(void); -static void fn_1_FD3C(omObjData *arg0); -static void fn_1_FE44(omObjData *arg0); -static void fn_1_FED0(omObjData *arg0); -static s16 fn_1_1001C(u32 arg0); -static void fn_1_101B8(s16 arg0); -static void fn_1_10664(omObjData *arg0); -static void fn_1_10820(omObjData *arg0); -static void fn_1_10AE8(omObjData *arg0); -static float fn_1_10BB0(u32 arg0); -static void fn_1_10CF0(u32 arg0); -static float fn_1_10EB8(Vec *arg0); -static void fn_1_11064(ModelData *model, ParticleData *particle, Mtx matrix); -static void fn_1_11484(ModelData *model, ParticleData *particle, Mtx matrix); +static void RoundItemEnd(void); +static void RoundItemClose(void); +static void RoundItemMainUpdate(omObjData *obj); +static void RoundItemUmaStop(omObjData *obj); +static void RoundItemPlayerJump(omObjData *obj); +static void RoundItemStartWait(omObjData *obj); +static void RoundItemComInputGet(omObjData *obj, u16 *btn); +static void RoundItemInputWait(omObjData *obj); +static void RoundItemStop(omObjData *obj); +static void RoundItemLightFlicker(omObjData *obj); +static void RoundItemUmaJumpWait(omObjData *obj); +static void RoundItemUmaJump(omObjData *obj); +static void RoundItemRotatePlayer(omObjData *obj); +static void RoundItemStreamWait(omObjData *obj); +static void RoundItemWinWait(omObjData *obj); +static void ItemGetWinExec(void); +static void ItemGetShrinkWait(omObjData *obj); +static void ItemGetReturnWinExec(void); +static void RoundItemGameClose(omObjData *obj); +static void RoundItemGameEnd(omObjData *obj); +static void RoundItemItemUpdate(omObjData *obj); +static s16 RoundItemItemGet(u32 umaNo); +static void ItemGetCreate(s16 itemNo); +static void ItemGetObjUpdate(omObjData *obj); +static void ItemGetPlayerMove(omObjData *obj); +static void ItemGetShrink(omObjData *obj); +static float RoundItemUmaRotYGet(u32 umaNo); +static void RoundItemUmaPlayerSet(u32 umaNo); +static float RoundItemAngleGet(Vec *arg0); +static void ItemGetEff1Hook(ModelData *model, ParticleData *particle, Mtx matrix); +static void ItemGetEff2Hook(ModelData *model, ParticleData *particle, Mtx matrix); -static void *lbl_1_bss_818; -static Vec lbl_1_bss_80C; -static omObjData *lbl_1_bss_7FC[4]; -static omObjData *lbl_1_bss_7F8; -static omObjData *lbl_1_bss_7F4; -static omObjData *lbl_1_bss_7F0; -static float lbl_1_bss_7EC; -static float lbl_1_bss_7E8; -static s32 lbl_1_bss_7E4; -static Vec lbl_1_bss_7D8; -static s16 lbl_1_bss_7D6; -static s16 lbl_1_bss_7D4; -static s16 lbl_1_bss_7D2; -static s16 lbl_1_bss_7D0; -static Vec lbl_1_bss_7C4; +static void *itemAnim; +static Vec roundItemPos; +static omObjData *itemObj[4]; +static omObjData *roundItemUmaObj; +static omObjData *roundItemMainObj; +static omObjData *itemGetObj; +static float umaSpeed; +static float borderSpeed; +static s32 roundItemPlayer; +static Vec umaPos; +static s16 seqStartId; +static s16 timerSeqId; +static s16 timerSec; +static s16 timerFrame; +static Vec roundItemPlayerPos; static s32 lbl_1_bss_7C0_pad; -static s32 lbl_1_bss_7BC; -static s32 lbl_1_bss_7B8; -static s16 lbl_1_bss_7B4; +static s32 itemGetMotId; +static s32 jumpMotId; +static s16 umaStopF; static s32 lbl_1_bss_7B0_pad; -static s32 lbl_1_bss_7AC; -static s16 lbl_1_bss_7AA; -static s16 lbl_1_bss_7A8; -static s32 lbl_1_bss_7A4; -static AnimData *lbl_1_bss_7A0; +static s32 itemGetSeNo; +static s16 roundItemStopF; +static s16 umaStopTimer; +static s32 roundItemStreamId; +static AnimData *roundItemEffAnim; #if VERSION_JP #define MDL_ID_SHIFT 0 @@ -89,7 +89,7 @@ static AnimData *lbl_1_bss_7A0; #define MDL_ID_SHIFT 1 #endif -static s32 lbl_1_data_F08[] = { +static s32 itemMdlTbl[] = { DATA_MAKE_NUM(DATADIR_BOARD, 108 + MDL_ID_SHIFT), DATA_MAKE_NUM(DATADIR_BOARD, 109 + MDL_ID_SHIFT), DATA_MAKE_NUM(DATADIR_BOARD, 110 + MDL_ID_SHIFT), @@ -106,884 +106,856 @@ static s32 lbl_1_data_F08[] = { DATA_MAKE_NUM(DATADIR_BOARD, 122 + MDL_ID_SHIFT), }; -static s32 lbl_1_data_F40[8] = { DATA_MAKE_NUM(DATADIR_MARIOMOT, 23), DATA_MAKE_NUM(DATADIR_LUIGIMOT, 23), DATA_MAKE_NUM(DATADIR_PEACHMOT, 23), +static s32 itemGetMotTbl[8] = { DATA_MAKE_NUM(DATADIR_MARIOMOT, 23), DATA_MAKE_NUM(DATADIR_LUIGIMOT, 23), DATA_MAKE_NUM(DATADIR_PEACHMOT, 23), DATA_MAKE_NUM(DATADIR_YOSHIMOT, 23), DATA_MAKE_NUM(DATADIR_WARIOMOT, 23), DATA_MAKE_NUM(DATADIR_DONKEYMOT, 23), DATA_MAKE_NUM(DATADIR_DAISYMOT, 23), DATA_MAKE_NUM(DATADIR_WALUIGIMOT, 23) }; -static s32 lbl_1_data_F60[8] = { DATA_MAKE_NUM(DATADIR_MARIOMOT, 64), DATA_MAKE_NUM(DATADIR_LUIGIMOT, 64), DATA_MAKE_NUM(DATADIR_PEACHMOT, 64), +static s32 jumpMotTbl[8] = { DATA_MAKE_NUM(DATADIR_MARIOMOT, 64), DATA_MAKE_NUM(DATADIR_LUIGIMOT, 64), DATA_MAKE_NUM(DATADIR_PEACHMOT, 64), DATA_MAKE_NUM(DATADIR_YOSHIMOT, 64), DATA_MAKE_NUM(DATADIR_WARIOMOT, 64), DATA_MAKE_NUM(DATADIR_DONKEYMOT, 64), DATA_MAKE_NUM(DATADIR_DAISYMOT, 64), DATA_MAKE_NUM(DATADIR_WALUIGIMOT, 64) }; -void fn_1_D740(s16 *arg0) +void RoundItemInit(s16 *itemTbl) { - s16 sp10[14]; - s16 sp8[4]; - float temp_f30; - float temp_f29; - float var_f31; - s32 var_r28; - s32 var_r30; + s16 itemOrderTbl[14]; + s16 itemMdlId[4]; + float borderTime; + float borderMaxTime; + float itemAngle; + s32 itemOrderNum; + s32 itemNum; s32 i; s32 j; - lbl_1_bss_818 = HuDataSelHeapReadNum(DATA_MAKE_NUM(DATADIR_W01, 28), MEMORY_DEFAULT_NUM, HEAP_DATA); - BoardModelPosGet(lbl_1_bss_6C4[16], &lbl_1_bss_80C); - sp8[0] = BoardModelIDGet(lbl_1_bss_6C4[19]); - BoardModelVisibilitySet(lbl_1_bss_6C4[19], 1); + itemAnim = HuDataSelHeapReadNum(DATA_MAKE_NUM(DATADIR_W01, 28), MEMORY_DEFAULT_NUM, HEAP_DATA); + BoardModelPosGet(mapObjMdlId[MAPOBJ_ROUNDITEM], &roundItemPos); + itemMdlId[0] = BoardModelIDGet(mapObjMdlId[MAPOBJ_ROUNDITEM_ITEM]); + BoardModelVisibilitySet(mapObjMdlId[MAPOBJ_ROUNDITEM_ITEM], 1); for (i = 1; i < 4; i++) { - sp8[i] = Hu3DModelCreateFile(DATA_MAKE_NUM(DATADIR_W01, 24)); + itemMdlId[i] = Hu3DModelCreateFile(DATA_MAKE_NUM(DATADIR_W01, 24)); } - var_r30 = 0; + itemNum = 0; for (i = 0; i < 4; i++) { - lbl_1_bss_7FC[i] = omAddObjEx(boardObjMan, 0x165, 2, 0, -1, NULL); - if (arg0[i] != -1) { - lbl_1_bss_7FC[var_r30++]->work[1] = arg0[i]; + itemObj[i] = omAddObjEx(boardObjMan, 0x165, 2, 0, -1, NULL); + if (itemTbl[i] != -1) { + itemObj[itemNum++]->work[1] = itemTbl[i]; } } - while (var_r30 != 4) { - var_r28 = 0; + while (itemNum != 4) { + itemOrderNum = 0; for (i = 0; i < 14; i++) { - for (j = 0; j < var_r30; j++) { - if (i == lbl_1_bss_7FC[j]->work[1]) { + for (j = 0; j < itemNum; j++) { + if (i == itemObj[j]->work[1]) { break; } } - if (j == var_r30) { - sp10[var_r28++] = i; + if (j == itemNum) { + itemOrderTbl[itemOrderNum++] = i; } } - lbl_1_bss_7FC[var_r30++]->work[1] = sp10[rand8() % var_r28]; + itemObj[itemNum++]->work[1] = itemOrderTbl[rand8() % itemOrderNum]; } - temp_f30 = BoardModelMotionTimeGet(lbl_1_bss_6C4[18]); - temp_f29 = BoardModelMotionMaxTimeGet(lbl_1_bss_6C4[18]); + borderTime = BoardModelMotionTimeGet(mapObjMdlId[MAPOBJ_ROUNDITEM_BORDER]); + borderMaxTime = BoardModelMotionMaxTimeGet(mapObjMdlId[MAPOBJ_ROUNDITEM_BORDER]); for (i = 0; i < 4; i++) { - lbl_1_bss_7FC[i]->model[0] = sp8[i]; - lbl_1_bss_7FC[i]->model[1] = Hu3DModelCreateFile(lbl_1_data_F08[lbl_1_bss_7FC[i]->work[1]]); - if (lbl_1_bss_7FC[i]->work[1] == 5) { - Hu3DData[lbl_1_bss_7FC[i]->model[1]].unk_F0[1][3] = -50.0f; + itemObj[i]->model[0] = itemMdlId[i]; + itemObj[i]->model[1] = Hu3DModelCreateFile(itemMdlTbl[itemObj[i]->work[1]]); + if (itemObj[i]->work[1] == 5) { + Hu3DData[itemObj[i]->model[1]].unk_F0[1][3] = -50.0f; } - if (lbl_1_bss_7FC[i]->work[1] == 11) { - Hu3DModelAttrSet(lbl_1_bss_7FC[i]->model[1], HU3D_MOTATTR_LOOP); + if (itemObj[i]->work[1] == 11) { + Hu3DModelAttrSet(itemObj[i]->model[1], HU3D_MOTATTR_LOOP); } - if (lbl_1_bss_7FC[i]->work[1] == 4) { - Hu3DMotionSpeedSet(lbl_1_bss_7FC[i]->model[1], 0.0f); + if (itemObj[i]->work[1] == 4) { + Hu3DMotionSpeedSet(itemObj[i]->model[1], 0.0f); } - Hu3DModelAttrReset(sp8[i], HU3D_ATTR_DISPOFF); - Hu3DModelAttrSet(lbl_1_bss_7FC[i]->model[1], HU3D_ATTR_DISPOFF); - Hu3DModelAttrSet(lbl_1_bss_7FC[i]->model[1], HU3D_MOTATTR_PAUSE); - omSetTra(lbl_1_bss_7FC[i], lbl_1_bss_80C.x, lbl_1_bss_80C.y + 66.0f, lbl_1_bss_80C.z); - var_f31 = 90.0f - 90.0f * i + 360.0f * (temp_f30 / temp_f29); - if (var_f31 >= 360.0f) { - var_f31 -= 360.0f; + Hu3DModelAttrReset(itemMdlId[i], HU3D_ATTR_DISPOFF); + Hu3DModelAttrSet(itemObj[i]->model[1], HU3D_ATTR_DISPOFF); + Hu3DModelAttrSet(itemObj[i]->model[1], HU3D_MOTATTR_PAUSE); + omSetTra(itemObj[i], roundItemPos.x, roundItemPos.y + 66.0f, roundItemPos.z); + itemAngle = 90.0f - 90.0f * i + 360.0f * (borderTime / borderMaxTime); + if (itemAngle >= 360.0f) { + itemAngle -= 360.0f; } - if (var_f31 < 0.0f) { - var_f31 += 360.0f; + if (itemAngle < 0.0f) { + itemAngle += 360.0f; } - omSetRot(lbl_1_bss_7FC[i], 0.0f, var_f31, 0.0f); - lbl_1_bss_7FC[i]->work[0] = Hu3DAnimCreate(lbl_1_bss_818, lbl_1_bss_7FC[i]->model[0], "item01"); - Hu3DAnimAttrSet(lbl_1_bss_7FC[i]->work[0], 1); - lbl_1_bss_7FC[i]->work[2] = i; + omSetRot(itemObj[i], 0.0f, itemAngle, 0.0f); + itemObj[i]->work[0] = Hu3DAnimCreate(itemAnim, itemObj[i]->model[0], "item01"); + Hu3DAnimAttrSet(itemObj[i]->work[0], 1); + itemObj[i]->work[2] = i; } for (i = 0; i < 4; i++) { - Hu3DAnmNoSet(lbl_1_bss_7FC[i]->work[0], lbl_1_bss_7FC[i]->work[1]); + Hu3DAnmNoSet(itemObj[i]->work[0], itemObj[i]->work[1]); } } -void fn_1_DD84(void) +void RoundItemKill(void) { s32 i; for (i = 0; i < 4; i++) { if (i != 0) { - Hu3DModelKill(lbl_1_bss_7FC[i]->model[0]); + Hu3DModelKill(itemObj[i]->model[0]); } else { - BoardModelVisibilitySet(lbl_1_bss_6C4[19], 0); - Hu3DAnimKill(lbl_1_bss_7FC[i]->work[0]); + BoardModelVisibilitySet(mapObjMdlId[MAPOBJ_ROUNDITEM_ITEM], 0); + Hu3DAnimKill(itemObj[i]->work[0]); } - Hu3DModelKill(lbl_1_bss_7FC[i]->model[1]); - omDelObjEx(boardObjMan, lbl_1_bss_7FC[i]); + Hu3DModelKill(itemObj[i]->model[1]); + omDelObjEx(boardObjMan, itemObj[i]); } - if (lbl_1_bss_7A0) { - HuSprAnimKill(lbl_1_bss_7A0); - lbl_1_bss_7A0 = NULL; + if (roundItemEffAnim) { + HuSprAnimKill(roundItemEffAnim); + roundItemEffAnim = NULL; } } -void fn_1_DE94(void) +void RoundItemEventStart(void) { s32 i; - BoardModelPosGet(lbl_1_bss_6C4[16], &lbl_1_bss_80C); + BoardModelPosGet(mapObjMdlId[MAPOBJ_ROUNDITEM], &roundItemPos); for (i = 0; i < 4; i++) { - lbl_1_bss_7FC[i]->func = fn_1_FED0; + itemObj[i]->func = RoundItemItemUpdate; } - lbl_1_bss_7F4 = omAddObjEx(boardObjMan, 0x101, 0, 0, -1, fn_1_E2B8); - lbl_1_bss_7F8 = omAddObjEx(boardObjMan, 0x133, 0, 0, -1, fn_1_E44C); - lbl_1_bss_7F8->work[3] = rand8() % 200 + 10; - lbl_1_bss_7E4 = GWSystem.player_curr; - BoardPlayerPosGet(lbl_1_bss_7E4, &lbl_1_bss_7C4); - lbl_1_bss_7EC = 1.0f; - lbl_1_bss_7E8 = 1.0f; - lbl_1_bss_7AA = 0; - lbl_1_bss_7BC = BoardPlayerMotionCreate(lbl_1_bss_7E4, lbl_1_data_F40[GWPlayer[lbl_1_bss_7E4].character]); - lbl_1_bss_7B8 = BoardPlayerMotionCreate(lbl_1_bss_7E4, lbl_1_data_F60[GWPlayer[lbl_1_bss_7E4].character]); - lbl_1_bss_7A0 = HuSprAnimReadFile(DATA_MAKE_NUM(DATADIR_EFFECT, 0)); - HuSprAnimLock(lbl_1_bss_7A0); - lbl_1_bss_7B4 = 0; + roundItemMainObj = omAddObjEx(boardObjMan, 0x101, 0, 0, -1, RoundItemMainUpdate); + roundItemUmaObj = omAddObjEx(boardObjMan, 0x133, 0, 0, -1, RoundItemUmaStop); + roundItemUmaObj->work[3] = rand8() % 200 + 10; + roundItemPlayer = GWSystem.player_curr; + BoardPlayerPosGet(roundItemPlayer, &roundItemPlayerPos); + umaSpeed = 1.0f; + borderSpeed = 1.0f; + roundItemStopF = 0; + itemGetMotId = BoardPlayerMotionCreate(roundItemPlayer, itemGetMotTbl[GWPlayer[roundItemPlayer].character]); + jumpMotId = BoardPlayerMotionCreate(roundItemPlayer, jumpMotTbl[GWPlayer[roundItemPlayer].character]); + roundItemEffAnim = HuSprAnimReadFile(DATA_MAKE_NUM(DATADIR_EFFECT, 0)); + HuSprAnimLock(roundItemEffAnim); + umaStopF = 0; } -static void fn_1_E100(void) +static void RoundItemEnd(void) { - lbl_1_bss_7AA = 1; + roundItemStopF = 1; BoardMGExit(); HuAudFXPlay(0x40F); - BoardModelMotionStart(lbl_1_bss_6C4[21], 0, 0x40000004); + BoardModelMotionStart(mapObjMdlId[MAPOBJ_ROUNDITEM_ITEM_UP], 0, HU3D_MOTATTR_REV); } -static void fn_1_E154(void) +static void RoundItemClose(void) { - fn_1_DD84(); - BoardPlayerMotionKill(lbl_1_bss_7E4, lbl_1_bss_7BC); - BoardPlayerMotionKill(lbl_1_bss_7E4, lbl_1_bss_7B8); - BoardModelVisibilitySet(lbl_1_bss_6C4[20], 0); + RoundItemKill(); + BoardPlayerMotionKill(roundItemPlayer, itemGetMotId); + BoardPlayerMotionKill(roundItemPlayer, jumpMotId); + BoardModelVisibilitySet(mapObjMdlId[MAPOBJ_ROUNDITEM_ITEM_LIGHT], 0); BoardMGDoneFlagSet(0); } -static void fn_1_E2B8(omObjData *arg0) +static void RoundItemMainUpdate(omObjData *obj) { - if (lbl_1_bss_7AA == 1 && BoardMGDoneFlagGet() == 1) { - fn_1_E154(); - omDelObjEx(HuPrcCurrentGet(), arg0); + if (roundItemStopF == 1 && BoardMGDoneFlagGet() == 1) { + RoundItemClose(); + omDelObjEx(HuPrcCurrentGet(), obj); } } -static char *lbl_1_data_F9C[] = { "uma1", "uma2", "uma3", "uma4" }; +static char *umaHookTbl[] = { "uma1", "uma2", "uma3", "uma4" }; -static void fn_1_E44C(omObjData *arg0) +static void RoundItemUmaStop(omObjData *obj) { - Vec sp18; - Vec spC; - float temp_f27; - float var_f29; - float temp_f28; - float var_f26; - float var_f24; + Vec playerPos; + Vec objPos; + float umaDist; + float motTime; + float motMaxTime; + float umaMinDist; s32 i; - temp_f28 = BoardModelMotionMaxTimeGet(lbl_1_bss_6C4[17]); - var_f29 = BoardModelMotionTimeGet(lbl_1_bss_6C4[17]); - if (var_f29 >= temp_f28) { - var_f29 -= temp_f28; + motMaxTime = BoardModelMotionMaxTimeGet(mapObjMdlId[MAPOBJ_ROUNDITEM_UMA]); + motTime = BoardModelMotionTimeGet(mapObjMdlId[MAPOBJ_ROUNDITEM_UMA]); + if (motTime >= motMaxTime) { + motTime -= motMaxTime; } - var_f24 = fmod(var_f29, temp_f28 / 4); - if (var_f24 >= temp_f28 / 4 - 30.0f && lbl_1_bss_7B4 == 0) { - lbl_1_bss_7B4 = 1; - lbl_1_bss_7A8 = 90; + if (fmodf(motTime, motMaxTime / 4) >= motMaxTime / 4 - 30.0f && umaStopF == 0) { + umaStopF = 1; + umaStopTimer = 90; } - if (lbl_1_bss_7B4 != 0) { - lbl_1_bss_7EC *= 0.97f; - lbl_1_bss_7A8--; + if (umaStopF != 0) { + umaSpeed *= 0.97f; + umaStopTimer--; } - if (lbl_1_bss_7EC != 1.0f && lbl_1_bss_7A8 == 0) { - lbl_1_bss_7EC = 0.0f; + if (umaSpeed != 1.0f && umaStopTimer == 0) { + umaSpeed = 0.0f; BoardAudSeqPause(0, 1, 1000); - BoardPlayerPosGet(lbl_1_bss_7E4, &sp18); - Hu3DModelObjPosGet(BoardModelIDGet(lbl_1_bss_6C4[17]), lbl_1_data_F9C[0], &spC); - var_f26 = VECSquareDistance(&sp18, &spC); - arg0->work[2] = 0; + BoardPlayerPosGet(roundItemPlayer, &playerPos); + Hu3DModelObjPosGet(BoardModelIDGet(mapObjMdlId[MAPOBJ_ROUNDITEM_UMA]), umaHookTbl[0], &objPos); + umaMinDist = VECSquareDistance(&playerPos, &objPos); + obj->work[2] = 0; for (i = 1; i < 4; i++) { - Hu3DModelObjPosGet(BoardModelIDGet(lbl_1_bss_6C4[17]), lbl_1_data_F9C[i], &spC); - temp_f27 = VECSquareDistance(&sp18, &spC); - if (temp_f27 < var_f26) { - var_f26 = temp_f27; - arg0->work[2] = i; + Hu3DModelObjPosGet(BoardModelIDGet(mapObjMdlId[MAPOBJ_ROUNDITEM_UMA]), umaHookTbl[i], &objPos); + umaDist = VECSquareDistance(&playerPos, &objPos); + if (umaDist < umaMinDist) { + umaMinDist = umaDist; + obj->work[2] = i; } } - Hu3DModelObjPosGet(BoardModelIDGet(lbl_1_bss_6C4[17]), lbl_1_data_F9C[arg0->work[2]], &lbl_1_bss_7D8); - VECSubtract(&lbl_1_bss_7D8, &sp18, &spC); - VECNormalize(&spC, &spC); - arg0->trans.x = spC.x; - arg0->trans.y = spC.y; - arg0->trans.z = spC.z; - arg0->rot.x = VECDistanceXZ(&lbl_1_bss_7D8, &sp18); - arg0->rot.y = 10.0f; - arg0->rot.z = sp18.y; - arg0->scale.x = 0.0f; - BoardPlayerMotionShiftSet(lbl_1_bss_7E4, 4, 0.0f, 5.0f, HU3D_MOTATTR_NONE); - arg0->func = fn_1_E914; + Hu3DModelObjPosGet(BoardModelIDGet(mapObjMdlId[MAPOBJ_ROUNDITEM_UMA]), umaHookTbl[obj->work[2]], &umaPos); + VECSubtract(&umaPos, &playerPos, &objPos); + VECNormalize(&objPos, &objPos); + obj->trans.x = objPos.x; + obj->trans.y = objPos.y; + obj->trans.z = objPos.z; + obj->rot.x = VECDistanceXZ(&umaPos, &playerPos); + obj->rot.y = 10.0f; + obj->rot.z = playerPos.y; + obj->scale.x = 0.0f; + BoardPlayerMotionShiftSet(roundItemPlayer, 4, 0.0f, 5.0f, HU3D_MOTATTR_NONE); + obj->func = RoundItemPlayerJump; } - BoardModelMotionSpeedSet(lbl_1_bss_6C4[17], lbl_1_bss_7EC); + BoardModelMotionSpeedSet(mapObjMdlId[MAPOBJ_ROUNDITEM_UMA], umaSpeed); } -static void fn_1_E914(omObjData *arg0) +static void RoundItemPlayerJump(omObjData *obj) { - Vec spC; + Vec pos; s32 i; - BoardPlayerPosGet(lbl_1_bss_7E4, &spC); - spC.x += arg0->trans.x * arg0->rot.x / 32.760002f; - spC.z += arg0->trans.z * arg0->rot.x / 32.760002f; - spC.y += arg0->rot.y - 0.016666668f * arg0->scale.x * arg0->scale.x; - arg0->scale.x += 1.0f; - if (VECDistanceXZ(&lbl_1_bss_7D8, &spC) < 2.0f) { - spC = lbl_1_bss_7D8; - BoardPlayerRotSet(lbl_1_bss_7E4, 0.0f, fn_1_10BB0(arg0->work[2]), 0.0f); - lbl_1_bss_7EC = 0.05f; - lbl_1_bss_7E8 = 0.05f; - BoardModelAttrReset(lbl_1_bss_6C4[18], 0x40000002); - BoardModelAttrSet(lbl_1_bss_6C4[18], 0x40000001); - BoardModelMotionSpeedSet(lbl_1_bss_6C4[18], 0.0f); + BoardPlayerPosGet(roundItemPlayer, &pos); + pos.x += obj->trans.x * obj->rot.x / 32.760002f; + pos.z += obj->trans.z * obj->rot.x / 32.760002f; + pos.y += obj->rot.y - 0.016666668f * obj->scale.x * obj->scale.x; + obj->scale.x += 1.0f; + if (VECDistanceXZ(&umaPos, &pos) < 2.0f) { + pos = umaPos; + BoardPlayerRotSet(roundItemPlayer, 0.0f, RoundItemUmaRotYGet(obj->work[2]), 0.0f); + umaSpeed = 0.05f; + borderSpeed = 0.05f; + BoardModelAttrReset(mapObjMdlId[MAPOBJ_ROUNDITEM_BORDER], HU3D_MOTATTR_PAUSE); + BoardModelAttrSet(mapObjMdlId[MAPOBJ_ROUNDITEM_BORDER], HU3D_MOTATTR_LOOP); + BoardModelMotionSpeedSet(mapObjMdlId[MAPOBJ_ROUNDITEM_BORDER], 0.0f); for (i = 0; i < 4; i++) { - lbl_1_bss_7FC[i]->func = fn_1_FED0; + itemObj[i]->func = RoundItemItemUpdate; } - BoardPlayerMotionShiftSet(lbl_1_bss_7E4, lbl_1_bss_7B8, 0.0f, 5.0f, HU3D_MOTATTR_LOOP); - lbl_1_bss_7D6 = MGSeqStartCreate(); + BoardPlayerMotionShiftSet(roundItemPlayer, jumpMotId, 0.0f, 5.0f, HU3D_MOTATTR_LOOP); + seqStartId = MGSeqStartCreate(); BoardMusStart(1, 0xE, 0x7F, 0); - arg0->func = fn_1_ECD4; + obj->func = RoundItemStartWait; } - BoardPlayerPosSetV(lbl_1_bss_7E4, &spC); + BoardPlayerPosSetV(roundItemPlayer, &pos); } -static void fn_1_ECD4(omObjData *arg0) +static void RoundItemStartWait(omObjData *obj) { - lbl_1_bss_7EC *= 1.05f; - lbl_1_bss_7E8 *= 1.05f; - if (lbl_1_bss_7EC > 2.0f) { - lbl_1_bss_7EC = 2.0f; + umaSpeed *= 1.05f; + borderSpeed *= 1.05f; + if (umaSpeed > 2.0f) { + umaSpeed = 2.0f; } - if (lbl_1_bss_7E8 > 4.0f) { - lbl_1_bss_7E8 = 4.0f; + if (borderSpeed > 4.0f) { + borderSpeed = 4.0f; } - if (MGSeqStatGet(lbl_1_bss_7D6) == 0) { - lbl_1_bss_7EC = 2.0f; - lbl_1_bss_7E8 = 4.0f; - arg0->func = fn_1_EED8; - lbl_1_bss_7D2 = 5; - lbl_1_bss_7D0 = REFRESH_RATE; - lbl_1_bss_7D4 = MGSeqTimerCreateXY(lbl_1_bss_7D2, 288, 64); + if (MGSeqStatGet(seqStartId) == 0) { + umaSpeed = 2.0f; + borderSpeed = 4.0f; + obj->func = RoundItemInputWait; + timerSec = 5; + timerFrame = REFRESH_RATE; + timerSeqId = MGSeqTimerCreateXY(timerSec, 288, 64); } - BoardModelMotionSpeedSet(lbl_1_bss_6C4[17], lbl_1_bss_7EC); - BoardModelMotionSpeedSet(lbl_1_bss_6C4[18], lbl_1_bss_7E8); - fn_1_10CF0(arg0->work[2]); + BoardModelMotionSpeedSet(mapObjMdlId[MAPOBJ_ROUNDITEM_UMA], umaSpeed); + BoardModelMotionSpeedSet(mapObjMdlId[MAPOBJ_ROUNDITEM_BORDER], borderSpeed); + RoundItemUmaPlayerSet(obj->work[2]); } -static void fn_1_EEA0(omObjData *arg0, u16 *arg1) +static void RoundItemComInputGet(omObjData *obj, u16 *btn) { - *arg1 = 0; - if (arg0->work[3] != 0) { - arg0->work[3]--; + *btn = 0; + if (obj->work[3] != 0) { + obj->work[3]--; } else { - *arg1 |= 0x100; + *btn |= PAD_BUTTON_A; } } -static void fn_1_EED8(omObjData *arg0) +static void RoundItemInputWait(omObjData *obj) { - s16 temp_r29; - u16 var_r30; + s16 padNo; + u16 btn; - fn_1_10CF0(arg0->work[2]); - temp_r29 = GWPlayer[lbl_1_bss_7E4].port; - if ((--lbl_1_bss_7D0) == 0) { - if ((--lbl_1_bss_7D2) >= 0) { - MGSeqParamSet(lbl_1_bss_7D4, 1, lbl_1_bss_7D2); + RoundItemUmaPlayerSet(obj->work[2]); + padNo = GWPlayer[roundItemPlayer].port; + if ((--timerFrame) == 0) { + if ((--timerSec) >= 0) { + MGSeqParamSet(timerSeqId, 1, timerSec); } - lbl_1_bss_7D0 = REFRESH_RATE; + timerFrame = REFRESH_RATE; } - if (GWPlayerCfg[lbl_1_bss_7E4].iscom == 1) { - fn_1_EEA0(arg0, &var_r30); + if (GWPlayerCfg[roundItemPlayer].iscom == 1) { + RoundItemComInputGet(obj, &btn); } else { - var_r30 = HuPadBtnDown[temp_r29]; + btn = HuPadBtnDown[padNo]; } - if (lbl_1_bss_7D2 < 0 || (var_r30 & 0x100)) { - BoardModelMotionSpeedSet(lbl_1_bss_6C4[17], 0.0f); - MGSeqParamSet(lbl_1_bss_7D4, 2, -1); - arg0->scale.y = 0.0f; - arg0->func = fn_1_F09C; + if (timerSec < 0 || (btn & PAD_BUTTON_A)) { + BoardModelMotionSpeedSet(mapObjMdlId[MAPOBJ_ROUNDITEM_UMA], 0.0f); + MGSeqParamSet(timerSeqId, 2, -1); + obj->scale.y = 0.0f; + obj->func = RoundItemStop; } } -static void fn_1_F09C(omObjData *arg0) +static void RoundItemStop(omObjData *obj) { - float temp_f31; - float var_f30; + float maxTime; + float time; - temp_f31 = BoardModelMotionMaxTimeGet(lbl_1_bss_6C4[18]); - arg0->scale.y += lbl_1_bss_7E8; - if (arg0->scale.y >= temp_f31 - 150.0f) { - lbl_1_bss_7E8 *= 0.9745f; - if (lbl_1_bss_7E8 < 0.08f) { - lbl_1_bss_7E8 = 0.08f; + maxTime = BoardModelMotionMaxTimeGet(mapObjMdlId[MAPOBJ_ROUNDITEM_BORDER]); + obj->scale.y += borderSpeed; + if (obj->scale.y >= maxTime - 150.0f) { + borderSpeed *= 0.9745f; + if (borderSpeed < 0.08f) { + borderSpeed = 0.08f; } } - BoardModelMotionSpeedSet(lbl_1_bss_6C4[18], lbl_1_bss_7E8); - if (arg0->scale.y >= temp_f31) { - BoardModelMotionSpeedSet(lbl_1_bss_6C4[18], 0.0f); - var_f30 = arg0->scale.y - temp_f31 + BoardModelMotionTimeGet(lbl_1_bss_6C4[18]); - if (var_f30 > temp_f31) { - var_f30 -= temp_f31; + BoardModelMotionSpeedSet(mapObjMdlId[MAPOBJ_ROUNDITEM_BORDER], borderSpeed); + if (obj->scale.y >= maxTime) { + BoardModelMotionSpeedSet(mapObjMdlId[MAPOBJ_ROUNDITEM_BORDER], 0.0f); + time = obj->scale.y - maxTime + BoardModelMotionTimeGet(mapObjMdlId[MAPOBJ_ROUNDITEM_BORDER]); + if (time > maxTime) { + time -= maxTime; } - BoardModelMotionTimeSet(lbl_1_bss_6C4[18], var_f30); - arg0->work[0] = fn_1_1001C(arg0->work[2]); - BoardModelVisibilitySet(lbl_1_bss_6C4[20], 1); - BoardModelPosSet(lbl_1_bss_6C4[20], lbl_1_bss_7FC[arg0->work[0]]->trans.x, lbl_1_bss_7FC[arg0->work[0]]->trans.y + 1.0f, - lbl_1_bss_7FC[arg0->work[0]]->trans.z); + BoardModelMotionTimeSet(mapObjMdlId[MAPOBJ_ROUNDITEM_BORDER], time); + obj->work[0] = RoundItemItemGet(obj->work[2]); + BoardModelVisibilitySet(mapObjMdlId[MAPOBJ_ROUNDITEM_ITEM_LIGHT], 1); + BoardModelPosSet(mapObjMdlId[MAPOBJ_ROUNDITEM_ITEM_LIGHT], itemObj[obj->work[0]]->trans.x, itemObj[obj->work[0]]->trans.y + 1.0f, + itemObj[obj->work[0]]->trans.z); BoardModelRotSet( - lbl_1_bss_6C4[20], lbl_1_bss_7FC[arg0->work[0]]->rot.x, lbl_1_bss_7FC[arg0->work[0]]->rot.y + 1.0f, lbl_1_bss_7FC[arg0->work[0]]->rot.z); - arg0->work[1] = 60; + mapObjMdlId[MAPOBJ_ROUNDITEM_ITEM_LIGHT], itemObj[obj->work[0]]->rot.x, itemObj[obj->work[0]]->rot.y + 1.0f, itemObj[obj->work[0]]->rot.z); + obj->work[1] = 60; BoardAudSeqFadeOut(1, 100); - arg0->func = fn_1_F348; + obj->func = RoundItemLightFlicker; HuAudFXPlay(0x40A); } } -static void fn_1_F348(omObjData *arg0) +static void RoundItemLightFlicker(omObjData *obj) { - if ((arg0->work[1] / 4) & 1) { - BoardModelVisibilitySet(lbl_1_bss_6C4[20], 0); + if ((obj->work[1] / 4) & 1) { + BoardModelVisibilitySet(mapObjMdlId[MAPOBJ_ROUNDITEM_ITEM_LIGHT], 0); } else { - BoardModelVisibilitySet(lbl_1_bss_6C4[20], 1); + BoardModelVisibilitySet(mapObjMdlId[MAPOBJ_ROUNDITEM_ITEM_LIGHT], 1); } - if ((arg0->work[1] -= 1) == 0) { - BoardModelVisibilitySet(lbl_1_bss_6C4[20], 0); - fn_1_101B8(arg0->work[0]); + if ((--obj->work[1]) == 0) { + BoardModelVisibilitySet(mapObjMdlId[MAPOBJ_ROUNDITEM_ITEM_LIGHT], 0); + ItemGetCreate(obj->work[0]); HuAudFXPlay(0x310); - arg0->func = fn_1_F3F8; + obj->func = RoundItemUmaJumpWait; } } -static void fn_1_F3F8(omObjData *arg0) +static void RoundItemUmaJumpWait(omObjData *obj) { - Vec sp18; - Vec spC; + Vec playerPos; + Vec dir; - if (lbl_1_bss_7F0->work[0] != 1) { + if (itemGetObj->work[0] != 1) { return; } - BoardPlayerPosGet(lbl_1_bss_7E4, &sp18); - VECSubtract(&lbl_1_bss_7C4, &sp18, &spC); - VECNormalize(&spC, &spC); - arg0->trans.x = spC.x; - arg0->trans.y = spC.y; - arg0->trans.z = spC.z; - arg0->rot.x = VECDistanceXZ(&lbl_1_bss_7C4, &sp18); - arg0->scale.y = 20.0f + 40.0f * (arg0->rot.x / 445.0f); - arg0->rot.y = 0.016666668f * (arg0->scale.y / 2) * (arg0->scale.y / 2); - arg0->rot.z = sp18.y; - arg0->scale.x = 0.0f; - BoardPlayerMotionShiftSet(lbl_1_bss_7E4, 4, 0.0f, 5.0f, HU3D_MOTATTR_NONE); - VECSubtract(&lbl_1_bss_7C4, &sp18, &spC); - VECNormalize(&spC, &spC); - BoardPlayerRotSet(lbl_1_bss_7E4, 0.0f, fn_1_10EB8(&spC), 0.0f); - arg0->func = fn_1_F6E8; + BoardPlayerPosGet(roundItemPlayer, &playerPos); + VECSubtract(&roundItemPlayerPos, &playerPos, &dir); + VECNormalize(&dir, &dir); + obj->trans.x = dir.x; + obj->trans.y = dir.y; + obj->trans.z = dir.z; + obj->rot.x = VECDistanceXZ(&roundItemPlayerPos, &playerPos); + obj->scale.y = 20.0f + 40.0f * (obj->rot.x / 445.0f); + obj->rot.y = 0.016666668f * (obj->scale.y / 2) * (obj->scale.y / 2); + obj->rot.z = playerPos.y; + obj->scale.x = 0.0f; + BoardPlayerMotionShiftSet(roundItemPlayer, 4, 0.0f, 5.0f, HU3D_MOTATTR_NONE); + VECSubtract(&roundItemPlayerPos, &playerPos, &dir); + VECNormalize(&dir, &dir); + BoardPlayerRotSet(roundItemPlayer, 0.0f, RoundItemAngleGet(&dir), 0.0f); + obj->func = RoundItemUmaJump; } -static void fn_1_F6E8(omObjData *arg0) +static void RoundItemUmaJump(omObjData *obj) { - Vec sp8; + Vec pos; - BoardPlayerPosGet(lbl_1_bss_7E4, &sp8); - sp8.x += arg0->trans.x * arg0->rot.x / arg0->scale.y; - sp8.z += arg0->trans.z * arg0->rot.x / arg0->scale.y; - sp8.y += arg0->rot.y - 0.016666668f * arg0->scale.x * arg0->scale.x; - arg0->scale.x += 1.0f; - if (sp8.y < lbl_1_bss_80C.y || arg0->scale.x >= arg0->scale.y) { - sp8.y = lbl_1_bss_80C.y; - BoardCameraMotionStart(BoardPlayerModelGet(lbl_1_bss_7E4), NULL, 700.0f, -1.0f); - BoardPlayerMotionStart(lbl_1_bss_7E4, 2, 0x40000001); - arg0->func = fn_1_F890; + BoardPlayerPosGet(roundItemPlayer, &pos); + pos.x += obj->trans.x * obj->rot.x / obj->scale.y; + pos.z += obj->trans.z * obj->rot.x / obj->scale.y; + pos.y += obj->rot.y - 0.016666668f * obj->scale.x * obj->scale.x; + obj->scale.x += 1.0f; + if (pos.y < roundItemPos.y || obj->scale.x >= obj->scale.y) { + pos.y = roundItemPos.y; + BoardCameraMotionStart(BoardPlayerModelGet(roundItemPlayer), NULL, 700.0f, -1.0f); + BoardPlayerMotionStart(roundItemPlayer, 2, HU3D_MOTATTR_LOOP); + obj->func = RoundItemRotatePlayer; } - BoardPlayerPosSetV(lbl_1_bss_7E4, &sp8); + BoardPlayerPosSetV(roundItemPlayer, &pos); } -static void fn_1_F890(omObjData *arg0) +static void RoundItemRotatePlayer(omObjData *obj) { - Vec sp8; + Vec rot; - BoardPlayerRotGet(lbl_1_bss_7E4, &sp8); - if (sp8.y == 0.0f) { - BoardPlayerMotionShiftSet(lbl_1_bss_7E4, 1, 0.0f, 10.0f, HU3D_MOTATTR_LOOP); - lbl_1_bss_7F0->work[0] = 0; - lbl_1_bss_7F0->func = fn_1_10820; - arg0->func = fn_1_FA1C; + BoardPlayerRotGet(roundItemPlayer, &rot); + if (rot.y == 0.0f) { + BoardPlayerMotionShiftSet(roundItemPlayer, 1, 0.0f, 10.0f, HU3D_MOTATTR_LOOP); + itemGetObj->work[0] = 0; + itemGetObj->func = ItemGetPlayerMove; + obj->func = RoundItemStreamWait; } - else if (sp8.y > 180.0f) { - if (360.0f - sp8.y < 3.0f) { - sp8.y = 0.0f; + else if (rot.y > 180.0f) { + if (360.0f - rot.y < 3.0f) { + rot.y = 0.0f; } else { - sp8.y += 3.0f; + rot.y += 3.0f; } } else { - if (sp8.y < 3.0f) { - sp8.y = 0.0f; + if (rot.y < 3.0f) { + rot.y = 0.0f; } else { - sp8.y -= 3.0f; + rot.y -= 3.0f; } } - BoardPlayerRotSetV(lbl_1_bss_7E4, &sp8); + BoardPlayerRotSetV(roundItemPlayer, &rot); } -static void fn_1_FA1C(omObjData *arg0) +static void RoundItemStreamWait(omObjData *obj) { - if (lbl_1_bss_7F0->work[0] == 1) { - BoardPlayerMotionShiftSet(lbl_1_bss_7E4, lbl_1_bss_7BC, 0.0f, 10.0f, HU3D_MOTATTR_NONE); - arg0->work[0] = 30; - lbl_1_bss_7A4 = HuAudSStreamPlay(2); - arg0->func = fn_1_FABC; + if (itemGetObj->work[0] == 1) { + BoardPlayerMotionShiftSet(roundItemPlayer, itemGetMotId, 0.0f, 10.0f, HU3D_MOTATTR_NONE); + obj->work[0] = 30; + roundItemStreamId = HuAudSStreamPlay(2); + obj->func = RoundItemWinWait; } } -static void fn_1_FABC(omObjData *arg0) +static void RoundItemWinWait(omObjData *obj) { - Process *var_r30; + Process *proc; - if (arg0->work[0] == 0) { - if (HuAudSStreamStatGet(lbl_1_bss_7A4) == 0) { - var_r30 = HuPrcCreate(fn_1_FB58, 0x2004, 0x1000, 0); - var_r30->user_data = arg0; + if (obj->work[0] == 0) { + if (HuAudSStreamStatGet(roundItemStreamId) == 0) { + proc = HuPrcCreate(ItemGetWinExec, 0x2004, 0x1000, 0); + proc->user_data = obj; BoardAudSeqPause(0, 0, 1000); - arg0->func = NULL; + obj->func = NULL; } } else { - arg0->work[0]--; + obj->work[0]--; } } -static void fn_1_FB58(void) +static void ItemGetWinExec(void) { - omObjData *temp_r31; + omObjData *obj; BoardWinCreate(2, MAKE_MESSID(10, 6), 0); - BoardWinInsertMesSet(MAKE_MESSID(8, lbl_1_bss_7F0->work[1]), 0); + BoardWinInsertMesSet(MAKE_MESSID(8, itemGetObj->work[1]), 0); BoardWinWait(); BoardWinKill(); - temp_r31 = HuPrcCurrentGet()->user_data; - BoardPlayerMotionShiftSet(lbl_1_bss_7E4, 1, 0.0f, 10.0f, HU3D_MOTATTR_NONE); - lbl_1_bss_7F0->work[0] = 0; + obj = HuPrcCurrentGet()->user_data; + BoardPlayerMotionShiftSet(roundItemPlayer, 1, 0.0f, 10.0f, HU3D_MOTATTR_NONE); + itemGetObj->work[0] = 0; HuAudFXPlay(0x30D); - HuAudFXFadeOut(lbl_1_bss_7AC, 1000); - lbl_1_bss_7F0->func = fn_1_10AE8; - temp_r31->func = fn_1_FC3C; + HuAudFXFadeOut(itemGetSeNo, 1000); + itemGetObj->func = ItemGetShrink; + obj->func = ItemGetShrinkWait; HuPrcKill(NULL); while (TRUE) { HuPrcVSleep(); } } -static void fn_1_FC3C(omObjData *arg0) +static void ItemGetShrinkWait(omObjData *obj) { - Process *var_r31; + Process *proc; - if (lbl_1_bss_7F0->work[0] == 1) { - BoardPlayerItemAdd(lbl_1_bss_7E4, lbl_1_bss_7F0->work[1]); - omVibrate(lbl_1_bss_7E4, 12, 6, 6); - var_r31 = HuPrcCreate(fn_1_FCEC, 0x2004, 0x1000, 0); - var_r31->user_data = arg0; - arg0->func = NULL; + if (itemGetObj->work[0] == 1) { + BoardPlayerItemAdd(roundItemPlayer, itemGetObj->work[1]); + omVibrate(roundItemPlayer, 12, 6, 6); + proc = HuPrcCreate(ItemGetReturnWinExec, 0x2004, 0x1000, 0); + proc->user_data = obj; + obj->func = NULL; } } -static void fn_1_FCEC(void) +static void ItemGetReturnWinExec(void) { - omObjData *var_r31; + omObjData *obj; BoardWinCreate(2, MAKE_MESSID(10, 7), 0); BoardWinWait(); BoardWinKill(); - var_r31 = HuPrcCurrentGet()->user_data; - var_r31->func = fn_1_FD3C; + obj = HuPrcCurrentGet()->user_data; + obj->func = RoundItemGameClose; HuPrcKill(NULL); while (TRUE) { HuPrcVSleep(); } } -static void fn_1_FD3C(omObjData *arg0) +static void RoundItemGameClose(omObjData *obj) { BoardStatusShowSetAll(1); - BoardCameraTargetModelSet(lbl_1_bss_6C4[21]); + BoardCameraTargetModelSet(mapObjMdlId[MAPOBJ_ROUNDITEM_ITEM_UP]); BoardCameraOffsetSet(0.0f, 0.0f, 0.0f); BoardCameraXRotZoomSet(1200.0f, -45.0f); - BoardModelMotionSpeedSet(lbl_1_bss_6C4[17], 1.0f); - Hu3DModelKill(lbl_1_bss_7F0->model[0]); - Hu3DModelKill(lbl_1_bss_7F0->model[1]); - Hu3DModelKill(lbl_1_bss_7F0->model[2]); - omDelObjEx(HuPrcCurrentGet(), lbl_1_bss_7F0); - arg0->func = fn_1_FE44; + BoardModelMotionSpeedSet(mapObjMdlId[MAPOBJ_ROUNDITEM_UMA], 1.0f); + Hu3DModelKill(itemGetObj->model[0]); + Hu3DModelKill(itemGetObj->model[1]); + Hu3DModelKill(itemGetObj->model[2]); + omDelObjEx(HuPrcCurrentGet(), itemGetObj); + obj->func = RoundItemGameEnd; } -static void fn_1_FE44(omObjData *arg0) +static void RoundItemGameEnd(omObjData *obj) { - if (BoardStatusStopCheck(lbl_1_bss_7E4) && BoardCameraMotionIsDone()) { - lbl_1_bss_7AA = 1; - BoardMGExit(); - HuAudFXPlay(0x40F); - BoardModelMotionStart(lbl_1_bss_6C4[21], 0, 0x40000004); - arg0->func = NULL; + if (BoardStatusStopCheck(roundItemPlayer) && BoardCameraMotionIsDone()) { + RoundItemEnd(); + obj->func = NULL; } } -static void fn_1_FED0(omObjData *arg0) +static void RoundItemItemUpdate(omObjData *obj) { - float temp_f30; - float var_f31; - float var_f29; + float time; + float rotY; + float maxTime; - temp_f30 = BoardModelMotionTimeGet(lbl_1_bss_6C4[18]); - var_f29 = BoardModelMotionMaxTimeGet(lbl_1_bss_6C4[18]); - var_f31 = 90.0f - 90.0f * arg0->work[2] + 360.0f * (temp_f30 / var_f29); - if (var_f31 >= 360.0f) { - var_f31 -= 360.0f; + time = BoardModelMotionTimeGet(mapObjMdlId[MAPOBJ_ROUNDITEM_BORDER]); + maxTime = BoardModelMotionMaxTimeGet(mapObjMdlId[MAPOBJ_ROUNDITEM_BORDER]); + rotY = 90.0f - 90.0f * obj->work[2] + 360.0f * (time / maxTime); + if (rotY >= 360.0f) { + rotY -= 360.0f; } - if (var_f31 < 0.0f) { - var_f31 += 360.0f; + if (rotY < 0.0f) { + rotY += 360.0f; } - omSetRot(arg0, 0.0f, var_f31, 0.0f); + omSetRot(obj, 0.0f, rotY, 0.0f); } -static s16 fn_1_1001C(u32 arg0) +static s16 RoundItemItemGet(u32 umaNo) { - float var_f29; - float var_f28; - float temp_f27; - float temp_f26; - float var_f31; - float var_f30; + float umaMaxTime; + float umaAngle; + float borderAngle; + float angle; + float umaTime; - temp_f26 = BoardModelMotionMaxTimeGet(lbl_1_bss_6C4[18]); - temp_f27 = 360.0f - 360.0f * (BoardModelMotionTimeGet(lbl_1_bss_6C4[18]) / temp_f26); - var_f30 = BoardModelMotionTimeGet(lbl_1_bss_6C4[17]); - var_f29 = BoardModelMotionMaxTimeGet(lbl_1_bss_6C4[17]); - var_f30 = var_f30 - (var_f29 / 4) * arg0; - if (var_f30 < 0.0f) { - var_f30 += var_f29; + borderAngle = 360.0f - 360.0f * (BoardModelMotionTimeGet(mapObjMdlId[MAPOBJ_ROUNDITEM_BORDER]) / BoardModelMotionMaxTimeGet(mapObjMdlId[MAPOBJ_ROUNDITEM_BORDER])); + umaTime = BoardModelMotionTimeGet(mapObjMdlId[MAPOBJ_ROUNDITEM_UMA]); + umaMaxTime = BoardModelMotionMaxTimeGet(mapObjMdlId[MAPOBJ_ROUNDITEM_UMA]); + umaTime = umaTime - (umaMaxTime / 4) * umaNo; + if (umaTime < 0.0f) { + umaTime += umaMaxTime; } - var_f28 = 360.0f * (var_f30 / var_f29); - var_f31 = var_f28 - temp_f27; - if (var_f31 < 0.0f) { - var_f31 += 360.0f; + umaAngle = 360.0f * (umaTime / umaMaxTime); + angle = umaAngle - borderAngle; + if (angle < 0.0f) { + angle += 360.0f; } - var_f31 /= 90.0f; - return var_f31; + angle /= 90.0f; + return angle; } -static void fn_1_101B8(s16 arg0) +static void ItemGetCreate(s16 itemNo) { - omObjData *var_r31; - float *var_r30; - float var_f27; - float temp_f26; - float temp_f30; - float temp_f29; - float temp_f28; - float var_f31; + omObjData *obj; + float *data; + float borderAngle; + float posX; + float posY; + float posZ; + float angle; - var_r31 = lbl_1_bss_7F0 = omAddObjEx(boardObjMan, 0x165, 3, 0, -1, fn_1_10664); - var_r31->model[0] = lbl_1_bss_7FC[arg0]->model[1]; - Hu3DModelAttrReset(var_r31->model[0], HU3D_ATTR_DISPOFF); - lbl_1_bss_7F0->work[1] = lbl_1_bss_7FC[arg0]->work[1]; - lbl_1_bss_7F0->data = HuMemDirectMallocNum(HEAP_SYSTEM, 3 * sizeof(float), MEMORY_DEFAULT_NUM); - var_r30 = lbl_1_bss_7F0->data; - omSetRot(var_r31, 0.0f, 0.0f, 0.0f); - omSetSca(var_r31, 0.0f, 0.0f, 0.0f); - temp_f26 = BoardModelMotionMaxTimeGet(lbl_1_bss_6C4[18]); - var_f27 = 360.0f - 360.0f * (BoardModelMotionTimeGet(lbl_1_bss_6C4[18]) / temp_f26); - var_f31 = 45.0f + var_f27 + 90.0f * arg0; - if (var_f31 >= 360.0f) { - var_f31 -= 360.0f; + obj = itemGetObj = omAddObjEx(boardObjMan, 0x165, 3, 0, -1, ItemGetObjUpdate); + obj->model[0] = itemObj[itemNo]->model[1]; + Hu3DModelAttrReset(obj->model[0], HU3D_ATTR_DISPOFF); + itemGetObj->work[1] = itemObj[itemNo]->work[1]; + itemGetObj->data = HuMemDirectMallocNum(HEAP_SYSTEM, 3 * sizeof(float), MEMORY_DEFAULT_NUM); + data = itemGetObj->data; + omSetRot(obj, 0.0f, 0.0f, 0.0f); + omSetSca(obj, 0.0f, 0.0f, 0.0f); + borderAngle = 360.0f - 360.0f * (BoardModelMotionTimeGet(mapObjMdlId[MAPOBJ_ROUNDITEM_BORDER]) / BoardModelMotionMaxTimeGet(mapObjMdlId[MAPOBJ_ROUNDITEM_BORDER])); + angle = 45.0f + borderAngle + 90.0f * itemNo; + if (angle >= 360.0f) { + angle -= 360.0f; } - temp_f30 = lbl_1_bss_80C.x - 100.0 * cosd(var_f31); - temp_f28 = lbl_1_bss_80C.z - 100.0 * sind(var_f31); - temp_f29 = lbl_1_bss_80C.y + 66.0f + 1.0f; - omSetTra(var_r31, temp_f30, temp_f29, temp_f28); - var_r31->work[0] = 0; - var_r30[0] = 0.1f; - var_r30[2] = 20.0f; - var_r30[1] = 0.0f; - var_r31->model[1] = Hu3DParticleCreate(lbl_1_bss_7A0, 200); - var_r31->model[2] = Hu3DParticleCreate(lbl_1_bss_7A0, 100); - Hu3DParticleHookSet(var_r31->model[1], fn_1_11064); - Hu3DParticleHookSet(var_r31->model[2], fn_1_11484); - Hu3DParticleColSet(var_r31->model[1], 0xFF, 0xFF, 0); - Hu3DParticleColSet(var_r31->model[2], 0xFF, 0xFF, 0); - Hu3DModelPosSet(var_r31->model[1], 0.0f, 0.0f, 0.0f); - Hu3DModelPosSet(var_r31->model[2], temp_f30, temp_f29, temp_f28); - Hu3DParticleBlendModeSet(var_r31->model[1], 1); - Hu3DParticleBlendModeSet(var_r31->model[2], 1); - Hu3DModelLayerSet(var_r31->model[1], 3); - Hu3DModelLayerSet(var_r31->model[2], 3); - lbl_1_bss_7AC = HuAudFXPlay(0x35F); + posX = roundItemPos.x - 100.0 * cosd(angle); + posZ = roundItemPos.z - 100.0 * sind(angle); + posY = roundItemPos.y + 66.0f + 1.0f; + omSetTra(obj, posX, posY, posZ); + obj->work[0] = 0; + data[0] = 0.1f; + data[2] = 20.0f; + data[1] = 0.0f; + obj->model[1] = Hu3DParticleCreate(roundItemEffAnim, 200); + obj->model[2] = Hu3DParticleCreate(roundItemEffAnim, 100); + Hu3DParticleHookSet(obj->model[1], ItemGetEff1Hook); + Hu3DParticleHookSet(obj->model[2], ItemGetEff2Hook); + Hu3DParticleColSet(obj->model[1], 0xFF, 0xFF, 0); + Hu3DParticleColSet(obj->model[2], 0xFF, 0xFF, 0); + Hu3DModelPosSet(obj->model[1], 0.0f, 0.0f, 0.0f); + Hu3DModelPosSet(obj->model[2], posX, posY, posZ); + Hu3DParticleBlendModeSet(obj->model[1], 1); + Hu3DParticleBlendModeSet(obj->model[2], 1); + Hu3DModelLayerSet(obj->model[1], 3); + Hu3DModelLayerSet(obj->model[2], 3); + itemGetSeNo = HuAudFXPlay(0x35F); } -static void fn_1_10664(omObjData *arg0) +static void ItemGetObjUpdate(omObjData *obj) { - float *temp_r31; - float var_f31; + float *data; + float scale; - temp_r31 = arg0->data; - var_f31 = temp_r31[0]; - if (arg0->work[0] == 0) { - if (var_f31 > 1.0f) { - var_f31 = 1.0f; + data = obj->data; + scale = data[0]; + if (obj->work[0] == 0) { + if (scale > 1.0f) { + scale = 1.0f; } else { - temp_r31[0] += 0.025f; + data[0] += 0.025f; } - arg0->trans.y += temp_r31[2]; - temp_r31[2] -= 1.0f; - if (temp_r31[2] < 0.0f && arg0->trans.y < lbl_1_bss_80C.y + 66.0f + 1.0f + 90.0f) { - arg0->work[0] = 1; + obj->trans.y += data[2]; + data[2] -= 1.0f; + if (data[2] < 0.0f && obj->trans.y < roundItemPos.y + 66.0f + 1.0f + 90.0f) { + obj->work[0] = 1; } - omSetSca(arg0, var_f31, var_f31, var_f31); + omSetSca(obj, scale, scale, scale); } else { - arg0->trans.y += sind(temp_r31[1]); - temp_r31[1] += 4.0f; - if (temp_r31[1] >= 360.0f) { - temp_r31[1] -= 360.0f; + obj->trans.y += sind(data[1]); + data[1] += 4.0f; + if (data[1] >= 360.0f) { + data[1] -= 360.0f; } } } -static void fn_1_10820(omObjData *arg0) +static void ItemGetPlayerMove(omObjData *obj) { - Vec sp24; - Vec sp18; - Vec spC; + Vec playerPos; + Vec objPos; + Vec dir; float var_f28; - float *temp_r30; + float *data; - temp_r30 = arg0->data; - if (arg0->work[0] == 0) { - BoardPlayerPosGet(lbl_1_bss_7E4, &sp24); - sp18.x = arg0->trans.x; - sp18.y = 0.0f; - sp18.z = arg0->trans.z; - sp24.y = 0.0f; - VECSubtract(&sp24, &sp18, &spC); - VECNormalize(&spC, &spC); - var_f28 = VECDistanceXZ(&sp24, &sp18); + data = obj->data; + if (obj->work[0] == 0) { + BoardPlayerPosGet(roundItemPlayer, &playerPos); + objPos.x = obj->trans.x; + objPos.y = 0.0f; + objPos.z = obj->trans.z; + playerPos.y = 0.0f; + VECSubtract(&playerPos, &objPos, &dir); + VECNormalize(&dir, &dir); + var_f28 = VECDistanceXZ(&playerPos, &objPos); if (var_f28 < 8.0f) { - arg0->trans.x = sp24.x; - arg0->trans.z = sp24.z; - arg0->work[0] = 1; + obj->trans.x = playerPos.x; + obj->trans.z = playerPos.z; + obj->work[0] = 1; } else { - arg0->trans.x += 8.0f * spC.x; - arg0->trans.z += 8.0f * spC.z; + obj->trans.x += 8.0f * dir.x; + obj->trans.z += 8.0f * dir.z; } } - arg0->trans.y += sind(temp_r30[1]); - temp_r30[1] += 4.0f; - if (temp_r30[1] >= 360.0f) { - temp_r30[1] -= 360.0f; + obj->trans.y += sind(data[1]); + data[1] += 4.0f; + if (data[1] >= 360.0f) { + data[1] -= 360.0f; } } -static void fn_1_10AE8(omObjData *arg0) +static void ItemGetShrink(omObjData *obj) { - float *temp_r31; + float *data; - temp_r31 = arg0->data; - if (arg0->work[0] == 0) { - temp_r31[0] -= 0.016666668f; - if (temp_r31[0] <= 0.0f) { - temp_r31[0] = 0.0f; - arg0->work[0] = 1; - HuAudFXStop(lbl_1_bss_7AC); + data = obj->data; + if (obj->work[0] == 0) { + data[0] -= 0.016666668f; + if (data[0] <= 0.0f) { + data[0] = 0.0f; + obj->work[0] = 1; + HuAudFXStop(itemGetSeNo); } - arg0->trans.y -= 2.1666667f; + obj->trans.y -= 2.1666667f; } - omSetSca(arg0, temp_r31[0], temp_r31[0], temp_r31[0]); + omSetSca(obj, data[0], data[0], data[0]); } -static float fn_1_10BB0(u32 arg0) +static float RoundItemUmaRotYGet(u32 umaNo) { - float var_f30; - float temp_f29; - float var_f31; + float time; + float maxTime; + float rotY; - var_f30 = BoardModelMotionTimeGet(lbl_1_bss_6C4[17]); - temp_f29 = BoardModelMotionMaxTimeGet(lbl_1_bss_6C4[17]); - var_f30 = var_f30 - (temp_f29 / 4) * arg0; - if (var_f30 < 0.0f) { - var_f30 += temp_f29; + time = BoardModelMotionTimeGet(mapObjMdlId[MAPOBJ_ROUNDITEM_UMA]); + maxTime = BoardModelMotionMaxTimeGet(mapObjMdlId[MAPOBJ_ROUNDITEM_UMA]); + time = time - (maxTime / 4) * umaNo; + if (time < 0.0f) { + time += maxTime; } - var_f31 = 180.0f + -360.0f * (var_f30 / temp_f29); - if (var_f31 >= 360.0f) { - var_f31 -= 360.0f; + rotY = 180.0f + -360.0f * (time / maxTime); + if (rotY >= 360.0f) { + rotY -= 360.0f; } - if (var_f31 < 0.0f) { - var_f31 += 360.0f; + if (rotY < 0.0f) { + rotY += 360.0f; } - return var_f31; + return rotY; } -static void fn_1_10CF0(u32 arg0) +static void RoundItemUmaPlayerSet(u32 umaNo) { - float var_f30; - float temp_f29; - float var_f31; - float var_f28; - - Hu3DModelObjPosGet(BoardModelIDGet(lbl_1_bss_6C4[17]), lbl_1_data_F9C[arg0], &lbl_1_bss_7D8); - BoardPlayerPosSetV(lbl_1_bss_7E4, &lbl_1_bss_7D8); - var_f30 = BoardModelMotionTimeGet(lbl_1_bss_6C4[17]); - temp_f29 = BoardModelMotionMaxTimeGet(lbl_1_bss_6C4[17]); - var_f30 = var_f30 - (temp_f29 / 4) * arg0; - if (var_f30 < 0.0f) { - var_f30 += temp_f29; - } - var_f31 = 180.0f + -360.0f * (var_f30 / temp_f29); - if (var_f31 >= 360.0f) { - var_f31 -= 360.0f; - } - if (var_f31 < 0.0f) { - var_f31 += 360.0f; - } - var_f28 = var_f31; - BoardPlayerRotSet(lbl_1_bss_7E4, 0.0f, var_f28, 0.0f); + Hu3DModelObjPosGet(BoardModelIDGet(mapObjMdlId[MAPOBJ_ROUNDITEM_UMA]), umaHookTbl[umaNo], &umaPos); + BoardPlayerPosSetV(roundItemPlayer, &umaPos); + BoardPlayerRotSet(roundItemPlayer, 0.0f, RoundItemUmaRotYGet(umaNo), 0.0f); } -static float fn_1_10EB8(Vec *arg0) +static float RoundItemAngleGet(Vec *dir) { - float var_f31; + float angle; - if (arg0->x || arg0->z) { - if (arg0->x == 0.0f) { - if (arg0->z > 0.0f) { + if (dir->x || dir->z) { + if (dir->x == 0.0f) { + if (dir->z > 0.0f) { return 0.0f; } else { return 180.0f; } } - if (arg0->z == 0.0f) { - if (arg0->x > 0.0f) { + if (dir->z == 0.0f) { + if (dir->x > 0.0f) { return 90.0f; } else { return 270.0f; } } - var_f31 = atan2d(arg0->z, arg0->x); - if (arg0->z < 0.0f) { - var_f31 = 90.0f - var_f31; + angle = atan2d(dir->z, dir->x); + if (dir->z < 0.0f) { + angle = 90.0f - angle; } else { - var_f31 = 90.0f - var_f31; - if (var_f31 < 0.0f) { - var_f31 += 360.0f; + angle = 90.0f - angle; + if (angle < 0.0f) { + angle += 360.0f; } } - return var_f31; + return angle; } return -1.0f; } -static void fn_1_11064(ModelData *model, ParticleData *particle, Mtx matrix) +static void ItemGetEff1Hook(ModelData *model, ParticleData *particle, Mtx matrix) { - HsfanimStruct01 *var_r31; - float temp_f30; - float temp_f29; - float temp_f31; - s32 var_r28; + HsfanimStruct01 *particleDataP; + float angle; + float radius; + float radiusBase; + s32 j; s32 i; if (particle->unk_34 == 0) { - var_r31 = particle->unk_48; - for (i = 0; i < particle->unk_30; i++, var_r31++) { - var_r31->unk40.a = 0; - var_r31->unk2C = 0.0f; + particleDataP = particle->unk_48; + for (i = 0; i < particle->unk_30; i++, particleDataP++) { + particleDataP->unk40.a = 0; + particleDataP->unk2C = 0.0f; } particle->unk_00 = 0; } - temp_f31 = lbl_1_bss_7F0->scale.x; + radiusBase = itemGetObj->scale.x; for (i = 0; i < 30; i++) { - var_r31 = particle->unk_48; - for (var_r28 = 0; var_r28 < particle->unk_30; var_r28++, var_r31++) { - if (var_r31->unk2C == 0.0f) { + particleDataP = particle->unk_48; + for (j = 0; j < particle->unk_30; j++, particleDataP++) { + if (particleDataP->unk2C == 0.0f) { break; } } - if (var_r28 != particle->unk_30) { - temp_f30 = 0.003921569f * frand8() * 360.0f; - temp_f29 = 0.003921569f * frand8() * 70.0f * temp_f31; - var_r31->unk34.x = lbl_1_bss_7F0->trans.x + temp_f29 * sind(temp_f30); - var_r31->unk34.z = lbl_1_bss_7F0->trans.z + temp_f29 * cosd(temp_f30); - var_r31->unk34.y = lbl_1_bss_7F0->trans.y + temp_f31 * (-30.0f + 0.003921569f * frand8() * 60.0f); - var_r31->unk08.x = 0.5f + 0.003921569f * frand8() * 3.0f; - var_r31->unk08.y = 0.3f + 0.003921569f * frand8() * 2.0f; - var_r31->unk40.a = 0xB4; - var_r31->unk2C = 15.0f * temp_f31; + if (j != particle->unk_30) { + angle = 0.003921569f * frand8() * 360.0f; + radius = 0.003921569f * frand8() * 70.0f * radiusBase; + particleDataP->unk34.x = itemGetObj->trans.x + radius * sind(angle); + particleDataP->unk34.z = itemGetObj->trans.z + radius * cosd(angle); + particleDataP->unk34.y = itemGetObj->trans.y + radiusBase * (-30.0f + 0.003921569f * frand8() * 60.0f); + particleDataP->unk08.x = 0.5f + 0.003921569f * frand8() * 3.0f; + particleDataP->unk08.y = 0.3f + 0.003921569f * frand8() * 2.0f; + particleDataP->unk40.a = 0xB4; + particleDataP->unk2C = 15.0f * radiusBase; } } - var_r31 = particle->unk_48; - for (i = 0; i < particle->unk_30; i++, var_r31++) { - if (var_r31->unk2C != 0.0f) { - var_r31->unk34.y -= var_r31->unk08.x; - var_r31->unk2C -= var_r31->unk08.y; - if (var_r31->unk2C <= 0.0f) { - var_r31->unk2C = 0.0f; + particleDataP = particle->unk_48; + for (i = 0; i < particle->unk_30; i++, particleDataP++) { + if (particleDataP->unk2C != 0.0f) { + particleDataP->unk34.y -= particleDataP->unk08.x; + particleDataP->unk2C -= particleDataP->unk08.y; + if (particleDataP->unk2C <= 0.0f) { + particleDataP->unk2C = 0.0f; } } } } -static void fn_1_11484(ModelData *model, ParticleData *particle, Mtx matrix) +static void ItemGetEff2Hook(ModelData *model, ParticleData *particle, Mtx matrix) { - HsfanimStruct01 *var_r31; - float temp_f29; - float temp_f30; - float temp_f31; - s32 var_r28; - s32 var_r29; + HsfanimStruct01 *particleDataP; + float angle2; + float angle; + float radius; + s32 j; + s32 i; if (particle->unk_34 == 0) { - var_r31 = particle->unk_48; - for (var_r29 = 0; var_r29 < particle->unk_30; var_r29++, var_r31++) { - var_r31->unk40.a = 0; - var_r31->unk2C = 0.0f; + particleDataP = particle->unk_48; + for (i = 0; i < particle->unk_30; i++, particleDataP++) { + particleDataP->unk40.a = 0; + particleDataP->unk2C = 0.0f; } particle->unk_00 = 0; } if (particle->unk_00 == 0) { - var_r31 = particle->unk_48; - for (var_r28 = 0; var_r28 < particle->unk_30; var_r28++, var_r31++) { - temp_f30 = 0.003921569f * frand8() * 360.0f; - temp_f31 = 0.003921569f * frand8() * 50.0f; - var_r31->unk08.x = temp_f31 * cosd(temp_f30); - var_r31->unk08.y = 2.0f + 0.003921569f * frand8() * 4.0f; - var_r31->unk08.z = temp_f31 * sind(temp_f30); - temp_f29 = 60.0f + 20.0f * frand8() * 0.003921569f; - temp_f31 = 4.0f + 5.0f * frand8() * 0.003921569f; - var_r31->unk14.x = temp_f31 * sind(temp_f30) * cosd(temp_f29); - var_r31->unk14.y = temp_f31 * sind(temp_f29); - var_r31->unk14.z = temp_f31 * cosd(temp_f30) * cosd(temp_f29); - var_r31->unk20 = 1.0f; - var_r31->unk40.a = 0xB4; - var_r31->unk2C = 9.0f + 0.003921569f * frand8() * 4.0f; + particleDataP = particle->unk_48; + for (j = 0; j < particle->unk_30; j++, particleDataP++) { + angle = 0.003921569f * frand8() * 360.0f; + radius = 0.003921569f * frand8() * 50.0f; + particleDataP->unk08.x = radius * cosd(angle); + particleDataP->unk08.y = 2.0f + 0.003921569f * frand8() * 4.0f; + particleDataP->unk08.z = radius * sind(angle); + angle2 = 60.0f + 20.0f * frand8() * 0.003921569f; + radius = 4.0f + 5.0f * frand8() * 0.003921569f; + particleDataP->unk14.x = radius * sind(angle) * cosd(angle2); + particleDataP->unk14.y = radius * sind(angle2); + particleDataP->unk14.z = radius * cosd(angle) * cosd(angle2); + particleDataP->unk20 = 1.0f; + particleDataP->unk40.a = 0xB4; + particleDataP->unk2C = 9.0f + 0.003921569f * frand8() * 4.0f; } particle->unk_00 = 1; } - var_r31 = particle->unk_48; - for (var_r29 = 0; var_r29 < particle->unk_30; var_r29++, var_r31++) { - if (var_r31->unk2C != 0.0f) { - var_r31->unk34.x = var_r31->unk08.x + var_r31->unk14.x * var_r31->unk20; - var_r31->unk34.z = var_r31->unk08.z + var_r31->unk14.z * var_r31->unk20; - var_r31->unk34.y = var_r31->unk08.y + var_r31->unk14.y * var_r31->unk20 - 0.2f * var_r31->unk20 * var_r31->unk20; - var_r31->unk2C -= 0.25f; - var_r31->unk20 += 1.0f; - if (var_r31->unk2C <= 0.0f) { - var_r31->unk2C = 0.0f; + particleDataP = particle->unk_48; + for (i = 0; i < particle->unk_30; i++, particleDataP++) { + if (particleDataP->unk2C != 0.0f) { + particleDataP->unk34.x = particleDataP->unk08.x + particleDataP->unk14.x * particleDataP->unk20; + particleDataP->unk34.z = particleDataP->unk08.z + particleDataP->unk14.z * particleDataP->unk20; + particleDataP->unk34.y = particleDataP->unk08.y + particleDataP->unk14.y * particleDataP->unk20 - 0.2f * particleDataP->unk20 * particleDataP->unk20; + particleDataP->unk2C -= 0.25f; + particleDataP->unk20 += 1.0f; + if (particleDataP->unk2C <= 0.0f) { + particleDataP->unk2C = 0.0f; } } } From ea3af4e95ab738b27ae899957140ab189c66ffb7 Mon Sep 17 00:00:00 2001 From: CreateSource <72283721+abnormalhare@users.noreply.github.com> Date: Wed, 5 Feb 2025 22:02:56 -0500 Subject: [PATCH 5/6] name audio.c and board/audio.c (#561) --- include/game/audio.h | 50 +++---- include/game/board/audio.h | 14 +- src/game/audio.c | 262 ++++++++++++++++++------------------- src/game/board/audio.c | 90 ++++++------- 4 files changed, 208 insertions(+), 208 deletions(-) diff --git a/include/game/audio.h b/include/game/audio.h index 16738144..f5ca39f0 100644 --- a/include/game/audio.h +++ b/include/game/audio.h @@ -30,41 +30,41 @@ void HuAudFXFadeOut(int seNo, s32 speed); void HuAudFXPanning(int seNo, s16 pan); void HuAudFXListnerSet(Vec *pos, Vec *heading, float sndDist, float sndSpeed); void HuAudFXListnerSetEX(Vec *pos, Vec *heading, float sndDist, float sndSpeed, float startDis, float frontSurDis, float backSurDis); -void HuAudFXListnerUpdate(Vec *arg0, Vec *arg1); +void HuAudFXListnerUpdate(Vec *pos, Vec *heading); int HuAudFXEmiterPlay(int seId, Vec *pos); void HuAudFXEmiterUpDate(int seNo, Vec *pos); void HuAudFXListnerKill(void); -void HuAudFXPauseAll(s32 arg0); +void HuAudFXPauseAll(s32 pause); s32 HuAudFXStatusGet(int seNo); s32 HuAudFXPitchSet(int seNo, s16 pitch); s32 HuAudFXVolSet(int seNo, s16 vol); -s32 HuAudSeqPlay(s16 arg0); -void HuAudSeqStop(s32 arg0); -void HuAudSeqFadeOut(s32 arg0, s32 arg1); -void HuAudSeqAllFadeOut(s32 arg0); +s32 HuAudSeqPlay(s16 musId); +void HuAudSeqStop(s32 musNo); +void HuAudSeqFadeOut(s32 musNo, s32 speed); +void HuAudSeqAllFadeOut(s32 speed); void HuAudSeqAllStop(void); -void HuAudSeqPauseAll(s32 arg0); -void HuAudSeqPause(s32 arg0, s32 arg1, s32 arg2); -s32 HuAudSeqMidiCtrlGet(s32 arg0, s8 arg1, s8 arg2); -s32 HuAudSStreamPlay(s16 arg0); -void HuAudSStreamStop(s32 arg0); -void HuAudSStreamFadeOut(s32 arg0, s32 arg1); -void HuAudSStreamAllFadeOut(s32 arg0); +void HuAudSeqPauseAll(s32 pause); +void HuAudSeqPause(s32 musNo, s32 pause, s32 speed); +s32 HuAudSeqMidiCtrlGet(s32 musNo, s8 channel, s8 ctrl); +s32 HuAudSStreamPlay(s16 streamId); +void HuAudSStreamStop(s32 seNo); +void HuAudSStreamFadeOut(s32 seNo, s32 speed); +void HuAudSStreamAllFadeOut(s32 speed); void HuAudSStreamAllStop(void); -s32 HuAudSStreamStatGet(s32 arg0); +s32 HuAudSStreamStatGet(s32 seNo); void HuAudDllSndGrpSet(u16 ovl); -void HuAudSndGrpSetSet(s16 arg0); -void HuAudSndGrpSet(s16 arg0); -void HuAudSndCommonGrpSet(s16 arg0, s32 arg1); -void HuAudAUXSet(s32 arg0, s32 arg1); -void HuAudAUXVolSet(s8 arg0, s8 arg1); +void HuAudSndGrpSetSet(s16 data_size); +void HuAudSndGrpSet(s16 grpId); +void HuAudSndCommonGrpSet(s16 grpId, s32 groupCheck); +void HuAudAUXSet(s32 auxA, s32 auxB); +void HuAudAUXVolSet(s8 auxA, s8 auxB); void HuAudVoiceInit(s16 ovl); -s32 HuAudPlayerVoicePlay(s16 arg0, s16 arg1); -s32 HuAudPlayerVoicePlayPos(s16 arg0, s16 arg1, Vec *arg2); -void HuAudPlayerVoicePlayEntry(s16 arg0, s16 arg1); -s32 HuAudCharVoicePlay(s16 arg0, s16 arg1); -s32 HuAudCharVoicePlayPos(s16 arg0, s16 arg1, Vec *arg2); -void HuAudCharVoicePlayEntry(s16 arg0, s16 arg1); +s32 HuAudPlayerVoicePlay(s16 player, s16 seId); +s32 HuAudPlayerVoicePlayPos(s16 player, s16 seId, Vec *pos); +void HuAudPlayerVoicePlayEntry(s16 player, s16 seId); +s32 HuAudCharVoicePlay(s16 charNo, s16 seId); +s32 HuAudCharVoicePlayPos(s16 charNo, s16 seId, Vec *pos); +void HuAudCharVoicePlayEntry(s16 charNo, s16 seId); extern float Snd3DBackSurDisOffset; extern float Snd3DFrontSurDisOffset; diff --git a/include/game/board/audio.h b/include/game/board/audio.h index a3b617b9..714e97fa 100755 --- a/include/game/board/audio.h +++ b/include/game/board/audio.h @@ -4,13 +4,13 @@ #include "dolphin/types.h" void BoardMusStartBoard(void); -void BoardMusStart(s32 arg0, s32 arg1, s8 arg2, u16 arg3); -void BoardAudSeqFadeOutFast(s32 arg0); -void BoardAudSeqFadeOut(s32 arg0, u16 arg1); -void BoardMusLoudSet(s32 arg0, s32 arg1); -void BoardMusVolPanSet(s32 arg0, s8 arg1, u16 arg2); -void BoardAudSeqPause(s32 arg0, s32 arg1, u16 arg2); -s32 BoardMusStatusGet(s32 arg0); +void BoardMusStart(s32 boardNo, s32 musId, s8 vol, u16 speed); +void BoardAudSeqFadeOutFast(s32 boardNo); +void BoardAudSeqFadeOut(s32 boardNo, u16 speed); +void BoardMusLoudSet(s32 boardNo, s32 isQuieter); +void BoardMusVolPanSet(s32 boardNo, s8 vol, u16 fadeSpeed); +void BoardAudSeqPause(s32 boardNo, s32 pause, u16 speed); +s32 BoardMusStatusGet(s32 boardNo); void BoardAudSeqClear(void); void BoardAudSeqFadeOutAll(void); void BoardAudFXPlay(void); diff --git a/src/game/audio.c b/src/game/audio.c index 8b01f192..83f5f259 100644 --- a/src/game/audio.c +++ b/src/game/audio.c @@ -100,10 +100,10 @@ void HuAudAllStop(void) { HuAudSStreamAllStop(); } -void HuAudFadeOut(s32 arg0) { +void HuAudFadeOut(s32 speed) { HuAudFXAllStop(); - HuAudSeqAllFadeOut(arg0); - HuAudSStreamAllFadeOut(arg0); + HuAudSeqAllFadeOut(speed); + HuAudSStreamAllFadeOut(speed); } int HuAudFXPlay(int seId) @@ -228,8 +228,8 @@ void HuAudFXListnerKill(void) { msmSeDelListener(); } -void HuAudFXPauseAll(s32 arg0) { - msmSePauseAll(arg0, 0x64); +void HuAudFXPauseAll(s32 pause) { + msmSePauseAll(pause, 0x64); } s32 HuAudFXStatusGet(int seNo) { @@ -259,35 +259,35 @@ s32 HuAudFXVolSet(int seNo, s16 vol) return msmSeSetParam(seNo, ¶m); } -s32 HuAudSeqPlay(s16 arg0) { - s32 temp_r31; +s32 HuAudSeqPlay(s16 musId) { + s32 channel; if (musicOffF != 0 || omSysExitReq != 0) { return 0; } - temp_r31 = msmMusPlay(arg0, NULL); - return temp_r31; + channel = msmMusPlay(musId, NULL); + return channel; } -void HuAudSeqStop(s32 arg0) { +void HuAudSeqStop(s32 musNo) { if (musicOffF != 0 || omSysExitReq != 0) { return; } - msmMusStop(arg0, 0); + msmMusStop(musNo, 0); } -void HuAudSeqFadeOut(s32 arg0, s32 arg1) { +void HuAudSeqFadeOut(s32 musNo, s32 speed) { if (musicOffF == 0) { - msmMusStop(arg0, arg1); + msmMusStop(musNo, speed); } } -void HuAudSeqAllFadeOut(s32 arg0) { +void HuAudSeqAllFadeOut(s32 speed) { s16 i; for (i = 0; i < 4; i++) { if (msmMusGetStatus(i) == 2) { - msmMusStop(i, arg0); + msmMusStop(i, speed); } } } @@ -296,22 +296,22 @@ void HuAudSeqAllStop(void) { msmMusStopAll(0, 0); } -void HuAudSeqPauseAll(s32 arg0) { - msmMusPauseAll(arg0, 0x64); +void HuAudSeqPauseAll(s32 pause) { + msmMusPauseAll(pause, 0x64); } -void HuAudSeqPause(s32 arg0, s32 arg1, s32 arg2) { +void HuAudSeqPause(s32 musNo, s32 pause, s32 speed) { if (musicOffF != 0 || omSysExitReq != 0) { return; } - msmMusPause(arg0, arg1, arg2); + msmMusPause(musNo, pause, speed); } -s32 HuAudSeqMidiCtrlGet(s32 arg0, s8 arg1, s8 arg2) { +s32 HuAudSeqMidiCtrlGet(s32 musNo, s8 channel, s8 ctrl) { if (musicOffF != 0 || omSysExitReq != 0) { return 0; } - return msmMusGetMidiCtrl(arg0, arg1, arg2); + return msmMusGetMidiCtrl(musNo, channel, ctrl); } s32 HuAudSStreamPlay(s16 streamId) { @@ -326,28 +326,28 @@ s32 HuAudSStreamPlay(s16 streamId) { return result; } -void HuAudSStreamStop(s32 arg0) { +void HuAudSStreamStop(s32 seNo) { if (musicOffF == 0) { - msmStreamStop(arg0, 0); + msmStreamStop(seNo, 0); } } -void HuAudSStreamFadeOut(s32 arg0, s32 arg1) { +void HuAudSStreamFadeOut(s32 seNo, s32 speed) { if (musicOffF == 0) { - msmStreamStop(arg0, arg1); + msmStreamStop(seNo, speed); } } -void HuAudSStreamAllFadeOut(s32 arg0) { - msmStreamStopAll(arg0); +void HuAudSStreamAllFadeOut(s32 speed) { + msmStreamStopAll(speed); } void HuAudSStreamAllStop(void) { msmStreamStopAll(0); } -s32 HuAudSStreamStatGet(s32 arg0) { - return msmStreamGetStatus(arg0); +s32 HuAudSStreamStatGet(s32 seNo) { + return msmStreamGetStatus(seNo); } SNDGRPTBL sndGrpTable[] = { @@ -445,75 +445,75 @@ SNDGRPTBL sndGrpTable[] = { }; void HuAudDllSndGrpSet(u16 ovl) { - SNDGRPTBL *var_r31; - s16 var_r29; + SNDGRPTBL *sndGrp; + s16 grpSet; - var_r31 = sndGrpTable; + sndGrp = sndGrpTable; while (1) { - if (var_r31->ovl == ovl) { - var_r29 = var_r31->grpSet; + if (sndGrp->ovl == ovl) { + grpSet = sndGrp->grpSet; break; } - if (var_r31->ovl == OVL_INVALID) { - var_r29 = 0x12; + if (sndGrp->ovl == OVL_INVALID) { + grpSet = 0x12; break; } - var_r31++; + sndGrp++; } - if (var_r29 != -1) { + if (grpSet != -1) { OSReport("SOUND ##########################\n"); - HuAudSndGrpSetSet(var_r29); - if (var_r31->auxANo != auxANoBak || var_r31->auxBNo != auxBNoBak) { - msmSysSetAux(var_r31->auxANo, var_r31->auxBNo); - OSReport("Change AUX %d,%d\n", var_r31->auxANo, var_r31->auxBNo); - auxANoBak = var_r31->auxANo; - auxBNoBak = var_r31->auxBNo; + HuAudSndGrpSetSet(grpSet); + if (sndGrp->auxANo != auxANoBak || sndGrp->auxBNo != auxBNoBak) { + msmSysSetAux(sndGrp->auxANo, sndGrp->auxBNo); + OSReport("Change AUX %d,%d\n", sndGrp->auxANo, sndGrp->auxBNo); + auxANoBak = sndGrp->auxANo; + auxBNoBak = sndGrp->auxBNo; HuPrcVSleep(); } - HuAudAUXVolSet(var_r31->auxAVol, var_r31->auxBVol); + HuAudAUXVolSet(sndGrp->auxAVol, sndGrp->auxBVol); OSReport("##########################\n"); } } -void HuAudSndGrpSetSet(s16 arg0) { - void *temp_r3; - OSTick temp_r31; - s32 temp_r26; - s32 temp_r27; +void HuAudSndGrpSetSet(s16 data_size) { + void *buf; + OSTick osTick; + s32 numPlay; + s32 err; - if (sndGroupBak != arg0) { + if (sndGroupBak != data_size) { msmMusStopAll(1, 0); msmSeStopAll(1, 0); - temp_r31 = OSGetTick(); + osTick = OSGetTick(); while ((msmMusGetNumPlay(1) != 0 || msmSeGetNumPlay(1) != 0) - && OSTicksToMilliseconds(OSGetTick() - temp_r31) < 500); - OSReport("%d\n", OSTicksToMilliseconds(OSGetTick() - temp_r31)); - if (OSTicksToMilliseconds(OSGetTick() - temp_r31) >= 500) { - temp_r26 = msmSeGetNumPlay(1); - OSReport("Timed Out! Mus %d:SE %d\n", msmMusGetNumPlay(1), temp_r26); + && OSTicksToMilliseconds(OSGetTick() - osTick) < 500); + OSReport("%d\n", OSTicksToMilliseconds(OSGetTick() - osTick)); + if (OSTicksToMilliseconds(OSGetTick() - osTick) >= 500) { + numPlay = msmSeGetNumPlay(1); + OSReport("Timed Out! Mus %d:SE %d\n", msmMusGetNumPlay(1), numPlay); } - OSReport("GroupSet %d\n", arg0); - sndGroupBak = arg0; - temp_r27 = msmSysDelGroupAll(); - temp_r3 = HuMemDirectMalloc(HEAP_DATA, msmSysGetSampSize(1)); - temp_r27 = msmSysLoadGroupSet(arg0, temp_r3); - OSReport("***********GroupSet Error %d\n", temp_r27); - HuMemDirectFree(temp_r3); + OSReport("GroupSet %d\n", data_size); + sndGroupBak = data_size; + err = msmSysDelGroupAll(); + buf = HuMemDirectMalloc(HEAP_DATA, msmSysGetSampSize(1)); + err = msmSysLoadGroupSet(data_size, buf); + OSReport("***********GroupSet Error %d\n", err); + HuMemDirectFree(buf); } } -void HuAudSndGrpSet(s16 arg0) { - void *temp_r3; +void HuAudSndGrpSet(s16 grpId) { + void *buf; - temp_r3 = HuMemDirectMalloc(HEAP_DATA, msmSysGetSampSize(arg0)); - msmSysLoadGroup(arg0, temp_r3, 0); - HuMemDirectFree(temp_r3); + buf = HuMemDirectMalloc(HEAP_DATA, msmSysGetSampSize(grpId)); + msmSysLoadGroup(grpId, buf, 0); + HuMemDirectFree(buf); } -void HuAudSndCommonGrpSet(s16 arg0, s32 arg1) { - s16 temp_r30; - OSTick temp_r27; - void *temp_r3; +void HuAudSndCommonGrpSet(s16 grpId, s32 groupCheck) { + s16 err; + OSTick osTick; + void *buf; s16 i; for (i = 0; i < 8; i++) { @@ -521,75 +521,75 @@ void HuAudSndCommonGrpSet(s16 arg0, s32 arg1) { } msmMusStopAll(1, 0); msmSeStopAll(1, 0); - temp_r27 = OSGetTick(); + osTick = OSGetTick(); while ((msmMusGetNumPlay(1) != 0 || msmSeGetNumPlay(1) != 0) - && OSTicksToMilliseconds(OSGetTick() - temp_r27) < 500); - OSReport("CommonGrpSet %d\n", arg0); - if (arg1 != 0) { - temp_r30 = msmSysDelGroupBase(0); - if (temp_r30 < 0) { - OSReport("Del Group Error %d\n", temp_r30); + && OSTicksToMilliseconds(OSGetTick() - osTick) < 500); + OSReport("CommonGrpSet %d\n", grpId); + if (groupCheck != 0) { + err = msmSysDelGroupBase(0); + if (err < 0) { + OSReport("Del Group Error %d\n", err); } } - temp_r3 = HuMemDirectMalloc(HEAP_DATA, msmSysGetSampSize(arg0)); - msmSysLoadGroupBase(arg0, temp_r3); - HuMemDirectFree(temp_r3); + buf = HuMemDirectMalloc(HEAP_DATA, msmSysGetSampSize(grpId)); + msmSysLoadGroupBase(grpId, buf); + HuMemDirectFree(buf); sndGroupBak = -1; } -void HuAudAUXSet(s32 arg0, s32 arg1) { - if (arg0 == -1) { - arg0 = 0; +void HuAudAUXSet(s32 auxA, s32 auxB) { + if (auxA == -1) { + auxA = 0; } - if (arg1 == -1) { - arg1 = 1; + if (auxB == -1) { + auxB = 1; } - msmSysSetAux(arg0, arg1); + msmSysSetAux(auxA, auxB); } -void HuAudAUXVolSet(s8 arg0, s8 arg1) { - HuAuxAVol = arg0; - HuAuxBVol = arg1; +void HuAudAUXVolSet(s8 auxA, s8 auxB) { + HuAuxAVol = auxA; + HuAuxBVol = auxB; } void HuAudVoiceInit(s16 ovl) { - SNDGRPTBL *var_r29; - OSTick temp_r23; - s16 var_r27; - s16 temp_r26; + SNDGRPTBL *sndGrp; + OSTick osTick; + s16 numNotChars; + s16 grpId; s16 temp_r25; - s16 temp_r30; + s16 character; - void *temp_r3; + void *buf; s16 i; if (ovl != OVL_INVALID) { - var_r29 = sndGrpTable; + sndGrp = sndGrpTable; while (1) { - if (var_r29->ovl == ovl && var_r29->grpSet == -1) { + if (sndGrp->ovl == ovl && sndGrp->grpSet == -1) { return; } - if (var_r29->ovl == OVL_INVALID) { + if (sndGrp->ovl == OVL_INVALID) { break; } - var_r29++; + sndGrp++; } } - for (i = var_r27 = 0; i < 4; i++) { - temp_r30 = GWPlayerCfg[i].character; - if (temp_r30 < 0 || temp_r30 >= 8 || temp_r30 == 0xFF || charVoiceGroupStat[temp_r30] != 0) { - var_r27++; + for (i = numNotChars = 0; i < 4; i++) { + character = GWPlayerCfg[i].character; + if (character < 0 || character >= 8 || character == 0xFF || charVoiceGroupStat[character] != 0) { + numNotChars++; } } - if (var_r27 < 4) { + if (numNotChars < 4) { for (i = 0; i < 8; i++) { charVoiceGroupStat[i] = 0; } msmMusStopAll(1, 0); msmSeStopAll(1, 0); - temp_r23 = OSGetTick(); + osTick = OSGetTick(); while ((msmMusGetNumPlay(1) != 0 || msmSeGetNumPlay(1) != 0) - && OSTicksToMilliseconds(OSGetTick() - temp_r23) < 500); + && OSTicksToMilliseconds(OSGetTick() - osTick) < 500); OSReport("############CharGrpSet\n"); temp_r25 = msmSysDelGroupBase(0); if (temp_r25 < 0) { @@ -598,39 +598,39 @@ void HuAudVoiceInit(s16 ovl) { OSReport("Del Group OK\n"); } for (i = 0; i < 4; i++) { - temp_r30 = GWPlayerCfg[i].character; - if (temp_r30 >= 0 && temp_r30 < 8 && temp_r30 != 0xFF) { - charVoiceGroupStat[temp_r30] = 1; - temp_r26 = temp_r30 + 0xA; - temp_r3 = HuMemDirectMalloc(HEAP_DATA, msmSysGetSampSize(temp_r26)); + character = GWPlayerCfg[i].character; + if (character >= 0 && character < 8 && character != 0xFF) { + charVoiceGroupStat[character] = 1; + grpId = character + 10; + buf = HuMemDirectMalloc(HEAP_DATA, msmSysGetSampSize(grpId)); #if VERSION_NTSC - msmSysLoadGroupBase(temp_r26, temp_r3); + msmSysLoadGroupBase(grpId, buf); #else - temp_r25 = msmSysLoadGroupBase(temp_r26, temp_r3); + temp_r25 = msmSysLoadGroupBase(grpId, buf); #endif - HuMemDirectFree(temp_r3); + HuMemDirectFree(buf); } } sndGroupBak = -1; } } -s32 HuAudPlayerVoicePlay(s16 arg0, s16 arg1) { - s16 temp_r31 = GWPlayerCfg[arg0].character; +s32 HuAudPlayerVoicePlay(s16 player, s16 seId) { + s16 charNo = GWPlayerCfg[player].character; - return HuAudCharVoicePlay(temp_r31, arg1); + return HuAudCharVoicePlay(charNo, seId); } -s32 HuAudPlayerVoicePlayPos(s16 arg0, s16 arg1, Vec *arg2) { - s16 temp_r31 = GWPlayerCfg[arg0].character; +s32 HuAudPlayerVoicePlayPos(s16 player, s16 seId, Vec *pos) { + s16 charNo = GWPlayerCfg[player].character; - return HuAudCharVoicePlayPos(temp_r31, arg1, arg2); + return HuAudCharVoicePlayPos(charNo, seId, pos); } -void HuAudPlayerVoicePlayEntry(s16 arg0, s16 arg1) { - s16 temp_r31 = GWPlayerCfg[arg0].character; +void HuAudPlayerVoicePlayEntry(s16 player, s16 seId) { + s16 charNo = GWPlayerCfg[player].character; - HuAudCharVoicePlayEntry(temp_r31, arg1); + HuAudCharVoicePlayEntry(charNo, seId); } s32 HuAudCharVoicePlay(s16 charNo, s16 seId) @@ -676,14 +676,14 @@ s32 HuAudCharVoicePlayPos(s16 charNo, s16 seId, Vec *pos) { } void HuAudCharVoicePlayEntry(s16 charNo, s16 seId) { - int spC[MSM_ENTRY_SENO_MAX]; // size unknown (min: 30, max: 33) - u16 temp_r29; + int seNoTbl[MSM_ENTRY_SENO_MAX]; // size unknown (min: 30, max: 33) + u16 id; u16 i; seId += (charNo << 6); - temp_r29 = msmSeGetEntryID(seId, spC); - for (i = 0; i < temp_r29; i++) { - msmSeStop(spC[i], 0); + id = msmSeGetEntryID(seId, seNoTbl); + for (i = 0; i < id; i++) { + msmSeStop(seNoTbl[i], 0); } } diff --git a/src/game/board/audio.c b/src/game/board/audio.c index e79abe27..d5d8ccda 100755 --- a/src/game/board/audio.c +++ b/src/game/board/audio.c @@ -15,64 +15,64 @@ static s16 boardMusTbl[] = { }; void BoardMusStartBoard(void) { - s16 temp_r31 = boardMusTbl[GWBoardGet()]; + s16 musIdx = boardMusTbl[GWBoardGet()]; - BoardMusStart(0, temp_r31, 0x7F, 0); + BoardMusStart(0, musIdx, 0x7F, 0); BoardAudFXPlay(); } -void BoardMusStart(s32 arg0, s32 arg1, s8 arg2, u16 arg3) { - s16 *temp_r31 = boardSeq[arg0]; +void BoardMusStart(s32 boardNo, s32 musId, s8 vol, u16 speed) { + s16 *board = boardSeq[boardNo]; MSM_MUSPARAM param; - if (arg1 == temp_r31[1]) { + if (musId == board[1]) { return; } - if (temp_r31[0] != -1) { - BoardAudSeqFadeOutFast(temp_r31[0]); + if (board[0] != -1) { + BoardAudSeqFadeOutFast(board[0]); } param.flag = MSM_MUSPARAM_CHAN; - if (arg3 != 0) { + if (speed != 0) { param.flag |= MSM_MUSPARAM_FADESPEED; } - if (arg2 < 0) { + if (vol < 0) { param.flag |= MSM_MUSPARAM_VOL; - arg2 = 0x7F; + vol = 0x7F; } - param.fadeSpeed = arg3; - param.vol = arg2; - param.chan = arg0; - temp_r31[0] = msmMusPlay(arg1, ¶m); - temp_r31[1] = arg1; + param.fadeSpeed = speed; + param.vol = vol; + param.chan = boardNo; + board[0] = msmMusPlay(musId, ¶m); + board[1] = musId; } -void BoardAudSeqFadeOutFast(s32 arg0) { - BoardAudSeqFadeOut(arg0, 0x64); +void BoardAudSeqFadeOutFast(s32 boardNo) { + BoardAudSeqFadeOut(boardNo, 0x64); } -void BoardAudSeqFadeOut(s32 arg0, u16 arg1) { - s16 *temp_r31 = boardSeq[arg0]; +void BoardAudSeqFadeOut(s32 boardNo, u16 speed) { + s16 *board = boardSeq[boardNo]; - if (temp_r31[0] == -1) { + if (board[0] == -1) { return; } - HuAudSeqFadeOut(temp_r31[0], arg1); - temp_r31[1] = temp_r31[0] = -1; + HuAudSeqFadeOut(board[0], speed); + board[1] = board[0] = -1; } -void BoardMusLoudSet(s32 arg0, s32 arg1) { - if (arg1 != 0) { - BoardMusVolPanSet(arg0, 0x60, 0x1F4); +void BoardMusLoudSet(s32 boardNo, s32 isQuieter) { + if (isQuieter != 0) { + BoardMusVolPanSet(boardNo, 0x60, 0x1F4); } else { - BoardMusVolPanSet(arg0, 0x7F, 0x1F4); + BoardMusVolPanSet(boardNo, 0x7F, 0x1F4); } } -void BoardMusVolPanSet(s32 arg0, s8 vol, u16 fadeSpeed) { - s16 *temp_r31 = boardSeq[arg0]; +void BoardMusVolPanSet(s32 boardNo, s8 vol, u16 fadeSpeed) { + s16 *board = boardSeq[boardNo]; MSM_MUSPARAM param; - if (temp_r31[0] == -1) { + if (board[0] == -1) { return; } param.flag = MSM_MUSPARAM_CHAN; @@ -82,32 +82,32 @@ void BoardMusVolPanSet(s32 arg0, s8 vol, u16 fadeSpeed) { } param.fadeSpeed = fadeSpeed; param.vol = vol; - msmMusSetParam(temp_r31[0], ¶m); + msmMusSetParam(board[0], ¶m); } -void BoardAudSeqPause(s32 arg0, s32 arg1, u16 arg2) { - s16 *temp_r31 = boardSeq[arg0]; +void BoardAudSeqPause(s32 boardNo, s32 pause, u16 speed) { + s16 *board = boardSeq[boardNo]; - if (temp_r31[0] == -1) { + if (board[0] == -1) { return; } - if (arg1 != 0) { - if (BoardMusStatusGet(arg0) == 3) { + if (pause != 0) { + if (BoardMusStatusGet(boardNo) == 3) { return; } - } else if (BoardMusStatusGet(arg0) != 3) { + } else if (BoardMusStatusGet(boardNo) != 3) { return; } - HuAudSeqPause(temp_r31[0], arg1, arg2); + HuAudSeqPause(board[0], pause, speed); } -s32 BoardMusStatusGet(s32 arg0) { - s16 *temp_r31 = boardSeq[arg0]; +s32 BoardMusStatusGet(s32 boardNo) { + s16 *board = boardSeq[boardNo]; - if (temp_r31[0] == -1) { + if (board[0] == -1) { return 0; } - return msmMusGetStatus(temp_r31[0]); + return msmMusGetStatus(board[0]); } void BoardAudSeqClear(void) { @@ -134,20 +134,20 @@ void BoardAudSeqFadeOutAll(void) { } void BoardAudFXPlay(void) { - s32 var_r31; + s32 seId; switch (GWBoardGet()) { case BOARD_ID_MAIN5: - var_r31 = 0x48D; + seId = 0x48D; break; case BOARD_ID_MAIN6: - var_r31 = 0x4A2; + seId = 0x4A2; break; default: return; } if (boardFX == -1) { - boardFX = HuAudFXPlay(var_r31); + boardFX = HuAudFXPlay(seId); } } From 560a59251803183e9608037fa4f6a0306703303a Mon Sep 17 00:00:00 2001 From: Liam Coleman Date: Thu, 6 Feb 2025 10:41:45 -0600 Subject: [PATCH 6/6] Add symbols for instdll and resultdll in us (#562) * Label most of w01Dll * Add symbols for instdll and resultdll in us * Fix pal symbols for instDll * Build resultdll+symbols for pal --- config/GMPE01_00/rels/instDll/symbols.txt | 76 +- config/GMPE01_00/rels/resultDll/symbols.txt | 184 +-- config/GMPP01_00/rels/instDll/symbols.txt | 88 +- config/GMPP01_00/rels/resultDll/symbols.txt | 188 +-- configure.py | 6 +- include/REL/instDll.h | 2 +- include/REL/resultdll.h | 34 +- src/REL/instDll/font.c | 156 +-- src/REL/instDll/main.c | 1033 +++++++------- src/REL/resultDll/battle.c | 589 ++++---- src/REL/resultDll/datalist.c | 38 +- src/REL/resultDll/main.c | 1357 +++++++++---------- 12 files changed, 1876 insertions(+), 1875 deletions(-) diff --git a/config/GMPE01_00/rels/instDll/symbols.txt b/config/GMPE01_00/rels/instDll/symbols.txt index 0580b867..cc0a6047 100644 --- a/config/GMPE01_00/rels/instDll/symbols.txt +++ b/config/GMPE01_00/rels/instDll/symbols.txt @@ -1,16 +1,16 @@ _prolog = .text:0x00000000; // type:function size:0x54 scope:global _epilog = .text:0x00000054; // type:function size:0x4C scope:global ObjectSetup = .text:0x000000A0; // type:function size:0x8F4 -fn_1_994 = .text:0x00000994; // type:function size:0xE50 scope:local -fn_1_17E4 = .text:0x000017E4; // type:function size:0xA28 scope:local -fn_1_220C = .text:0x0000220C; // type:function size:0x5F8 scope:local -fn_1_2804 = .text:0x00002804; // type:function size:0x79C scope:local -fn_1_2FA0 = .text:0x00002FA0; // type:function size:0x11D4 scope:local -fn_1_4174 = .text:0x00004174; // type:function size:0x3B4 scope:local -fn_1_4528 = .text:0x00004528; // type:function size:0xB88 scope:local -fn_1_50B0 = .text:0x000050B0; // type:function size:0xAB4 scope:local -fn_1_5B64 = .text:0x00005B64; // type:function size:0x340 scope:local -fn_1_5EA4 = .text:0x00005EA4; // type:function size:0x4B8 +InstMain = .text:0x00000994; // type:function size:0xE50 scope:local +InstPlayerMain = .text:0x000017E4; // type:function size:0xA28 scope:local +InstHostMain = .text:0x0000220C; // type:function size:0x5F8 scope:local +InstWinMain = .text:0x00002804; // type:function size:0x79C scope:local +InstNameMain = .text:0x00002FA0; // type:function size:0x11D4 scope:local +CameraOutView = .text:0x00004174; // type:function size:0x3B4 scope:local +CameraDebug = .text:0x00004528; // type:function size:0xB88 scope:local +InstPicDraw = .text:0x000050B0; // type:function size:0xAB4 scope:local +ShadowDraw = .text:0x00005B64; // type:function size:0x340 scope:local +FontCreate = .text:0x00005EA4; // type:function size:0x4B8 _ctors = .ctors:0x00000000; // type:label scope:global data:4byte _dtors = .dtors:0x00000000; // type:label scope:global data:4byte lbl_1_rodata_10 = .rodata:0x00000010; // type:object size:0x4 scope:local data:float @@ -115,38 +115,38 @@ lbl_1_rodata_204 = .rodata:0x00000204; // type:object size:0x4 scope:local data: lbl_1_rodata_208 = .rodata:0x00000208; // type:object size:0x4 scope:local data:float lbl_1_rodata_20C = .rodata:0x0000020C; // type:object size:0x4 scope:local data:float lbl_1_rodata_210 = .rodata:0x00000210; // type:object size:0x8 scope:local data:double -lbl_1_data_0 = .data:0x00000000; // type:object size:0x2 scope:local data:2byte +instMode = .data:0x00000000; // type:object size:0x2 scope:local data:2byte lbl_1_data_2 = .data:0x00000002; // type:object size:0x24 scope:local data:string -lbl_1_data_26 = .data:0x00000026; // type:object size:0x20 scope:local -lbl_1_data_46 = .data:0x00000046; // type:object size:0x8 scope:local -lbl_1_data_50 = .data:0x00000050; // type:object size:0x20 scope:local -lbl_1_data_70 = .data:0x00000070; // type:object size:0x20 scope:local +instGrpTbl = .data:0x00000026; // type:object size:0x20 scope:local +instPlayerNumTbl = .data:0x00000046; // type:object size:0x8 scope:local +instBoxFile = .data:0x00000050; // type:object size:0x20 scope:local +instBackFile = .data:0x00000070; // type:object size:0x20 scope:local lbl_1_data_90 = .data:0x00000090; // type:object size:0x8 scope:local data:string lbl_1_data_98 = .data:0x00000098; // type:object size:0x8 scope:local data:string lbl_1_data_A0 = .data:0x000000A0; // type:object size:0x8 scope:local data:string lbl_1_data_A8 = .data:0x000000A8; // type:object size:0x8 scope:local data:string -lbl_1_data_B0 = .data:0x000000B0; // type:object size:0x10 scope:local -lbl_1_data_C0 = .data:0x000000C0; // type:object size:0x4 scope:local -lbl_1_data_C4 = .data:0x000000C4; // type:object size:0x48 scope:local -lbl_1_data_10C = .data:0x0000010C; // type:object size:0x18 scope:local -lbl_1_data_124 = .data:0x00000124; // type:object size:0x20 scope:local data:float -lbl_1_data_144 = .data:0x00000144; // type:object size:0x4 scope:local +playerPosNameTbl = .data:0x000000B0; // type:object size:0x10 scope:local +playerDelayTbl = .data:0x000000C0; // type:object size:0x4 scope:local +hostFileTbl = .data:0x000000C4; // type:object size:0x48 scope:local +hostSeTbl = .data:0x0000010C; // type:object size:0x18 scope:local +instNamePosTbl = .data:0x00000124; // type:object size:0x20 scope:local data:float +cameraMask$858 = .data:0x00000144; // type:object size:0x4 scope:local lbl_1_data_148 = .data:0x00000148; // type:object size:0x4 scope:local -lbl_1_data_14C = .data:0x0000014C; // type:object size:0x4 scope:local data:float -lbl_1_data_150 = .data:0x00000150; // type:object size:0x318 scope:local -lbl_1_bss_0 = .bss:0x00000000; // type:object size:0x4 scope:local data:4byte -lbl_1_bss_4 = .bss:0x00000004; // type:object size:0x2 scope:local data:2byte -lbl_1_bss_6 = .bss:0x00000006; // type:object size:0x2 scope:local data:2byte -lbl_1_bss_8 = .bss:0x00000008; // type:object size:0x1 scope:local data:byte -lbl_1_bss_C = .bss:0x0000000C; // type:object size:0x4 scope:local data:float -lbl_1_bss_10 = .bss:0x00000010; // type:object size:0x2 scope:local data:2byte -lbl_1_bss_12 = .bss:0x00000012; // type:object size:0x2 scope:local data:2byte -lbl_1_bss_14 = .bss:0x00000014; // type:object size:0x2 scope:local data:2byte -lbl_1_bss_18 = .bss:0x00000018; // type:object size:0x4 scope:local data:4byte -lbl_1_bss_1C = .bss:0x0000001C; // type:object size:0x4 scope:local data:4byte -lbl_1_bss_20 = .bss:0x00000020; // type:object size:0x8 scope:local data:float -lbl_1_bss_28 = .bss:0x00000028; // type:object size:0x18 scope:local data:float -lbl_1_bss_40 = .bss:0x00000040; // type:object size:0x18 scope:local data:float -lbl_1_bss_58 = .bss:0x00000058; // type:object size:0x4 scope:local data:4byte -lbl_1_bss_5C = .bss:0x0000005C; // type:object size:0x4 scope:local data:4byte +instPicRadius = .data:0x0000014C; // type:object size:0x4 scope:local data:float +FontCharFile = .data:0x00000150; // type:object size:0x318 scope:local +debugCamOnF = .bss:0x00000000; // type:object size:0x4 scope:local data:4byte +instBusyF = .bss:0x00000004; // type:object size:0x2 scope:local data:2byte +instPage = .bss:0x00000006; // type:object size:0x2 scope:local data:2byte +LanguageNo = .bss:0x00000008; // type:object size:0x1 scope:local data:byte +instFov = .bss:0x0000000C; // type:object size:0x4 scope:local data:float +instMesOfs = .bss:0x00000010; // type:object size:0x2 scope:local data:2byte +instHostNo = .bss:0x00000012; // type:object size:0x2 scope:local data:2byte +instMgNo = .bss:0x00000014; // type:object size:0x2 scope:local data:2byte +instPicAnim = .bss:0x00000018; // type:object size:0x4 scope:local data:4byte +instBoxMdlId = .bss:0x0000001C; // type:object size:0x4 scope:local data:4byte +cameraZoom = .bss:0x00000020; // type:object size:0x8 data:float +cameraPos = .bss:0x00000028; // type:object size:0x18 data:float +cameraRot = .bss:0x00000040; // type:object size:0x18 data:float +objman = .bss:0x00000058; // type:object size:0x4 data:4byte +outViewObj = .bss:0x0000005C; // type:object size:0x4 scope:local data:4byte lbl_1_bss_60 = .bss:0x00000060; // type:object size:0x4 scope:local data:4byte diff --git a/config/GMPE01_00/rels/resultDll/symbols.txt b/config/GMPE01_00/rels/resultDll/symbols.txt index 14dbe624..db16ef1b 100644 --- a/config/GMPE01_00/rels/resultDll/symbols.txt +++ b/config/GMPE01_00/rels/resultDll/symbols.txt @@ -1,34 +1,34 @@ _prolog = .text:0x00000000; // type:function size:0x54 scope:global _epilog = .text:0x00000054; // type:function size:0x4C scope:global ObjectSetup = .text:0x000000A0; // type:function size:0x438 -fn_1_4D8 = .text:0x000004D8; // type:function size:0x3B0 -fn_1_888 = .text:0x00000888; // type:function size:0x2F0 -fn_1_B78 = .text:0x00000B78; // type:function size:0x13D4 -fn_1_1F4C = .text:0x00001F4C; // type:function size:0xB90 -fn_1_2ADC = .text:0x00002ADC; // type:function size:0x1074 -fn_1_3B50 = .text:0x00003B50; // type:function size:0x15C -fn_1_3CAC = .text:0x00003CAC; // type:function size:0x15C -fn_1_3E08 = .text:0x00003E08; // type:function size:0x1D0 -fn_1_3FD8 = .text:0x00003FD8; // type:function size:0x104 -fn_1_40DC = .text:0x000040DC; // type:function size:0x160 -fn_1_423C = .text:0x0000423C; // type:function size:0x3E0 -fn_1_461C = .text:0x0000461C; // type:function size:0x1E0 -fn_1_47FC = .text:0x000047FC; // type:function size:0x1084 -fn_1_5880 = .text:0x00005880; // type:function size:0xC10 -fn_1_6490 = .text:0x00006490; // type:function size:0x2D0 -fn_1_6760 = .text:0x00006760; // type:function size:0xC4 -fn_1_6824 = .text:0x00006824; // type:function size:0xD20 -fn_1_7544 = .text:0x00007544; // type:function size:0xA54 -fn_1_7F98 = .text:0x00007F98; // type:function size:0x3A0 -fn_1_8338 = .text:0x00008338; // type:function size:0x14C -fn_1_8484 = .text:0x00008484; // type:function size:0x1D4 -fn_1_8658 = .text:0x00008658; // type:function size:0x84 -fn_1_86DC = .text:0x000086DC; // type:function size:0x2BC -fn_1_8998 = .text:0x00008998; // type:function size:0x320 -fn_1_8CB8 = .text:0x00008CB8; // type:function size:0x340 -fn_1_8FF8 = .text:0x00008FF8; // type:function size:0x284 -fn_1_927C = .text:0x0000927C; // type:function size:0x138 -fn_1_93B4 = .text:0x000093B4; // type:function size:0x78 +ResultMain = .text:0x000004D8; // type:function size:0x3B0 scope:local +ResultIdle = .text:0x00000888; // type:function size:0x2F0 scope:local +ResultCreate = .text:0x00000B78; // type:function size:0x13D4 scope:local +ResultStatAdd = .text:0x00001F4C; // type:function size:0xB90 scope:local +ResultOrderApply = .text:0x00002ADC; // type:function size:0x1074 scope:local +ResultSprNumSet = .text:0x00003B50; // type:function size:0x15C scope:local +ResultCoinAddNumSet = .text:0x00003CAC; // type:function size:0x15C scope:local +ResultOrderSet = .text:0x00003E08; // type:function size:0x1D0 scope:local +ResultBoardDataRead = .text:0x00003FD8; // type:function size:0x104 +ResultCoinAdd = .text:0x000040DC; // type:function size:0x160 +ResultCoinNumGet = .text:0x0000423C; // type:function size:0x3E0 +SaveExec = .text:0x0000461C; // type:function size:0x1E0 scope:local +ResultTeamExec = .text:0x000047FC; // type:function size:0x1084 scope:local +CameraDebug = .text:0x00005880; // type:function size:0xC10 +ResultBattleMain = .text:0x00006490; // type:function size:0x2D0 +ResultBattleIdle = .text:0x00006760; // type:function size:0xC4 scope:local +ResultBattleCreate = .text:0x00006824; // type:function size:0xD20 scope:local +ResultBattleStatAdd = .text:0x00007544; // type:function size:0xA54 scope:local +ResultBattleCoinAddShow = .text:0x00007F98; // type:function size:0x3A0 scope:local +ResultBattleCoinAddNumSet = .text:0x00008338; // type:function size:0x14C scope:local +ResultBattleOrderSet = .text:0x00008484; // type:function size:0x1D4 scope:local +CoinEffectInit = .text:0x00008658; // type:function size:0x84 scope:local +CoinEffectAdd = .text:0x000086DC; // type:function size:0x2BC scope:local +CoinEffectMain = .text:0x00008998; // type:function size:0x320 scope:local +ResultShadowDraw = .text:0x00008CB8; // type:function size:0x340 scope:local +StageModelCreate = .text:0x00008FF8; // type:function size:0x284 +StageSpriteCreate = .text:0x0000927C; // type:function size:0x138 +StageSpriteKill = .text:0x000093B4; // type:function size:0x78 _ctors = .ctors:0x00000000; // type:label scope:global data:4byte _dtors = .dtors:0x00000000; // type:label scope:global data:4byte lbl_1_rodata_10 = .rodata:0x00000010; // type:object size:0x4 scope:local data:float @@ -134,77 +134,77 @@ lbl_1_rodata_218 = .rodata:0x00000218; // type:object size:0x4 scope:local data: lbl_1_rodata_21C = .rodata:0x0000021C; // type:object size:0x4 scope:local data:float lbl_1_rodata_220 = .rodata:0x00000220; // type:object size:0x4 scope:local data:float lbl_1_rodata_228 = .rodata:0x00000228; // type:object size:0x8 scope:local data:double -lbl_1_data_0 = .data:0x00000000; // type:object size:0x2A4 -lbl_1_data_2A4 = .data:0x000002A4; // type:object size:0xDC data:4byte -lbl_1_data_380 = .data:0x00000380; // type:object size:0x2 data:2byte +resultModel = .data:0x00000000; // type:object size:0x2A4 scope:local +resultSprite = .data:0x000002A4; // type:object size:0xDC scope:local data:4byte +rankNewGrpId = .data:0x00000380; // type:object size:0x2 scope:local data:2byte lbl_1_data_382 = .data:0x00000382; // type:object size:0x26 scope:local data:string -lbl_1_data_3A8 = .data:0x000003A8; // type:object size:0x18 -lbl_1_data_3C0 = .data:0x000003C0; // type:object size:0x18 -lbl_1_data_3D8 = .data:0x000003D8; // type:object size:0x20 -lbl_1_data_3F8 = .data:0x000003F8; // type:object size:0x10 -lbl_1_data_408 = .data:0x00000408; // type:object size:0x30 -lbl_1_data_438 = .data:0x00000438; // type:object size:0x10 +resultBackFile = .data:0x000003A8; // type:object size:0x18 scope:local +resultLetterFile = .data:0x000003C0; // type:object size:0x18 scope:local +resultStatPosTbl = .data:0x000003D8; // type:object size:0x20 scope:local +resultRankPosTbl = .data:0x000003F8; // type:object size:0x10 scope:local +resultCharPosTbl = .data:0x00000408; // type:object size:0x30 scope:local +resultCoinAddPosTbl = .data:0x00000438; // type:object size:0x10 scope:local lbl_1_data_448 = .data:0x00000448; // type:object size:0x5 scope:local data:string -lbl_1_data_450 = .data:0x00000450; // type:object size:0x18 -lbl_1_data_468 = .data:0x00000468; // type:object size:0x20 -lbl_1_data_488 = .data:0x00000488; // type:object size:0x30 +resultBoardDirTbl = .data:0x00000450; // type:object size:0x18 scope:local +resultCharMdlTbl = .data:0x00000468; // type:object size:0x20 scope:local +resultTeamCharPosTbl = .data:0x00000488; // type:object size:0x30 scope:local lbl_1_data_4B8 = .data:0x000004B8; // type:object size:0x11 scope:local data:string lbl_1_data_4C9 = .data:0x000004C9; // type:object size:0x11 scope:local data:string lbl_1_data_4DA = .data:0x000004DA; // type:object size:0xB scope:local data:string -lbl_1_data_4E8 = .data:0x000004E8; // type:object size:0x270 -lbl_1_data_758 = .data:0x00000758; // type:object size:0x28 -lbl_1_data_780 = .data:0x00000780; // type:object size:0x50 -lbl_1_data_7D0 = .data:0x000007D0; // type:object size:0x20 -lbl_1_data_7F0 = .data:0x000007F0; // type:object size:0x30 +resultBattleModel = .data:0x000004E8; // type:object size:0x270 scope:local +resultBattleSprite = .data:0x00000758; // type:object size:0x28 scope:local +resultBattleEffParMan = .data:0x00000780; // type:object size:0x50 scope:local +resultStatPosTbl = .data:0x000007D0; // type:object size:0x20 scope:local +playerPosTbl = .data:0x000007F0; // type:object size:0x30 scope:local lbl_1_data_820 = .data:0x00000820; // type:object size:0x10 -lbl_1_data_830 = .data:0x00000830; // type:object size:0x10 -lbl_1_data_840 = .data:0x00000840; // type:object size:0x20 -lbl_1_data_860 = .data:0x00000860; // type:object size:0x20 -lbl_1_data_880 = .data:0x00000880; // type:object size:0x20 -lbl_1_data_8A0 = .data:0x000008A0; // type:object size:0x6 data:2byte -lbl_1_data_8A6 = .data:0x000008A6; // type:object size:0x8 scope:local data:float -lbl_1_data_8AE = .data:0x000008AE; // type:object size:0x8 scope:local data:float -lbl_1_data_8B8 = .data:0x000008B8; // type:object size:0x60 -lbl_1_bss_0 = .bss:0x00000000; // type:object size:0x4 data:4byte -lbl_1_bss_4 = .bss:0x00000004; // type:object size:0x4 data:4byte -lbl_1_bss_8 = .bss:0x00000008; // type:object size:0x2 data:2byte -lbl_1_bss_A = .bss:0x0000000A; // type:object size:0x8 -lbl_1_bss_12 = .bss:0x00000012; // type:object size:0x28 -lbl_1_bss_3A = .bss:0x0000003A; // type:object size:0x8 -lbl_1_bss_42 = .bss:0x00000042; // type:object size:0x8 -lbl_1_bss_4A = .bss:0x0000004A; // type:object size:0x8 -lbl_1_bss_52 = .bss:0x00000052; // type:object size:0x2 data:2byte -lbl_1_bss_54 = .bss:0x00000054; // type:object size:0x8 -lbl_1_bss_5C = .bss:0x0000005C; // type:object size:0x40 -lbl_1_bss_9C = .bss:0x0000009C; // type:object size:0x2 data:2byte -lbl_1_bss_9E = .bss:0x0000009E; // type:object size:0x30 -lbl_1_bss_CE = .bss:0x000000CE; // type:object size:0x12 -lbl_1_bss_E0 = .bss:0x000000E0; // type:object size:0x4 data:4byte -lbl_1_bss_E4 = .bss:0x000000E4; // type:object size:0x60 -lbl_1_bss_144 = .bss:0x00000144; // type:object size:0x14 -lbl_1_bss_158 = .bss:0x00000158; // type:object size:0x10 -lbl_1_bss_168 = .bss:0x00000168; // type:object size:0x8 -lbl_1_bss_170 = .bss:0x00000170; // type:object size:0x2 data:2byte -lbl_1_bss_172 = .bss:0x00000172; // type:object size:0x2 data:2byte -lbl_1_bss_174 = .bss:0x00000174; // type:object size:0x4 data:4byte -lbl_1_bss_178 = .bss:0x00000178; // type:object size:0x4 data:4byte -lbl_1_bss_17C = .bss:0x0000017C; // type:object size:0x2 data:2byte -lbl_1_bss_180 = .bss:0x00000180; // type:object size:0x4 data:4byte -lbl_1_bss_184 = .bss:0x00000184; // type:object size:0x4 data:4byte +bomheiCubeMdlTbl = .data:0x00000830; // type:object size:0x10 scope:local +coinEffectYOfs = .data:0x00000840; // type:object size:0x20 scope:local +coinAddYOfs = .data:0x00000860; // type:object size:0x20 scope:local +coinBlankYOfs = .data:0x00000880; // type:object size:0x20 scope:local +coinNumXOfs = .data:0x000008A0; // type:object size:0x6 scope:local data:2byte +lbl_1_data_8A6 = .data:0x000008A6; // type:object size:0x8 scope:local data:string +lbl_1_data_8AE = .data:0x000008AE; // type:object size:0x8 scope:local data:string +cameraShakeOfs = .data:0x000008B8; // type:object size:0x60 scope:local +resultReorderF = .bss:0x00000000; // type:object size:0x4 scope:local data:4byte +resultSkipF = .bss:0x00000004; // type:object size:0x4 scope:local data:4byte +resultTeamOrder = .bss:0x00000008; // type:object size:0x2 scope:local data:2byte +resultCharCubeMdlId = .bss:0x0000000A; // type:object size:0x8 scope:local +resultCoinAddSprId = .bss:0x00000012; // type:object size:0x28 scope:local +resultCoinAddGrpId = .bss:0x0000003A; // type:object size:0x8 scope:local +resultRank = .bss:0x00000042; // type:object size:0x8 scope:local +resultOrder = .bss:0x0000004A; // type:object size:0x8 scope:local +resultRankGrpId = .bss:0x00000052; // type:object size:0x2 scope:local data:2byte +resultPlayerCubeMdlId = .bss:0x00000054; // type:object size:0x8 scope:local +resultCubeMdlId = .bss:0x0000005C; // type:object size:0x40 scope:local +resultCrownGrpId = .bss:0x0000009C; // type:object size:0x2 scope:local data:2byte +resultNumSprId = .bss:0x0000009E; // type:object size:0x30 scope:local +resultNumGrpId = .bss:0x000000CE; // type:object size:0x10 scope:local +resultCrownAnim = .bss:0x000000E0; // type:object size:0x4 scope:local data:4byte +resultCharAnim = .bss:0x000000E4; // type:object size:0x60 scope:local +resultRankAnim = .bss:0x00000144; // type:object size:0x14 scope:local +statShadowMdlId = .bss:0x00000158; // type:object size:0x10 scope:local +charShadowMdlId = .bss:0x00000168; // type:object size:0x8 scope:local +teamResultGrpId = .bss:0x00000170; // type:object size:0x2 scope:local data:2byte +resultBonusPlayer = .bss:0x00000172; // type:object size:0x2 data:2byte +resultFastF = .bss:0x00000174; // type:object size:0x4 data:4byte +resultReadEndF = .bss:0x00000178; // type:object size:0x4 data:4byte +resultMgNo = .bss:0x0000017C; // type:object size:0x2 data:2byte +objman = .bss:0x00000180; // type:object size:0x4 data:4byte +outViewObj = .bss:0x00000184; // type:object size:0x4 scope:local data:4byte lbl_1_bss_188 = .bss:0x00000188; // type:object size:0x4 data:4byte -lbl_1_bss_190 = .bss:0x00000190; // type:object size:0x4 data:4byte -lbl_1_bss_194 = .bss:0x00000194; // type:object size:0x1680 -lbl_1_bss_1814 = .bss:0x00001814; // type:object size:0x8 +resultBattleSkipF = .bss:0x00000190; // type:object size:0x4 scope:local data:4byte +coinEffectData = .bss:0x00000194; // type:object size:0x1680 scope:local +resultBattleEffParManId = .bss:0x00001814; // type:object size:0x8 scope:local lbl_1_bss_181C = .bss:0x0000181C; // type:object size:0xC -lbl_1_bss_1828 = .bss:0x00001828; // type:object size:0x168 data:2byte -lbl_1_bss_1990 = .bss:0x00001990; // type:object size:0x20 -lbl_1_bss_19B0 = .bss:0x000019B0; // type:object size:0x8 -lbl_1_bss_19B8 = .bss:0x000019B8; // type:object size:0x28 -lbl_1_bss_19E0 = .bss:0x000019E0; // type:object size:0x8 -lbl_1_bss_19E8 = .bss:0x000019E8; // type:object size:0x8 -lbl_1_bss_19F0 = .bss:0x000019F0; // type:object size:0x8 +coinEffectMdlId = .bss:0x00001828; // type:object size:0x168 scope:local data:2byte +resultBattleCharMot = .bss:0x00001990; // type:object size:0x20 scope:local +resultBattleCharMdl = .bss:0x000019B0; // type:object size:0x8 scope:local +coinNumSprId = .bss:0x000019B8; // type:object size:0x28 scope:local +coinNumGrpId = .bss:0x000019E0; // type:object size:0x8 scope:local +resultBattleRank = .bss:0x000019E8; // type:object size:0x8 scope:local +resultBattleOrder = .bss:0x000019F0; // type:object size:0x8 scope:local lbl_1_bss_19F8 = .bss:0x000019F8; // type:object size:0x20 lbl_1_bss_1A18 = .bss:0x00001A18; // type:object size:0x2 -lbl_1_bss_1A1A = .bss:0x00001A1A; // type:object size:0x42 data:2byte -lbl_1_bss_1A5C = .bss:0x00001A5C; // type:object size:0x40 data:2byte -lbl_1_bss_1A9C = .bss:0x00001A9C; // type:object size:0x40 data:2byte +stageSprId = .bss:0x00001A1A; // type:object size:0x42 data:2byte +stageMotId = .bss:0x00001A5C; // type:object size:0x40 data:2byte +stageSprId = .bss:0x00001A9C; // type:object size:0x40 data:2byte diff --git a/config/GMPP01_00/rels/instDll/symbols.txt b/config/GMPP01_00/rels/instDll/symbols.txt index 5cb1ad79..da39c5b5 100644 --- a/config/GMPP01_00/rels/instDll/symbols.txt +++ b/config/GMPP01_00/rels/instDll/symbols.txt @@ -1,16 +1,16 @@ _prolog = .text:0x00000000; // type:function size:0x54 scope:global _epilog = .text:0x00000054; // type:function size:0x4C scope:global ObjectSetup = .text:0x000000A0; // type:function size:0x8F4 -fn_1_994 = .text:0x00000994; // type:function size:0xE50 -fn_1_17E4 = .text:0x000017E4; // type:function size:0xA28 -fn_1_220C = .text:0x0000220C; // type:function size:0x5F8 -fn_1_2804 = .text:0x00002804; // type:function size:0x79C -fn_1_2FA0 = .text:0x00002FA0; // type:function size:0x11D4 -fn_1_4174 = .text:0x00004174; // type:function size:0x3B4 -fn_1_4528 = .text:0x00004528; // type:function size:0xB88 -fn_1_50B0 = .text:0x000050B0; // type:function size:0xAB4 -fn_1_5B64 = .text:0x00005B64; // type:function size:0x340 -fn_1_5EA4 = .text:0x00005EA4; // type:function size:0x3F8 +InstMain = .text:0x00000994; // type:function size:0xE50 scope:local +InstPlayerMain = .text:0x000017E4; // type:function size:0xA28 scope:local +InstHostMain = .text:0x0000220C; // type:function size:0x5F8 scope:local +InstWinMain = .text:0x00002804; // type:function size:0x79C scope:local +InstNameMain = .text:0x00002FA0; // type:function size:0x11D4 scope:local +CameraOutView = .text:0x00004174; // type:function size:0x3B4 scope:local +CameraDebug = .text:0x00004528; // type:function size:0xB88 scope:local +InstPicDraw = .text:0x000050B0; // type:function size:0xAB4 scope:local +ShadowDraw = .text:0x00005B64; // type:function size:0x340 scope:local +FontCreate = .text:0x00005EA4; // type:function size:0x3F8 _ctors = .ctors:0x00000000; // type:label scope:global data:4byte _dtors = .dtors:0x00000000; // type:label scope:global data:4byte lbl_1_rodata_10 = .rodata:0x00000010; // type:object size:0x4 data:float @@ -112,36 +112,38 @@ lbl_1_rodata_1F8 = .rodata:0x000001F8; // type:object size:0x4 data:float lbl_1_rodata_1FC = .rodata:0x000001FC; // type:object size:0x4 data:float lbl_1_rodata_200 = .rodata:0x00000200; // type:object size:0x4 data:float lbl_1_rodata_208 = .rodata:0x00000208; // type:object size:0x8 data:double -lbl_1_data_0 = .data:0x00000000; // type:object size:0x2 data:2byte -lbl_1_data_2 = .data:0x00000002; // type:object size:0x24 data:string -lbl_1_data_26 = .data:0x00000026; // type:object size:0x20 -lbl_1_data_46 = .data:0x00000046; // type:object size:0xA -lbl_1_data_50 = .data:0x00000050; // type:object size:0x20 -lbl_1_data_70 = .data:0x00000070; // type:object size:0x20 -lbl_1_data_90 = .data:0x00000090; // type:object size:0x8 data:string -lbl_1_data_98 = .data:0x00000098; // type:object size:0x8 data:string -lbl_1_data_A0 = .data:0x000000A0; // type:object size:0x8 data:string -lbl_1_data_A8 = .data:0x000000A8; // type:object size:0x8 data:string -lbl_1_data_B0 = .data:0x000000B0; // type:object size:0x10 -lbl_1_data_C0 = .data:0x000000C0; // type:object size:0x4 -lbl_1_data_C4 = .data:0x000000C4; // type:object size:0x48 -lbl_1_data_10C = .data:0x0000010C; // type:object size:0x18 -lbl_1_data_124 = .data:0x00000124; // type:object size:0x20 data:float -lbl_1_data_144 = .data:0x00000144; // type:object size:0x8 -lbl_1_data_14C = .data:0x0000014C; // type:object size:0x4 data:float -lbl_1_data_150 = .data:0x00000150; // type:object size:0x4C0 -lbl_1_bss_0 = .bss:0x00000000; // type:object size:0x4 data:4byte -lbl_1_bss_4 = .bss:0x00000004; // type:object size:0x2 data:2byte -lbl_1_bss_6 = .bss:0x00000006; // type:object size:0x2 data:2byte -lbl_1_bss_8 = .bss:0x00000008; // type:object size:0x1 data:byte -lbl_1_bss_C = .bss:0x0000000C; // type:object size:0x4 data:float -lbl_1_bss_10 = .bss:0x00000010; // type:object size:0x2 data:2byte -lbl_1_bss_12 = .bss:0x00000012; // type:object size:0x2 data:2byte -lbl_1_bss_14 = .bss:0x00000014; // type:object size:0x2 data:2byte -lbl_1_bss_18 = .bss:0x00000018; // type:object size:0x4 data:4byte -lbl_1_bss_1C = .bss:0x0000001C; // type:object size:0x4 data:4byte -lbl_1_bss_20 = .bss:0x00000020; // type:object size:0x8 data:float -lbl_1_bss_28 = .bss:0x00000028; // type:object size:0x18 data:float -lbl_1_bss_40 = .bss:0x00000040; // type:object size:0x18 data:float -lbl_1_bss_58 = .bss:0x00000058; // type:object size:0x4 data:4byte -lbl_1_bss_5C = .bss:0x0000005C; // type:object size:0x8 data:4byte +instMode = .data:0x00000000; // type:object size:0x2 scope:local data:2byte +lbl_1_data_2 = .data:0x00000002; // type:object size:0x24 scope:local data:string +instGrpTbl = .data:0x00000026; // type:object size:0x20 scope:local +instPlayerNumTbl = .data:0x00000046; // type:object size:0x8 scope:local +instBoxFile = .data:0x00000050; // type:object size:0x20 scope:local +instBackFile = .data:0x00000070; // type:object size:0x20 scope:local +lbl_1_data_90 = .data:0x00000090; // type:object size:0x8 scope:local data:string +lbl_1_data_98 = .data:0x00000098; // type:object size:0x8 scope:local data:string +lbl_1_data_A0 = .data:0x000000A0; // type:object size:0x8 scope:local data:string +lbl_1_data_A8 = .data:0x000000A8; // type:object size:0x8 scope:local data:string +playerPosNameTbl = .data:0x000000B0; // type:object size:0x10 scope:local +playerDelayTbl = .data:0x000000C0; // type:object size:0x4 scope:local +hostFileTbl = .data:0x000000C4; // type:object size:0x48 scope:local +hostSeTbl = .data:0x0000010C; // type:object size:0x18 scope:local +instNamePosTbl = .data:0x00000124; // type:object size:0x20 scope:local data:float +cameraMask$858 = .data:0x00000144; // type:object size:0x4 scope:local +lbl_1_data_148 = .data:0x00000148; // type:object size:0x4 scope:local +instPicRadius = .data:0x0000014C; // type:object size:0x4 scope:local data:float +FontCharFile = .data:0x00000150; // type:object size:0x4C0 scope:local +debugCamOnF = .bss:0x00000000; // type:object size:0x4 scope:local data:4byte +instBusyF = .bss:0x00000004; // type:object size:0x2 scope:local data:2byte +instPage = .bss:0x00000006; // type:object size:0x2 scope:local data:2byte +LanguageNo = .bss:0x00000008; // type:object size:0x1 scope:local data:byte +instFov = .bss:0x0000000C; // type:object size:0x4 scope:local data:float +instMesOfs = .bss:0x00000010; // type:object size:0x2 scope:local data:2byte +instHostNo = .bss:0x00000012; // type:object size:0x2 scope:local data:2byte +instMgNo = .bss:0x00000014; // type:object size:0x2 scope:local data:2byte +instPicAnim = .bss:0x00000018; // type:object size:0x4 scope:local data:4byte +instBoxMdlId = .bss:0x0000001C; // type:object size:0x4 scope:local data:4byte +cameraZoom = .bss:0x00000020; // type:object size:0x8 data:float +cameraPos = .bss:0x00000028; // type:object size:0x18 data:float +cameraRot = .bss:0x00000040; // type:object size:0x18 data:float +objman = .bss:0x00000058; // type:object size:0x4 data:4byte +outViewObj = .bss:0x0000005C; // type:object size:0x4 scope:local data:4byte +lbl_1_bss_60 = .bss:0x00000060; // type:object size:0x4 scope:local data:4byte diff --git a/config/GMPP01_00/rels/resultDll/symbols.txt b/config/GMPP01_00/rels/resultDll/symbols.txt index b0b7a9af..db16ef1b 100644 --- a/config/GMPP01_00/rels/resultDll/symbols.txt +++ b/config/GMPP01_00/rels/resultDll/symbols.txt @@ -1,34 +1,34 @@ _prolog = .text:0x00000000; // type:function size:0x54 scope:global _epilog = .text:0x00000054; // type:function size:0x4C scope:global ObjectSetup = .text:0x000000A0; // type:function size:0x438 -fn_1_4D8 = .text:0x000004D8; // type:function size:0x3B0 -fn_1_888 = .text:0x00000888; // type:function size:0x2F0 -fn_1_B78 = .text:0x00000B78; // type:function size:0x13D4 -fn_1_1F4C = .text:0x00001F4C; // type:function size:0xB90 -fn_1_2ADC = .text:0x00002ADC; // type:function size:0x1074 -fn_1_3B50 = .text:0x00003B50; // type:function size:0x15C -fn_1_3CAC = .text:0x00003CAC; // type:function size:0x15C -fn_1_3E08 = .text:0x00003E08; // type:function size:0x1D0 -fn_1_3FD8 = .text:0x00003FD8; // type:function size:0x104 -fn_1_40DC = .text:0x000040DC; // type:function size:0x160 -fn_1_423C = .text:0x0000423C; // type:function size:0x3E0 -fn_1_461C = .text:0x0000461C; // type:function size:0x1E0 -fn_1_47FC = .text:0x000047FC; // type:function size:0x1084 -fn_1_5880 = .text:0x00005880; // type:function size:0xC10 -fn_1_6490 = .text:0x00006490; // type:function size:0x2D0 -fn_1_6760 = .text:0x00006760; // type:function size:0xC4 -fn_1_6824 = .text:0x00006824; // type:function size:0xD20 -fn_1_7544 = .text:0x00007544; // type:function size:0xA54 -fn_1_7F98 = .text:0x00007F98; // type:function size:0x3A0 -fn_1_8338 = .text:0x00008338; // type:function size:0x14C -fn_1_8484 = .text:0x00008484; // type:function size:0x1D4 -fn_1_8658 = .text:0x00008658; // type:function size:0x84 -fn_1_86DC = .text:0x000086DC; // type:function size:0x2BC -fn_1_8998 = .text:0x00008998; // type:function size:0x320 -fn_1_8CB8 = .text:0x00008CB8; // type:function size:0x340 -fn_1_8FF8 = .text:0x00008FF8; // type:function size:0x284 -fn_1_927C = .text:0x0000927C; // type:function size:0x138 -fn_1_93B4 = .text:0x000093B4; // type:function size:0x78 +ResultMain = .text:0x000004D8; // type:function size:0x3B0 scope:local +ResultIdle = .text:0x00000888; // type:function size:0x2F0 scope:local +ResultCreate = .text:0x00000B78; // type:function size:0x13D4 scope:local +ResultStatAdd = .text:0x00001F4C; // type:function size:0xB90 scope:local +ResultOrderApply = .text:0x00002ADC; // type:function size:0x1074 scope:local +ResultSprNumSet = .text:0x00003B50; // type:function size:0x15C scope:local +ResultCoinAddNumSet = .text:0x00003CAC; // type:function size:0x15C scope:local +ResultOrderSet = .text:0x00003E08; // type:function size:0x1D0 scope:local +ResultBoardDataRead = .text:0x00003FD8; // type:function size:0x104 +ResultCoinAdd = .text:0x000040DC; // type:function size:0x160 +ResultCoinNumGet = .text:0x0000423C; // type:function size:0x3E0 +SaveExec = .text:0x0000461C; // type:function size:0x1E0 scope:local +ResultTeamExec = .text:0x000047FC; // type:function size:0x1084 scope:local +CameraDebug = .text:0x00005880; // type:function size:0xC10 +ResultBattleMain = .text:0x00006490; // type:function size:0x2D0 +ResultBattleIdle = .text:0x00006760; // type:function size:0xC4 scope:local +ResultBattleCreate = .text:0x00006824; // type:function size:0xD20 scope:local +ResultBattleStatAdd = .text:0x00007544; // type:function size:0xA54 scope:local +ResultBattleCoinAddShow = .text:0x00007F98; // type:function size:0x3A0 scope:local +ResultBattleCoinAddNumSet = .text:0x00008338; // type:function size:0x14C scope:local +ResultBattleOrderSet = .text:0x00008484; // type:function size:0x1D4 scope:local +CoinEffectInit = .text:0x00008658; // type:function size:0x84 scope:local +CoinEffectAdd = .text:0x000086DC; // type:function size:0x2BC scope:local +CoinEffectMain = .text:0x00008998; // type:function size:0x320 scope:local +ResultShadowDraw = .text:0x00008CB8; // type:function size:0x340 scope:local +StageModelCreate = .text:0x00008FF8; // type:function size:0x284 +StageSpriteCreate = .text:0x0000927C; // type:function size:0x138 +StageSpriteKill = .text:0x000093B4; // type:function size:0x78 _ctors = .ctors:0x00000000; // type:label scope:global data:4byte _dtors = .dtors:0x00000000; // type:label scope:global data:4byte lbl_1_rodata_10 = .rodata:0x00000010; // type:object size:0x4 scope:local data:float @@ -94,7 +94,7 @@ lbl_1_rodata_148 = .rodata:0x00000148; // type:object size:0x4 scope:local data: lbl_1_rodata_14C = .rodata:0x0000014C; // type:object size:0x4 scope:local data:float lbl_1_rodata_150 = .rodata:0x00000150; // type:object size:0x4 scope:local data:float lbl_1_rodata_154 = .rodata:0x00000154; // type:object size:0x4 scope:local data:float -lbl_1_rodata_158 = .rodata:0x00000158; // type:object size:0x8 scope:local data:float +lbl_1_rodata_158 = .rodata:0x00000158; // type:object size:0x4 scope:local data:float lbl_1_rodata_160 = .rodata:0x00000160; // type:object size:0x4 scope:local data:float lbl_1_rodata_164 = .rodata:0x00000164; // type:object size:0x4 scope:local data:float lbl_1_rodata_168 = .rodata:0x00000168; // type:object size:0x4 scope:local data:float @@ -134,77 +134,77 @@ lbl_1_rodata_218 = .rodata:0x00000218; // type:object size:0x4 scope:local data: lbl_1_rodata_21C = .rodata:0x0000021C; // type:object size:0x4 scope:local data:float lbl_1_rodata_220 = .rodata:0x00000220; // type:object size:0x4 scope:local data:float lbl_1_rodata_228 = .rodata:0x00000228; // type:object size:0x8 scope:local data:double -lbl_1_data_0 = .data:0x00000000; // type:object size:0x2A4 -lbl_1_data_2A4 = .data:0x000002A4; // type:object size:0xDC data:4byte -lbl_1_data_380 = .data:0x00000380; // type:object size:0x2 data:2byte +resultModel = .data:0x00000000; // type:object size:0x2A4 scope:local +resultSprite = .data:0x000002A4; // type:object size:0xDC scope:local data:4byte +rankNewGrpId = .data:0x00000380; // type:object size:0x2 scope:local data:2byte lbl_1_data_382 = .data:0x00000382; // type:object size:0x26 scope:local data:string -lbl_1_data_3A8 = .data:0x000003A8; // type:object size:0x18 -lbl_1_data_3C0 = .data:0x000003C0; // type:object size:0x18 -lbl_1_data_3D8 = .data:0x000003D8; // type:object size:0x20 -lbl_1_data_3F8 = .data:0x000003F8; // type:object size:0x10 -lbl_1_data_408 = .data:0x00000408; // type:object size:0x30 -lbl_1_data_438 = .data:0x00000438; // type:object size:0x10 -lbl_1_data_448 = .data:0x00000448; // type:object size:0x8 scope:local -lbl_1_data_450 = .data:0x00000450; // type:object size:0x18 -lbl_1_data_468 = .data:0x00000468; // type:object size:0x20 -lbl_1_data_488 = .data:0x00000488; // type:object size:0x30 +resultBackFile = .data:0x000003A8; // type:object size:0x18 scope:local +resultLetterFile = .data:0x000003C0; // type:object size:0x18 scope:local +resultStatPosTbl = .data:0x000003D8; // type:object size:0x20 scope:local +resultRankPosTbl = .data:0x000003F8; // type:object size:0x10 scope:local +resultCharPosTbl = .data:0x00000408; // type:object size:0x30 scope:local +resultCoinAddPosTbl = .data:0x00000438; // type:object size:0x10 scope:local +lbl_1_data_448 = .data:0x00000448; // type:object size:0x5 scope:local data:string +resultBoardDirTbl = .data:0x00000450; // type:object size:0x18 scope:local +resultCharMdlTbl = .data:0x00000468; // type:object size:0x20 scope:local +resultTeamCharPosTbl = .data:0x00000488; // type:object size:0x30 scope:local lbl_1_data_4B8 = .data:0x000004B8; // type:object size:0x11 scope:local data:string lbl_1_data_4C9 = .data:0x000004C9; // type:object size:0x11 scope:local data:string lbl_1_data_4DA = .data:0x000004DA; // type:object size:0xB scope:local data:string -lbl_1_data_4E8 = .data:0x000004E8; // type:object size:0x270 -lbl_1_data_758 = .data:0x00000758; // type:object size:0x28 -lbl_1_data_780 = .data:0x00000780; // type:object size:0x50 -lbl_1_data_7D0 = .data:0x000007D0; // type:object size:0x20 -lbl_1_data_7F0 = .data:0x000007F0; // type:object size:0x30 +resultBattleModel = .data:0x000004E8; // type:object size:0x270 scope:local +resultBattleSprite = .data:0x00000758; // type:object size:0x28 scope:local +resultBattleEffParMan = .data:0x00000780; // type:object size:0x50 scope:local +resultStatPosTbl = .data:0x000007D0; // type:object size:0x20 scope:local +playerPosTbl = .data:0x000007F0; // type:object size:0x30 scope:local lbl_1_data_820 = .data:0x00000820; // type:object size:0x10 -lbl_1_data_830 = .data:0x00000830; // type:object size:0x10 -lbl_1_data_840 = .data:0x00000840; // type:object size:0x20 -lbl_1_data_860 = .data:0x00000860; // type:object size:0x20 -lbl_1_data_880 = .data:0x00000880; // type:object size:0x20 -lbl_1_data_8A0 = .data:0x000008A0; // type:object size:0x6 data:2byte -lbl_1_data_8A6 = .data:0x000008A6; // type:object size:0x8 scope:local data:float -lbl_1_data_8AE = .data:0x000008AE; // type:object size:0x8 scope:local data:float -lbl_1_data_8B8 = .data:0x000008B8; // type:object size:0x60 -lbl_1_bss_0 = .bss:0x00000000; // type:object size:0x4 data:4byte -lbl_1_bss_4 = .bss:0x00000004; // type:object size:0x4 data:4byte -lbl_1_bss_8 = .bss:0x00000008; // type:object size:0x2 data:2byte -lbl_1_bss_A = .bss:0x0000000A; // type:object size:0x8 -lbl_1_bss_12 = .bss:0x00000012; // type:object size:0x28 -lbl_1_bss_3A = .bss:0x0000003A; // type:object size:0x8 -lbl_1_bss_42 = .bss:0x00000042; // type:object size:0x8 -lbl_1_bss_4A = .bss:0x0000004A; // type:object size:0x8 -lbl_1_bss_52 = .bss:0x00000052; // type:object size:0x2 data:2byte -lbl_1_bss_54 = .bss:0x00000054; // type:object size:0x8 -lbl_1_bss_5C = .bss:0x0000005C; // type:object size:0x40 -lbl_1_bss_9C = .bss:0x0000009C; // type:object size:0x2 data:2byte -lbl_1_bss_9E = .bss:0x0000009E; // type:object size:0x30 -lbl_1_bss_CE = .bss:0x000000CE; // type:object size:0x12 -lbl_1_bss_E0 = .bss:0x000000E0; // type:object size:0x4 data:4byte -lbl_1_bss_E4 = .bss:0x000000E4; // type:object size:0x60 -lbl_1_bss_144 = .bss:0x00000144; // type:object size:0x14 -lbl_1_bss_158 = .bss:0x00000158; // type:object size:0x10 -lbl_1_bss_168 = .bss:0x00000168; // type:object size:0x8 -lbl_1_bss_170 = .bss:0x00000170; // type:object size:0x2 data:2byte -lbl_1_bss_172 = .bss:0x00000172; // type:object size:0x2 data:2byte -lbl_1_bss_174 = .bss:0x00000174; // type:object size:0x4 data:4byte -lbl_1_bss_178 = .bss:0x00000178; // type:object size:0x4 data:4byte -lbl_1_bss_17C = .bss:0x0000017C; // type:object size:0x2 data:2byte -lbl_1_bss_180 = .bss:0x00000180; // type:object size:0x4 data:4byte -lbl_1_bss_184 = .bss:0x00000184; // type:object size:0x4 data:4byte +bomheiCubeMdlTbl = .data:0x00000830; // type:object size:0x10 scope:local +coinEffectYOfs = .data:0x00000840; // type:object size:0x20 scope:local +coinAddYOfs = .data:0x00000860; // type:object size:0x20 scope:local +coinBlankYOfs = .data:0x00000880; // type:object size:0x20 scope:local +coinNumXOfs = .data:0x000008A0; // type:object size:0x6 scope:local data:2byte +lbl_1_data_8A6 = .data:0x000008A6; // type:object size:0x8 scope:local data:string +lbl_1_data_8AE = .data:0x000008AE; // type:object size:0x8 scope:local data:string +cameraShakeOfs = .data:0x000008B8; // type:object size:0x60 scope:local +resultReorderF = .bss:0x00000000; // type:object size:0x4 scope:local data:4byte +resultSkipF = .bss:0x00000004; // type:object size:0x4 scope:local data:4byte +resultTeamOrder = .bss:0x00000008; // type:object size:0x2 scope:local data:2byte +resultCharCubeMdlId = .bss:0x0000000A; // type:object size:0x8 scope:local +resultCoinAddSprId = .bss:0x00000012; // type:object size:0x28 scope:local +resultCoinAddGrpId = .bss:0x0000003A; // type:object size:0x8 scope:local +resultRank = .bss:0x00000042; // type:object size:0x8 scope:local +resultOrder = .bss:0x0000004A; // type:object size:0x8 scope:local +resultRankGrpId = .bss:0x00000052; // type:object size:0x2 scope:local data:2byte +resultPlayerCubeMdlId = .bss:0x00000054; // type:object size:0x8 scope:local +resultCubeMdlId = .bss:0x0000005C; // type:object size:0x40 scope:local +resultCrownGrpId = .bss:0x0000009C; // type:object size:0x2 scope:local data:2byte +resultNumSprId = .bss:0x0000009E; // type:object size:0x30 scope:local +resultNumGrpId = .bss:0x000000CE; // type:object size:0x10 scope:local +resultCrownAnim = .bss:0x000000E0; // type:object size:0x4 scope:local data:4byte +resultCharAnim = .bss:0x000000E4; // type:object size:0x60 scope:local +resultRankAnim = .bss:0x00000144; // type:object size:0x14 scope:local +statShadowMdlId = .bss:0x00000158; // type:object size:0x10 scope:local +charShadowMdlId = .bss:0x00000168; // type:object size:0x8 scope:local +teamResultGrpId = .bss:0x00000170; // type:object size:0x2 scope:local data:2byte +resultBonusPlayer = .bss:0x00000172; // type:object size:0x2 data:2byte +resultFastF = .bss:0x00000174; // type:object size:0x4 data:4byte +resultReadEndF = .bss:0x00000178; // type:object size:0x4 data:4byte +resultMgNo = .bss:0x0000017C; // type:object size:0x2 data:2byte +objman = .bss:0x00000180; // type:object size:0x4 data:4byte +outViewObj = .bss:0x00000184; // type:object size:0x4 scope:local data:4byte lbl_1_bss_188 = .bss:0x00000188; // type:object size:0x4 data:4byte -lbl_1_bss_190 = .bss:0x00000190; // type:object size:0x4 data:4byte -lbl_1_bss_194 = .bss:0x00000194; // type:object size:0x1680 -lbl_1_bss_1814 = .bss:0x00001814; // type:object size:0x8 +resultBattleSkipF = .bss:0x00000190; // type:object size:0x4 scope:local data:4byte +coinEffectData = .bss:0x00000194; // type:object size:0x1680 scope:local +resultBattleEffParManId = .bss:0x00001814; // type:object size:0x8 scope:local lbl_1_bss_181C = .bss:0x0000181C; // type:object size:0xC -lbl_1_bss_1828 = .bss:0x00001828; // type:object size:0x168 data:2byte -lbl_1_bss_1990 = .bss:0x00001990; // type:object size:0x20 -lbl_1_bss_19B0 = .bss:0x000019B0; // type:object size:0x8 -lbl_1_bss_19B8 = .bss:0x000019B8; // type:object size:0x28 -lbl_1_bss_19E0 = .bss:0x000019E0; // type:object size:0x8 -lbl_1_bss_19E8 = .bss:0x000019E8; // type:object size:0x8 -lbl_1_bss_19F0 = .bss:0x000019F0; // type:object size:0x8 +coinEffectMdlId = .bss:0x00001828; // type:object size:0x168 scope:local data:2byte +resultBattleCharMot = .bss:0x00001990; // type:object size:0x20 scope:local +resultBattleCharMdl = .bss:0x000019B0; // type:object size:0x8 scope:local +coinNumSprId = .bss:0x000019B8; // type:object size:0x28 scope:local +coinNumGrpId = .bss:0x000019E0; // type:object size:0x8 scope:local +resultBattleRank = .bss:0x000019E8; // type:object size:0x8 scope:local +resultBattleOrder = .bss:0x000019F0; // type:object size:0x8 scope:local lbl_1_bss_19F8 = .bss:0x000019F8; // type:object size:0x20 lbl_1_bss_1A18 = .bss:0x00001A18; // type:object size:0x2 -lbl_1_bss_1A1A = .bss:0x00001A1A; // type:object size:0x42 data:2byte -lbl_1_bss_1A5C = .bss:0x00001A5C; // type:object size:0x40 data:2byte -lbl_1_bss_1A9C = .bss:0x00001A9C; // type:object size:0x40 data:2byte +stageSprId = .bss:0x00001A1A; // type:object size:0x42 data:2byte +stageMotId = .bss:0x00001A5C; // type:object size:0x40 data:2byte +stageSprId = .bss:0x00001A9C; // type:object size:0x40 data:2byte diff --git a/configure.py b/configure.py index bd9561f0..1e740726 100644 --- a/configure.py +++ b/configure.py @@ -1457,9 +1457,9 @@ config.libs = [ Rel( "resultDll", objects={ - Object(MatchingFor("GMPE01_00", "GMPE01_01", "GMPJ01_00"), "REL/resultDll/main.c"), - Object(MatchingFor("GMPE01_00", "GMPE01_01", "GMPJ01_00"), "REL/resultDll/battle.c"), - Object(MatchingFor("GMPE01_00", "GMPE01_01", "GMPJ01_00"), "REL/resultDll/datalist.c"), + Object(Matching, "REL/resultDll/main.c"), + Object(Matching, "REL/resultDll/battle.c"), + Object(Matching, "REL/resultDll/datalist.c"), }, ), Rel( diff --git a/include/REL/instDll.h b/include/REL/instDll.h index 8b00303e..adf1fe5c 100644 --- a/include/REL/instDll.h +++ b/include/REL/instDll.h @@ -3,6 +3,6 @@ #include "game/minigame_seq.h" -s32 fn_1_5EA4(SeqWork *work, char *mess, s16 jp_flag); +s32 FontCreate(SeqWork *work, char *mess, s16 jp_flag); #endif diff --git a/include/REL/resultdll.h b/include/REL/resultdll.h index afaf5df3..240731b4 100644 --- a/include/REL/resultdll.h +++ b/include/REL/resultdll.h @@ -7,7 +7,7 @@ #include "game/sprite.h" -typedef struct datalist_model { +typedef struct StageModel_s { s32 datanum; u32 attr; s16 type; @@ -16,33 +16,33 @@ typedef struct datalist_model { Vec pos; Vec rot; Vec scale; -} DataListModel; +} StageModel; -typedef struct datalist_sprite { +typedef struct StageSprite_s { u32 datanum; s16 attr; s16 prio; float x; float y; GXColor color; -} DataListSprite; +} StageSprite; -void fn_1_3FD8(void); -void fn_1_40DC(void); -void fn_1_423C(s16 *data); +void ResultBoardDataRead(void); +void ResultCoinAdd(void); +void ResultCoinNumGet(s16 *coinNum); -void fn_1_6490(void); +void ResultBattleMain(void); -void fn_1_8FF8(DataListModel *model_list); -void fn_1_927C(DataListSprite *sprite_list); -void fn_1_93B4(void); +void StageModelCreate(StageModel *model_list); +void StageSpriteCreate(StageSprite *sprite_list); +void StageSpriteKill(void); -extern s16 lbl_1_bss_1A9C[32]; -extern s16 lbl_1_bss_1A5C[32]; -extern s16 lbl_1_bss_1A1A[33]; +extern s16 stageMdlId[32]; +extern s16 stageMotId[32]; +extern s16 stageSprId[33]; extern s16 lbl_1_bss_1A18; -extern s32 lbl_1_bss_178; -extern s32 lbl_1_bss_174; -extern s16 lbl_1_bss_172; +extern s32 resultReadEndF; +extern s32 resultFastF; +extern s16 resultBonusPlayer; #endif \ No newline at end of file diff --git a/src/REL/instDll/font.c b/src/REL/instDll/font.c index af50f5d5..9986bd62 100644 --- a/src/REL/instDll/font.c +++ b/src/REL/instDll/font.c @@ -2,7 +2,7 @@ #include "REL/instDll.h" -s32 lbl_1_data_150[0xC6] = { +static s32 FontCharFile[0xC6] = { 0, 0, 0, @@ -203,115 +203,115 @@ s32 lbl_1_data_150[0xC6] = { DATA_MAKE_NUM(DATADIR_INST, 0x25), }; -s32 fn_1_5EA4(SeqWork *work, char *mess, s16 jp_flag) +s32 FontCreate(SeqWork *work, char *mess, s16 jp_flag) { - char *var_r31; - s16 var_r30; - s16 *var_r29; - s16 var_r28; - s32 *var_r27; - s16 var_r26; - s16 var_r25; - s32 var_r24; - s16 *var_r22; - AnimData **var_r21; - s16 var_r20; - s16 var_r19; + char *str; + s16 len; + s16 *posY; + s16 charNum; + s32 *fileTbl; + s16 i; + s16 grpNo; + s32 file; + s16 *posX; + AnimData **animP; + s16 gid; + s16 sprid; - var_r27 = lbl_1_data_150; - for (var_r25 = 0; var_r25 < 0x10; var_r25++) { - if (work->spr_grp[var_r25] == -1) { + fileTbl = FontCharFile; + for (grpNo = 0; grpNo < 0x10; grpNo++) { + if (work->spr_grp[grpNo] == -1) { break; } } - if (var_r25 == 0x10) { + if (grpNo == 0x10) { return -1; } - var_r21 = HuMemDirectMalloc(HEAP_SYSTEM, 0x190); - var_r22 = HuMemDirectMalloc(HEAP_SYSTEM, 0xC8); - var_r29 = HuMemDirectMalloc(HEAP_SYSTEM, 0xC8); + animP = HuMemDirectMalloc(HEAP_SYSTEM, 0x190); + posX = HuMemDirectMalloc(HEAP_SYSTEM, 0xC8); + posY = HuMemDirectMalloc(HEAP_SYSTEM, 0xC8); - for (var_r31 = mess, var_r30 = 0, var_r28 = 0; var_r31[0] != 0; var_r31++) { - if (var_r31[0] == 0x20 || var_r31[0] == 0x10) { - var_r30 += 0xE; + for (str = mess, len = 0, charNum = 0; str[0] != 0; str++) { + if (str[0] == 0x20 || str[0] == 0x10) { + len += 0xE; } - else if (var_r31[0] < 0x30) { + else if (str[0] < 0x30) { } - else if (var_r31[0] == 0x80) { + else if (str[0] == 0x80) { } - else if (var_r31[0] == 0x81) { + else if (str[0] == 0x81) { } else { - if (var_r31[1] == 0x80) { - if ((var_r31[0] >= 0x96) && (var_r31[0] <= 0xA4)) { - var_r24 = var_r27[var_r31[0] + 0x6A]; + if (str[1] == 0x80) { + if ((str[0] >= 0x96) && (str[0] <= 0xA4)) { + file = fileTbl[str[0] + 0x6A]; } - else if ((var_r31[0] >= 0xAA) && (var_r31[0] <= 0xAE)) { - var_r24 = var_r27[var_r31[0] + 0x65]; + else if ((str[0] >= 0xAA) && (str[0] <= 0xAE)) { + file = fileTbl[str[0] + 0x65]; } - else if ((var_r31[0] >= 0xD6) && (var_r31[0] <= 0xE4)) { - var_r24 = var_r27[var_r31[0] + 0x43]; + else if ((str[0] >= 0xD6) && (str[0] <= 0xE4)) { + file = fileTbl[str[0] + 0x43]; } - else if ((var_r31[0] >= 0xEA) && (var_r31[0] <= 0xEE)) { - var_r24 = var_r27[var_r31[0] + 0x3E]; + else if ((str[0] >= 0xEA) && (str[0] <= 0xEE)) { + file = fileTbl[str[0] + 0x3E]; } } - else if (var_r31[1] == 0x81) { - if ((var_r31[0] >= 0xAA) && (var_r31[0] <= 0xAE)) { - var_r24 = var_r27[var_r31[0] + 0x6A]; + else if (str[1] == 0x81) { + if ((str[0] >= 0xAA) && (str[0] <= 0xAE)) { + file = fileTbl[str[0] + 0x6A]; } - else if ((var_r31[0] >= 0xEA) && (var_r31[0] <= 0xEE)) { - var_r24 = var_r27[var_r31[0] + 0x43]; + else if ((str[0] >= 0xEA) && (str[0] <= 0xEE)) { + file = fileTbl[str[0] + 0x43]; } } else { - var_r24 = var_r27[var_r31[0]]; + file = fileTbl[str[0]]; } - var_r21[var_r28] = HuSprAnimReadFile(var_r24); - var_r22[var_r28] = var_r30; - if ((var_r31[0] >= 0x61) && (var_r31[0] <= 0x7A)) { - var_r29[var_r28] = 2; - var_r30 += 0x12; + animP[charNum] = HuSprAnimReadFile(file); + posX[charNum] = len; + if ((str[0] >= 0x61) && (str[0] <= 0x7A)) { + posY[charNum] = 2; + len += 0x12; } - else if ((var_r31[0] == 0xC2) || (var_r31[0] == 0xC3)) { - var_r29[var_r28] = 0; - var_r30 += 0x12; + else if ((str[0] == 0xC2) || (str[0] == 0xC3)) { + posY[charNum] = 0; + len += 0x12; } - else if (var_r31[0] == 0x5C || var_r31[0] == 0x85) { - var_r29[var_r28] = 0; - var_r30 += 8; + else if (str[0] == 0x5C || str[0] == 0x85) { + posY[charNum] = 0; + len += 8; } - else if ((var_r31[0] >= 0x87) && (var_r31[0] <= 0x8F)) { - var_r29[var_r28] = 4; - var_r30 += 0x18; + else if ((str[0] >= 0x87) && (str[0] <= 0x8F)) { + posY[charNum] = 4; + len += 0x18; } - else if ((var_r31[0] >= 0xC7) && (var_r31[0] <= 0xCF)) { - var_r29[var_r28] = 4; - var_r30 += 0x18; + else if ((str[0] >= 0xC7) && (str[0] <= 0xCF)) { + posY[charNum] = 4; + len += 0x18; } - else if ((var_r31[0] == 0x3D) || (var_r31[0] == 0x84)) { - var_r29[var_r28] = 0; - var_r30 += 0x14; + else if ((str[0] == 0x3D) || (str[0] == 0x84)) { + posY[charNum] = 0; + len += 0x14; } else { - var_r29[var_r28] = 0; - var_r30 += 0x1C; + posY[charNum] = 0; + len += 0x1C; } - var_r28++; + charNum++; } } - var_r20 = HuSprGrpCreate(var_r28); - work->spr_grp[var_r25] = var_r20; - work->alt_word_len = var_r30; - var_r30 = (var_r30 / 2) - 0xE; - for (var_r26 = 0; var_r26 < var_r28; var_r26++) { - var_r19 = HuSprCreate(var_r21[var_r26], 0, 0); - HuSprGrpMemberSet(var_r20, var_r26, var_r19); - HuSprPosSet(var_r20, var_r26, var_r22[var_r26] - var_r30, var_r29[var_r26]); + gid = HuSprGrpCreate(charNum); + work->spr_grp[grpNo] = gid; + work->alt_word_len = len; + len = (len / 2) - 0xE; + for (i = 0; i < charNum; i++) { + sprid = HuSprCreate(animP[i], 0, 0); + HuSprGrpMemberSet(gid, i, sprid); + HuSprPosSet(gid, i, posX[i] - len, posY[i]); } - work->word_len = var_r28; - HuMemDirectFree(var_r21); - HuMemDirectFree(var_r22); - HuMemDirectFree(var_r29); - return var_r25; + work->word_len = charNum; + HuMemDirectFree(animP); + HuMemDirectFree(posX); + HuMemDirectFree(posY); + return grpNo; } diff --git a/src/REL/instDll/main.c b/src/REL/instDll/main.c index 5bfac016..5d7b064c 100644 --- a/src/REL/instDll/main.c +++ b/src/REL/instDll/main.c @@ -23,55 +23,55 @@ #include "REL/instDll.h" -static s16 lbl_1_data_0 = 1; +static s16 instMode = 1; static omObjData *lbl_1_bss_60; -static omObjData *lbl_1_bss_5C; -static Process *lbl_1_bss_58; -static Vec lbl_1_bss_40[2]; -static Vec lbl_1_bss_28[2]; -static float lbl_1_bss_20[2]; -static s32 lbl_1_bss_1C; -static AnimData *lbl_1_bss_18; -static u16 lbl_1_bss_14; -static u16 lbl_1_bss_12; -static u16 lbl_1_bss_10; -static float lbl_1_bss_C; -static u8 lbl_1_bss_8; -static u16 lbl_1_bss_6; -static u16 lbl_1_bss_4; -static s32 lbl_1_bss_0; +static omObjData *outViewObj; +Process *objman; +Vec cameraRot[2]; +Vec cameraPos[2]; +float cameraZoom[2]; +static s32 instBoxMdlId; +static AnimData *instPicAnim; +static u16 instMgNo; +static u16 instHostNo; +static u16 instMesOfs; +static float instFov; +static u8 LanguageNo; +static u16 instPage; +static u16 instBusyF; +static s32 debugCamOnF; -static void fn_1_994(void); -static void fn_1_17E4(void); -static void fn_1_220C(void); -static void fn_1_2804(void); -static void fn_1_2FA0(void); -static void fn_1_4174(omObjData *object); -static void fn_1_4528(omObjData *object); +static void InstMain(void); +static void InstPlayerMain(void); +static void InstHostMain(void); +static void InstWinMain(void); +static void InstNameMain(void); +static void CameraOutView(omObjData *object); +static void CameraDebug(omObjData *object); void ObjectSetup(void) { s32 i; omOvlHisData *his; - s32 light; + s32 lightId; OSReport("******* INST ObjectSetup *********\n"); - lbl_1_bss_58 = omInitObjMan(50, 8192); - omGameSysInit(lbl_1_bss_58); - lbl_1_bss_8 = GWLanguageGet(); - lbl_1_bss_14 = GWSystem.mg_next; - lbl_1_bss_10 = 0; - lbl_1_bss_4 = 0; + objman = omInitObjMan(50, 8192); + omGameSysInit(objman); + LanguageNo = GWLanguageGet(); + instMgNo = GWSystem.mg_next; + instMesOfs = 0; + instBusyF = 0; _ClearFlag(0x1000C); for (i = 0; sndGrpTable[i].ovl != OVL_INVALID; i++) { - if (sndGrpTable[i].ovl == mgInfoTbl[lbl_1_bss_14].ovl) { + if (sndGrpTable[i].ovl == mgInfoTbl[instMgNo].ovl) { break; } } if (sndGrpTable[i].ovl != OVL_INVALID) { HuAudSndGrpSetSet(sndGrpTable[i].grpSet); } - if (mgInfoTbl[lbl_1_bss_14].ovl == OVL_M411) { + if (mgInfoTbl[instMgNo].ovl == OVL_M411) { if (GWMGTypeGet() == -1) { GWMGTypeSet(frandmod(3)); } @@ -79,10 +79,10 @@ void ObjectSetup(void) else { GWMGTypeSet(-1); } - HuDataDirClose(mgInfoTbl[lbl_1_bss_14].data_dir); + HuDataDirClose(mgInfoTbl[instMgNo].data_dir); his = omOvlHisGet(0); omOvlHisChg(0, OVL_RESULT, his->event, his->stat); - if (omovlevtno == 0 && mgInfoTbl[lbl_1_bss_14].ovl == OVL_M430) { + if (omovlevtno == 0 && mgInfoTbl[instMgNo].ovl == OVL_M430) { s32 team_cnt[2]; s32 team_players[2][2]; team_cnt[0] = team_cnt[1] = 0; @@ -106,53 +106,53 @@ void ObjectSetup(void) GWPlayerCfg[team_players[1][1]].group = 2; } } - if (mgInfoTbl[lbl_1_bss_14].type == 3 || mgInfoTbl[lbl_1_bss_14].type == 5 || mgInfoTbl[lbl_1_bss_14].type == 6 - || mgInfoTbl[lbl_1_bss_14].type == 8 || !_CheckFlag(FLAG_ID_MAKE(0, 11))) { + if (mgInfoTbl[instMgNo].type == 3 || mgInfoTbl[instMgNo].type == 5 || mgInfoTbl[instMgNo].type == 6 + || mgInfoTbl[instMgNo].type == 8 || !_CheckFlag(FLAG_ID_MAKE(0, 11))) { HuDataDirClose(DATADIR_INST); omSysPauseEnable(1); - omOvlCallEx(mgInfoTbl[lbl_1_bss_14].ovl, 1, 0, 0); + omOvlCallEx(mgInfoTbl[instMgNo].ovl, 1, 0, 0); return; } - lbl_1_bss_40[0].x = -67.0f; - lbl_1_bss_40[0].y = 40.0f; - lbl_1_bss_40[0].z = 0.0f; - lbl_1_bss_28[0].x = 260.0f; - lbl_1_bss_28[0].y = -103.0f; - lbl_1_bss_28[0].z = -18.0f; - lbl_1_bss_20[0] = 2885.0f; - lbl_1_bss_C = 20.0f; - lbl_1_bss_12 = GWSystem.board; + cameraRot[0].x = -67.0f; + cameraRot[0].y = 40.0f; + cameraRot[0].z = 0.0f; + cameraPos[0].x = 260.0f; + cameraPos[0].y = -103.0f; + cameraPos[0].z = -18.0f; + cameraZoom[0] = 2885.0f; + instFov = 20.0f; + instHostNo = GWSystem.board; if (mgBoardHostEnableF) { - lbl_1_bss_12 = 1; + instHostNo = 1; } - lbl_1_bss_40[1].x = lbl_1_bss_40[1].y = lbl_1_bss_40[1].z = 0.0f; - lbl_1_bss_28[1].x = lbl_1_bss_28[1].y = lbl_1_bss_28[1].z = 0.0f; - lbl_1_bss_20[1] = 1000.0f; + cameraRot[1].x = cameraRot[1].y = cameraRot[1].z = 0.0f; + cameraPos[1].x = cameraPos[1].y = cameraPos[1].z = 0.0f; + cameraZoom[1] = 1000.0f; omSysPauseEnable(0); Hu3DCameraCreate(3); Hu3DCameraPerspectiveSet(1, 30.0f, 20.0f, 15000.0f, 1.2f); Hu3DCameraViewportSet(1, 0, 0, 640, 480, 0, 1); Hu3DCameraPerspectiveSet(2, 30.0f, 20.0f, 15000.0f, 1.2f); Hu3DCameraViewportSet(2, 0, 0, 640, 480, 0, 1); - light = Hu3DGLightCreate(0, 100, 1000, 0, -0.5, -1, 255, 255, 255); - Hu3DGLightInfinitytSet(light); - HuPrcChildCreate(fn_1_994, 100, 12288, 0, lbl_1_bss_58); - HuPrcChildCreate(fn_1_17E4, 100, 12288, 0, lbl_1_bss_58); - HuPrcChildCreate(fn_1_220C, 100, 12288, 0, lbl_1_bss_58); - HuPrcChildCreate(fn_1_2804, 100, 12288, 0, lbl_1_bss_58); - HuPrcChildCreate(fn_1_2FA0, 100, 12288, 0, lbl_1_bss_58); - lbl_1_bss_5C = omAddObjEx(lbl_1_bss_58, 32730, 0, 0, -1, fn_1_4174); - omAddObjEx(lbl_1_bss_58, 0, 32, 32, -1, fn_1_4528); + lightId = Hu3DGLightCreate(0, 100, 1000, 0, -0.5, -1, 255, 255, 255); + Hu3DGLightInfinitytSet(lightId); + HuPrcChildCreate(InstMain, 100, 12288, 0, objman); + HuPrcChildCreate(InstPlayerMain, 100, 12288, 0, objman); + HuPrcChildCreate(InstHostMain, 100, 12288, 0, objman); + HuPrcChildCreate(InstWinMain, 100, 12288, 0, objman); + HuPrcChildCreate(InstNameMain, 100, 12288, 0, objman); + outViewObj = omAddObjEx(objman, 32730, 0, 0, -1, CameraOutView); + omAddObjEx(objman, 0, 32, 32, -1, CameraDebug); HuAudSeqPlay(59); Hu3DBGColorSet(0, 0, 0); HuWinInit(1); } -static s8 lbl_1_data_26[] = { 3, 2, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 2, 3, 3, 2, 1, 0, 0, -1, -1, -1, 0, -1, -1, -1, 3, 2, 1, 0 }; +static s8 instGrpTbl[] = { 3, 2, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 2, 3, 3, 2, 1, 0, 0, -1, -1, -1, 0, -1, -1, -1, 3, 2, 1, 0 }; -static s8 lbl_1_data_46[] = { 4, 4, 4, 4, 4, 1, 1, 4 }; +static s8 instPlayerNumTbl[] = { 4, 4, 4, 4, 4, 1, 1, 4 }; -static s32 lbl_1_data_50[] = { +static s32 instBoxFile[] = { DATA_MAKE_NUM(DATADIR_INST, 0), DATA_MAKE_NUM(DATADIR_INST, 1), DATA_MAKE_NUM(DATADIR_INST, 2), @@ -163,7 +163,7 @@ static s32 lbl_1_data_50[] = { DATA_MAKE_NUM(DATADIR_INST, 0), }; -static s32 lbl_1_data_70[] = { +static s32 instBackFile[] = { DATA_MAKE_NUM(DATADIR_INST, 9), DATA_MAKE_NUM(DATADIR_INST, 10), DATA_MAKE_NUM(DATADIR_INST, 11), @@ -174,51 +174,50 @@ static s32 lbl_1_data_70[] = { DATA_MAKE_NUM(DATADIR_INST, 9), }; -static void fn_1_50B0(ModelData *model, Mtx mtx); -static void fn_1_5B64(ModelData *model, Mtx mtx); +static void InstPicDraw(ModelData *model, Mtx mtx); +static void ShadowDraw(ModelData *model, Mtx mtx); -static void fn_1_994(void) +static void InstMain(void) { - Vec pos; Vec target; Vec up; - Vec spC; - Process *process; + Vec rot; + Process *proc; s16 i; s16 model; - s16 num_coms; + s16 comNum; s16 j; - s16 btns; - s32 status; - s32 done; - s16 group; - s32 pic; + s16 btnDown; + s32 statId; + s32 endF; + s16 grpId; + s32 picFile; omOvlHisData *his; - s16 sprite; + s16 sprId; AnimData *anim; - float pos_z; + float z; float time; - float fov_vel; - float rot_x; + float fovSpeed; + float rotX; - process = HuPrcCurrentGet(); - status = -1; - group = HuSprGrpCreate(1); - anim = HuSprAnimRead(HuDataReadNum(lbl_1_data_70[mgInfoTbl[lbl_1_bss_14].type], MEMORY_DEFAULT_NUM)); - sprite = HuSprCreate(anim, 0, 0); - HuSprGrpMemberSet(group, 0, sprite); - HuSprGrpDrawNoSet(group, 127); - HuSprPosSet(group, 0, 288, 240); + proc = HuPrcCurrentGet(); + statId = -1; + grpId = HuSprGrpCreate(1); + anim = HuSprAnimRead(HuDataReadNum(instBackFile[mgInfoTbl[instMgNo].type], MEMORY_DEFAULT_NUM)); + sprId = HuSprCreate(anim, 0, 0); + HuSprGrpMemberSet(grpId, 0, sprId); + HuSprGrpDrawNoSet(grpId, 127); + HuSprPosSet(grpId, 0, 288, 240); if (GWMGTypeGet() == -1) { - pic = mgInfoTbl[lbl_1_bss_14].inst_pic[0]; + picFile = mgInfoTbl[instMgNo].inst_pic[0]; } else { - pic = mgInfoTbl[lbl_1_bss_14].inst_pic[GWMGTypeGet()]; + picFile = mgInfoTbl[instMgNo].inst_pic[GWMGTypeGet()]; } - lbl_1_bss_18 = HuSprAnimRead(HuDataReadNumHeapShortForce(pic, MEMORY_DEFAULT_NUM, HEAP_DATA)); + instPicAnim = HuSprAnimRead(HuDataReadNumHeapShortForce(picFile, MEMORY_DEFAULT_NUM, HEAP_DATA)); Hu3DShadowCreate(20, 500, 8000); Hu3DShadowTPLvlSet(0); Hu3DShadowSizeSet(192); @@ -228,34 +227,34 @@ static void fn_1_994(void) up.x = up.y = 0.0f; up.z = 1.0f; Hu3DShadowPosSet(&pos, &up, &target); - model = Hu3DModelCreateFile(lbl_1_data_50[mgInfoTbl[lbl_1_bss_14].type]); - lbl_1_bss_1C = model; + model = Hu3DModelCreateFile(instBoxFile[mgInfoTbl[instMgNo].type]); + instBoxMdlId = model; Hu3DModelPosSet(model, 0, 2000, 0); Hu3DModelAttrSet(model, HU3D_MOTATTR_PAUSE); Hu3DModelCameraSet(model, 1); Hu3DModelShadowSet(model); - i = Hu3DHookFuncCreate(fn_1_5B64); + i = Hu3DHookFuncCreate(ShadowDraw); Hu3DModelPosSet(i, 0, -200, 0); Hu3DModelCameraSet(i, 1); WipeCreate(WIPE_MODE_IN, WIPE_TYPE_NORMAL, 10); while (WipeStatGet()) { HuPrcVSleep(); } - pos_z = -500.0f; + z = -500.0f; for (i = 0; i <= 50; i++) { - Hu3DModelPosSet(model, 0.0f, 2500.0 * cosd(i * 1.8f) - 200.0, pos_z); + Hu3DModelPosSet(model, 0.0f, 2500.0 * cosd(i * 1.8f) - 200.0, z); Hu3DModelRotSet(model, 0, 0, 45.0f * (1.0f - (i / 50.0f))); - pos_z += 50.0 / 7.0; + z += 50.0 / 7.0; Hu3DShadowTPLvlSet(0.5 * (i / 50.0f)); HuPrcVSleep(); } HuAudFXPlay(1211); Hu3DModelAttrReset(model, HU3D_MOTATTR_PAUSE); for (i = 1; i <= 20; i++) { - Hu3DModelPosSet(model, 0.0f, (200.0 * (sind(i * 2.25f) * (1.0 / sind(45)))) - 200.0, pos_z); - rot_x = (20 - i) * cosd(i * 13.5f); - Hu3DModelRotSet(model, rot_x, 0.0f, 0.0f); - pos_z += 50.0 / 7.0; + Hu3DModelPosSet(model, 0.0f, (200.0 * (sind(i * 2.25f) * (1.0 / sind(45)))) - 200.0, z); + rotX = (20 - i) * cosd(i * 13.5f); + Hu3DModelRotSet(model, rotX, 0.0f, 0.0f); + z += 50.0 / 7.0; HuPrcVSleep(); } Hu3DModelPosSet(model, 0.0f, 0.0f, 0.0f); @@ -263,52 +262,52 @@ static void fn_1_994(void) HuPrcSleep(10); HuAudFXPlay(1212); Hu3DModelAttrReset(model, HU3D_MOTATTR_PAUSE); - i = Hu3DHookFuncCreate(fn_1_50B0); + i = Hu3DHookFuncCreate(InstPicDraw); Hu3DModelCameraSet(i, 1); Hu3DModelPosSet(i, 0, 415, 0); - lbl_1_data_0 = 0; + instMode = 0; while (Hu3DMotionTimeGet(model) < 80.0f) { if (Hu3DMotionTimeGet(model) > 30.0f) { - lbl_1_data_0 = 2; + instMode = 2; } HuPrcVSleep(); } Hu3DModelAttrSet(model, HU3D_MOTATTR_PAUSE); HuDataDirClose(DATADIR_INST); - status = HuDataDirReadAsync(mgInfoTbl[lbl_1_bss_14].data_dir); - while (lbl_1_data_0 != 1) { + statId = HuDataDirReadAsync(mgInfoTbl[instMgNo].data_dir); + while (instMode != 1) { HuPrcVSleep(); } - done = 0; - for (i = num_coms = 0; i < 4; i++) { + endF = 0; + for (i = comNum = 0; i < 4; i++) { if (GWPlayerCfg[i].iscom) { - num_coms++; + comNum++; } } i = 0; while (1) { - if (!done) { - for (btns = j = 0; j < 4; j++) { + if (!endF) { + for (btnDown = j = 0; j < 4; j++) { if (!GWPlayerCfg[j].iscom) { - btns |= HuPadBtnDown[GWPlayerCfg[j].pad_idx]; + btnDown |= HuPadBtnDown[GWPlayerCfg[j].pad_idx]; } } - if ((btns == PAD_BUTTON_START) || omSysExitReq || (num_coms == 4 && i > 60)) { + if ((btnDown == PAD_BUTTON_START) || omSysExitReq || (comNum == 4 && i > 60)) { HuAudFXPlay(2); - done = 1; + endF = 1; } - if (btns == PAD_TRIGGER_Z) { + if (btnDown == PAD_TRIGGER_Z) { HuAudFXPlay(1); - done = 1; + endF = 1; his = omOvlHisGet(0); omOvlHisChg(0, OVL_INST, 1, his->stat); _SetFlag(0x1000C); } - if (mgInstExitEnableF && (btns & PAD_BUTTON_B)) { + if (mgInstExitEnableF && (btnDown & PAD_BUTTON_B)) { HuAudFXPlay(3); - if (status != -1) { - while (!HuDataGetAsyncStat(status)) { + if (statId != -1) { + while (!HuDataGetAsyncStat(statId)) { HuPrcVSleep(); } } @@ -317,10 +316,10 @@ static void fn_1_994(void) while (WipeStatGet()) { HuPrcVSleep(); } - HuDataDirClose(mgInfoTbl[lbl_1_bss_14].data_dir); - if (mgInfoTbl[lbl_1_bss_14].ovl == OVL_M430) { - for (num_coms = 0; num_coms < 4; num_coms++) { - GWPlayerCfg[num_coms].group = GWPlayerCfg[num_coms].group / 2; + HuDataDirClose(mgInfoTbl[instMgNo].data_dir); + if (mgInfoTbl[instMgNo].ovl == OVL_M430) { + for (comNum = 0; comNum < 4; comNum++) { + GWPlayerCfg[comNum].group = GWPlayerCfg[comNum].group / 2; } } omOvlReturnEx(1, 1); @@ -330,7 +329,7 @@ static void fn_1_994(void) } } } - if (!lbl_1_bss_4 || !done) { + if (!instBusyF || !endF) { HuPrcVSleep(); i++; continue; @@ -339,32 +338,32 @@ static void fn_1_994(void) break; } } - if (status != -1) { - while (!HuDataGetAsyncStat(status)) { + if (statId != -1) { + while (!HuDataGetAsyncStat(statId)) { HuPrcVSleep(); } } - spC = lbl_1_bss_40[0]; - pos = lbl_1_bss_28[0]; - pos_z = lbl_1_bss_20[0]; + rot = cameraRot[0]; + pos = cameraPos[0]; + z = cameraZoom[0]; WipeColorSet(255, 255, 255); - lbl_1_data_0 = 3; + instMode = 3; HuPrcSleep(20); - lbl_1_data_0 = 4; + instMode = 4; HuPrcSleep(10); Hu3DModelAttrReset(model, HU3D_MOTATTR_PAUSE); HuPrcSleep(10); - fov_vel = 0; + fovSpeed = 0; for (i = 0; i <= 60; i++) { time = i / 60.0f; - lbl_1_bss_40[0].x = spC.x + ((-65.0f - spC.x) * time); - lbl_1_bss_40[0].y = spC.y + ((8.0f - spC.y) * time); - lbl_1_bss_40[0].z = spC.z + (-spC.z) * time; - lbl_1_bss_28[0].x = pos.x + ((17.0f - pos.x) * time); - lbl_1_bss_28[0].y = pos.y + ((5.0f - pos.y) * time); - lbl_1_bss_28[0].z = pos.z + ((-188.0f - pos.z) * time); - lbl_1_bss_20[0] = pos_z + ((1173.0f - pos_z) * time); + cameraRot[0].x = rot.x + ((-65.0f - rot.x) * time); + cameraRot[0].y = rot.y + ((8.0f - rot.y) * time); + cameraRot[0].z = rot.z + (-rot.z) * time; + cameraPos[0].x = pos.x + ((17.0f - pos.x) * time); + cameraPos[0].y = pos.y + ((5.0f - pos.y) * time); + cameraPos[0].z = pos.z + ((-188.0f - pos.z) * time); + cameraZoom[0] = z + ((1173.0f - z) * time); if (i == 30) { HuAudFXPlay(1210); WipeCreate(WIPE_MODE_OUT, WIPE_TYPE_NORMAL, 30); @@ -374,25 +373,25 @@ static void fn_1_994(void) Hu3DModelAttrSet(model, HU3D_MOTATTR_PAUSE); } if (i > 20) { - lbl_1_bss_C += fov_vel; - fov_vel += 0.04; + instFov += fovSpeed; + fovSpeed += 0.04; } HuPrcVSleep(); } while (WipeStatGet()) { - lbl_1_bss_C += fov_vel; - fov_vel += 0.04; + instFov += fovSpeed; + fovSpeed += 0.04; HuPrcVSleep(); } - lbl_1_data_0 = 6; + instMode = 6; HuPrcVSleep(); omSysPauseEnable(1); if (omSysExitReq) { - HuDataDirClose(mgInfoTbl[lbl_1_bss_14].data_dir); + HuDataDirClose(mgInfoTbl[instMgNo].data_dir); omOvlReturnEx(1, 1); } else { - omOvlCallEx(mgInfoTbl[lbl_1_bss_14].ovl, 1, 0, 0); + omOvlCallEx(mgInfoTbl[instMgNo].ovl, 1, 0, 0); } HuPrcEnd(); while (1) { @@ -400,133 +399,133 @@ static void fn_1_994(void) } } -static char *lbl_1_data_B0[] = { "p_pos_a", "p_pos_b", "p_pos_c", "p_pos_d" }; +static char *playerPosNameTbl[] = { "p_pos_a", "p_pos_b", "p_pos_c", "p_pos_d" }; -static u8 lbl_1_data_C0[] = { 8, 0, 12, 4 }; +static u8 playerDelayTbl[] = { 8, 0, 12, 4 }; -static void fn_1_17E4(void) +static void InstPlayerMain(void) { - float tplvl; + float tpLvl; s16 i; s16 j; s16 time; - s16 player_cnt; + s16 playerNum; s16 order; s16 type; - s16 group_type; + s16 grpType; s16 group; - ModelData *model; - s16 player_mdl[4]; - s16 char_tbl[4]; - s16 platform_mdl[4]; - s16 player_order[4]; - s16 mot_tbl[4][3]; - Vec player_pos[4]; + ModelData *modelP; + s16 playerMdlId[4]; + s16 charNo[4]; + s16 shadowMdl[4]; + s16 playerOrder[4]; + s16 motId[4][3]; + Vec playerPos[4]; - type = mgInfoTbl[lbl_1_bss_14].type; - player_cnt = lbl_1_data_46[type]; - for (i = 0; i < player_cnt; i++) { - player_order[i] = -1; + type = mgInfoTbl[instMgNo].type; + playerNum = instPlayerNumTbl[type]; + for (i = 0; i < playerNum; i++) { + playerOrder[i] = -1; } - if (mgInfoTbl[lbl_1_bss_14].ovl != OVL_M430) { - group_type = type; + if (mgInfoTbl[instMgNo].ovl != OVL_M430) { + grpType = type; } else { - group_type = 0; + grpType = 0; } - for (i = 0; i < player_cnt; i++) { - group = lbl_1_data_26[(group_type * 4) + i]; + for (i = 0; i < playerNum; i++) { + group = instGrpTbl[(grpType * 4) + i]; for (j = 0; j < 4; j++) { if (group == GWPlayerCfg[j].group) { for (order = 0; order < i; order++) { - if (j == player_order[order]) { + if (j == playerOrder[order]) { break; } } if (order == i) { - player_order[i] = j; + playerOrder[i] = j; break; } } } } - for (i = 0; i < player_cnt; i++) { - if (player_order[i] == -1) { - for (j = 0; j < player_cnt; j++) { - player_order[j] = j; + for (i = 0; i < playerNum; i++) { + if (playerOrder[i] == -1) { + for (j = 0; j < playerNum; j++) { + playerOrder[j] = j; } break; } } - for (i = 0; i < player_cnt; i++) { - char_tbl[i] = GWPlayerCfg[player_order[i]].character; - player_mdl[i] = CharModelCreate(char_tbl[i], 2); - Hu3DModelPosSet(player_mdl[i], 5000.0f, 0.0f, 0.0f); - Hu3DModelRotSet(player_mdl[i], 0.0f, 180.0f, 0.0f); - Hu3DModelCameraSet(player_mdl[i], 1); - mot_tbl[i][0] = CharModelMotionCreate(char_tbl[i], DATA_MAKE_NUM(DATADIR_MARIOMOT, 0)); - mot_tbl[i][1] = CharModelMotionCreate(char_tbl[i], DATA_MAKE_NUM(DATADIR_MARIOMOT, 5)); - mot_tbl[i][2] = CharModelMotionCreate(char_tbl[i], DATA_MAKE_NUM(DATADIR_MARIOMOT, 6)); - CharModelVoiceEnableSet(char_tbl[i], mot_tbl[i][1], 0); - CharModelMotionSet(char_tbl[i], mot_tbl[i][1]); + for (i = 0; i < playerNum; i++) { + charNo[i] = GWPlayerCfg[playerOrder[i]].character; + playerMdlId[i] = CharModelCreate(charNo[i], 2); + Hu3DModelPosSet(playerMdlId[i], 5000.0f, 0.0f, 0.0f); + Hu3DModelRotSet(playerMdlId[i], 0.0f, 180.0f, 0.0f); + Hu3DModelCameraSet(playerMdlId[i], 1); + motId[i][0] = CharModelMotionCreate(charNo[i], DATA_MAKE_NUM(DATADIR_MARIOMOT, 0)); + motId[i][1] = CharModelMotionCreate(charNo[i], DATA_MAKE_NUM(DATADIR_MARIOMOT, 5)); + motId[i][2] = CharModelMotionCreate(charNo[i], DATA_MAKE_NUM(DATADIR_MARIOMOT, 6)); + CharModelVoiceEnableSet(charNo[i], motId[i][1], 0); + CharModelMotionSet(charNo[i], motId[i][1]); CharModelDataClose(-1); - platform_mdl[i] = Hu3DModelCreateFile(DATA_MAKE_NUM(DATADIR_INST, 7)); - Hu3DModelTPLvlSet(platform_mdl[i], 0.0f); - Hu3DModelScaleSet(platform_mdl[i], 0.0f, 0.0f, 0.0f); + shadowMdl[i] = Hu3DModelCreateFile(DATA_MAKE_NUM(DATADIR_INST, 7)); + Hu3DModelTPLvlSet(shadowMdl[i], 0.0f); + Hu3DModelScaleSet(shadowMdl[i], 0.0f, 0.0f, 0.0f); } - while (lbl_1_data_0 != 2) { + while (instMode != 2) { HuPrcVSleep(); } - for (i = 0; i < player_cnt; i++) { - Hu3DModelObjPosGet(lbl_1_bss_1C, lbl_1_data_B0[i], &player_pos[i]); - Hu3DModelPosSet(platform_mdl[i], player_pos[i].x, 10 + player_pos[i].y, player_pos[i].z); + for (i = 0; i < playerNum; i++) { + Hu3DModelObjPosGet(instBoxMdlId, playerPosNameTbl[i], &playerPos[i]); + Hu3DModelPosSet(shadowMdl[i], playerPos[i].x, 10 + playerPos[i].y, playerPos[i].z); } HuPrcSleep(10); for (i = 0; i <= 50; i++) { - for (j = 0; j < player_cnt; j++) { - time = i - lbl_1_data_C0[j]; + for (j = 0; j < playerNum; j++) { + time = i - playerDelayTbl[j]; if (time < 0) { continue; } if (time == 15) { - CharModelMotionSet(char_tbl[j], mot_tbl[j][2]); + CharModelMotionSet(charNo[j], motId[j][2]); } if (time == 30) { - CharModelMotionShiftSet(char_tbl[j], mot_tbl[j][0], 0, 10, HU3D_MOTATTR_LOOP); + CharModelMotionShiftSet(charNo[j], motId[j][0], 0, 10, HU3D_MOTATTR_LOOP); } if (time <= 20) { - Hu3DModelPosSet(player_mdl[j], player_pos[j].x, player_pos[j].y + 1000.0 * cosd(time * 4.5f), player_pos[j].z); + Hu3DModelPosSet(playerMdlId[j], playerPos[j].x, playerPos[j].y + 1000.0 * cosd(time * 4.5f), playerPos[j].z); time -= 10; if (time >= 0) { - tplvl = 0.1 * time; - Hu3DModelTPLvlSet(platform_mdl[j], 0.5 * tplvl); - Hu3DModelScaleSet(platform_mdl[j], tplvl, tplvl, tplvl); + tpLvl = 0.1 * time; + Hu3DModelTPLvlSet(shadowMdl[j], 0.5 * tpLvl); + Hu3DModelScaleSet(shadowMdl[j], tpLvl, tpLvl, tpLvl); } } } HuPrcVSleep(); } - model = &Hu3DData[player_mdl[0]]; - while (lbl_1_data_0 != 4) { + modelP = &Hu3DData[playerMdlId[0]]; + while (instMode != 4) { HuPrcVSleep(); } for (i = 0; i <= 45; i++) { - for (j = 0; j < player_cnt; j++) { - time = i - lbl_1_data_C0[j]; + for (j = 0; j < playerNum; j++) { + time = i - playerDelayTbl[j]; if (time < 0) { continue; } if (time == 0) { - Hu3DModelAttrReset(player_mdl[j], HU3D_MOTATTR_LOOP); - CharModelVoiceEnableSet(char_tbl[i], mot_tbl[i][1], 1); - CharModelMotionSet(char_tbl[j], mot_tbl[j][1]); + Hu3DModelAttrReset(playerMdlId[j], HU3D_MOTATTR_LOOP); + CharModelVoiceEnableSet(charNo[i], motId[i][1], 1); + CharModelMotionSet(charNo[j], motId[j][1]); } if (time <= 30) { - Hu3DModelPosSet(player_mdl[j], player_pos[j].x, player_pos[j].y + (300.0 * sind(time * 9.0f)), player_pos[j].z - (time * 20)); + Hu3DModelPosSet(playerMdlId[j], playerPos[j].x, playerPos[j].y + (300.0 * sind(time * 9.0f)), playerPos[j].z - (time * 20)); if (time <= 10) { - tplvl = 1 - (0.1 * time); - Hu3DModelTPLvlSet(platform_mdl[j], 0.5 * tplvl); - Hu3DModelScaleSet(platform_mdl[j], tplvl, tplvl, tplvl); + tpLvl = 1 - (0.1 * time); + Hu3DModelTPLvlSet(shadowMdl[j], 0.5 * tpLvl); + Hu3DModelScaleSet(shadowMdl[j], tpLvl, tpLvl, tpLvl); } } } @@ -538,7 +537,7 @@ static void fn_1_17E4(void) } } -static s32 lbl_1_data_C4[] = { +static s32 hostFileTbl[] = { DATA_MAKE_NUM(DATADIR_INST, 19), DATA_MAKE_NUM(DATADIR_INST, 20), DATA_MAKE_NUM(DATADIR_INST, 21), @@ -559,57 +558,57 @@ static s32 lbl_1_data_C4[] = { DATA_MAKE_NUM(DATADIR_INST, 36), }; -static u16 lbl_1_data_10C[] = { 55, 57, 68, 67, 64, 65, 75, 76, 70, 71, 62, 62 }; +static u16 hostSeTbl[] = { 55, 57, 68, 67, 64, 65, 75, 76, 70, 71, 62, 62 }; -static void fn_1_220C(void) +static void InstHostMain(void) { - float ofs_x; + float ofsX; s16 i; - s16 model; - s16 motion[2]; - ModelData *model_ptr; - model = Hu3DModelCreateFile(lbl_1_data_C4[lbl_1_bss_12 * 3]); - motion[0] = Hu3DJointMotionFile(model, lbl_1_data_C4[(lbl_1_bss_12 * 3) + 1]); - motion[1] = Hu3DJointMotionFile(model, lbl_1_data_C4[(lbl_1_bss_12 * 3) + 2]); - Hu3DMotionSet(model, motion[1]); - if (lbl_1_bss_12 == 3) { - ofs_x = 50; + s16 modelId; + s16 motId[2]; + ModelData *modelP; + modelId = Hu3DModelCreateFile(hostFileTbl[instHostNo * 3]); + motId[0] = Hu3DJointMotionFile(modelId, hostFileTbl[(instHostNo * 3) + 1]); + motId[1] = Hu3DJointMotionFile(modelId, hostFileTbl[(instHostNo * 3) + 2]); + Hu3DMotionSet(modelId, motId[1]); + if (instHostNo == 3) { + ofsX = 50; } else { - ofs_x = 0; + ofsX = 0; } - Hu3DModelPosSet(model, -353.0f + ofs_x, -150, 356); - Hu3DModelRotSet(model, 0, 90, 0); - Hu3DModelCameraSet(model, 2); - while (lbl_1_data_0 != 2) { + Hu3DModelPosSet(modelId, -353.0f + ofsX, -150, 356); + Hu3DModelRotSet(modelId, 0, 90, 0); + Hu3DModelCameraSet(modelId, 2); + while (instMode != 2) { HuPrcVSleep(); } HuPrcSleep(30); - Hu3DMotionTimeSet(model, 40); - HuAudFXPlay(lbl_1_data_10C[lbl_1_bss_12 * 2]); + Hu3DMotionTimeSet(modelId, 40); + HuAudFXPlay(hostSeTbl[instHostNo * 2]); for (i = 0; i <= 20; i++) { - Hu3DModelPosSet(model, -153.0f - (100.0f - (100.0f * (i / 20.0f))), (100.0 * sind(i * 9.0f)) + -150.0 + ofs_x, 356.0f); + Hu3DModelPosSet(modelId, -153.0f - (100.0f - (100.0f * (i / 20.0f))), (100.0 * sind(i * 9.0f)) + -150.0 + ofsX, 356.0f); HuPrcVSleep(); } for (i = 0; i <= 10; i++) { - Hu3DModelPosSet(model, -153.0f, (15.0 * sind(i * 18.0f)) + -150.f + ofs_x, 356.0f); - Hu3DModelRotSet(model, 0.0f, 90 - ((i / 10.0f) * 70), 0); + Hu3DModelPosSet(modelId, -153.0f, (15.0 * sind(i * 18.0f)) + -150.f + ofsX, 356.0f); + Hu3DModelRotSet(modelId, 0.0f, 90 - ((i / 10.0f) * 70), 0); HuPrcVSleep(); } - Hu3DMotionShiftSet(model, motion[0], 0, 10, HU3D_MOTATTR_LOOP); - model_ptr = &Hu3DData[model]; + Hu3DMotionShiftSet(modelId, motId[0], 0, 10, HU3D_MOTATTR_LOOP); + modelP = &Hu3DData[modelId]; while (1) { fontcolor = FONT_COLOR_RED; - if (lbl_1_data_0 == 3) { + if (instMode == 3) { break; } HuPrcVSleep(); } - Hu3DMotionSet(model, motion[1]); + Hu3DMotionSet(modelId, motId[1]); HuPrcSleep(20); - HuAudFXPlay(lbl_1_data_10C[(lbl_1_bss_12 * 2) + 1]); + HuAudFXPlay(hostSeTbl[(instHostNo * 2) + 1]); for (i = 0; i <= 30; i++) { - Hu3DModelPosSet(model, (i * 5) - 153, (50.0 * sind(i * 9.0f)) + -150.0 + ofs_x, (i * 20) + 356); + Hu3DModelPosSet(modelId, (i * 5) - 153, (50.0 * sind(i * 9.0f)) + -150.0 + ofsX, (i * 20) + 356); HuPrcVSleep(); } HuPrcEnd(); @@ -618,31 +617,31 @@ static void fn_1_220C(void) } } -static void fn_1_2804(void) +static void InstWinMain(void) { - float pos_x; + float posX; s16 i; - s16 window; - s16 window_other; + s16 winId; + s16 win2Id; s16 j; s16 insert_idx; - s16 rtrig; + s16 trigR; s16 groupCnt[4]; s16 charTbl[4][4]; - window = HuWinExCreateStyled(640, 320, 412, 120, -1, 1); - while (lbl_1_data_0 != 0) { + winId = HuWinExCreateStyled(640, 320, 412, 120, -1, 1); + while (instMode != 0) { HuPrcVSleep(); } - HuWinDispOn(window); - HuWinMesSet(window, mgInfoTbl[lbl_1_bss_14].inst_mess[0]); - HuWinMesPalSet(window, 7, 0, 0, 192); - HuWinMesSpeedSet(window, 0); - window_other = HuWinExCreateStyled(640, 320, 412, 120, -1, 1); - HuWinDispOn(window_other); - HuWinMesSpeedSet(window_other, 0); - HuWinPosSet(window_other, 142.0f, 640.0f); - lbl_1_bss_6 = 0; + HuWinDispOn(winId); + HuWinMesSet(winId, mgInfoTbl[instMgNo].inst_mess[0]); + HuWinMesPalSet(winId, 7, 0, 0, 192); + HuWinMesSpeedSet(winId, 0); + win2Id = HuWinExCreateStyled(640, 320, 412, 120, -1, 1); + HuWinDispOn(win2Id); + HuWinMesSpeedSet(win2Id, 0); + HuWinPosSet(win2Id, 142.0f, 640.0f); + instPage = 0; for (i = 0; i < 4; i++) { groupCnt[i] = 0; } @@ -653,57 +652,57 @@ static void fn_1_2804(void) } for (i = insert_idx = 0; i < 4; i++) { for (j = 0; j < groupCnt[i]; j++) { - HuWinInsertMesSet(window, charTbl[i][j], (s16)insert_idx); + HuWinInsertMesSet(winId, charTbl[i][j], (s16)insert_idx); insert_idx++; } } - while (lbl_1_data_0 != 2) { + while (instMode != 2) { HuPrcVSleep(); } HuPrcSleep(40); for (i = 0; i <= 20; i++) { - pos_x = 500.0 * cosd(i * 4.5f) + 142.0; - HuWinPosSet(window, pos_x, 320); + posX = 500.0 * cosd(i * 4.5f) + 142.0; + HuWinPosSet(winId, posX, 320); HuPrcVSleep(); } - lbl_1_data_0 = 1; - while (lbl_1_data_0 != 3) { - for (i = rtrig = 0; i < 4; i++) { + instMode = 1; + while (instMode != 3) { + for (i = trigR = 0; i < 4; i++) { if (!GWPlayerCfg[i].iscom) { - rtrig |= HuPadTrigR[GWPlayerCfg[i].pad_idx] & 0xC0; + trigR |= HuPadTrigR[GWPlayerCfg[i].pad_idx] & 0xC0; } } - if (rtrig) { + if (trigR) { HuAudFXPlay(1213); - lbl_1_bss_4 = 0; - HuWinMesSet(window_other, mgInfoTbl[lbl_1_bss_14].inst_mess[lbl_1_bss_6]); - HuWinMesPalSet(window_other, 7, 0, 0, 192); - lbl_1_bss_6++; - if (mgInfoTbl[lbl_1_bss_14].inst_mess[lbl_1_bss_6] == 0) { - lbl_1_bss_6++; + instBusyF = 0; + HuWinMesSet(win2Id, mgInfoTbl[instMgNo].inst_mess[instPage]); + HuWinMesPalSet(win2Id, 7, 0, 0, 192); + instPage++; + if (mgInfoTbl[instMgNo].inst_mess[instPage] == 0) { + instPage++; } - if (lbl_1_bss_6 >= 4) { - lbl_1_bss_6 = 0; + if (instPage >= 4) { + instPage = 0; } - HuWinMesSet(window, mgInfoTbl[lbl_1_bss_14].inst_mess[lbl_1_bss_6]); - HuWinMesPalSet(window, 7, 0, 0, 192); - HuWinPosSet(window_other, 142.0f, 320.0f); + HuWinMesSet(winId, mgInfoTbl[instMgNo].inst_mess[instPage]); + HuWinMesPalSet(winId, 7, 0, 0, 192); + HuWinPosSet(win2Id, 142.0f, 320.0f); for (i = 0; i <= 10; i++) { #if VERSION_NTSC - HuWinPosSet(window_other, 30.0 * sind(i * 9.0f) + 142.0, 160.0 * (1.0 - cosd(i * 9.0f)) + 320.0); + HuWinPosSet(win2Id, 30.0 * sind(i * 9.0f) + 142.0, 160.0 * (1.0 - cosd(i * 9.0f)) + 320.0); #else - HuWinPosSet(window_other, 30.0 * sind(i * 9.0f) + 142.0, 180.0 * (1.0 - cosd(i * 9.0f)) + 320.0); + HuWinPosSet(win2Id, 30.0 * sind(i * 9.0f) + 142.0, 180.0 * (1.0 - cosd(i * 9.0f)) + 320.0); #endif HuPrcVSleep(); } HuPrcSleep(5); } - lbl_1_bss_4 = 1; + instBusyF = 1; HuPrcVSleep(); } for (i = 0; i <= 20; i++) { - pos_x = 500.0 * (1.0 - cosd(i * 4.5f)) + 142.0; - HuWinPosSet(window, pos_x, 320); + posX = 500.0 * (1.0 - cosd(i * 4.5f)) + 142.0; + HuWinPosSet(winId, posX, 320); HuPrcVSleep(); } HuWinAllKill(); @@ -713,7 +712,7 @@ static void fn_1_2804(void) } } -static float lbl_1_data_124[] = { 420, 70, 488, 186, 476, 242, 400, 292 }; +static float instNamePosTbl[] = { 420, 70, 488, 186, 476, 242, 400, 292 }; #if VERSION_NTSC #define WIN_ANIM_OFS 201 @@ -721,238 +720,238 @@ static float lbl_1_data_124[] = { 420, 70, 488, 186, 476, 242, 400, 292 }; #define WIN_ANIM_OFS 219 #endif -static void fn_1_2FA0(void) +static void InstNameMain(void) { - float temp_f31; - float temp_f30; - float temp_f29; - float temp_f28; - float temp_f27; - s16 temp_r31; - s16 temp_r30; - char *temp_r29; - AnimData *temp_r28; - s16 temp_r27; - s16 temp_r26; - s16 temp_r25; - s16 temp_r24; - s16 temp_r23; - s16 temp_r22; - u16 temp_r21; - char *temp_r20; - s16 temp_r17; - s16 spA; - s16 sp8; + float posX; + float t; + float nameX; + float nameY; + float nameScaleY; + s16 i; + s16 j; + char *mes; + AnimData *nameAnim; + s16 rulesWinId; + s16 mesSpaceNum; + s16 nameGrpId; + s16 startGrpId; + s16 practiceGrpId; + s16 nameW; + u16 prevPage; + char *mesWord; + s16 nameSprId; + s16 startSprId; + s16 practiceSprId; s16 spC[2]; s16 sp10[4]; SeqWork work; - temp_r21 = 0; - for (temp_r31 = 0; temp_r31 < 16; temp_r31++) { - work.sprite[temp_r31] = work.spr_grp[temp_r31] = -1; + prevPage = 0; + for (i = 0; i < 16; i++) { + work.sprite[i] = work.spr_grp[i] = -1; } - temp_r20 = MessData_MesPtrGet(messDataPtr, mgInfoTbl[lbl_1_bss_14].name_mess); - temp_r29 = temp_r20; - temp_r31 = 0; - temp_r26 = 0; + mesWord = MessData_MesPtrGet(messDataPtr, mgInfoTbl[instMgNo].name_mess); + mes = mesWord; + i = 0; + mesSpaceNum = 0; while (1) { - if (*temp_r29 == 0 || *temp_r29 == 10) { - if (*temp_r29 == 0) { - temp_r31 = 1; + if (*mes == 0 || *mes == 10) { + if (*mes == 0) { + i = 1; } - *temp_r29 = 0; - fn_1_5EA4(&work, temp_r20, (lbl_1_bss_8 == 0) ? 1 : 0); - HuSprGrpPosSet(work.spr_grp[temp_r26], 288.0f, 240.0f); - spC[temp_r26] = work.alt_word_len; - temp_r26++; - if (temp_r31) { + *mes = 0; + FontCreate(&work, mesWord, (LanguageNo == 0) ? 1 : 0); + HuSprGrpPosSet(work.spr_grp[mesSpaceNum], 288.0f, 240.0f); + spC[mesSpaceNum] = work.alt_word_len; + mesSpaceNum++; + if (i) { break; } - temp_r20 = temp_r29 + 1; + mesWord = mes + 1; } - temp_r29++; + mes++; } #if VERSION_NTSC - if (temp_r26 == 1) { - temp_r22 = spC[0]; - temp_r28 = HuSprAnimReadFile(DATA_MAKE_NUM(DATADIR_INST, 18)); - temp_f29 = ((576.0f - temp_r22) - 24.0f) - 16.0f + 227; - temp_f28 = 78; - temp_f27 = 0.5f; + if (mesSpaceNum == 1) { + nameW = spC[0]; + nameAnim = HuSprAnimReadFile(DATA_MAKE_NUM(DATADIR_INST, 18)); + nameX = ((576.0f - nameW) - 24.0f) - 16.0f + 227; + nameY = 78; + nameScaleY = 0.5f; } else { - temp_r22 = (spC[0] > spC[1]) ? spC[0] : spC[1]; - temp_r28 = HuSprAnimReadFile(DATA_MAKE_NUM(DATADIR_INST, 15)); + nameW = (spC[0] > spC[1]) ? spC[0] : spC[1]; + nameAnim = HuSprAnimReadFile(DATA_MAKE_NUM(DATADIR_INST, 15)); - temp_f29 = ((576.0f - temp_r22) - 24.0f) - 16.0f + 172.0f; - temp_f28 = 84; - temp_f27 = 1.0f; + nameX = ((576.0f - nameW) - 24.0f) - 16.0f + 172.0f; + nameY = 84; + nameScaleY = 1.0f; } #else - if (temp_r26 == 1) { - temp_r22 = spC[0]; - temp_r28 = HuSprAnimReadFile(DATA_MAKE_NUM(DATADIR_INST, 18)); - temp_f29 = ((576.0f - temp_r22) - 24.0f) - 16.0f + 235; - temp_f28 = 78; - temp_f27 = 0.5f; + if (mesSpaceNum == 1) { + nameW = spC[0]; + nameAnim = HuSprAnimReadFile(DATA_MAKE_NUM(DATADIR_INST, 18)); + nameX = ((576.0f - nameW) - 24.0f) - 16.0f + 235; + nameY = 78; + nameScaleY = 0.5f; } else { - temp_r22 = (spC[0] > spC[1]) ? spC[0] : spC[1]; - temp_r28 = HuSprAnimReadFile(DATA_MAKE_NUM(DATADIR_INST, 15)); + nameW = (spC[0] > spC[1]) ? spC[0] : spC[1]; + nameAnim = HuSprAnimReadFile(DATA_MAKE_NUM(DATADIR_INST, 15)); - temp_f29 = ((576.0f - temp_r22) - 24.0f) - 16.0f + 235; - temp_f28 = 84; - temp_f27 = 1.0f; + nameX = ((576.0f - nameW) - 24.0f) - 16.0f + 235; + nameY = 84; + nameScaleY = 1.0f; } #endif - temp_r25 = HuSprGrpCreate(1); - temp_r17 = HuSprCreate(temp_r28, 0, 0); - HuSprGrpMemberSet(temp_r25, 0, temp_r17); - HuSprPriSet(temp_r25, 0, 100); - HuSprGrpPosSet(temp_r25, 10000, 70); - HuSprScaleSet(temp_r25, 0, 1.0f, temp_f27); - for (temp_r31 = 0; temp_r31 < temp_r26; temp_r31++) { - HuSprGrpPosSet(work.spr_grp[temp_r31], 1000, 70); + nameGrpId = HuSprGrpCreate(1); + nameSprId = HuSprCreate(nameAnim, 0, 0); + HuSprGrpMemberSet(nameGrpId, 0, nameSprId); + HuSprPriSet(nameGrpId, 0, 100); + HuSprGrpPosSet(nameGrpId, 10000, 70); + HuSprScaleSet(nameGrpId, 0, 1.0f, nameScaleY); + for (i = 0; i < mesSpaceNum; i++) { + HuSprGrpPosSet(work.spr_grp[i], 1000, 70); } - temp_r28 = HuSprAnimReadFile(DATA_MAKE_NUM(DATADIR_INST, 16)); - temp_r24 = HuSprGrpCreate(1); - spA = HuSprCreate(temp_r28, 0, 0); - HuSprGrpMemberSet(temp_r24, 0, spA); - HuSprGrpPosSet(temp_r24, 1000, 186); - HuSprPriSet(temp_r24, 0, 1000); + nameAnim = HuSprAnimReadFile(DATA_MAKE_NUM(DATADIR_INST, 16)); + startGrpId = HuSprGrpCreate(1); + startSprId = HuSprCreate(nameAnim, 0, 0); + HuSprGrpMemberSet(startGrpId, 0, startSprId); + HuSprGrpPosSet(startGrpId, 1000, 186); + HuSprPriSet(startGrpId, 0, 1000); sp10[0] = HuWinCreate(1000, 186, 456, 42, 0); - HuWinMesSet(sp10[0], MAKE_MESSID(0x24, lbl_1_bss_10)); + HuWinMesSet(sp10[0], MAKE_MESSID(0x24, instMesOfs)); HuWinBGTPLvlSet(sp10[0], 0.0f); - temp_r28 = HuSprAnimReadFile(DATA_MAKE_NUM(DATADIR_INST, 17)); - temp_r23 = HuSprGrpCreate(1); - sp8 = HuSprCreate(temp_r28, 0, 0); - HuSprGrpMemberSet(temp_r23, 0, sp8); - HuSprGrpPosSet(temp_r23, 1000, 242); - HuSprPriSet(temp_r23, 0, 1000); + nameAnim = HuSprAnimReadFile(DATA_MAKE_NUM(DATADIR_INST, 17)); + practiceGrpId = HuSprGrpCreate(1); + practiceSprId = HuSprCreate(nameAnim, 0, 0); + HuSprGrpMemberSet(practiceGrpId, 0, practiceSprId); + HuSprGrpPosSet(practiceGrpId, 1000, 242); + HuSprPriSet(practiceGrpId, 0, 1000); sp10[1] = HuWinCreate(1000, 242, 456, 42, 0); - HuWinMesSet(sp10[1], lbl_1_bss_10 + MAKE_MESSID(0x24, 0x01)); + HuWinMesSet(sp10[1], instMesOfs + MAKE_MESSID(0x24, 0x01)); HuWinBGTPLvlSet(sp10[1], 0.0f); - temp_r28 = HuSprAnimReadFile(DATA_MAKE_NUM(DATADIR_INST, 18)); + nameAnim = HuSprAnimReadFile(DATA_MAKE_NUM(DATADIR_INST, 18)); sp10[2] = HuWinCreate(1000, 292, 456, 42, 0); - HuWinMesSet(sp10[2], lbl_1_bss_10 + MAKE_MESSID(0x24, 0x02)); + HuWinMesSet(sp10[2], instMesOfs + MAKE_MESSID(0x24, 0x02)); HuWinBGTPLvlSet(sp10[2], 0.0f); HuWinMesSpeedSet(sp10[2], 0); - temp_r31 = HuWinAnimSet(sp10[2], temp_r28, 0, WIN_ANIM_OFS, 18); - HuWinSprPriSet(sp10[2], temp_r31, 1000); - temp_r27 = HuWinCreate(1000, 292, 456, 42, 0); - HuWinBGTPLvlSet(temp_r27, 0.0f); - HuWinMesSpeedSet(temp_r27, 0); - HuWinMesSet(temp_r27, lbl_1_bss_10 + MAKE_MESSID(0x24, 0x02)); - temp_r31 = HuWinAnimSet(temp_r27, temp_r28, 0, WIN_ANIM_OFS, 18); - HuWinPriSet(temp_r27, 10); - HuWinSprPriSet(temp_r27, temp_r31, 11); - while (lbl_1_data_0 != 0) { + i = HuWinAnimSet(sp10[2], nameAnim, 0, WIN_ANIM_OFS, 18); + HuWinSprPriSet(sp10[2], i, 1000); + rulesWinId = HuWinCreate(1000, 292, 456, 42, 0); + HuWinBGTPLvlSet(rulesWinId, 0.0f); + HuWinMesSpeedSet(rulesWinId, 0); + HuWinMesSet(rulesWinId, instMesOfs + MAKE_MESSID(0x24, 0x02)); + i = HuWinAnimSet(rulesWinId, nameAnim, 0, WIN_ANIM_OFS, 18); + HuWinPriSet(rulesWinId, 10); + HuWinSprPriSet(rulesWinId, i, 11); + while (instMode != 0) { HuPrcVSleep(); } - for (temp_r31 = 0; temp_r31 < 36; temp_r31++) { - temp_f30 = temp_r31; - if (temp_f30 <= 20.0f) { + for (i = 0; i < 36; i++) { + t = i; + if (t <= 20.0f) { #if VERSION_NTSC - temp_f31 = 300.0 * cosd(4.5f * temp_f30) + temp_f29; - HuSprGrpPosSet(temp_r25, temp_f31, temp_f28); - temp_f31 = 300.0 * cosd(4.5f * temp_f30) + (576.0f - (temp_r22 / 2) - 24.0f); - for (temp_r30 = 0; temp_r30 < temp_r26; temp_r30++) { - HuSprGrpPosSet(work.spr_grp[temp_r30], temp_f31, (temp_r30 * 28) + 70); + posX = 300.0 * cosd(4.5f * t) + nameX; + HuSprGrpPosSet(nameGrpId, posX, nameY); + posX = 300.0 * cosd(4.5f * t) + (576.0f - (nameW / 2) - 24.0f); + for (j = 0; j < mesSpaceNum; j++) { + HuSprGrpPosSet(work.spr_grp[j], posX, (j * 28) + 70); } #else - temp_f31 = 500.0 * cosd(4.5f * temp_f30) + temp_f29; - HuSprGrpPosSet(temp_r25, temp_f31, temp_f28); - temp_f31 = 500.0 * cosd(4.5f * temp_f30) + (576.0f - (temp_r22 / 2) - 24.0f); - for (temp_r30 = 0; temp_r30 < temp_r26; temp_r30++) { - HuSprGrpPosSet(work.spr_grp[temp_r30], temp_f31, (temp_r30 * 28) + 70); + posX = 500.0 * cosd(4.5f * t) + nameX; + HuSprGrpPosSet(nameGrpId, posX, nameY); + posX = 500.0 * cosd(4.5f * t) + (576.0f - (nameW / 2) - 24.0f); + for (j = 0; j < mesSpaceNum; j++) { + HuSprGrpPosSet(work.spr_grp[j], posX, (j * 28) + 70); } #endif } - temp_f30 = temp_r31 - 3; - if (temp_f30 > 0.0f) { - if (temp_f30 <= 20.0f) { - temp_f31 = 300.0 * cosd(4.5f * temp_f30) + lbl_1_data_124[2]; - HuSprGrpPosSet(temp_r24, temp_f31, 186.0f); - temp_f31 = 300.0 * cosd(4.5f * temp_f30) + (lbl_1_data_124[2] - 88.0f); + t = i - 3; + if (t > 0.0f) { + if (t <= 20.0f) { + posX = 300.0 * cosd(4.5f * t) + instNamePosTbl[2]; + HuSprGrpPosSet(startGrpId, posX, 186.0f); + posX = 300.0 * cosd(4.5f * t) + (instNamePosTbl[2] - 88.0f); #if VERSION_NTSC - HuWinPosSet(sp10[0], 16.0f + temp_f31, 168.0f); + HuWinPosSet(sp10[0], 16.0f + posX, 168.0f); #else - HuWinPosSet(sp10[0], 8.0f + temp_f31, 168.0f); + HuWinPosSet(sp10[0], 8.0f + posX, 168.0f); #endif } } - temp_f30 = temp_r31 - 6; - if (temp_f30 > 0.0f) { - if (temp_f30 <= 20.0f) { - temp_f31 = 300.0 * cosd(4.5f * temp_f30) + lbl_1_data_124[4]; - HuSprGrpPosSet(temp_r23, temp_f31, 242.0f); - temp_f31 = 300.0 * cosd(4.5f * temp_f30) + (lbl_1_data_124[4] - 100.0f); + t = i - 6; + if (t > 0.0f) { + if (t <= 20.0f) { + posX = 300.0 * cosd(4.5f * t) + instNamePosTbl[4]; + HuSprGrpPosSet(practiceGrpId, posX, 242.0f); + posX = 300.0 * cosd(4.5f * t) + (instNamePosTbl[4] - 100.0f); #if VERSION_NTSC - HuWinPosSet(sp10[1], 16.0f + temp_f31, 224.0f); + HuWinPosSet(sp10[1], 16.0f + posX, 224.0f); #else - HuWinPosSet(sp10[1], 8.0f + temp_f31, 224.0f); + HuWinPosSet(sp10[1], 8.0f + posX, 224.0f); #endif } } - temp_f30 = temp_r31 - 9; - if (temp_f30 > 0.0f) { - if (temp_f30 <= 20.0f) { - temp_f31 = 300.0 * cosd(4.5f * temp_f30) + (lbl_1_data_124[6] - (WIN_ANIM_OFS+16)); - HuWinPosSet(sp10[2], 16.0f + temp_f31, 274.0f); + t = i - 9; + if (t > 0.0f) { + if (t <= 20.0f) { + posX = 300.0 * cosd(4.5f * t) + (instNamePosTbl[6] - (WIN_ANIM_OFS+16)); + HuWinPosSet(sp10[2], 16.0f + posX, 274.0f); } } HuPrcVSleep(); } - while (lbl_1_data_0 != 3) { - if (temp_r21 != lbl_1_bss_6) { - temp_f31 = 16.0f + (lbl_1_data_124[6] - (WIN_ANIM_OFS+16)); - HuWinMesSet(temp_r27, MAKE_MESSID(0x24, 0x02) + lbl_1_bss_10 + temp_r21); - temp_r21 = lbl_1_bss_6; - if (lbl_1_bss_6 == 1) { - if (mgInfoTbl[lbl_1_bss_14].inst_mess[2]) { - HuWinMesSet(sp10[2], MAKE_MESSID(0x24, 0x02) + lbl_1_bss_10 + lbl_1_bss_6); + while (instMode != 3) { + if (prevPage != instPage) { + posX = 16.0f + (instNamePosTbl[6] - (WIN_ANIM_OFS+16)); + HuWinMesSet(rulesWinId, MAKE_MESSID(0x24, 0x02) + instMesOfs + prevPage); + prevPage = instPage; + if (instPage == 1) { + if (mgInfoTbl[instMgNo].inst_mess[2]) { + HuWinMesSet(sp10[2], MAKE_MESSID(0x24, 0x02) + instMesOfs + instPage); } else { - HuWinMesSet(sp10[2], MAKE_MESSID(0x24, 0x06) + lbl_1_bss_10); + HuWinMesSet(sp10[2], MAKE_MESSID(0x24, 0x06) + instMesOfs); } } else { - HuWinMesSet(sp10[2], MAKE_MESSID(0x24, 0x02) + lbl_1_bss_10 + lbl_1_bss_6); + HuWinMesSet(sp10[2], MAKE_MESSID(0x24, 0x02) + instMesOfs + instPage); } - for (temp_r31 = 0; temp_r31 <= 10; temp_r31++) { + for (i = 0; i <= 10; i++) { #if VERSION_NTSC - HuWinPosSet(temp_r27, 30.0 * sind(temp_r31 * 9.0f) + temp_f31, 200.0 * (1.0 - cosd(temp_r31 * 9.0f)) + 274.0); + HuWinPosSet(rulesWinId, 30.0 * sind(i * 9.0f) + posX, 200.0 * (1.0 - cosd(i * 9.0f)) + 274.0); #else - HuWinPosSet(temp_r27, 30.0 * sind(temp_r31 * 9.0f) + temp_f31, 220.0 * (1.0 - cosd(temp_r31 * 9.0f)) + 274.0); + HuWinPosSet(rulesWinId, 30.0 * sind(i * 9.0f) + posX, 220.0 * (1.0 - cosd(i * 9.0f)) + 274.0); #endif HuPrcVSleep(); } } HuPrcVSleep(); } - for (temp_r31 = 0; temp_r31 < 20; temp_r31++) { - temp_f30 = 1.0 - cosd(temp_r31 * 4.5f); - temp_f31 = temp_f29 + (500.0f * temp_f30); - HuSprGrpPosSet(temp_r25, temp_f31, temp_f28); - temp_f31 = ((576.0f - (work.alt_word_len / 2)) - 24.0f) + (500.0f * temp_f30); - for (temp_r30 = 0; temp_r30 < temp_r26; temp_r30++) { - HuSprGrpPosSet(work.spr_grp[temp_r30], temp_f31, (temp_r30 * 28) + 70); + for (i = 0; i < 20; i++) { + t = 1.0 - cosd(i * 4.5f); + posX = nameX + (500.0f * t); + HuSprGrpPosSet(nameGrpId, posX, nameY); + posX = ((576.0f - (work.alt_word_len / 2)) - 24.0f) + (500.0f * t); + for (j = 0; j < mesSpaceNum; j++) { + HuSprGrpPosSet(work.spr_grp[j], posX, (j * 28) + 70); } - temp_f31 = lbl_1_data_124[2] + (300.0f * temp_f30); - HuSprGrpPosSet(temp_r24, temp_f31, 186.0f); - temp_f31 = (lbl_1_data_124[2] - 88.0f) + (300.0f * temp_f30); - HuWinPosSet(sp10[0], 16.0f + temp_f31, 168); - temp_f31 = lbl_1_data_124[4] + (300.0f * temp_f30); - HuSprGrpPosSet(temp_r23, temp_f31, 242.0f); - temp_f31 = (lbl_1_data_124[4] - 100.0f) + (300.0f * temp_f30); - HuWinPosSet(sp10[1], 16.0f + temp_f31, 224); + posX = instNamePosTbl[2] + (300.0f * t); + HuSprGrpPosSet(startGrpId, posX, 186.0f); + posX = (instNamePosTbl[2] - 88.0f) + (300.0f * t); + HuWinPosSet(sp10[0], 16.0f + posX, 168); + posX = instNamePosTbl[4] + (300.0f * t); + HuSprGrpPosSet(practiceGrpId, posX, 242.0f); + posX = (instNamePosTbl[4] - 100.0f) + (300.0f * t); + HuWinPosSet(sp10[1], 16.0f + posX, 224); #if VERSION_NTSC - temp_f31 = (lbl_1_data_124[6] - 184.0f) + (400.0f * temp_f30); + posX = (instNamePosTbl[6] - 184.0f) + (400.0f * t); #else - temp_f31 = (lbl_1_data_124[6] - 235.0f) + (400.0f * temp_f30); + posX = (instNamePosTbl[6] - 235.0f) + (400.0f * t); #endif - HuWinPosSet(sp10[2], 16.0f + temp_f31, 274); + HuWinPosSet(sp10[2], 16.0f + posX, 274); HuPrcVSleep(); } MGSeqSprKill(&work); @@ -962,98 +961,98 @@ static void fn_1_2FA0(void) } } -static u16 lbl_1_data_144[2] = { 1, 2 }; -static void fn_1_4174(omObjData *object) +static void CameraOutView(omObjData *object) { s16 i; + static u16 cameraMask[] = { HU3D_CAM0, HU3D_CAM1 }; for (i = 0; i < 2; i++) { Vec pos, target, up; float x, y, z; - x = lbl_1_bss_40[i].x; - y = lbl_1_bss_40[i].y; - z = lbl_1_bss_40[i].z; + x = cameraRot[i].x; + y = cameraRot[i].y; + z = cameraRot[i].z; - pos.x = (((sind(y) * cosd(x)) * lbl_1_bss_20[i]) + lbl_1_bss_28[i].x); - pos.y = (-sind(x) * lbl_1_bss_20[i]) + lbl_1_bss_28[i].y; - pos.z = ((cosd(y) * cosd(x)) * lbl_1_bss_20[i]) + lbl_1_bss_28[i].z; - target.x = lbl_1_bss_28[i].x; - target.y = lbl_1_bss_28[i].y; - target.z = lbl_1_bss_28[i].z; + pos.x = (((sind(y) * cosd(x)) * cameraZoom[i]) + cameraPos[i].x); + pos.y = (-sind(x) * cameraZoom[i]) + cameraPos[i].y; + pos.z = ((cosd(y) * cosd(x)) * cameraZoom[i]) + cameraPos[i].z; + target.x = cameraPos[i].x; + target.y = cameraPos[i].y; + target.z = cameraPos[i].z; up.x = sind(y) * sind(x); up.y = cosd(x); up.z = cosd(y) * sind(x); - Hu3DCameraPosSet(lbl_1_data_144[i], pos.x, pos.y, pos.z, up.x, up.y, up.z, target.x, target.y, target.z); + Hu3DCameraPosSet(cameraMask[i], pos.x, pos.y, pos.z, up.x, up.y, up.z, target.x, target.y, target.z); } } -static void fn_1_4528(omObjData *object) +static void CameraDebug(omObjData *object) { Vec pos; Vec offset; Vec dir; - Vec y_offset; + Vec yOffset; - f32 z_rot; - s8 stick_pos; + float rotZ; + s8 stickPos; - if (lbl_1_bss_0 != 0) { - lbl_1_bss_40[0].y += 0.1f * HuPadStkX[0]; - lbl_1_bss_40[0].x += 0.1f * HuPadStkY[0]; - lbl_1_bss_20[0] += HuPadTrigL[0] / 2; - lbl_1_bss_20[0] -= HuPadTrigR[0] / 2; - if (lbl_1_bss_20[0] < 100.0f) { - lbl_1_bss_20[0] = 100.0f; + if (debugCamOnF != 0) { + cameraRot[0].y += 0.1f * HuPadStkX[0]; + cameraRot[0].x += 0.1f * HuPadStkY[0]; + cameraZoom[0] += HuPadTrigL[0] / 2; + cameraZoom[0] -= HuPadTrigR[0] / 2; + if (cameraZoom[0] < 100.0f) { + cameraZoom[0] = 100.0f; } - pos.x = lbl_1_bss_28[0].x + (lbl_1_bss_20[0] * (sind(lbl_1_bss_40[0].y) * cosd(lbl_1_bss_40[0].x))); - pos.y = (lbl_1_bss_28[0].y + (lbl_1_bss_20[0] * -sind(lbl_1_bss_40[0].x))); - pos.z = (lbl_1_bss_28[0].z + (lbl_1_bss_20[0] * (cosd(lbl_1_bss_40[0].y) * cosd(lbl_1_bss_40[0].x)))); - offset.x = lbl_1_bss_28[0].x - pos.x; - offset.y = lbl_1_bss_28[0].y - pos.y; - offset.z = lbl_1_bss_28[0].z - pos.z; - dir.x = (sind(lbl_1_bss_40[0].y) * sind(lbl_1_bss_40[0].x)); - dir.y = cosd(lbl_1_bss_40[0].x); - dir.z = (cosd(lbl_1_bss_40[0].y) * sind(lbl_1_bss_40[0].x)); - z_rot = lbl_1_bss_40[0].z; - y_offset.x = dir.x * (offset.x * offset.x + (1.0f - offset.x * offset.x) * cosd(z_rot)) - + dir.y * (offset.x * offset.y * (1.0f - cosd(z_rot)) - offset.z * sind(z_rot)) - + dir.z * (offset.x * offset.z * (1.0f - cosd(z_rot)) + offset.y * sind(z_rot)); + pos.x = cameraPos[0].x + (cameraZoom[0] * (sind(cameraRot[0].y) * cosd(cameraRot[0].x))); + pos.y = (cameraPos[0].y + (cameraZoom[0] * -sind(cameraRot[0].x))); + pos.z = (cameraPos[0].z + (cameraZoom[0] * (cosd(cameraRot[0].y) * cosd(cameraRot[0].x)))); + offset.x = cameraPos[0].x - pos.x; + offset.y = cameraPos[0].y - pos.y; + offset.z = cameraPos[0].z - pos.z; + dir.x = (sind(cameraRot[0].y) * sind(cameraRot[0].x)); + dir.y = cosd(cameraRot[0].x); + dir.z = (cosd(cameraRot[0].y) * sind(cameraRot[0].x)); + rotZ = cameraRot[0].z; + yOffset.x = dir.x * (offset.x * offset.x + (1.0f - offset.x * offset.x) * cosd(rotZ)) + + dir.y * (offset.x * offset.y * (1.0f - cosd(rotZ)) - offset.z * sind(rotZ)) + + dir.z * (offset.x * offset.z * (1.0f - cosd(rotZ)) + offset.y * sind(rotZ)); - y_offset.y = dir.y * (offset.y * offset.y + (1.0f - offset.y * offset.y) * cosd(z_rot)) - + dir.x * (offset.x * offset.y * (1.0f - cosd(z_rot)) + offset.z * sind(z_rot)) - + dir.z * (offset.y * offset.z * (1.0f - cosd(z_rot)) - offset.x * sind(z_rot)); + yOffset.y = dir.y * (offset.y * offset.y + (1.0f - offset.y * offset.y) * cosd(rotZ)) + + dir.x * (offset.x * offset.y * (1.0f - cosd(rotZ)) + offset.z * sind(rotZ)) + + dir.z * (offset.y * offset.z * (1.0f - cosd(rotZ)) - offset.x * sind(rotZ)); - y_offset.z = dir.z * (offset.z * offset.z + (1.0f - offset.z * offset.z) * cosd(z_rot)) - + (dir.x * (offset.x * offset.z * (1.0 - cosd(z_rot)) - offset.y * sind(z_rot)) - + dir.y * (offset.y * offset.z * (1.0 - cosd(z_rot)) + offset.x * sind(z_rot))); + yOffset.z = dir.z * (offset.z * offset.z + (1.0f - offset.z * offset.z) * cosd(rotZ)) + + (dir.x * (offset.x * offset.z * (1.0 - cosd(rotZ)) - offset.y * sind(rotZ)) + + dir.y * (offset.y * offset.z * (1.0 - cosd(rotZ)) + offset.x * sind(rotZ))); VECCrossProduct(&dir, &offset, &offset); VECNormalize(&offset, &offset); - stick_pos = (HuPadSubStkX[0] & 0xF8); - if (stick_pos != 0) { - lbl_1_bss_28[0].x += 0.05f * (offset.x * stick_pos); - lbl_1_bss_28[0].y += 0.05f * (offset.y * stick_pos); - lbl_1_bss_28[0].z += 0.05f * (offset.z * stick_pos); + stickPos = (HuPadSubStkX[0] & 0xF8); + if (stickPos != 0) { + cameraPos[0].x += 0.05f * (offset.x * stickPos); + cameraPos[0].y += 0.05f * (offset.y * stickPos); + cameraPos[0].z += 0.05f * (offset.z * stickPos); } - VECNormalize(&y_offset, &offset); - stick_pos = -(HuPadSubStkY[0] & 0xF8); - if (stick_pos != 0) { - lbl_1_bss_28[0].x += 0.05f * (offset.x * stick_pos); - lbl_1_bss_28[0].y += 0.05f * (offset.y * stick_pos); - lbl_1_bss_28[0].z += 0.05f * (offset.z * stick_pos); + VECNormalize(&yOffset, &offset); + stickPos = -(HuPadSubStkY[0] & 0xF8); + if (stickPos != 0) { + cameraPos[0].x += 0.05f * (offset.x * stickPos); + cameraPos[0].y += 0.05f * (offset.y * stickPos); + cameraPos[0].z += 0.05f * (offset.z * stickPos); } } } static float lbl_1_data_148 = 842; -static float lbl_1_data_14C = 34; +static float instPicRadius = 34; -static void fn_1_50B0(ModelData *model, Mtx mtx) +static void InstPicDraw(ModelData *model, Mtx mtx) { Mtx final; - Mtx inv_camera; - Mtx lookatlight; + Mtx invCamera; + Mtx lookAtLight; Mtx light; Mtx lookat; Vec pos; @@ -1067,7 +1066,7 @@ static void fn_1_50B0(ModelData *model, Mtx mtx) u8 b; s16 row; - s32 sp8 = 0; + s32 practiceSprId = 0; GXClearVtxDesc(); GXSetVtxDesc(GX_VA_POS, GX_DIRECT); GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XYZ, GX_F32, 0); @@ -1076,22 +1075,22 @@ static void fn_1_50B0(ModelData *model, Mtx mtx) GXSetVtxDesc(GX_VA_NRM, GX_DIRECT); GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_NRM, GX_NRM_XYZ, GX_F32, 0); target.x = target.z = 0.0f; - target.x = lbl_1_data_14C * sind(lbl_1_bss_40[0].y); - target.z = lbl_1_data_14C * cosd(lbl_1_bss_40[0].y); + target.x = instPicRadius * sind(cameraRot[0].y); + target.z = instPicRadius * cosd(cameraRot[0].y); target.y = 415.0f; - pos.x = (sind(lbl_1_bss_40[0].y) * cosd(lbl_1_bss_40[0].x) * lbl_1_bss_20[0]) + lbl_1_bss_28[0].x; - pos.y = (-sind(lbl_1_bss_40[0].x) * lbl_1_bss_20[0]) + lbl_1_bss_28[0].y; - pos.z = (cosd(lbl_1_bss_40[0].y) * cosd(lbl_1_bss_40[0].x) * lbl_1_bss_20[0]) + lbl_1_bss_28[0].z; - up.x = -sind(lbl_1_bss_40[0].y); - up.z = -cosd(lbl_1_bss_40[0].y); + pos.x = (sind(cameraRot[0].y) * cosd(cameraRot[0].x) * cameraZoom[0]) + cameraPos[0].x; + pos.y = (-sind(cameraRot[0].x) * cameraZoom[0]) + cameraPos[0].y; + pos.z = (cosd(cameraRot[0].y) * cosd(cameraRot[0].x) * cameraZoom[0]) + cameraPos[0].z; + up.x = -sind(cameraRot[0].y); + up.z = -cosd(cameraRot[0].y); up.y = 0; MTXLookAt(lookat, &pos, &up, &target); - MTXLightPerspective(light, lbl_1_bss_C, 1.2f, 0.5f, -0.5f, 0.5f, 0.5f); - HuSprTexLoad(lbl_1_bss_18, 0, 0, GX_CLAMP, GX_CLAMP, GX_NEAR); - MTXInverse(Hu3DCameraMtx, inv_camera); - MTXConcat(inv_camera, mtx, final); - MTXConcat(light, lookat, lookatlight); - MTXConcat(lookatlight, final, final); + MTXLightPerspective(light, instFov, 1.2f, 0.5f, -0.5f, 0.5f, 0.5f); + HuSprTexLoad(instPicAnim, 0, 0, GX_CLAMP, GX_CLAMP, GX_NEAR); + MTXInverse(Hu3DCameraMtx, invCamera); + MTXConcat(invCamera, mtx, final); + MTXConcat(light, lookat, lookAtLight); + MTXConcat(lookAtLight, final, final); GXLoadTexMtxImm(final, GX_TEXMTX0, GX_MTX3x4); GXSetTexCoordGen(GX_TEXCOORD0, GX_TG_MTX3x4, GX_TG_POS, GX_TEXMTX0); GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR0A0); @@ -1144,12 +1143,12 @@ static void fn_1_50B0(ModelData *model, Mtx mtx) GXEnd(); } -static void fn_1_5B64(ModelData *model, Mtx mtx) +static void ShadowDraw(ModelData *model, Mtx mtx) { - s32 sp8 = 0; + s32 temp = 0; GXTexObj tex; Mtx final; - Mtx inv_camera; + Mtx invCamera; Mtx shadow; GXClearVtxDesc(); GXSetVtxDesc(GX_VA_POS, GX_DIRECT); @@ -1157,8 +1156,8 @@ static void fn_1_5B64(ModelData *model, Mtx mtx) GXInitTexObj(&tex, Hu3DShadowData.unk_04, Hu3DShadowData.unk_02, Hu3DShadowData.unk_02, GX_TF_I8, GX_CLAMP, GX_CLAMP, GX_FALSE); GXInitTexObjLOD(&tex, GX_LINEAR, GX_LINEAR, 0.0f, 0.0f, 0.0f, GX_FALSE, GX_FALSE, GX_ANISO_1); GXLoadTexObj(&tex, 0); - MTXInverse(Hu3DCameraMtx, inv_camera); - MTXConcat(inv_camera, mtx, final); + MTXInverse(Hu3DCameraMtx, invCamera); + MTXConcat(invCamera, mtx, final); MTXConcat(Hu3DShadowData.unk_68, Hu3DShadowData.unk_38, shadow); MTXConcat(shadow, final, final); GXLoadTexMtxImm(final, GX_TEXMTX9, GX_MTX3x4); diff --git a/src/REL/resultDll/battle.c b/src/REL/resultDll/battle.c index 8818f975..8baf9450 100644 --- a/src/REL/resultDll/battle.c +++ b/src/REL/resultDll/battle.c @@ -19,7 +19,9 @@ #include "REL/resultdll.h" -DataListModel lbl_1_data_4E8[] = { { DATA_MAKE_NUM(DATADIR_RESULT, 0x08), 0, 0, -1, -1, { -300, 0, 0 }, { 0, 0, 0 }, { 0.9f, 0.9f, 0.9f } }, +#define COIN_EFFECT_MAX 180 + +static StageModel resultBattleModel[] = { { DATA_MAKE_NUM(DATADIR_RESULT, 0x08), 0, 0, -1, -1, { -300, 0, 0 }, { 0, 0, 0 }, { 0.9f, 0.9f, 0.9f } }, { DATA_MAKE_NUM(DATADIR_RESULT, 0x09), 0, 0, -1, -1, { -100, 0, 0 }, { 0, 0, 0 }, { 0.9f, 0.9f, 0.9f } }, { DATA_MAKE_NUM(DATADIR_RESULT, 0x0A), 0, 0, -1, -1, { 100, 0, 0 }, { 0, 0, 0 }, { 0.9f, 0.9f, 0.9f } }, { DATA_MAKE_NUM(DATADIR_RESULT, 0x0A), 0, 0, -1, -1, { 300, 0, 0 }, { 0, 0, 0 }, { 0.9f, 0.9f, 0.9f } }, @@ -32,12 +34,12 @@ DataListModel lbl_1_data_4E8[] = { { DATA_MAKE_NUM(DATADIR_RESULT, 0x08), 0, 0, { DATA_MAKE_NUM(DATADIR_RESULT, 0x0F), 0x40000002, 0, -1, -1, { 5000, 0, 0 }, { 0, 0, 0 }, { 2.0f, 2.0f, 2.0f } }, { -1, 0, 0, -1, -1, { 0, 0, 0 }, { 0, 0, 0 }, { 1, 1, 1 } } }; -DataListSprite lbl_1_data_758[] = { +static StageSprite resultBattleSprite[] = { { DATA_MAKE_NUM(DATADIR_RESULT, 0x43), 0, 10, 288, 240, { 255, 255, 255, 255 } }, { 0, 0, 0, 0, 0, { 0, 0, 0, 0 } }, }; -HsfanimStruct00 lbl_1_data_780 = { 80, { 0, 0 }, 3, 30, 90, { 0, -0.2, 0 }, 5.0f, 0.95f, 10.0f, 0.995f, 2, +static HsfanimStruct00 resultBattleEffParMan = { 80, { 0, 0 }, 3, 30, 90, { 0, -0.2, 0 }, 5.0f, 0.95f, 10.0f, 0.995f, 2, { { 255, 192, 112, 255 }, { 0, 0, 0, 0 }, @@ -49,9 +51,10 @@ HsfanimStruct00 lbl_1_data_780 = { 80, { 0, 0 }, 3, 30, 90, { 0, -0.2, 0 }, 5.0f { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, - } }; + } +}; -s16 lbl_1_data_7D0[] = { +static s16 resultStatPosTbl[] = { 320, 132, 500, @@ -70,103 +73,103 @@ s16 lbl_1_data_7D0[] = { 387, }; -Vec lbl_1_data_7F0[] = { { -300, 270, 0 }, { -100, 180, 500 }, { 100, 90, 500 }, { 300, 0, 500 } }; +static Vec playerPosTbl[] = { { -300, 270, 0 }, { -100, 180, 500 }, { 100, 90, 500 }, { 300, 0, 500 } }; s16 lbl_1_data_820[] = { -284, 148, -84, 233, 116, 318, 316, 403 }; -s32 lbl_1_data_830[] = { DATA_MAKE_NUM(DATADIR_RESULT, 0x08), DATA_MAKE_NUM(DATADIR_RESULT, 0x09), DATA_MAKE_NUM(DATADIR_RESULT, 0x0A), +static s32 bomheiCubeMdlTbl[] = { DATA_MAKE_NUM(DATADIR_RESULT, 0x08), DATA_MAKE_NUM(DATADIR_RESULT, 0x09), DATA_MAKE_NUM(DATADIR_RESULT, 0x0A), DATA_MAKE_NUM(DATADIR_RESULT, 0x0A) }; -float lbl_1_data_840[] = { 130, 150, 170, 150, 150, 130, 170, 190 }; +static float coinEffectYOfs[] = { 130, 150, 170, 150, 150, 130, 170, 190 }; -float lbl_1_data_860[] = { 130, 150, 180, 150, 150, 170, 180, 210 }; +static float coinAddYOfs[] = { 130, 150, 180, 150, 150, 170, 180, 210 }; -float lbl_1_data_880[] = { 140, 160, 180, 150, 150, 120, 180, 210 }; +static float coinBlankYOfs[] = { 140, 160, 180, 150, 150, 120, 180, 210 }; -s16 lbl_1_data_8A0[] = { 8, 0, -8 }; +static s16 coinNumXOfs[] = { 8, 0, -8 }; -typedef struct struct_unk194 { - s16 unk0; - s16 unk2; - Vec unk4; - Vec unk10; - float unk1C; -} StructUnk194; +typedef struct CoinEffect_s { + s16 playerNo; + s16 rank; + Vec pos; + Vec rotVel; + float velY; +} CoinEffect; u8 lbl_1_bss_19F8[32]; -s16 lbl_1_bss_19F0[4]; -s16 lbl_1_bss_19E8[4]; -s16 lbl_1_bss_19E0[4]; -s16 lbl_1_bss_19B8[4][5]; -s16 lbl_1_bss_19B0[4]; -s16 lbl_1_bss_1990[4][4]; -s16 lbl_1_bss_1828[180]; +static s16 resultBattleOrder[4]; +static s16 resultBattleRank[4]; +static s16 coinNumGrpId[4]; +static s16 coinNumSprId[4][5]; +static s16 resultBattleCharMdl[4]; +static s16 resultBattleCharMot[4][4]; +static s16 coinEffectMdlId[COIN_EFFECT_MAX]; s16 lbl_1_bss_181C[6]; -s16 lbl_1_bss_1814[4]; -StructUnk194 lbl_1_bss_194[180]; -s32 lbl_1_bss_190; +static s16 resultBattleEffParManId[4]; +static CoinEffect coinEffectData[COIN_EFFECT_MAX]; +static s32 resultBattleSkipF; -void fn_1_6760(void); -void fn_1_6824(void); -void fn_1_7544(void); +static void ResultBattleIdle(void); +static void ResultBattleCreate(void); +static void ResultBattleStatAdd(void); -void fn_1_6490(void) +void ResultBattleMain(void) { - s16 player; + s16 playerNo; s16 i; - s16 window; - s16 button; - Process *process = HuPrcCurrentGet(); + s16 winId; + s16 btnDown; + Process *proc = HuPrcCurrentGet(); HuAudSeqPlay(10); - for (i = player = 0; i < 4; i++) { + for (i = playerNo = 0; i < 4; i++) { if (GWPlayerCfg[i].iscom) { - player++; + playerNo++; } } - if (player == 4) { - lbl_1_bss_190 = 1; + if (playerNo == 4) { + resultBattleSkipF = 1; } else { - lbl_1_bss_190 = 0; + resultBattleSkipF = 0; } - fn_1_6824(); - HuPrcChildCreate(fn_1_6760, 100, 8192, 0, process); + ResultBattleCreate(); + HuPrcChildCreate(ResultBattleIdle, 100, 8192, 0, proc); WipeCreate(WIPE_MODE_IN, WIPE_TYPE_NORMAL, 20); while (WipeStatGet()) { HuPrcVSleep(); } - lbl_1_bss_178 = 0; - HuPrcChildCreate(fn_1_3FD8, 100, 12288, 0, process); + resultReadEndF = 0; + HuPrcChildCreate(ResultBoardDataRead, 100, 12288, 0, proc); HuPrcSleep(10); - if (!lbl_1_bss_174) { + if (!resultFastF) { HuPrcSleep(20); } - fn_1_7544(); - fn_1_40DC(); - window = HuWinCreate(-10000.0f, 400.0f, 320, 40, 0); - HuWinMesSpeedSet(window, 0); - HuWinBGTPLvlSet(window, 0); - HuWinAttrSet(window, 0x800); - HuWinMesSet(window, MAKE_MESSID(0x24, 0x07)); + ResultBattleStatAdd(); + ResultCoinAdd(); + winId = HuWinCreate(-10000.0f, 400.0f, 320, 40, 0); + HuWinMesSpeedSet(winId, 0); + HuWinBGTPLvlSet(winId, 0); + HuWinAttrSet(winId, 0x800); + HuWinMesSet(winId, MAKE_MESSID(0x24, 0x07)); i = 0; while (1) { - if (lbl_1_bss_190 && i > 120) { + if (resultBattleSkipF && i > 120) { break; } - for (player = button = 0; player < 4; player++) { - if (!GWPlayerCfg[player].iscom) { - button |= HuPadBtnDown[GWPlayerCfg[player].pad_idx]; + for (playerNo = btnDown = 0; playerNo < 4; playerNo++) { + if (!GWPlayerCfg[playerNo].iscom) { + btnDown |= HuPadBtnDown[GWPlayerCfg[playerNo].pad_idx]; } } - if (button & PAD_BUTTON_A) { + if (btnDown & PAD_BUTTON_A) { HuAudFXPlay(28); break; } HuPrcVSleep(); i++; } - HuWinKill(window); - while (!lbl_1_bss_178) { + HuWinKill(winId); + while (!resultReadEndF) { HuPrcVSleep(); } WipeCreate(WIPE_MODE_OUT, WIPE_TYPE_NORMAL, 30); @@ -183,45 +186,45 @@ void fn_1_6490(void) } } -void fn_1_6760(void) +static void ResultBattleIdle(void) { Vec temp; temp.z = 0.0f; temp.y = 0.0f; temp.x = 0.0f; while (1) { - if (((HuPadBtn[0] | HuPadBtn[1] | HuPadBtn[2] | HuPadBtn[3]) & 0x100) != 0 || lbl_1_bss_190 != 0) { - lbl_1_bss_174 = 1; + if (((HuPadBtn[0] | HuPadBtn[1] | HuPadBtn[2] | HuPadBtn[3]) & 0x100) != 0 || resultBattleSkipF != 0) { + resultFastF = 1; } else { - lbl_1_bss_174 = 0; + resultFastF = 0; } HuPrcVSleep(); } } -void fn_1_7F98(void); -void fn_1_8338(s16 group, s16 value); -void fn_1_8484(void); -void fn_1_8658(void); -void fn_1_86DC(s16 player); -void fn_1_8CB8(struct model_data *model, Mtx matrix); +static void ResultBattleCoinAddShow(void); +static void ResultBattleCoinAddNumSet(s16 grpId, s16 value); +static void ResultBattleOrderSet(void); +static void CoinEffectInit(void); +static void CoinEffectAdd(s16 playerNo); +static void ResultShadowDraw(struct model_data *model, Mtx matrix); -void fn_1_6824(void) +static void ResultBattleCreate(void) { s16 i; - s16 character; - s16 player; - s16 x_ofs; + s16 charNo; + s16 playerNo; + s16 xOfs; AnimData *anim; AnimData *anim2; AnimData *anim3; - s16 char_mdl; + s16 charMdlId; Vec pos; Vec target; Vec up; - s16 gains[5]; - Process *process = HuPrcCurrentGet(); + s16 coinNum[5]; + Process *proc = HuPrcCurrentGet(); CRot.x = 0; CRot.y = 0; CRot.z = 0; @@ -240,168 +243,167 @@ void fn_1_6824(void) up.y = 1; up.z = 0; Hu3DShadowPosSet(&pos, &up, &target); - i = Hu3DHookFuncCreate(fn_1_8CB8); + i = Hu3DHookFuncCreate(ResultShadowDraw); Hu3DModelPosSet(i, 0, 0, 0); - fn_1_8484(); - fn_1_423C(gains); - gains[lbl_1_bss_172] += gains[4]; + ResultBattleOrderSet(); + ResultCoinNumGet(coinNum); + coinNum[resultBonusPlayer] += coinNum[4]; for (i = 0; i < 4; i++) { - lbl_1_data_4E8[i].datanum = lbl_1_data_830[lbl_1_bss_19E8[i]]; - if (lbl_1_bss_19E8[i] == 3) { - lbl_1_data_4E8[i].attr = 1; + resultBattleModel[i].datanum = bomheiCubeMdlTbl[resultBattleRank[i]]; + if (resultBattleRank[i] == 3) { + resultBattleModel[i].attr = 1; } } - fn_1_8FF8(lbl_1_data_4E8); - fn_1_927C(lbl_1_data_758); - espDrawNoSet(lbl_1_bss_1A1A[0], 127); + StageModelCreate(resultBattleModel); + StageSpriteCreate(resultBattleSprite); + espDrawNoSet(stageSprId[0], 127); for (i = 0; i < 4; i++) { - Hu3DModelShadowSet(lbl_1_bss_1A9C[i]); + Hu3DModelShadowSet(stageMdlId[i]); } for (i = 0; i < 4; i++) { - anim = HuSprAnimRead(HuDataReadNum(lbl_1_bss_19E8[i] + DATA_MAKE_NUM(DATADIR_RESULT, 0x44), MEMORY_DEFAULT_NUM)); - ; - if (lbl_1_bss_19E8[i] <= 2) { + anim = HuSprAnimRead(HuDataReadNum(resultBattleRank[i] + DATA_MAKE_NUM(DATADIR_RESULT, 0x44), MEMORY_DEFAULT_NUM)); + if (resultBattleRank[i] <= 2) { anim2 = HuSprAnimRead(HuDataReadNum(DATA_MAKE_NUM(DATADIR_RESULT, 0x48), MEMORY_DEFAULT_NUM)); } else { anim2 = HuSprAnimRead(HuDataReadNum(DATA_MAKE_NUM(DATADIR_RESULT, 0x48), MEMORY_DEFAULT_NUM)); } - Hu3DAnimCreate(anim, lbl_1_bss_1A9C[i + 4], "ys22_a0"); - Hu3DAnimCreate(anim2, lbl_1_bss_1A9C[i + 4], "ys22_a1"); - Hu3DModelAttrSet(lbl_1_bss_1A9C[i + 4], HU3D_MOTATTR_PAUSE); + Hu3DAnimCreate(anim, stageMdlId[i + 4], "ys22_a0"); + Hu3DAnimCreate(anim2, stageMdlId[i + 4], "ys22_a1"); + Hu3DModelAttrSet(stageMdlId[i + 4], HU3D_MOTATTR_PAUSE); } anim = HuSprAnimRead(HuDataReadNum(DATA_MAKE_NUM(DATADIR_RESULT, 0x3D), MEMORY_DEFAULT_NUM)); anim2 = HuSprAnimRead(HuDataReadNum(DATA_MAKE_NUM(DATADIR_RESULT, 0x3B), MEMORY_DEFAULT_NUM)); anim3 = HuSprAnimRead(HuDataReadNum(DATA_MAKE_NUM(DATADIR_RESULT, 0x3C), MEMORY_DEFAULT_NUM)); for (i = 0; i < 4; i++) { - if (gains[lbl_1_bss_19F0[i]] >= 100) { - x_ofs = lbl_1_data_8A0[2]; + if (coinNum[resultBattleOrder[i]] >= 100) { + xOfs = coinNumXOfs[2]; } - else if (gains[lbl_1_bss_19F0[i]] >= 10) { - x_ofs = lbl_1_data_8A0[1]; + else if (coinNum[resultBattleOrder[i]] >= 10) { + xOfs = coinNumXOfs[1]; } else { - x_ofs = lbl_1_data_8A0[0]; + xOfs = coinNumXOfs[0]; } - lbl_1_bss_19E0[i] = HuSprGrpCreate(5); - lbl_1_bss_19B8[i][0] = HuSprCreate(anim, 10, 0); - HuSprGrpMemberSet(lbl_1_bss_19E0[i], 0, lbl_1_bss_19B8[i][0]); - HuSprPosSet(lbl_1_bss_19E0[i], 0, 17, -32); - lbl_1_bss_19B8[i][1] = HuSprCreate(anim2, 0, 0); - HuSprGrpMemberSet(lbl_1_bss_19E0[i], 1, lbl_1_bss_19B8[i][1]); - HuSprPosSet(lbl_1_bss_19E0[i], 1, x_ofs, -36); - lbl_1_bss_19B8[i][2] = HuSprCreate(anim3, 0, 0); - HuSprGrpMemberSet(lbl_1_bss_19E0[i], 2, lbl_1_bss_19B8[i][2]); - HuSprPosSet(lbl_1_bss_19E0[i], 2, x_ofs + 16, -36); - lbl_1_bss_19B8[i][3] = HuSprCreate(anim3, 0, 0); - HuSprGrpMemberSet(lbl_1_bss_19E0[i], 3, lbl_1_bss_19B8[i][3]); - HuSprPosSet(lbl_1_bss_19E0[i], 3, x_ofs + 32, -36); - lbl_1_bss_19B8[i][4] = HuSprCreate(anim3, 0, 0); - HuSprGrpMemberSet(lbl_1_bss_19E0[i], 4, lbl_1_bss_19B8[i][4]); - HuSprPosSet(lbl_1_bss_19E0[i], 4, x_ofs + 48, -36); - HuSprGrpPosSet(lbl_1_bss_19E0[i], 0, 0); - fn_1_8338(lbl_1_bss_19E0[i], 9); - HuSprGrpScaleSet(lbl_1_bss_19E0[i], 0, 0); + coinNumGrpId[i] = HuSprGrpCreate(5); + coinNumSprId[i][0] = HuSprCreate(anim, 10, 0); + HuSprGrpMemberSet(coinNumGrpId[i], 0, coinNumSprId[i][0]); + HuSprPosSet(coinNumGrpId[i], 0, 17, -32); + coinNumSprId[i][1] = HuSprCreate(anim2, 0, 0); + HuSprGrpMemberSet(coinNumGrpId[i], 1, coinNumSprId[i][1]); + HuSprPosSet(coinNumGrpId[i], 1, xOfs, -36); + coinNumSprId[i][2] = HuSprCreate(anim3, 0, 0); + HuSprGrpMemberSet(coinNumGrpId[i], 2, coinNumSprId[i][2]); + HuSprPosSet(coinNumGrpId[i], 2, xOfs + 16, -36); + coinNumSprId[i][3] = HuSprCreate(anim3, 0, 0); + HuSprGrpMemberSet(coinNumGrpId[i], 3, coinNumSprId[i][3]); + HuSprPosSet(coinNumGrpId[i], 3, xOfs + 32, -36); + coinNumSprId[i][4] = HuSprCreate(anim3, 0, 0); + HuSprGrpMemberSet(coinNumGrpId[i], 4, coinNumSprId[i][4]); + HuSprPosSet(coinNumGrpId[i], 4, xOfs + 48, -36); + HuSprGrpPosSet(coinNumGrpId[i], 0, 0); + ResultBattleCoinAddNumSet(coinNumGrpId[i], 9); + HuSprGrpScaleSet(coinNumGrpId[i], 0, 0); } (void)anim3; - Hu3DMotionSet(lbl_1_bss_1A9C[8], lbl_1_bss_1A5C[9]); - Hu3DModelAttrSet(lbl_1_bss_1A9C[8], HU3D_MOTATTR_LOOP); - Hu3DModelShadowSet(lbl_1_bss_1A9C[8]); - for (i = 0; i < 180; i++) { + Hu3DMotionSet(stageMdlId[8], stageMotId[9]); + Hu3DModelAttrSet(stageMdlId[8], HU3D_MOTATTR_LOOP); + Hu3DModelShadowSet(stageMdlId[8]); + for (i = 0; i < COIN_EFFECT_MAX; i++) { if (i == 0) { - lbl_1_bss_1828[0] = Hu3DModelCreateFile(DATA_MAKE_NUM(DATADIR_RESULT, 0x0C)); + coinEffectMdlId[0] = Hu3DModelCreateFile(DATA_MAKE_NUM(DATADIR_RESULT, 0x0C)); } else { - lbl_1_bss_1828[i] = Hu3DModelLink(lbl_1_bss_1828[0]); + coinEffectMdlId[i] = Hu3DModelLink(coinEffectMdlId[0]); } - Hu3DModelScaleSet(lbl_1_bss_1828[i], 0.5f, 0.5f, 0.5f); - Hu3DModelAttrSet(lbl_1_bss_1828[i], HU3D_ATTR_DISPOFF); + Hu3DModelScaleSet(coinEffectMdlId[i], 0.5f, 0.5f, 0.5f); + Hu3DModelAttrSet(coinEffectMdlId[i], HU3D_ATTR_DISPOFF); } - fn_1_8658(); + CoinEffectInit(); anim = HuSprAnimRead(HuAR_ARAMtoMRAMFileRead(DATA_MAKE_NUM(DATADIR_EFFECT, 4), MEMORY_DEFAULT_NUM, HEAP_DATA)); for (i = 0; i < 4; i++) { - lbl_1_bss_1814[i] = Hu3DParManCreate(anim, 300, &lbl_1_data_780); - Hu3DParManAttrSet(lbl_1_bss_1814[i], 0x65); - Hu3DParticleBlendModeSet(Hu3DParManModelIDGet(lbl_1_bss_1814[i]), 1); - Hu3DParManRotSet(lbl_1_bss_1814[i], 90, 0, 0); + resultBattleEffParManId[i] = Hu3DParManCreate(anim, 300, &resultBattleEffParMan); + Hu3DParManAttrSet(resultBattleEffParManId[i], 0x65); + Hu3DParticleBlendModeSet(Hu3DParManModelIDGet(resultBattleEffParManId[i]), 1); + Hu3DParManRotSet(resultBattleEffParManId[i], 90, 0, 0); } HuDataDirClose(DATADIR_RESULT); for (i = 0; i < 4; i++) { - player = lbl_1_bss_19F0[i]; - character = GWPlayerCfg[lbl_1_bss_19F0[i]].character; - char_mdl = CharModelCreate(character, 2); - lbl_1_bss_19B0[player] = char_mdl; - lbl_1_bss_1990[player][0] = CharModelMotionCreate(character, DATA_MAKE_NUM(DATADIR_MARIOMOT, 0x00)); - lbl_1_bss_1990[player][1] = CharModelMotionCreate(character, DATA_MAKE_NUM(DATADIR_MARIOMOT, 0x17)); - lbl_1_bss_1990[player][2] = CharModelMotionCreate(character, DATA_MAKE_NUM(DATADIR_MARIOMOT, 0x49)); - CharModelVoiceEnableSet(character, lbl_1_bss_1990[player][1], 0); - CharModelMotionSet(character, lbl_1_bss_1990[player][0]); - Hu3DModelPosSet(char_mdl, lbl_1_data_7F0[i].x, lbl_1_data_7F0[lbl_1_bss_19E8[i]].y, 0); - Hu3DModelAttrSet(char_mdl, HU3D_MOTATTR_LOOP); - Hu3DModelShadowSet(char_mdl); + playerNo = resultBattleOrder[i]; + charNo = GWPlayerCfg[resultBattleOrder[i]].character; + charMdlId = CharModelCreate(charNo, 2); + resultBattleCharMdl[playerNo] = charMdlId; + resultBattleCharMot[playerNo][0] = CharModelMotionCreate(charNo, DATA_MAKE_NUM(DATADIR_MARIOMOT, 0x00)); + resultBattleCharMot[playerNo][1] = CharModelMotionCreate(charNo, DATA_MAKE_NUM(DATADIR_MARIOMOT, 0x17)); + resultBattleCharMot[playerNo][2] = CharModelMotionCreate(charNo, DATA_MAKE_NUM(DATADIR_MARIOMOT, 0x49)); + CharModelVoiceEnableSet(charNo, resultBattleCharMot[playerNo][1], 0); + CharModelMotionSet(charNo, resultBattleCharMot[playerNo][0]); + Hu3DModelPosSet(charMdlId, playerPosTbl[i].x, playerPosTbl[resultBattleRank[i]].y, 0); + Hu3DModelAttrSet(charMdlId, HU3D_MOTATTR_LOOP); + Hu3DModelShadowSet(charMdlId); } CharModelDataClose(-1); } -Vec lbl_1_data_8B8[] = { { 8, 0, 0 }, { 0, 8, 0 }, { 10, 5, 0 }, { -5, 10, 0 }, { 0, -8, 0 }, { 8, 10, 0 }, { -10, 8, 0 }, { 15, 0, 0 } }; +static Vec cameraShakeOfs[] = { { 8, 0, 0 }, { 0, 8, 0 }, { 10, 5, 0 }, { -5, 10, 0 }, { 0, -8, 0 }, { 8, 10, 0 }, { -10, 8, 0 }, { 15, 0, 0 } }; -void fn_1_7544(void) +static void ResultBattleStatAdd(void) { s16 i; s16 time; s16 done_cnt; float pos_y; - s16 gains[5]; - s16 time_player[4]; - fn_1_423C(gains); + s16 coinNum[5]; + s16 delay[4]; + ResultCoinNumGet(coinNum); for (time = 0; time <= 5; time++) { pos_y = ((5 - time) * 50) + 580; for (i = 0; i < 4; i++) { - Hu3DModelPosSet(lbl_1_bss_1A9C[i + 4], lbl_1_data_7F0[i].x, pos_y, 0); + Hu3DModelPosSet(stageMdlId[i + 4], playerPosTbl[i].x, pos_y, 0); } HuPrcVSleep(); } for (i = 0; i < 4; i++) { - Hu3DModelAttrReset(lbl_1_bss_1A9C[i + 4], HU3D_MOTATTR_PAUSE); - Hu3DMotionSpeedSet(lbl_1_bss_1A9C[i + 4], 1.5f); + Hu3DModelAttrReset(stageMdlId[i + 4], HU3D_MOTATTR_PAUSE); + Hu3DMotionSpeedSet(stageMdlId[i + 4], 1.5f); } HuPrcSleep(35); for (i = 0; i < 4; i++) { - if (gains[lbl_1_bss_19F0[i]] > 0) { - Hu3DParManAttrReset(lbl_1_bss_1814[i], 1); - time_player[i] = frandmod(10); + if (coinNum[resultBattleOrder[i]] > 0) { + Hu3DParManAttrReset(resultBattleEffParManId[i], 1); + delay[i] = frandmod(10); } else { - time_player[i] = 0; + delay[i] = 0; } - Hu3DParManPosSet(lbl_1_bss_1814[i], lbl_1_data_7F0[i].x, 610.0f, 0.0f); + Hu3DParManPosSet(resultBattleEffParManId[i], playerPosTbl[i].x, 610.0f, 0.0f); } while (1) { for (i = done_cnt = 0; i < 4; i++) { - if (time_player[i]) { - time_player[i]--; + if (delay[i]) { + delay[i]--; continue; } - if (gains[lbl_1_bss_19F0[i]] <= 0) { - Hu3DParManAttrSet(lbl_1_bss_1814[i], 1); + if (coinNum[resultBattleOrder[i]] <= 0) { + Hu3DParManAttrSet(resultBattleEffParManId[i], 1); done_cnt++; } else { - fn_1_86DC(i); - gains[lbl_1_bss_19F0[i]]--; - if (gains[lbl_1_bss_19F0[i]] <= 10) { - time_player[i] = 4; + CoinEffectAdd(i); + coinNum[resultBattleOrder[i]]--; + if (coinNum[resultBattleOrder[i]] <= 10) { + delay[i] = 4; } else { - if (gains[lbl_1_bss_19F0[i]] <= 20) { - time_player[i] = 3; + if (coinNum[resultBattleOrder[i]] <= 20) { + delay[i] = 3; } else { - if (gains[lbl_1_bss_19F0[i]] <= 40) { - time_player[i] = 2; + if (coinNum[resultBattleOrder[i]] <= 40) { + delay[i] = 2; } else { - time_player[i] = 1; + delay[i] = 1; } } } @@ -412,234 +414,233 @@ void fn_1_7544(void) } HuPrcVSleep(); } - if (gains[4]) { + if (coinNum[4]) { HuPrcSleep(20); - Hu3DModelRotSet(lbl_1_bss_1A9C[8], 0, -90, 0); - Hu3DModelScaleSet(lbl_1_bss_1A9C[8], 0.8f, 0.8f, 0.8f); - Hu3DMotionSpeedSet(lbl_1_bss_1A9C[8], 2.0f); + Hu3DModelRotSet(stageMdlId[8], 0, -90, 0); + Hu3DModelScaleSet(stageMdlId[8], 0.8f, 0.8f, 0.8f); + Hu3DMotionSpeedSet(stageMdlId[8], 2.0f); for (i = 0; i <= 40; i++) { - Hu3DModelPosSet(lbl_1_bss_1A9C[8], 500.0f * (1.0f - (i / 40.0f)), 0, 100.0f); + Hu3DModelPosSet(stageMdlId[8], 500.0f * (1.0f - (i / 40.0f)), 0, 100.0f); HuPrcVSleep(); } HuAudFXPlay(828); - Hu3DModelAttrReset(lbl_1_bss_1A9C[10], HU3D_MOTATTR_PAUSE); - Hu3DModelPosSet(lbl_1_bss_1A9C[10], 0, 0, 200); - for (i = 0; i < Hu3DMotionMaxTimeGet(lbl_1_bss_1A9C[10]); i++) { + Hu3DModelAttrReset(stageMdlId[10], HU3D_MOTATTR_PAUSE); + Hu3DModelPosSet(stageMdlId[10], 0, 0, 200); + for (i = 0; i < Hu3DMotionMaxTimeGet(stageMdlId[10]); i++) { if (i > 10) { - Hu3DModelAttrSet(lbl_1_bss_1A9C[8], HU3D_ATTR_DISPOFF); + Hu3DModelAttrSet(stageMdlId[8], HU3D_ATTR_DISPOFF); } - Center.x = lbl_1_data_8B8[(i / 2) & 0x7].x; - Center.y = 330.0f + lbl_1_data_8B8[(i / 2) & 0x7].y; - Center.z = lbl_1_data_8B8[(i / 2) & 0x7].z; - espPosSet(lbl_1_bss_1A1A[0], 288.0f + lbl_1_data_8B8[(i / 2) & 0x7].x, 240.0f - lbl_1_data_8B8[(i / 2) & 0x7].y); + Center.x = cameraShakeOfs[(i / 2) & 0x7].x; + Center.y = 330.0f + cameraShakeOfs[(i / 2) & 0x7].y; + Center.z = cameraShakeOfs[(i / 2) & 0x7].z; + espPosSet(stageSprId[0], 288.0f + cameraShakeOfs[(i / 2) & 0x7].x, 240.0f - cameraShakeOfs[(i / 2) & 0x7].y); HuPrcVSleep(); } - espPosSet(lbl_1_bss_1A1A[0], 288.0, 240.0); + espPosSet(stageSprId[0], 288.0, 240.0); Center.x = 0; Center.y = 330; Center.z = 0; - time_player[0] = 10; + delay[0] = 10; for (i = 0; i < 4; i++) { - if (lbl_1_bss_172 == lbl_1_bss_19F0[i]) { + if (resultBonusPlayer == resultBattleOrder[i]) { break; } } - Hu3DParManAttrReset(lbl_1_bss_1814[i], 1); + Hu3DParManAttrReset(resultBattleEffParManId[i], 1); while (1) { - if (time_player[0] != 0) { - time_player[0]--; + if (delay[0] != 0) { + delay[0]--; HuPrcVSleep(); continue; } - if (gains[4] <= 0) { - Hu3DParManAttrSet(lbl_1_bss_1814[i], 1); + if (coinNum[4] <= 0) { + Hu3DParManAttrSet(resultBattleEffParManId[i], 1); break; } - fn_1_86DC(i); - gains[4]--; - time_player[0] = 5; + CoinEffectAdd(i); + coinNum[4]--; + delay[0] = 5; HuPrcVSleep(); } - Hu3DParManAttrSet(lbl_1_bss_1814[i], 1); + Hu3DParManAttrSet(resultBattleEffParManId[i], 1); } - fn_1_423C(gains); - gains[lbl_1_bss_172] += gains[4]; + ResultCoinNumGet(coinNum); + coinNum[resultBonusPlayer] += coinNum[4]; for (i = 0; i < 4; i++) { - if (gains[lbl_1_bss_19F0[i]]) { - CharModelMotionShiftSet(GWPlayerCfg[lbl_1_bss_19F0[i]].character, lbl_1_bss_1990[lbl_1_bss_19F0[i]][1], 0, 4, HU3D_MOTATTR_NONE); - HuAudPlayerVoicePlay(lbl_1_bss_19F0[i], 293); + if (coinNum[resultBattleOrder[i]]) { + CharModelMotionShiftSet(GWPlayerCfg[resultBattleOrder[i]].character, resultBattleCharMot[resultBattleOrder[i]][1], 0, 4, HU3D_MOTATTR_NONE); + HuAudPlayerVoicePlay(resultBattleOrder[i], 293); } else { - CharModelMotionShiftSet(GWPlayerCfg[lbl_1_bss_19F0[i]].character, lbl_1_bss_1990[lbl_1_bss_19F0[i]][2], 0, 4, HU3D_MOTATTR_NONE); + CharModelMotionShiftSet(GWPlayerCfg[resultBattleOrder[i]].character, resultBattleCharMot[resultBattleOrder[i]][2], 0, 4, HU3D_MOTATTR_NONE); } } HuPrcSleep(20); - fn_1_7F98(); + ResultBattleCoinAddShow(); HuPrcSleep(120); } -void fn_1_7F98(void) +static void ResultBattleCoinAddShow(void) { s16 i; s16 time; - s16 delay; - s16 gains[5]; - Vec pos_3d; - Vec pos_2d; - fn_1_423C(gains); - gains[lbl_1_bss_172] += gains[4]; + s16 speed; + s16 coinNum[5]; + Vec pos3D; + Vec pos2D; + ResultCoinNumGet(coinNum); + coinNum[resultBonusPlayer] += coinNum[4]; for (i = 0; i < 4; i++) { - fn_1_8338(lbl_1_bss_19E0[i], gains[lbl_1_bss_19F0[i]]); - pos_3d.x = lbl_1_data_7F0[i].x; - if (gains[lbl_1_bss_19F0[i]]) { - pos_3d.y = lbl_1_data_7F0[lbl_1_bss_19E8[i]].y + lbl_1_data_860[GWPlayerCfg[lbl_1_bss_19F0[i]].character]; + ResultBattleCoinAddNumSet(coinNumGrpId[i], coinNum[resultBattleOrder[i]]); + pos3D.x = playerPosTbl[i].x; + if (coinNum[resultBattleOrder[i]]) { + pos3D.y = playerPosTbl[resultBattleRank[i]].y + coinAddYOfs[GWPlayerCfg[resultBattleOrder[i]].character]; } else { - pos_3d.y = lbl_1_data_7F0[lbl_1_bss_19E8[i]].y + lbl_1_data_880[GWPlayerCfg[lbl_1_bss_19F0[i]].character]; + pos3D.y = playerPosTbl[resultBattleRank[i]].y + coinBlankYOfs[GWPlayerCfg[resultBattleOrder[i]].character]; } - pos_3d.z = 0; - Hu3D3Dto2D(&pos_3d, 1, &pos_2d); - HuSprGrpPosSet(lbl_1_bss_19E0[i], pos_2d.x, pos_2d.y); + pos3D.z = 0; + Hu3D3Dto2D(&pos3D, 1, &pos2D); + HuSprGrpPosSet(coinNumGrpId[i], pos2D.x, pos2D.y); } - delay = (lbl_1_bss_174) ? 3 : 10; - for (time = 0; time <= delay; time++) { - float scale = sind((90.0 / delay) * time); + speed = (resultFastF) ? 3 : 10; + for (time = 0; time <= speed; time++) { + float scale = sind((90.0 / speed) * time); for (i = 0; i < 4; i++) { - HuSprGrpScaleSet(lbl_1_bss_19E0[i], scale, scale); + HuSprGrpScaleSet(coinNumGrpId[i], scale, scale); } HuPrcVSleep(); } for (i = 0; i < 4; i++) { - HuSprGrpScaleSet(lbl_1_bss_19E0[i], 1.0f, 1.0f); + HuSprGrpScaleSet(coinNumGrpId[i], 1.0f, 1.0f); } } -void fn_1_8338(s16 group, s16 value) +static void ResultBattleCoinAddNumSet(s16 grpId, s16 value) { - s16 digit; - s16 digit_value; - - digit = 2; - digit_value = value / 100; - if (digit_value != 0) { - HuSprBankSet(group, digit, digit_value); - HuSprAttrReset(group, digit, 4); - digit++; + s16 no; + s16 bank; + no = 2; + bank = value / 100; + if (bank != 0) { + HuSprBankSet(grpId, no, bank); + HuSprAttrReset(grpId, no, 4); + no++; } - value -= digit_value * 100; - digit_value = value / 10; - if (digit_value != 0 || digit == 3) { - HuSprBankSet(group, digit, digit_value); - HuSprAttrReset(group, digit, 4); - digit++; + value -= bank * 100; + bank = value / 10; + if (bank != 0 || no == 3) { + HuSprBankSet(grpId, no, bank); + HuSprAttrReset(grpId, no, 4); + no++; } - value -= digit_value * 10; - HuSprBankSet(group, digit, value); - HuSprAttrReset(group, digit, 4); - digit++; - for (digit_value = digit; digit_value < 5; digit_value++) { - HuSprAttrSet(group, digit_value, 4); + value -= bank * 10; + HuSprBankSet(grpId, no, value); + HuSprAttrReset(grpId, no, 4); + no++; + for (bank = no; bank < 5; bank++) { + HuSprAttrSet(grpId, bank, 4); } } -void fn_1_8484(void) +static void ResultBattleOrderSet(void) { s16 i; s16 j; for (i = 0; i < 4; i++) { - lbl_1_bss_19E8[i] = GWPlayerCoinWinGet(i); - lbl_1_bss_19F0[i] = i; + resultBattleRank[i] = GWPlayerCoinWinGet(i); + resultBattleOrder[i] = i; } for (j = 1; j < 4; j++) { for (i = 0; i < 4 - j; i++) { - if (lbl_1_bss_19E8[i] > lbl_1_bss_19E8[i + 1]) { + if (resultBattleRank[i] > resultBattleRank[i + 1]) { s16 temp; - temp = lbl_1_bss_19E8[i]; - lbl_1_bss_19E8[i] = lbl_1_bss_19E8[i + 1]; - lbl_1_bss_19E8[i + 1] = temp; - temp = lbl_1_bss_19F0[i]; - lbl_1_bss_19F0[i] = lbl_1_bss_19F0[i + 1]; - lbl_1_bss_19F0[i + 1] = temp; + temp = resultBattleRank[i]; + resultBattleRank[i] = resultBattleRank[i + 1]; + resultBattleRank[i + 1] = temp; + temp = resultBattleOrder[i]; + resultBattleOrder[i] = resultBattleOrder[i + 1]; + resultBattleOrder[i + 1] = temp; } } } } -void fn_1_8998(void); +static void CoinEffectMain(void); -void fn_1_8658(void) +static void CoinEffectInit(void) { s16 i; Process *process = HuPrcCurrentGet(); - for (i = 0; i < 180; i++) { - lbl_1_bss_194[i].unk0 = -1; + for (i = 0; i < COIN_EFFECT_MAX; i++) { + coinEffectData[i].playerNo = -1; } - HuPrcChildCreate(fn_1_8998, 100, 8192, 0, process); + HuPrcChildCreate(CoinEffectMain, 100, 8192, 0, process); } -void fn_1_86DC(s16 player) +static void CoinEffectAdd(s16 playerNo) { s16 i; - for (i = 0; i < 180; i++) { - if (lbl_1_bss_194[i].unk0 == -1) { + for (i = 0; i < COIN_EFFECT_MAX; i++) { + if (coinEffectData[i].playerNo == -1) { break; } } - if (i == 180) { + if (i == COIN_EFFECT_MAX) { return; } - lbl_1_bss_194[i].unk0 = player; - lbl_1_bss_194[i].unk4.x = lbl_1_data_7F0[player].x; - lbl_1_bss_194[i].unk4.y = 610.0f; - lbl_1_bss_194[i].unk4.z = 0.0f; - lbl_1_bss_194[i].unk2 = lbl_1_bss_19E8[player]; - lbl_1_bss_194[i].unk10.x = frandmod(20) - 10.0f; - lbl_1_bss_194[i].unk10.y = frandmod(20) - 10.0f; - lbl_1_bss_194[i].unk10.z = 0; - lbl_1_bss_194[i].unk1C = 10.0f; - Hu3DModelAttrReset(lbl_1_bss_1828[i], HU3D_ATTR_DISPOFF); - Hu3DModelPosSet(lbl_1_bss_1828[i], 0, 100, 0); - Hu3DModelRotSet(lbl_1_bss_1828[i], 0, 0, 0); + coinEffectData[i].playerNo = playerNo; + coinEffectData[i].pos.x = playerPosTbl[playerNo].x; + coinEffectData[i].pos.y = 610.0f; + coinEffectData[i].pos.z = 0.0f; + coinEffectData[i].rank = resultBattleRank[playerNo]; + coinEffectData[i].rotVel.x = frandmod(20) - 10.0f; + coinEffectData[i].rotVel.y = frandmod(20) - 10.0f; + coinEffectData[i].rotVel.z = 0; + coinEffectData[i].velY = 10.0f; + Hu3DModelAttrReset(coinEffectMdlId[i], HU3D_ATTR_DISPOFF); + Hu3DModelPosSet(coinEffectMdlId[i], 0, 100, 0); + Hu3DModelRotSet(coinEffectMdlId[i], 0, 0, 0); } -void fn_1_8998(void) +static void CoinEffectMain(void) { s16 i; - ModelData *model_ptr; + ModelData *modelP; s16 player; while (1) { - for (i = 0; i < 180; i++) { - if (lbl_1_bss_194[i].unk0 == -1) { + for (i = 0; i < COIN_EFFECT_MAX; i++) { + if (coinEffectData[i].playerNo == -1) { continue; } - player = lbl_1_bss_194[i].unk0; - model_ptr = &Hu3DData[lbl_1_bss_1828[i]]; - model_ptr->pos = lbl_1_bss_194[i].unk4; - model_ptr->rot.x += lbl_1_bss_194[i].unk10.x; - model_ptr->rot.y += lbl_1_bss_194[i].unk10.y; - lbl_1_bss_194[i].unk4.y -= lbl_1_bss_194[i].unk1C; - lbl_1_bss_194[i].unk1C += 0.2f; - if (lbl_1_bss_194[i].unk4.y < ((3 - lbl_1_bss_194[i].unk2) * 100) + lbl_1_data_840[GWPlayerCfg[lbl_1_bss_19F0[player]].character]) { + player = coinEffectData[i].playerNo; + modelP = &Hu3DData[coinEffectMdlId[i]]; + modelP->pos = coinEffectData[i].pos; + modelP->rot.x += coinEffectData[i].rotVel.x; + modelP->rot.y += coinEffectData[i].rotVel.y; + coinEffectData[i].pos.y -= coinEffectData[i].velY; + coinEffectData[i].velY += 0.2f; + if (coinEffectData[i].pos.y < ((3 - coinEffectData[i].rank) * 100) + coinEffectYOfs[GWPlayerCfg[resultBattleOrder[player]].character]) { Vec pos; - pos.x = lbl_1_data_7F0[player].x; - pos.y = ((3 - lbl_1_bss_194[i].unk2) * 100) + lbl_1_data_840[GWPlayerCfg[lbl_1_bss_19F0[player]].character]; + pos.x = playerPosTbl[player].x; + pos.y = ((3 - coinEffectData[i].rank) * 100) + coinEffectYOfs[GWPlayerCfg[resultBattleOrder[player]].character]; pos.z = 0.0f; CharModelCoinEffectCreate(1, &pos); - lbl_1_bss_194[i].unk0 = -1; + coinEffectData[i].playerNo = -1; HuAudFXPlay(7); - Hu3DModelAttrSet(lbl_1_bss_1828[i], HU3D_ATTR_DISPOFF); + Hu3DModelAttrSet(coinEffectMdlId[i], HU3D_ATTR_DISPOFF); } } HuPrcVSleep(); } } -void fn_1_8CB8(struct model_data *model, Mtx matrix) +static void ResultShadowDraw(struct model_data *model, Mtx matrix) { s32 sp8 = 0; GXTexObj tex; Mtx final; - Mtx inv_camera; + Mtx invCamera; Mtx shadow; GXClearVtxDesc(); GXSetVtxDesc(GX_VA_POS, GX_DIRECT); @@ -647,8 +648,8 @@ void fn_1_8CB8(struct model_data *model, Mtx matrix) GXInitTexObj(&tex, Hu3DShadowData.unk_04, Hu3DShadowData.unk_02, Hu3DShadowData.unk_02, GX_TF_I8, GX_CLAMP, GX_CLAMP, GX_FALSE); GXInitTexObjLOD(&tex, GX_LINEAR, GX_LINEAR, 0.0f, 0.0f, 0.0f, GX_FALSE, GX_FALSE, GX_ANISO_1); GXLoadTexObj(&tex, 0); - MTXInverse(Hu3DCameraMtx, inv_camera); - MTXConcat(inv_camera, matrix, final); + MTXInverse(Hu3DCameraMtx, invCamera); + MTXConcat(invCamera, matrix, final); MTXConcat(Hu3DShadowData.unk_68, Hu3DShadowData.unk_38, shadow); MTXConcat(shadow, final, final); GXLoadTexMtxImm(final, GX_TEXMTX9, GX_MTX3x4); diff --git a/src/REL/resultDll/datalist.c b/src/REL/resultDll/datalist.c index 6b5705a2..1a37f8a0 100644 --- a/src/REL/resultDll/datalist.c +++ b/src/REL/resultDll/datalist.c @@ -1,13 +1,13 @@ #include "REL/resultdll.h" -s16 lbl_1_bss_1A9C[32]; -s16 lbl_1_bss_1A5C[32]; -s16 lbl_1_bss_1A1A[33]; +s16 stageMdlId[32]; +s16 stageMotId[32]; +s16 stageSprId[33]; s16 lbl_1_bss_1A18; -void fn_1_8FF8(DataListModel *model_list) +void StageModelCreate(StageModel *model_list) { - DataListModel *list; + StageModel *list; s16 i; s16 model; s16 clear_i; @@ -15,24 +15,24 @@ void fn_1_8FF8(DataListModel *model_list) void *data; list = model_list; for(clear_i=0; clear_i<32; clear_i++) { - lbl_1_bss_1A9C[clear_i] = lbl_1_bss_1A5C[clear_i] = -1; + stageMdlId[clear_i] = stageMotId[clear_i] = -1; } for(i=0; list->datanum != DATA_NUM_LISTEND; list++, i++) { if(list->type == 0) { data = HuDataSelHeapReadNum(list->datanum, MEMORY_DEFAULT_NUM, HEAP_DATA); model = Hu3DModelCreate(data); - lbl_1_bss_1A9C[i] = model; + stageMdlId[i] = model; Hu3DModelAttrSet(model, list->attr); Hu3DModelPosSetV(model, &list->pos); Hu3DModelRotSetV(model, &list->rot); Hu3DModelScaleSetV(model, &list->scale); model_ptr = &Hu3DData[model]; if(model_ptr->unk_08 != -1) { - lbl_1_bss_1A5C[i] = model_ptr->unk_08; + stageMotId[i] = model_ptr->unk_08; } } else if(list->type == 1) { data = HuDataSelHeapReadNum(list->datanum, MEMORY_DEFAULT_NUM, HEAP_DATA); - lbl_1_bss_1A5C[i] = Hu3DJointMotion(lbl_1_bss_1A9C[list->mot_link], data); + stageMotId[i] = Hu3DJointMotion(stageMdlId[list->mot_link], data); } (void)i; @@ -40,33 +40,33 @@ void fn_1_8FF8(DataListModel *model_list) list = model_list; for(i=0; list->datanum != DATA_NUM_LISTEND; list++, i++) { if(list->type == 2) { - model = Hu3DModelLink(lbl_1_bss_1A9C[list->link]); - lbl_1_bss_1A9C[i] = model; + model = Hu3DModelLink(stageMdlId[list->link]); + stageMdlId[i] = model; Hu3DModelAttrSet(model, list->attr); Hu3DModelPosSetV(model, &list->pos); Hu3DModelRotSetV(model, &list->rot); Hu3DModelScaleSetV(model, &list->scale); } if(list->mot_link != -1) { - Hu3DMotionSet(lbl_1_bss_1A9C[i], lbl_1_bss_1A5C[list->mot_link]); + Hu3DMotionSet(stageMdlId[i], stageMotId[list->mot_link]); } (void)i; } } -void fn_1_927C(DataListSprite *sprite_list) +void StageSpriteCreate(StageSprite *sprite_list) { - DataListSprite *list; + StageSprite *list; s16 sprite; s16 clear_i; s16 i; list = sprite_list; for(clear_i=0; clear_i<32; clear_i++) { - lbl_1_bss_1A1A[clear_i] = -1; + stageSprId[clear_i] = -1; } for(i=0; list->datanum; i++, list++) { sprite = espEntry(list->datanum, 100, 0); - lbl_1_bss_1A1A[i] = sprite; + stageSprId[i] = sprite; espPosSet(sprite, list->x, list->y); espColorSet(sprite, list->color.r, list->color.g, list->color.b); espTPLvlSet(sprite, list->color.a/255.0f); @@ -75,12 +75,12 @@ void fn_1_927C(DataListSprite *sprite_list) } } -void fn_1_93B4(void) +void StageSpriteKill(void) { s16 i; for(i=0; i<32; i++) { - if(lbl_1_bss_1A1A[i] != -1) { - espKill(lbl_1_bss_1A1A[i]); + if(stageSprId[i] != -1) { + espKill(stageSprId[i]); } } } \ No newline at end of file diff --git a/src/REL/resultDll/main.c b/src/REL/resultDll/main.c index bda3b255..57433d33 100644 --- a/src/REL/resultDll/main.c +++ b/src/REL/resultDll/main.c @@ -18,7 +18,7 @@ #include "REL/resultdll.h" -DataListModel lbl_1_data_0[] = { { DATA_MAKE_NUM(DATADIR_RESULT, 0x00), 1, 0, -1, -1, { 148, 132, 500 }, { 0, 0, 0 }, { 1, 1, 1 } }, +static StageModel resultModel[] = { { DATA_MAKE_NUM(DATADIR_RESULT, 0x00), 1, 0, -1, -1, { 148, 132, 500 }, { 0, 0, 0 }, { 1, 1, 1 } }, { DATA_MAKE_NUM(DATADIR_RESULT, 0x01), 1, 0, -1, -1, { 148, 217, 500 }, { 0, 0, 0 }, { 1, 1, 1 } }, { DATA_MAKE_NUM(DATADIR_RESULT, 0x02), 1, 0, -1, -1, { 148, 302, 500 }, { 0, 0, 0 }, { 1, 1, 1 } }, { DATA_MAKE_NUM(DATADIR_RESULT, 0x03), 1, 0, -1, -1, { 148, 387, 500 }, { 0, 0, 0 }, { 1, 1, 1 } }, @@ -32,7 +32,7 @@ DataListModel lbl_1_data_0[] = { { DATA_MAKE_NUM(DATADIR_RESULT, 0x00), 1, 0, -1 { DATA_MAKE_NUM(DATADIR_RESULT, 0x06), 0, 2, 8, -1, { 410, 387, 500 }, { 0, 0, 0 }, { 1, 1, 1 } }, { -1, 0, 0, -1, -1, { 0, 0, 0 }, { 0, 0, 0 }, { 1, 1, 1 } } }; -DataListSprite lbl_1_data_2A4[] = { +static StageSprite resultSprite[] = { { DATA_MAKE_NUM(DATADIR_RESULT, 0x43), 0, 10, 288, 240, { 255, 255, 255, 255 } }, { DATA_MAKE_NUM(DATADIR_RESULT, 0x1D), 0, 10, 288, 60, { 255, 255, 255, 255 } }, { DATA_MAKE_NUM(DATADIR_RESULT, 0x1A), 0, 10, 270, 132, { 255, 255, 255, 255 } }, @@ -46,60 +46,60 @@ DataListSprite lbl_1_data_2A4[] = { { 0, 0, 0, 0, 0, { 0, 0, 0, 0 } }, }; -s16 lbl_1_data_380 = -1; +static s16 rankNewGrpId = -1; omObjData *lbl_1_bss_188; -omObjData *lbl_1_bss_184; -Process *lbl_1_bss_180; -s16 lbl_1_bss_17C; -s32 lbl_1_bss_178; -s32 lbl_1_bss_174; -s16 lbl_1_bss_172; -s16 lbl_1_bss_170; -s16 lbl_1_bss_168[4]; -s16 lbl_1_bss_158[8]; -AnimData *lbl_1_bss_144[5]; -AnimData *lbl_1_bss_E4[8][3]; -AnimData *lbl_1_bss_E0; -s16 lbl_1_bss_CE[9]; -s16 lbl_1_bss_9E[8][3]; -s16 lbl_1_bss_9C; -s16 lbl_1_bss_5C[8][4]; -s16 lbl_1_bss_54[4]; -s16 lbl_1_bss_52; -s16 lbl_1_bss_4A[4]; -s16 lbl_1_bss_42[4]; -s16 lbl_1_bss_3A[4]; -s16 lbl_1_bss_12[4][5]; -s16 lbl_1_bss_A[4]; -s16 lbl_1_bss_8; -s32 lbl_1_bss_4; -s32 lbl_1_bss_0; +static omObjData *outViewObj; +Process *objman; +s16 resultMgNo; +s32 resultReadEndF; +s32 resultFastF; +s16 resultBonusPlayer; +static s16 teamResultGrpId; +static s16 charShadowMdlId[4]; +static s16 statShadowMdlId[8]; +static AnimData *resultRankAnim[5]; +static AnimData *resultCharAnim[8][3]; +static AnimData *resultCrownAnim; +static s16 resultNumGrpId[8]; +static s16 resultNumSprId[8][3]; +static s16 resultCrownGrpId; +static s16 resultCubeMdlId[8][4]; +static s16 resultPlayerCubeMdlId[4]; +static s16 resultRankGrpId; +static s16 resultOrder[4]; +static s16 resultRank[4]; +static s16 resultCoinAddGrpId[4]; +static s16 resultCoinAddSprId[4][5]; +static s16 resultCharCubeMdlId[4]; +static s16 resultTeamOrder; +static s32 resultSkipF; +static s32 resultReorderF; -void fn_1_4D8(void); -void fn_1_888(void); +static void ResultMain(void); +static void ResultIdle(void); -void fn_1_B78(void); -void fn_1_1F4C(void); -void fn_1_2ADC(void); -void fn_1_461C(void); -void fn_1_47FC(void); +static void ResultCreate(void); +static void ResultStatAdd(void); +static void ResultOrderApply(void); +static void SaveExec(void); +static void ResultTeamExec(void); void ObjectSetup(void) { s32 i; - s32 light; + s32 lightId; OSReport("******* RESULT ObjectSetup *********\n"); - lbl_1_bss_180 = omInitObjMan(50, 8192); - lbl_1_bss_17C = GWSystem.mg_next; + objman = omInitObjMan(50, 8192); + resultMgNo = GWSystem.mg_next; - if (mgInfoTbl[lbl_1_bss_17C].ovl == OVL_M430) { + if (mgInfoTbl[resultMgNo].ovl == OVL_M430) { for (i = 0; i < 4; i++) { GWPlayerCfg[i].group = GWPlayerCfg[i].group / 2; } } - HuDataDirClose(mgInfoTbl[lbl_1_bss_17C].data_dir); - if (mgInfoTbl[lbl_1_bss_17C].type == 3 || mgInfoTbl[lbl_1_bss_17C].type == 5 || mgInfoTbl[lbl_1_bss_17C].type == 6 + HuDataDirClose(mgInfoTbl[resultMgNo].data_dir); + if (mgInfoTbl[resultMgNo].type == 3 || mgInfoTbl[resultMgNo].type == 5 || mgInfoTbl[resultMgNo].type == 6 || !_CheckFlag(FLAG_ID_MAKE(1, 0))) { if (_CheckFlag(0x10000)) { HuAR_DVDtoARAM(DATADIR_BOARD); @@ -119,27 +119,27 @@ void ObjectSetup(void) Hu3DCameraCreate(1); Hu3DCameraPerspectiveSet(1, 20.0f, 20.0f, 15000.0f, 1.2f); Hu3DCameraViewportSet(1, 0, 0, 640, 480, 0, 1); - light = Hu3DGLightCreate(0, 100, 1000, 0, -0.5, -1, 255, 255, 255); - Hu3DGLightInfinitytSet(light); - lbl_1_bss_174 = 0; + lightId = Hu3DGLightCreate(0, 100, 1000, 0, -0.5, -1, 255, 255, 255); + Hu3DGLightInfinitytSet(lightId); + resultFastF = 0; if (mgInfoTbl[GWSystem.mg_next].type != 4) { - HuPrcChildCreate(fn_1_4D8, 100, 12288, 0, lbl_1_bss_180); + HuPrcChildCreate(ResultMain, 100, 12288, 0, objman); } else { - HuPrcChildCreate(fn_1_6490, 100, 12288, 0, lbl_1_bss_180); + HuPrcChildCreate(ResultBattleMain, 100, 12288, 0, objman); } - lbl_1_bss_184 = omAddObjEx(lbl_1_bss_180, 32730, 0, 0, -1, omOutView); + outViewObj = omAddObjEx(objman, 32730, 0, 0, -1, omOutView); HuWinInit(1); - lbl_1_bss_172 = frandmod(4); + resultBonusPlayer = frandmod(4); } -void fn_1_4D8(void) +static void ResultMain(void) { s16 player; s16 i; - s16 window; - s16 button; - Process *process_curr = HuPrcCurrentGet(); + s16 winId; + s16 btnDown; + Process *proc = HuPrcCurrentGet(); HuAudSeqPlay(57); for (i = player = 0; i < 4; i++) { if (GWPlayerCfg[i].iscom) { @@ -147,43 +147,43 @@ void fn_1_4D8(void) } } if (player == 4) { - lbl_1_bss_4 = 1; + resultSkipF = 1; } else { - lbl_1_bss_4 = 0; + resultSkipF = 0; } - fn_1_B78(); - HuPrcChildCreate(fn_1_888, 100, 8192, 0, lbl_1_bss_180); + ResultCreate(); + HuPrcChildCreate(ResultIdle, 100, 8192, 0, objman); WipeCreate(WIPE_MODE_IN, WIPE_TYPE_NORMAL, 20); while (WipeStatGet()) { HuPrcVSleep(); } HuDataDirClose(DATADIR_RESULT); - lbl_1_bss_178 = 0; - HuPrcChildCreate(fn_1_3FD8, 100, 12288, 0, lbl_1_bss_180); + resultReadEndF = 0; + HuPrcChildCreate(ResultBoardDataRead, 100, 12288, 0, objman); HuPrcSleep(10); - if (!lbl_1_bss_174) { + if (!resultFastF) { HuPrcSleep(20); } - fn_1_1F4C(); - fn_1_40DC(); - fn_1_2ADC(); - window = HuWinCreate(-10000.0f, 400.0f, 320, 40, 0); - HuWinMesSpeedSet(window, 0); - HuWinBGTPLvlSet(window, 0); - HuWinPriSet(window, 5); - HuWinAttrSet(window, 0x800); - HuWinMesSet(window, MAKE_MESSID(0x24, 0x07)); + ResultStatAdd(); + ResultCoinAdd(); + ResultOrderApply(); + winId = HuWinCreate(-10000.0f, 400.0f, 320, 40, 0); + HuWinMesSpeedSet(winId, 0); + HuWinBGTPLvlSet(winId, 0); + HuWinPriSet(winId, 5); + HuWinAttrSet(winId, 0x800); + HuWinMesSet(winId, MAKE_MESSID(0x24, 0x07)); HuPrcSleep(4); i = 0; while (1) { - if (!lbl_1_bss_4 || i <= 120) { - for (player = button = 0; player < 4; player++) { + if (!resultSkipF || i <= 120) { + for (player = btnDown = 0; player < 4; player++) { if (!GWPlayerCfg[player].iscom) { - button |= HuPadBtnDown[GWPlayerCfg[player].pad_idx]; + btnDown |= HuPadBtnDown[GWPlayerCfg[player].pad_idx]; } } - if (button & PAD_BUTTON_A) { + if (btnDown & PAD_BUTTON_A) { HuAudFXPlay(28); break; } @@ -194,11 +194,11 @@ void fn_1_4D8(void) break; } } - HuWinKill(window); + HuWinKill(winId); if (GWTeamGet()) { - fn_1_47FC(); + ResultTeamExec(); } - while (!lbl_1_bss_178) { + while (!resultReadEndF) { HuPrcVSleep(); } HuAudSeqAllFadeOut(1000); @@ -208,7 +208,7 @@ void fn_1_4D8(void) while (WipeStatGet()) { HuPrcVSleep(); } - fn_1_461C(); + SaveExec(); } else { WipeCreate(WIPE_MODE_OUT, WIPE_TYPE_NORMAL, 60); @@ -224,51 +224,51 @@ void fn_1_4D8(void) } } -void fn_1_888(void) +static void ResultIdle(void) { - f32 var_f29; - f32 var_f31; - f32 var_f30; + float rotRightSpeed; + float rotLeft; + float rotRight; - var_f31 = 0.0f; - var_f30 = 0.0f; - var_f29 = 0.0f; - lbl_1_bss_0 = 0; + rotLeft = 0.0f; + rotRight = 0.0f; + rotRightSpeed = 0.0f; + resultReorderF = 0; while (1) { - if (((HuPadBtn[0] | HuPadBtn[1] | HuPadBtn[2] | HuPadBtn[3]) & 0x100) != 0 || lbl_1_bss_4 != 0) { - lbl_1_bss_174 = 1; + if (((HuPadBtn[0] | HuPadBtn[1] | HuPadBtn[2] | HuPadBtn[3]) & PAD_BUTTON_A) != 0 || resultSkipF != 0) { + resultFastF = 1; } else { - lbl_1_bss_174 = 0; + resultFastF = 0; } - Hu3DModelRotSet(lbl_1_bss_1A9C[4], 0.0f, var_f31, 0.0f); - Hu3DModelRotSet(lbl_1_bss_1A9C[5], 0.0f, -var_f31, 0.0f); - Hu3DModelRotSet(lbl_1_bss_1A9C[6], 0.0f, var_f31, 0.0f); - Hu3DModelRotSet(lbl_1_bss_1A9C[7], 0.0f, -var_f31, 0.0f); - var_f31 += 0.2; - if (var_f31 >= 360.0f) { - var_f31 -= 360.0f; + Hu3DModelRotSet(stageMdlId[4], 0.0f, rotLeft, 0.0f); + Hu3DModelRotSet(stageMdlId[5], 0.0f, -rotLeft, 0.0f); + Hu3DModelRotSet(stageMdlId[6], 0.0f, rotLeft, 0.0f); + Hu3DModelRotSet(stageMdlId[7], 0.0f, -rotLeft, 0.0f); + rotLeft += 0.2; + if (rotLeft >= 360.0f) { + rotLeft -= 360.0f; } - if (lbl_1_bss_0 != 0) { - Hu3DModelRotSet(lbl_1_bss_1A9C[8], 0.0f, var_f30, 0.0f); - Hu3DModelRotSet(lbl_1_bss_1A9C[9], 0.0f, -var_f30, 0.0f); - Hu3DModelRotSet(lbl_1_bss_1A9C[10], 0.0f, var_f30, 0.0f); - Hu3DModelRotSet(lbl_1_bss_1A9C[11], 0.0f, -var_f30, 0.0f); - var_f29 += 0.001; - if (var_f29 > 0.1) { - var_f29 = 0.1f; + if (resultReorderF != 0) { + Hu3DModelRotSet(stageMdlId[8], 0.0f, rotRight, 0.0f); + Hu3DModelRotSet(stageMdlId[9], 0.0f, -rotRight, 0.0f); + Hu3DModelRotSet(stageMdlId[10], 0.0f, rotRight, 0.0f); + Hu3DModelRotSet(stageMdlId[11], 0.0f, -rotRight, 0.0f); + rotRightSpeed += 0.001; + if (rotRightSpeed > 0.1) { + rotRightSpeed = 0.1f; } - var_f30 += var_f29; - if (var_f30 >= 360.0f) { - var_f30 -= 360.0f; + rotRight += rotRightSpeed; + if (rotRight >= 360.0f) { + rotRight -= 360.0f; } } HuPrcVSleep(); } } -s32 lbl_1_data_3A8[] = { +static s32 resultBackFile[] = { DATA_MAKE_NUM(DATADIR_RESULT, 0x10), DATA_MAKE_NUM(DATADIR_RESULT, 0x11), DATA_MAKE_NUM(DATADIR_RESULT, 0x12), @@ -277,7 +277,7 @@ s32 lbl_1_data_3A8[] = { DATA_MAKE_NUM(DATADIR_RESULT, 0x15), }; -s32 lbl_1_data_3C0[] = { +static s32 resultLetterFile[] = { DATA_MAKE_NUM(DATADIR_RESULT, 0x1F), DATA_MAKE_NUM(DATADIR_RESULT, 0x1E), DATA_MAKE_NUM(DATADIR_RESULT, 0x1D), @@ -286,7 +286,7 @@ s32 lbl_1_data_3C0[] = { DATA_MAKE_NUM(DATADIR_RESULT, 0x1F), }; -s16 lbl_1_data_3D8[] = { +static s16 resultStatPosTbl[] = { 320, 132, 500, @@ -305,123 +305,123 @@ s16 lbl_1_data_3D8[] = { 387, }; -s16 lbl_1_data_3F8[] = { 74, 132, 74, 217, 74, 302, 74, 387 }; +static s16 resultRankPosTbl[] = { 74, 132, 74, 217, 74, 302, 74, 387 }; -Vec lbl_1_data_408[4] = { { 148, 132, 500 }, { 148, 217, 500 }, { 148, 302, 500 }, { 148, 387, 500 } }; +static Vec resultCharPosTbl[4] = { { 148, 132, 500 }, { 148, 217, 500 }, { 148, 302, 500 }, { 148, 387, 500 } }; -s16 lbl_1_data_438[] = { 164, 148, 164, 233, 164, 318, 164, 403 }; +static s16 resultCoinAddPosTbl[] = { 164, 148, 164, 233, 164, 318, 164, 403 }; -void fn_1_3B50(s16 group, s16 value); -void fn_1_3CAC(s16 group, s16 value); +static void ResultSprNumSet(s16 grpId, s16 value); +static void ResultCoinAddNumSet(s16 grpId, s16 value); -void fn_1_3E08(void); +static void ResultOrderSet(void); -void fn_1_B78(void) +static void ResultCreate(void) { Vec pos; - s16 sp8[5]; + s16 coinNum[5]; s16 i; s16 j; - s16 character; + s16 charNo; AnimData *anim; - s16 sprite; - s16 group; - s16 model; + s16 sprId; + s16 grpId; + s16 mdlId; AnimData *anim2; AnimData *anim3; AnimData *anim4; - fn_1_8FF8(lbl_1_data_0); - lbl_1_data_2A4[0].datanum = lbl_1_data_3A8[mgInfoTbl[lbl_1_bss_17C].type]; - lbl_1_data_2A4[1].datanum = lbl_1_data_3C0[mgInfoTbl[lbl_1_bss_17C].type]; - fn_1_927C(lbl_1_data_2A4); - espDrawNoSet(lbl_1_bss_1A1A[0], 127); + StageModelCreate(resultModel); + resultSprite[0].datanum = resultBackFile[mgInfoTbl[resultMgNo].type]; + resultSprite[1].datanum = resultLetterFile[mgInfoTbl[resultMgNo].type]; + StageSpriteCreate(resultSprite); + espDrawNoSet(stageSprId[0], 127); anim = HuSprAnimReadFile(DATA_MAKE_NUM(DATADIR_RESULT, 0x1B)); for (i = 0; i < 8; i++) { - lbl_1_bss_CE[i] = HuSprGrpCreate(3); - lbl_1_bss_9E[i][0] = HuSprCreate(anim, 0, 0); - HuSprGrpMemberSet(lbl_1_bss_CE[i], 0, lbl_1_bss_9E[i][0]); - HuSprPosSet(lbl_1_bss_CE[i], 0, -28.0f, 0.0f); - lbl_1_bss_9E[i][1] = HuSprCreate(anim, 0, 0); - HuSprGrpMemberSet(lbl_1_bss_CE[i], 1, lbl_1_bss_9E[i][1]); - HuSprPosSet(lbl_1_bss_CE[i], 1, 0.0f, 0.0f); - lbl_1_bss_9E[i][2] = HuSprCreate(anim, 0, 0); - HuSprGrpMemberSet(lbl_1_bss_CE[i], 2, lbl_1_bss_9E[i][2]); - HuSprPosSet(lbl_1_bss_CE[i], 2, 28.0f, 0.0f); - HuSprGrpPosSet(lbl_1_bss_CE[i], lbl_1_data_3D8[(i * 2)], lbl_1_data_3D8[(i * 2) + 1]); - fn_1_3B50(lbl_1_bss_CE[i], 999); + resultNumGrpId[i] = HuSprGrpCreate(3); + resultNumSprId[i][0] = HuSprCreate(anim, 0, 0); + HuSprGrpMemberSet(resultNumGrpId[i], 0, resultNumSprId[i][0]); + HuSprPosSet(resultNumGrpId[i], 0, -28.0f, 0.0f); + resultNumSprId[i][1] = HuSprCreate(anim, 0, 0); + HuSprGrpMemberSet(resultNumGrpId[i], 1, resultNumSprId[i][1]); + HuSprPosSet(resultNumGrpId[i], 1, 0.0f, 0.0f); + resultNumSprId[i][2] = HuSprCreate(anim, 0, 0); + HuSprGrpMemberSet(resultNumGrpId[i], 2, resultNumSprId[i][2]); + HuSprPosSet(resultNumGrpId[i], 2, 28.0f, 0.0f); + HuSprGrpPosSet(resultNumGrpId[i], resultStatPosTbl[(i * 2)], resultStatPosTbl[(i * 2) + 1]); + ResultSprNumSet(resultNumGrpId[i], 999); } - fn_1_3E08(); - fn_1_423C(sp8); + ResultOrderSet(); + ResultCoinNumGet(coinNum); anim = HuSprAnimReadFile(DATA_MAKE_NUM(DATADIR_RESULT, 0x3A)); anim3 = HuSprAnimReadFile(DATA_MAKE_NUM(DATADIR_RESULT, 0x3B)); anim2 = HuSprAnimReadFile(DATA_MAKE_NUM(DATADIR_RESULT, 0x3C)); anim4 = HuSprAnimReadFile(DATA_MAKE_NUM(DATADIR_RESULT, 0x3E)); for (i = 0; i < 4; i++) { - lbl_1_bss_3A[i] = HuSprGrpCreate(5); - if (sp8[lbl_1_bss_4A[i]] < 100) { - lbl_1_bss_12[i][0] = HuSprCreate(anim, 10, 0); - HuSprGrpMemberSet(lbl_1_bss_3A[i], 0, lbl_1_bss_12[i][0]); - HuSprPosSet(lbl_1_bss_3A[i], 0, 30.0f, -25.0f); + resultCoinAddGrpId[i] = HuSprGrpCreate(5); + if (coinNum[resultOrder[i]] < 100) { + resultCoinAddSprId[i][0] = HuSprCreate(anim, 10, 0); + HuSprGrpMemberSet(resultCoinAddGrpId[i], 0, resultCoinAddSprId[i][0]); + HuSprPosSet(resultCoinAddGrpId[i], 0, 30.0f, -25.0f); } else { - lbl_1_bss_12[i][0] = HuSprCreate(anim4, 10, 0); - HuSprGrpMemberSet(lbl_1_bss_3A[i], 0, lbl_1_bss_12[i][0]); - HuSprPosSet(lbl_1_bss_3A[i], 0, 40.0f, -21.0f); + resultCoinAddSprId[i][0] = HuSprCreate(anim4, 10, 0); + HuSprGrpMemberSet(resultCoinAddGrpId[i], 0, resultCoinAddSprId[i][0]); + HuSprPosSet(resultCoinAddGrpId[i], 0, 40.0f, -21.0f); } - lbl_1_bss_12[i][1] = HuSprCreate(anim3, 0, 0); - HuSprGrpMemberSet(lbl_1_bss_3A[i], 1, lbl_1_bss_12[i][1]); - HuSprPosSet(lbl_1_bss_3A[i], 1, 12.0f, -25.0f); - lbl_1_bss_12[i][2] = HuSprCreate(anim2, 0, 0); - HuSprGrpMemberSet(lbl_1_bss_3A[i], 2, lbl_1_bss_12[i][2]); - HuSprPosSet(lbl_1_bss_3A[i], 2, 28.0f, -25.0f); - lbl_1_bss_12[i][3] = HuSprCreate(anim2, 0, 0); - HuSprGrpMemberSet(lbl_1_bss_3A[i], 3, lbl_1_bss_12[i][3]); - HuSprPosSet(lbl_1_bss_3A[i], 3, 44.0f, -25.0f); - lbl_1_bss_12[i][4] = HuSprCreate(anim2, 0, 0); - HuSprGrpMemberSet(lbl_1_bss_3A[i], 4, lbl_1_bss_12[i][4]); - HuSprPosSet(lbl_1_bss_3A[i], 4, 60.0f, -25.0f); - HuSprGrpPosSet(lbl_1_bss_3A[i], lbl_1_data_438[(i * 2)], lbl_1_data_438[(i * 2) + 1]); - fn_1_3CAC(lbl_1_bss_3A[i], 9); - HuSprGrpScaleSet(lbl_1_bss_3A[i], 0.0f, 0.0f); + resultCoinAddSprId[i][1] = HuSprCreate(anim3, 0, 0); + HuSprGrpMemberSet(resultCoinAddGrpId[i], 1, resultCoinAddSprId[i][1]); + HuSprPosSet(resultCoinAddGrpId[i], 1, 12.0f, -25.0f); + resultCoinAddSprId[i][2] = HuSprCreate(anim2, 0, 0); + HuSprGrpMemberSet(resultCoinAddGrpId[i], 2, resultCoinAddSprId[i][2]); + HuSprPosSet(resultCoinAddGrpId[i], 2, 28.0f, -25.0f); + resultCoinAddSprId[i][3] = HuSprCreate(anim2, 0, 0); + HuSprGrpMemberSet(resultCoinAddGrpId[i], 3, resultCoinAddSprId[i][3]); + HuSprPosSet(resultCoinAddGrpId[i], 3, 44.0f, -25.0f); + resultCoinAddSprId[i][4] = HuSprCreate(anim2, 0, 0); + HuSprGrpMemberSet(resultCoinAddGrpId[i], 4, resultCoinAddSprId[i][4]); + HuSprPosSet(resultCoinAddGrpId[i], 4, 60.0f, -25.0f); + HuSprGrpPosSet(resultCoinAddGrpId[i], resultCoinAddPosTbl[(i * 2)], resultCoinAddPosTbl[(i * 2) + 1]); + ResultCoinAddNumSet(resultCoinAddGrpId[i], 9); + HuSprGrpScaleSet(resultCoinAddGrpId[i], 0.0f, 0.0f); } for (i = 0; i < 4; i++) { - character = GWPlayerCfg[i].character; - lbl_1_bss_E4[character][0] = HuSprAnimReadFile(DATA_MAKE_NUM(DATADIR_RESULT, 0x22) + (character * 3)); - lbl_1_bss_E4[character][1] = HuSprAnimReadFile(DATA_MAKE_NUM(DATADIR_RESULT, 0x23) + (character * 3)); - lbl_1_bss_E4[character][2] = HuSprAnimReadFile(DATA_MAKE_NUM(DATADIR_RESULT, 0x24) + (character * 3)); + charNo = GWPlayerCfg[i].character; + resultCharAnim[charNo][0] = HuSprAnimReadFile(DATA_MAKE_NUM(DATADIR_RESULT, 0x22) + (charNo * 3)); + resultCharAnim[charNo][1] = HuSprAnimReadFile(DATA_MAKE_NUM(DATADIR_RESULT, 0x23) + (charNo * 3)); + resultCharAnim[charNo][2] = HuSprAnimReadFile(DATA_MAKE_NUM(DATADIR_RESULT, 0x24) + (charNo * 3)); for (j = 0; j < 4; j++) { - lbl_1_bss_5C[character][j] = Hu3DModelCreateFile(DATA_MAKE_NUM(DATADIR_RESULT, 0x00) + j); - Hu3DModelScaleSet(lbl_1_bss_5C[character][j], 1.1f, 1.1f, 1.1f); - Hu3DAnimCreate(lbl_1_bss_E4[character][0], lbl_1_bss_5C[character][j], "ys22"); - Hu3DModelAttrSet(lbl_1_bss_5C[character][j], HU3D_ATTR_DISPOFF); + resultCubeMdlId[charNo][j] = Hu3DModelCreateFile(DATA_MAKE_NUM(DATADIR_RESULT, 0x00) + j); + Hu3DModelScaleSet(resultCubeMdlId[charNo][j], 1.1f, 1.1f, 1.1f); + Hu3DAnimCreate(resultCharAnim[charNo][0], resultCubeMdlId[charNo][j], "ys22"); + Hu3DModelAttrSet(resultCubeMdlId[charNo][j], HU3D_ATTR_DISPOFF); } } for (i = 0; i < 4; i++) { - lbl_1_bss_144[i] = HuSprAnimReadFile(DATA_MAKE_NUM(DATADIR_RESULT, 0x16) + i); + resultRankAnim[i] = HuSprAnimReadFile(DATA_MAKE_NUM(DATADIR_RESULT, 0x16) + i); } - lbl_1_bss_52 = HuSprGrpCreate(4); + resultRankGrpId = HuSprGrpCreate(4); for (i = 0; i < 4; i++) { - sprite = HuSprCreate(lbl_1_bss_144[lbl_1_bss_42[i]], i, 0); - HuSprGrpMemberSet(lbl_1_bss_52, i, sprite); - HuSprPosSet(lbl_1_bss_52, i, lbl_1_data_3F8[(i * 2)], lbl_1_data_3F8[(i * 2) + 1]); - fn_1_3B50(lbl_1_bss_CE[(i * 2)], GWStarsGet(lbl_1_bss_4A[i])); - fn_1_3B50(lbl_1_bss_CE[(i * 2) + 1], BoardPlayerCoinsGet(lbl_1_bss_4A[i])); - character = GWPlayerCfg[lbl_1_bss_4A[i]].character; - Hu3D2Dto3D(&lbl_1_data_408[i], 1, &pos); - Hu3DModelPosSetV(lbl_1_bss_5C[character][lbl_1_bss_42[i]], &pos); - Hu3DModelAttrReset(lbl_1_bss_5C[character][lbl_1_bss_42[i]], HU3D_ATTR_DISPOFF); + sprId = HuSprCreate(resultRankAnim[resultRank[i]], i, 0); + HuSprGrpMemberSet(resultRankGrpId, i, sprId); + HuSprPosSet(resultRankGrpId, i, resultRankPosTbl[(i * 2)], resultRankPosTbl[(i * 2) + 1]); + ResultSprNumSet(resultNumGrpId[(i * 2)], GWStarsGet(resultOrder[i])); + ResultSprNumSet(resultNumGrpId[(i * 2) + 1], BoardPlayerCoinsGet(resultOrder[i])); + charNo = GWPlayerCfg[resultOrder[i]].character; + Hu3D2Dto3D(&resultCharPosTbl[i], 1, &pos); + Hu3DModelPosSetV(resultCubeMdlId[charNo][resultRank[i]], &pos); + Hu3DModelAttrReset(resultCubeMdlId[charNo][resultRank[i]], HU3D_ATTR_DISPOFF); } for (i = 4; i <= 11; i++) { - Hu3D2Dto3D(&lbl_1_data_0[i].pos, 1, &pos); - Hu3DModelPosSetV(lbl_1_bss_1A9C[i], &pos); + Hu3D2Dto3D(&resultModel[i].pos, 1, &pos); + Hu3DModelPosSetV(stageMdlId[i], &pos); Hu3D3Dto2D(&pos, 1, &pos); } - model = Hu3DModelCreateFile(DATA_MAKE_NUM(DATADIR_RESULT, 0x04)); + mdlId = Hu3DModelCreateFile(DATA_MAKE_NUM(DATADIR_RESULT, 0x04)); for (i = 0; i < 4; i++) { - j = Hu3DModelLink(model); - lbl_1_bss_168[i] = j; - pos = lbl_1_data_408[i]; + j = Hu3DModelLink(mdlId); + charShadowMdlId[i] = j; + pos = resultCharPosTbl[i]; pos.x += 5.0f; pos.y += 3.0f; pos.z += 200.0f; @@ -429,12 +429,12 @@ void fn_1_B78(void) Hu3DModelPosSetV(j, &pos); Hu3DModelScaleSet(j, 1.5f, 1.5f, 1.5f); } - Hu3DModelAttrSet(model, HU3D_ATTR_DISPOFF); - model = Hu3DModelCreateFile(DATA_MAKE_NUM(DATADIR_RESULT, 0x07)); + Hu3DModelAttrSet(mdlId, HU3D_ATTR_DISPOFF); + mdlId = Hu3DModelCreateFile(DATA_MAKE_NUM(DATADIR_RESULT, 0x07)); for (i = 0; i < 8; i++) { - j = Hu3DModelLink(model); - lbl_1_bss_158[i] = j; - pos = lbl_1_data_0[i + 4].pos; + j = Hu3DModelLink(mdlId); + statShadowMdlId[i] = j; + pos = resultModel[i + 4].pos; pos.x += 5.0f; pos.y += 3.0f; pos.z += 200.0f; @@ -442,461 +442,460 @@ void fn_1_B78(void) Hu3DModelPosSetV(j, &pos); Hu3DModelScaleSet(j, 1.5f, 1.5f, 1.5f); } - Hu3DModelAttrSet(model, HU3D_ATTR_DISPOFF); - lbl_1_bss_E0 = HuSprAnimReadFile(DATA_MAKE_NUM(DATADIR_RESULT, 0x1C)); - lbl_1_bss_9C = HuSprGrpCreate(4); + Hu3DModelAttrSet(mdlId, HU3D_ATTR_DISPOFF); + resultCrownAnim = HuSprAnimReadFile(DATA_MAKE_NUM(DATADIR_RESULT, 0x1C)); + resultCrownGrpId = HuSprGrpCreate(4); for (i = 0; i < 4; i++) { - sprite = HuSprCreate(lbl_1_bss_E0, i, 0); - HuSprGrpMemberSet(lbl_1_bss_9C, i, sprite); - HuSprScaleSet(lbl_1_bss_9C, i, 0.0f, 0.0f); - HuSprPosSet(lbl_1_bss_9C, i, lbl_1_data_408[i].x - 4.0f, lbl_1_data_408[i].y - 35.0f); - HuSprAttrSet(lbl_1_bss_9C, i, 4); + sprId = HuSprCreate(resultCrownAnim, i, 0); + HuSprGrpMemberSet(resultCrownGrpId, i, sprId); + HuSprScaleSet(resultCrownGrpId, i, 0.0f, 0.0f); + HuSprPosSet(resultCrownGrpId, i, resultCharPosTbl[i].x - 4.0f, resultCharPosTbl[i].y - 35.0f); + HuSprAttrSet(resultCrownGrpId, i, 4); } - group = HuSprGrpCreate(4); - lbl_1_bss_170 = group; + grpId = HuSprGrpCreate(4); + teamResultGrpId = grpId; anim = HuSprAnimReadFile(DATA_MAKE_NUM(DATADIR_RESULT, 0x3F)); - sprite = HuSprCreate(anim, 100, 0); - HuSprGrpMemberSet(group, 0, sprite); - HuSprAttrSet(group, 0, 4); - HuSprDrawNoSet(group, 0, 127); + sprId = HuSprCreate(anim, 100, 0); + HuSprGrpMemberSet(grpId, 0, sprId); + HuSprAttrSet(grpId, 0, 4); + HuSprDrawNoSet(grpId, 0, 127); anim = HuSprAnimReadFile(DATA_MAKE_NUM(DATADIR_RESULT, 0x40)); - sprite = HuSprCreate(anim, 90, 0); - HuSprGrpMemberSet(group, 1, sprite); - HuSprAttrSet(group, 1, 4); + sprId = HuSprCreate(anim, 90, 0); + HuSprGrpMemberSet(grpId, 1, sprId); + HuSprAttrSet(grpId, 1, 4); anim = HuSprAnimReadFile(DATA_MAKE_NUM(DATADIR_RESULT, 0x41)); - sprite = HuSprCreate(anim, 80, 0); - HuSprGrpMemberSet(group, 2, sprite); - HuSprAttrSet(group, 2, 4); - HuSprDrawNoSet(group, 2, 127); + sprId = HuSprCreate(anim, 80, 0); + HuSprGrpMemberSet(grpId, 2, sprId); + HuSprAttrSet(grpId, 2, 4); + HuSprDrawNoSet(grpId, 2, 127); anim = HuSprAnimReadFile(DATA_MAKE_NUM(DATADIR_RESULT, 0x42)); - sprite = HuSprCreate(anim, 80, 0); - HuSprGrpMemberSet(group, 3, sprite); - HuSprAttrSet(group, 3, 4); - HuSprDrawNoSet(group, 3, 127); - (void)sprite; + sprId = HuSprCreate(anim, 80, 0); + HuSprGrpMemberSet(grpId, 3, sprId); + HuSprAttrSet(grpId, 3, 4); + HuSprDrawNoSet(grpId, 3, 127); + (void)sprId; } -void fn_1_1F4C(void) +static void ResultStatAdd(void) { - float temp_f31; - float temp_f30; + float scale; + float addTime; s16 i; - s16 temp_r30; - s16 temp_r29; - s16 temp_r28; - s32 status; - s32 temp_r26; - s32 sp24[4]; - float sp14[4]; - s16 sp8[5]; + s16 time; + s16 maxTime; + s16 crownTime; + s32 seNo; + s32 sePlayF; + s32 doneF[4]; + float coinRot[4]; + s16 coinNum[5]; - fn_1_423C(sp8); + ResultCoinNumGet(coinNum); for (i = 0; i < 4; i++) { - fn_1_3CAC(lbl_1_bss_3A[i], sp8[lbl_1_bss_4A[i]]); - sp24[i] = 0; + ResultCoinAddNumSet(resultCoinAddGrpId[i], coinNum[resultOrder[i]]); + doneF[i] = 0; } - temp_r29 = (lbl_1_bss_174) ? 3 : 10; - for (temp_r30 = 0; temp_r30 <= temp_r29; temp_r30++) { - temp_f31 = sind((90.0 / temp_r29) * temp_r30); + maxTime = (resultFastF) ? 3 : 10; + for (time = 0; time <= maxTime; time++) { + scale = sind((90.0 / maxTime) * time); for (i = 0; i < 4; i++) { - HuSprGrpScaleSet(lbl_1_bss_3A[i], temp_f31, temp_f31); + HuSprGrpScaleSet(resultCoinAddGrpId[i], scale, scale); } HuPrcVSleep(); } for (i = 0; i < 4; i++) { - HuSprGrpScaleSet(lbl_1_bss_3A[i], 1.0f, 1.0f); + HuSprGrpScaleSet(resultCoinAddGrpId[i], 1.0f, 1.0f); } - for (temp_r28 = 0; temp_r28 <= 14;) { + for (crownTime = 0; crownTime <= 14;) { for (i = 0; i < 4; i++) { - if (GWPlayerCoinWinGet(lbl_1_bss_4A[i]) >= 10) { - HuSprAttrReset(lbl_1_bss_9C, i, 4); + if (GWPlayerCoinWinGet(resultOrder[i]) >= 10) { + HuSprAttrReset(resultCrownGrpId, i, 4); } - HuSprScaleSet(lbl_1_bss_9C, i, sind((120.0f / 14.0f) * temp_r28) * (0.8 * (1.0 / sin((M_PI * 2) / 3))), - 0.8 * (sind((120.0f / 14.0f) * temp_r28) * (1.0 / sin((M_PI * 2) / 3)))); + HuSprScaleSet(resultCrownGrpId, i, sind((120.0f / 14.0f) * crownTime) * (0.8 * (1.0 / sin((M_PI * 2) / 3))), + 0.8 * (sind((120.0f / 14.0f) * crownTime) * (1.0 / sin((M_PI * 2) / 3)))); } - temp_r28 += (lbl_1_bss_174) ? 2 : 1; + crownTime += (resultFastF) ? 2 : 1; HuPrcVSleep(); } - if (!lbl_1_bss_174) { + if (!resultFastF) { HuPrcSleep(15); } for (i = 0; i < 4; i++) { - sp14[i] = 0.0f; + coinRot[i] = 0.0f; } - for (i = temp_r30 = 0; i < 4; i++) { - temp_r30 += sp8[i]; + for (i = time = 0; i < 4; i++) { + time += coinNum[i]; } - status = -1; - if (temp_r30) { - status = HuAudFXPlay(23); + seNo = -1; + if (time) { + seNo = HuAudFXPlay(23); } - temp_r30 = 0; - temp_f30 = temp_r30; - temp_r30 = 0; + time = 0; + addTime = time; + time = 0; while (1) { - temp_r26 = 0; - temp_f30 += (lbl_1_bss_174) ? 1.0f : 0.2f; - temp_r30 = temp_f30; - for (i = temp_r29 = 0; i < 4; i++) { - if (sp8[lbl_1_bss_4A[i]] - temp_r30 <= 0) { - if (!sp24[lbl_1_bss_4A[i]] && sp8[lbl_1_bss_4A[i]] != 0) { - sp24[lbl_1_bss_4A[i]] = 1; - if (!temp_r26) { + sePlayF = FALSE; + addTime += (resultFastF) ? 1.0f : 0.2f; + time = addTime; + for (i = maxTime = 0; i < 4; i++) { + if (coinNum[resultOrder[i]] - time <= 0) { + if (!doneF[resultOrder[i]] && coinNum[resultOrder[i]] != 0) { + doneF[resultOrder[i]] = 1; + if (!sePlayF) { HuAudFXPlay(9); - temp_r26 = 1; + sePlayF = TRUE; } } - temp_r29++; - fn_1_3CAC(lbl_1_bss_3A[i], 0); - fn_1_3B50(lbl_1_bss_CE[(i * 2) + 1], sp8[lbl_1_bss_4A[i]] + BoardPlayerCoinsGet(lbl_1_bss_4A[i])); - if (!sp14[i]) { + maxTime++; + ResultCoinAddNumSet(resultCoinAddGrpId[i], 0); + ResultSprNumSet(resultNumGrpId[(i * 2) + 1], coinNum[resultOrder[i]] + BoardPlayerCoinsGet(resultOrder[i])); + if (!coinRot[i]) { continue; } - sp14[i] += 20.0f; - if (sp14[i] >= 360.0f) { - sp14[i] -= 360.0f; + coinRot[i] += 20.0f; + if (coinRot[i] >= 360.0f) { + coinRot[i] -= 360.0f; } - Hu3DModelRotSet(lbl_1_bss_1A9C[i + 8], 0.0f, sp14[i], 0.0f); + Hu3DModelRotSet(stageMdlId[i + 8], 0.0f, coinRot[i], 0.0f); } else { - fn_1_3CAC(lbl_1_bss_3A[i], sp8[lbl_1_bss_4A[i]] - temp_r30); - fn_1_3B50(lbl_1_bss_CE[(i * 2) + 1], (s32)temp_r30 + BoardPlayerCoinsGet(lbl_1_bss_4A[i])); - sp14[i] += 20.0f; - if (sp14[i] >= 360.0f) { - sp14[i] -= 360.0f; + ResultCoinAddNumSet(resultCoinAddGrpId[i], coinNum[resultOrder[i]] - time); + ResultSprNumSet(resultNumGrpId[(i * 2) + 1], (s32)time + BoardPlayerCoinsGet(resultOrder[i])); + coinRot[i] += 20.0f; + if (coinRot[i] >= 360.0f) { + coinRot[i] -= 360.0f; } - Hu3DModelRotSet(lbl_1_bss_1A9C[i + 8], 0.0f, sp14[i], 0.0f); + Hu3DModelRotSet(stageMdlId[i + 8], 0.0f, coinRot[i], 0.0f); } } - if (temp_r29 == 4) { + if (maxTime == 4) { break; } HuPrcVSleep(); } - if (status != -1) { - HuAudFXStop(status); + if (seNo != -1) { + HuAudFXStop(seNo); } - temp_r29 = 0; + maxTime = 0; while (1) { - for (i = temp_r30 = 0; i < 4; i++) { - if (sp14[i]) { - sp14[i] += 20.0f; - if (sp14[i] >= 360.0f) { - sp14[i] -= 360.0f; + for (i = time = 0; i < 4; i++) { + if (coinRot[i]) { + coinRot[i] += 20.0f; + if (coinRot[i] >= 360.0f) { + coinRot[i] -= 360.0f; } - Hu3DModelRotSet(lbl_1_bss_1A9C[i + 8], 0.0f, sp14[i], 0.0f); + Hu3DModelRotSet(stageMdlId[i + 8], 0.0f, coinRot[i], 0.0f); } else { - temp_r30++; + time++; } } - if (temp_r30 >= 4) { + if (time >= 4) { break; } HuPrcVSleep(); - temp_r29++; + maxTime++; } - if (temp_r29 < 30) { - HuPrcSleep(30 - temp_r29); + if (maxTime < 30) { + HuPrcSleep(30 - maxTime); } - temp_r29 = (lbl_1_bss_174) ? 3 : 10; - for (temp_r30 = 0; temp_r30 <= temp_r29; temp_r30++) { - temp_f31 = cosd((90.0 / temp_r29) * temp_r30); + maxTime = (resultFastF) ? 3 : 10; + for (time = 0; time <= maxTime; time++) { + scale = cosd((90.0 / maxTime) * time); for (i = 0; i < 4; i++) { - HuSprGrpScaleSet(lbl_1_bss_3A[i], temp_f31, temp_f31); + HuSprGrpScaleSet(resultCoinAddGrpId[i], scale, scale); } HuPrcVSleep(); } for (i = 0; i < 4; i++) { - HuSprGrpScaleSet(lbl_1_bss_3A[i], 0.0f, 0.0f); + HuSprGrpScaleSet(resultCoinAddGrpId[i], 0.0f, 0.0f); } } - -void fn_1_2ADC(void) +static void ResultOrderApply(void) { - float temp_f31; + float weight; s16 i; - s16 temp_r30; - s16 temp_r29; - s16 temp_r28; - s16 temp_r27; - s16 temp_r26; - s16 temp_r25; - s16 temp_r24; - float sp54[4]; - Vec sp48; - s32 sp38[4] = { -1, -1, -1, -1 }; - s16 sp30[4]; - s16 sp28[4]; - s16 sp20[4]; - s16 sp18[4]; - s16 sp10[4]; - s16 sp8[4]; + s16 charNo; + s16 num; + s16 scaleTime; + s16 rankTime; + s16 doneNum; + s16 sePlayF; + s16 sprId; + float cubeRot[4]; + Vec cubePos; + s32 voiceSeNo[4] = { -1, -1, -1, -1 }; + s16 order[4]; + s16 statOrder[4]; + s16 statRank[4]; + s16 rank[4]; + s16 coin[4]; + s16 star[4]; for (i = 0; i < 4; i++) { - sp30[i] = sp28[i] = lbl_1_bss_4A[i]; - sp18[i] = sp20[i] = lbl_1_bss_42[i]; - sp10[i] = BoardPlayerCoinsGet(lbl_1_bss_4A[i]); - sp8[i] = GWStarsGet(lbl_1_bss_4A[i]); + order[i] = statOrder[i] = resultOrder[i]; + rank[i] = statRank[i] = resultRank[i]; + coin[i] = BoardPlayerCoinsGet(resultOrder[i]); + star[i] = GWStarsGet(resultOrder[i]); } - fn_1_3E08(); + ResultOrderSet(); for (i = 0; i < 4; i++) { - if (sp30[i] != lbl_1_bss_4A[i] || sp18[i] != lbl_1_bss_42[i]) { + if (order[i] != resultOrder[i] || rank[i] != resultRank[i]) { break; } } if (i == 4) { - lbl_1_bss_0 = 1; + resultReorderF = 1; return; } - lbl_1_data_380 = HuSprGrpCreate(4); + rankNewGrpId = HuSprGrpCreate(4); for (i = 0; i < 4; i++) { - temp_r24 = HuSprCreate(lbl_1_bss_144[lbl_1_bss_42[i]], i, 0); - HuSprGrpMemberSet(lbl_1_data_380, i, temp_r24); - HuSprPosSet(lbl_1_data_380, i, lbl_1_data_3F8[(i * 2)], lbl_1_data_3F8[(i * 2) + 1]); - HuSprAttrSet(lbl_1_data_380, i, 4); - temp_r30 = GWPlayerCfg[lbl_1_bss_4A[i]].character; - lbl_1_bss_54[i] = lbl_1_bss_A[i] = Hu3DModelLink(lbl_1_bss_5C[temp_r30][lbl_1_bss_42[i]]); - Hu3D2Dto3D(&lbl_1_data_408[i], 1, &sp48); - Hu3DModelPosSetV(lbl_1_bss_A[i], &sp48); - if (sp30[i] == lbl_1_bss_4A[i] && sp18[i] == lbl_1_bss_42[i]) { - Hu3DModelAttrSet(lbl_1_bss_5C[temp_r30][sp18[i]], HU3D_ATTR_DISPOFF); - Hu3DModelAttrReset(lbl_1_bss_A[i], HU3D_ATTR_DISPOFF); - Hu3DModelScaleSet(lbl_1_bss_A[i], 1.1f, 1.1f, 1.1f); + sprId = HuSprCreate(resultRankAnim[resultRank[i]], i, 0); + HuSprGrpMemberSet(rankNewGrpId, i, sprId); + HuSprPosSet(rankNewGrpId, i, resultRankPosTbl[(i * 2)], resultRankPosTbl[(i * 2) + 1]); + HuSprAttrSet(rankNewGrpId, i, 4); + charNo = GWPlayerCfg[resultOrder[i]].character; + resultPlayerCubeMdlId[i] = resultCharCubeMdlId[i] = Hu3DModelLink(resultCubeMdlId[charNo][resultRank[i]]); + Hu3D2Dto3D(&resultCharPosTbl[i], 1, &cubePos); + Hu3DModelPosSetV(resultCharCubeMdlId[i], &cubePos); + if (order[i] == resultOrder[i] && rank[i] == resultRank[i]) { + Hu3DModelAttrSet(resultCubeMdlId[charNo][rank[i]], HU3D_ATTR_DISPOFF); + Hu3DModelAttrReset(resultCharCubeMdlId[i], HU3D_ATTR_DISPOFF); + Hu3DModelScaleSet(resultCharCubeMdlId[i], 1.1f, 1.1f, 1.1f); } else { - Hu3DModelAttrSet(lbl_1_bss_A[i], HU3D_ATTR_DISPOFF); + Hu3DModelAttrSet(resultCharCubeMdlId[i], HU3D_ATTR_DISPOFF); } } for (i = 0; i < 4; i++) { - sp54[i] = 0; + cubeRot[i] = 0; } - temp_r25 = 0; - temp_r28 = 0; + sePlayF = 0; + scaleTime = 0; while (1) { - for (temp_r26 = i = 0; i < 4; i++) { - if (sp30[i] == lbl_1_bss_4A[i] && sp18[i] == lbl_1_bss_42[i]) { - temp_r26++; - fn_1_3B50(lbl_1_bss_CE[(i * 2)], GWStarsGet(lbl_1_bss_4A[i])); - fn_1_3B50(lbl_1_bss_CE[(i * 2) + 1], BoardPlayerCoinsGet(lbl_1_bss_4A[i])); + for (doneNum = i = 0; i < 4; i++) { + if (order[i] == resultOrder[i] && rank[i] == resultRank[i]) { + doneNum++; + ResultSprNumSet(resultNumGrpId[(i * 2)], GWStarsGet(resultOrder[i])); + ResultSprNumSet(resultNumGrpId[(i * 2) + 1], BoardPlayerCoinsGet(resultOrder[i])); } else { - if (temp_r28 > (i * 20)) { - temp_r27 = temp_r28 - (i * 20); - if (temp_r27 <= 20) { - if (temp_r27 <= 10) { - HuSprScaleSet(lbl_1_bss_52, i, 1.0f, cosd(9.0f * temp_r27)); + if (scaleTime > (i * 20)) { + rankTime = scaleTime - (i * 20); + if (rankTime <= 20) { + if (rankTime <= 10) { + HuSprScaleSet(resultRankGrpId, i, 1.0f, cosd(9.0f * rankTime)); } else { - HuSprAttrSet(lbl_1_bss_52, i, 4); - HuSprAttrReset(lbl_1_data_380, i, 4); - HuSprScaleSet(lbl_1_data_380, i, 1.0f, sind(9.0f * (temp_r27 - 10))); + HuSprAttrSet(resultRankGrpId, i, 4); + HuSprAttrReset(rankNewGrpId, i, 4); + HuSprScaleSet(rankNewGrpId, i, 1.0f, sind(9.0f * (rankTime - 10))); } - temp_f31 = temp_r27 / 20.0f; - temp_r29 = GWStarsGet(sp28[i]) + (temp_f31 * (GWStarsGet(lbl_1_bss_4A[i]) - GWStarsGet(sp28[i]))); - fn_1_3B50(lbl_1_bss_CE[(i * 2)], temp_r29); - temp_r29 = BoardPlayerCoinsGet(sp28[i]) + (temp_f31 * (BoardPlayerCoinsGet(lbl_1_bss_4A[i]) - BoardPlayerCoinsGet(sp28[i]))); - fn_1_3B50(lbl_1_bss_CE[(i * 2) + 1], temp_r29); + weight = rankTime / 20.0f; + num = GWStarsGet(statOrder[i]) + (weight * (GWStarsGet(resultOrder[i]) - GWStarsGet(statOrder[i]))); + ResultSprNumSet(resultNumGrpId[(i * 2)], num); + num = BoardPlayerCoinsGet(statOrder[i]) + (weight * (BoardPlayerCoinsGet(resultOrder[i]) - BoardPlayerCoinsGet(statOrder[i]))); + ResultSprNumSet(resultNumGrpId[(i * 2) + 1], num); } else { - temp_r30 = GWPlayerCfg[sp28[i]].character; - Hu3DModelAttrSet(lbl_1_bss_5C[temp_r30][sp18[i]], HU3D_ATTR_DISPOFF); - temp_r30 = GWPlayerCfg[lbl_1_bss_4A[i]].character; - Hu3DModelAttrReset(lbl_1_bss_A[i], HU3D_ATTR_DISPOFF); - Hu3DModelScaleSet(lbl_1_bss_A[i], 1.1f, 1.1f, 1.1f); - fn_1_3B50(lbl_1_bss_CE[(i * 2)], GWStarsGet(lbl_1_bss_4A[i])); - fn_1_3B50(lbl_1_bss_CE[(i * 2) + 1], BoardPlayerCoinsGet(lbl_1_bss_4A[i])); - for (temp_r29 = 0; temp_r29 < 4; temp_r29++) { - if (sp28[temp_r29] == lbl_1_bss_4A[i]) { + charNo = GWPlayerCfg[statOrder[i]].character; + Hu3DModelAttrSet(resultCubeMdlId[charNo][rank[i]], HU3D_ATTR_DISPOFF); + charNo = GWPlayerCfg[resultOrder[i]].character; + Hu3DModelAttrReset(resultCharCubeMdlId[i], HU3D_ATTR_DISPOFF); + Hu3DModelScaleSet(resultCharCubeMdlId[i], 1.1f, 1.1f, 1.1f); + ResultSprNumSet(resultNumGrpId[(i * 2)], GWStarsGet(resultOrder[i])); + ResultSprNumSet(resultNumGrpId[(i * 2) + 1], BoardPlayerCoinsGet(resultOrder[i])); + for (num = 0; num < 4; num++) { + if (statOrder[num] == resultOrder[i]) { break; } } - if (lbl_1_bss_42[i] != sp20[temp_r29]) { - if (lbl_1_bss_42[i] < sp20[temp_r29]) { - Hu3DAnimCreate(lbl_1_bss_E4[temp_r30][1], lbl_1_bss_5C[temp_r30][lbl_1_bss_42[i]], "ys22"); + if (resultRank[i] != statRank[num]) { + if (resultRank[i] < statRank[num]) { + Hu3DAnimCreate(resultCharAnim[charNo][1], resultCubeMdlId[charNo][resultRank[i]], "ys22"); } else { - Hu3DAnimCreate(lbl_1_bss_E4[temp_r30][2], lbl_1_bss_5C[temp_r30][lbl_1_bss_42[i]], "ys22"); + Hu3DAnimCreate(resultCharAnim[charNo][2], resultCubeMdlId[charNo][resultRank[i]], "ys22"); } - if (lbl_1_bss_42[i] == 0) { - sp38[lbl_1_bss_4A[i]] = HuAudPlayerVoicePlay(lbl_1_bss_4A[i], 293); + if (resultRank[i] == 0) { + voiceSeNo[resultOrder[i]] = HuAudPlayerVoicePlay(resultOrder[i], 293); } - if (!temp_r25) { - temp_r25 = 1; + if (!sePlayF) { + sePlayF = 1; HuAudFXPlay(27); } } - sp30[i] = lbl_1_bss_4A[i]; - sp18[i] = lbl_1_bss_42[i]; + order[i] = resultOrder[i]; + rank[i] = resultRank[i]; } } - sp54[i] += 20.0f; - if (sp54[i] >= 360.0f) { - sp54[i] -= 360.0f; + cubeRot[i] += 20.0f; + if (cubeRot[i] >= 360.0f) { + cubeRot[i] -= 360.0f; } - temp_r30 = GWPlayerCfg[sp28[i]].character; - Hu3DModelRotSet(lbl_1_bss_5C[temp_r30][sp18[i]], sp54[i] / (4 - i), sp54[i], 0.0f); + charNo = GWPlayerCfg[statOrder[i]].character; + Hu3DModelRotSet(resultCubeMdlId[charNo][rank[i]], cubeRot[i] / (4 - i), cubeRot[i], 0.0f); } } - if (temp_r28 <= 10) { + if (scaleTime <= 10) { for (i = 0; i < 4; i++) { - HuSprScaleSet(lbl_1_bss_9C, i, cosd(9.0f * temp_r28), cosd(9.0f * temp_r28)); + HuSprScaleSet(resultCrownGrpId, i, cosd(9.0f * scaleTime), cosd(9.0f * scaleTime)); } } else { for (i = 0; i < 4; i++) { - HuSprScaleSet(lbl_1_bss_9C, i, 0.0f, 0.0f); + HuSprScaleSet(resultCrownGrpId, i, 0.0f, 0.0f); } } - if (temp_r26 >= 4) { + if (doneNum >= 4) { break; } - if (lbl_1_bss_174) { - temp_r28 += 2; + if (resultFastF) { + scaleTime += 2; } HuPrcVSleep(); - temp_r28++; + scaleTime++; } for (i = 0; i < 4; i++) { - HuSprScaleSet(lbl_1_bss_9C, i, 0.0f, 0.0f); + HuSprScaleSet(resultCrownGrpId, i, 0.0f, 0.0f); } - lbl_1_bss_0 = 1; + resultReorderF = 1; } -void fn_1_3B50(s16 group, s16 value) +static void ResultSprNumSet(s16 grpId, s16 value) { - s16 digit; - s16 digit_value; + s16 no; + s16 bank; if (value > 999) { value = 999; } - digit = 0; - digit_value = value / 100; - if (digit_value != 0) { - HuSprBankSet(group, digit, digit_value); - HuSprAttrReset(group, digit, 4); - digit++; + no = 0; + bank = value / 100; + if (bank != 0) { + HuSprBankSet(grpId, no, bank); + HuSprAttrReset(grpId, no, 4); + no++; } - value -= digit_value * 100; - digit_value = value / 10; - if (digit_value != 0 || digit == 1) { - HuSprBankSet(group, digit, digit_value); - HuSprAttrReset(group, digit, 4); - digit++; + value -= bank * 100; + bank = value / 10; + if (bank != 0 || no == 1) { + HuSprBankSet(grpId, no, bank); + HuSprAttrReset(grpId, no, 4); + no++; } - value -= digit_value * 10; - HuSprBankSet(group, digit, value); - HuSprAttrReset(group, digit, 4); - digit++; - for (digit_value = digit; digit_value < 3; digit_value++) { - HuSprAttrSet(group, digit_value, 4); + value -= bank * 10; + HuSprBankSet(grpId, no, value); + HuSprAttrReset(grpId, no, 4); + no++; + for (bank = no; bank < 3; bank++) { + HuSprAttrSet(grpId, bank, 4); } } -void fn_1_3CAC(s16 group, s16 value) +static void ResultCoinAddNumSet(s16 grpId, s16 value) { - s16 digit; - s16 digit_value; + s16 no; + s16 bank; if (value > 999) { value = 999; } - digit = 2; - digit_value = value / 100; - if (digit_value != 0) { - HuSprBankSet(group, digit, digit_value); - HuSprAttrReset(group, digit, 4); - digit++; + no = 2; + bank = value / 100; + if (bank != 0) { + HuSprBankSet(grpId, no, bank); + HuSprAttrReset(grpId, no, 4); + no++; } - value -= digit_value * 100; - digit_value = value / 10; - if (digit_value != 0 || digit == 3) { - HuSprBankSet(group, digit, digit_value); - HuSprAttrReset(group, digit, 4); - digit++; + value -= bank * 100; + bank = value / 10; + if (bank != 0 || no == 3) { + HuSprBankSet(grpId, no, bank); + HuSprAttrReset(grpId, no, 4); + no++; } - value -= digit_value * 10; - HuSprBankSet(group, digit, value); - HuSprAttrReset(group, digit, 4); - digit++; - for (digit_value = digit; digit_value < 5; digit_value++) { - HuSprAttrSet(group, digit_value, 4); + value -= bank * 10; + HuSprBankSet(grpId, no, value); + HuSprAttrReset(grpId, no, 4); + no++; + for (bank = no; bank < 5; bank++) { + HuSprAttrSet(grpId, bank, 4); } } -void fn_1_3E08(void) +static void ResultOrderSet(void) { s16 i; s16 j; for (i = 0; i < 4; i++) { - lbl_1_bss_42[i] = BoardPlayerRankCalc(i); - lbl_1_bss_4A[i] = i; + resultRank[i] = BoardPlayerRankCalc(i); + resultOrder[i] = i; } for (j = 1; j < 4; j++) { for (i = 0; i < 4 - j; i++) { - if (lbl_1_bss_42[i] > lbl_1_bss_42[i + 1]) { - s16 temp = lbl_1_bss_42[i]; - lbl_1_bss_42[i] = lbl_1_bss_42[i + 1]; - lbl_1_bss_42[i + 1] = temp; - temp = lbl_1_bss_4A[i]; - lbl_1_bss_4A[i] = lbl_1_bss_4A[i + 1]; - lbl_1_bss_4A[i + 1] = temp; + if (resultRank[i] > resultRank[i + 1]) { + s16 temp = resultRank[i]; + resultRank[i] = resultRank[i + 1]; + resultRank[i + 1] = temp; + temp = resultOrder[i]; + resultOrder[i] = resultOrder[i + 1]; + resultOrder[i + 1] = temp; } } } } -s32 lbl_1_data_450[] = { DATADIR_W01, DATADIR_W02, DATADIR_W03, DATADIR_W04, DATADIR_W05, DATADIR_W06 }; +static s32 resultBoardDirTbl[] = { DATADIR_W01, DATADIR_W02, DATADIR_W03, DATADIR_W04, DATADIR_W05, DATADIR_W06 }; -void fn_1_3FD8(void) +void ResultBoardDataRead(void) { - s32 status; - u32 ardma; + s32 statId; + u32 aMemP; if (!_CheckFlag(0x10000)) { - lbl_1_bss_178 = 1; + resultReadEndF = 1; HuPrcEnd(); while (1) { HuPrcVSleep(); } } - status = HuDataDirReadAsync(DATADIR_BOARD); - if (status != -1) { - while (!HuDataGetAsyncStat(status)) { + statId = HuDataDirReadAsync(DATADIR_BOARD); + if (statId != -1) { + while (!HuDataGetAsyncStat(statId)) { HuPrcVSleep(); } } - ardma = HuAR_MRAMtoARAM(DATADIR_BOARD); - if (ardma) { + aMemP = HuAR_MRAMtoARAM(DATADIR_BOARD); + if (aMemP) { while (HuARDMACheck()) { HuPrcVSleep(); } } HuDataDirClose(DATADIR_BOARD); - status = HuDataDirReadAsync(lbl_1_data_450[GWSystem.board]); - if (status != -1) { - while (!HuDataGetAsyncStat(status)) { + statId = HuDataDirReadAsync(resultBoardDirTbl[GWSystem.board]); + if (statId != -1) { + while (!HuDataGetAsyncStat(statId)) { HuPrcVSleep(); } } - lbl_1_bss_178 = 1; + resultReadEndF = 1; HuPrcEnd(); while (1) { HuPrcVSleep(); } } -void fn_1_40DC(void) +void ResultCoinAdd(void) { s16 i; - s16 sp8[5]; - fn_1_423C(sp8); - sp8[lbl_1_bss_172] += sp8[4]; + s16 coinNum[5]; + ResultCoinNumGet(coinNum); + coinNum[resultBonusPlayer] += coinNum[4]; for (i = 0; i < 4; i++) { - GWCoinsAdd(i, sp8[i]); + GWCoinsAdd(i, coinNum[i]); GWPlayerCoinWinSet(i, 0); GWPlayerCoinCollectSet(i, 0); if (mgInfoTbl[GWSystem.mg_next].type != 4) { - GWPlayer[i].coins_mg += sp8[i]; + GWPlayer[i].coins_mg += coinNum[i]; if (GWPlayer[i].coins_mg > 9999) { GWPlayer[i].coins_mg = 9999; } @@ -904,99 +903,99 @@ void fn_1_40DC(void) } } -void fn_1_423C(s16 *data) +void ResultCoinNumGet(s16 *coinNum) { s16 i; s32 coin; - u32 mul_coin; + u32 coinMul; u32 coin_battle; - s16 temp_r26; - s16 mgtype; - float sp10[4]; - s16 sp8[4]; - mgtype = mgInfoTbl[GWSystem.mg_next].type; - switch (mgtype) { + s16 unkRankF; + s16 mgType; + float scale[4]; + s16 rank[4]; + mgType = mgInfoTbl[GWSystem.mg_next].type; + switch (mgType) { case 4: - temp_r26 = 0; + unkRankF = 0; for (i = coin_battle = 0; i < 4; i++) { coin_battle += GWPlayerCoinBattleGet(i); } - sp8[0] = sp8[1] = sp8[2] = sp8[3] = 0; + rank[0] = rank[1] = rank[2] = rank[3] = 0; for (i = 0; i < 4; i++) { - sp8[GWPlayerCoinWinGet(i)]++; + rank[GWPlayerCoinWinGet(i)]++; } - sp10[0] = sp10[1] = sp10[2] = sp10[3] = 0; - if (sp8[0] == 1 && sp8[1] == 1 && sp8[2] == 1) { - sp10[0] = 0.7f; - sp10[1] = 0.3f; + scale[0] = scale[1] = scale[2] = scale[3] = 0; + if (rank[0] == 1 && rank[1] == 1 && rank[2] == 1) { + scale[0] = 0.7f; + scale[1] = 0.3f; } - else if (sp8[0] == 2) { - sp10[0] = 0.5f; + else if (rank[0] == 2) { + scale[0] = 0.5f; } - else if (sp8[0] == 3) { - sp10[0] = 0.3333333f; + else if (rank[0] == 3) { + scale[0] = 0.3333333f; } - else if (sp8[0] == 1 && sp8[1] == 2) { - sp10[0] = 0.6f; - sp10[1] = 0.2f; + else if (rank[0] == 1 && rank[1] == 2) { + scale[0] = 0.6f; + scale[1] = 0.2f; } - else if (sp8[0] == 1 && sp8[1] == 3) { - sp10[0] = 0.7f; - sp10[1] = 0.1f; + else if (rank[0] == 1 && rank[1] == 3) { + scale[0] = 0.7f; + scale[1] = 0.1f; } - else if (sp8[0] == 1 && sp8[1] == 1 && sp8[2] == 2) { - sp10[0] = 0.7f; - sp10[1] = 0.3f; + else if (rank[0] == 1 && rank[1] == 1 && rank[2] == 2) { + scale[0] = 0.7f; + scale[1] = 0.3f; } - else if (sp8[0] == 4) { - sp10[0] = 0.25f; + else if (rank[0] == 4) { + scale[0] = 0.25f; } else { - temp_r26 = 1; + unkRankF = 1; } for (i = coin = 0; i < 4; i++) { - if (!temp_r26) { - mul_coin = coin_battle * sp10[GWPlayerCoinWinGet(i)]; + if (!unkRankF) { + coinMul = coin_battle * scale[GWPlayerCoinWinGet(i)]; } else { - mul_coin = GWPlayerCoinBattleGet(i); + coinMul = GWPlayerCoinBattleGet(i); } - data[i] = mul_coin; - coin += mul_coin; + coinNum[i] = coinMul; + coin += coinMul; } if (coin < coin_battle) { - data[4] = coin_battle - coin; + coinNum[4] = coin_battle - coin; } else { - data[4] = 0; + coinNum[4] = 0; } break; default: for (i = 0; i < 4; i++) { coin = GWPlayerCoinWinGet(i) + GWPlayerCoinCollectGet(i); - mul_coin = GWLuckyValueGet(); - if (mul_coin == 0) { - mul_coin = 1; + coinMul = GWLuckyValueGet(); + if (coinMul == 0) { + coinMul = 1; } - coin *= mul_coin; - data[i] = coin; + coin *= coinMul; + coinNum[i] = coin; } break; } } -void fn_1_461C(void) +static void SaveExec(void) { - s16 sprite; + s16 sprId; Hu3DAllKill(); HuSprClose(); HuSprInit(); espInit(); HuPrcVSleep(); - sprite = espEntry(0x860020, 5000, 0); - espPosSet(sprite, 288.0, 240.0); - espAttrReset(sprite, HUSPR_ATTR_DISPOFF); + sprId = espEntry(0x860020, 5000, 0); + espPosSet(sprId, 288.0, 240.0); + espAttrReset(sprId, HUSPR_ATTR_DISPOFF); Hu3DBGColorSet(0, 0, 0); WipeCreate(WIPE_MODE_IN, WIPE_TYPE_NORMAL, 20); while (WipeStatGet()) { @@ -1026,222 +1025,222 @@ void fn_1_461C(void) } } -s32 lbl_1_data_468[] = { DATADIR_MARIOMDL1, DATADIR_LUIGIMDL1, DATADIR_PEACHMDL1, DATADIR_YOSHIMDL1, DATADIR_WARIOMDL1, DATADIR_DONKEYMDL1, +static s32 resultCharMdlTbl[] = { DATADIR_MARIOMDL1, DATADIR_LUIGIMDL1, DATADIR_PEACHMDL1, DATADIR_YOSHIMDL1, DATADIR_WARIOMDL1, DATADIR_DONKEYMDL1, DATADIR_DAISYMDL1, DATADIR_WALUIGIMDL1 }; -Vec lbl_1_data_488[] = { +static Vec resultTeamCharPosTbl[] = { { 160, 185, 500 }, { 240, 185, 500 }, { 160, 355, 500 }, { 240, 355, 500 }, }; -void fn_1_47FC(void) +static void ResultTeamExec(void) { - s16 temp_r31; - s16 temp_r24; - s16 temp_r21; - s16 temp_r20; - s16 temp_r19; - s16 temp_r18; - s16 temp_r17; - Vec sp40; - Vec sp34; - s16 sp2C[4]; - s16 sp28[2]; - s16 sp24[2]; - s16 sp20[2]; - s16 sp1C[2]; - s16 sp18[2]; - AnimData *sp14; - s32 sp10; - s16 spC; - s16 spA; - s16 sp8; + s16 i; + s16 temp; + s16 winId; + s16 player; + s16 j; + s16 cubeMdlId; + s16 teamNo; + Vec pos3D; + Vec pos2D; + s16 charNo[4]; + s16 coinNum[2]; + s16 starNum[2]; + s16 teamYPos[2]; + s16 teamPlayerNo[2]; + s16 rank[2]; + AnimData *rankAnim; + s32 cubeNo; + s16 rankGrpId; + s16 rankSprId; + s16 btnDown; WipeColorSet(0, 0, 0); WipeCreate(WIPE_MODE_OUT, WIPE_TYPE_NORMAL, 10); while (WipeStatGet()) { HuPrcVSleep(); } - espAttrSet(lbl_1_bss_1A1A[0], HUSPR_ATTR_DISPOFF); - espAttrSet(lbl_1_bss_1A1A[1], HUSPR_ATTR_DISPOFF); - for (temp_r31 = 0; temp_r31 < 2; temp_r31++) { - Hu3DModelAttrSet(lbl_1_bss_1A9C[temp_r31 + 6], HU3D_ATTR_DISPOFF); - Hu3DModelAttrSet(lbl_1_bss_1A9C[temp_r31 + 10], HU3D_ATTR_DISPOFF); + espAttrSet(stageSprId[0], HUSPR_ATTR_DISPOFF); + espAttrSet(stageSprId[1], HUSPR_ATTR_DISPOFF); + for (i = 0; i < 2; i++) { + Hu3DModelAttrSet(stageMdlId[i + 6], HU3D_ATTR_DISPOFF); + Hu3DModelAttrSet(stageMdlId[i + 10], HU3D_ATTR_DISPOFF); } - for (temp_r31 = 0; temp_r31 < 4; temp_r31++) { - espAttrSet(lbl_1_bss_1A1A[temp_r31 + 6], HUSPR_ATTR_DISPOFF); + for (i = 0; i < 4; i++) { + espAttrSet(stageSprId[i + 6], HUSPR_ATTR_DISPOFF); } - for (temp_r31 = 4; temp_r31 < 8; temp_r31++) { - Hu3DModelAttrSet(lbl_1_bss_158[temp_r31], HU3D_ATTR_DISPOFF); + for (i = 4; i < 8; i++) { + Hu3DModelAttrSet(statShadowMdlId[i], HU3D_ATTR_DISPOFF); } - for (temp_r31 = 4; temp_r31 < 8; temp_r31++) { - HuSprGrpTPLvlSet(lbl_1_bss_CE[temp_r31], 0.0f); + for (i = 4; i < 8; i++) { + HuSprGrpTPLvlSet(resultNumGrpId[i], 0.0f); } - for (temp_r31 = 0; temp_r31 < 4; temp_r31++) { - for (temp_r19 = 0; temp_r19 < 4; temp_r19++) { - Hu3DModelAttrSet(lbl_1_bss_5C[GWPlayerCfg[temp_r31].character][temp_r19], HU3D_ATTR_DISPOFF); + for (i = 0; i < 4; i++) { + for (j = 0; j < 4; j++) { + Hu3DModelAttrSet(resultCubeMdlId[GWPlayerCfg[i].character][j], HU3D_ATTR_DISPOFF); } - Hu3DModelAttrSet(lbl_1_bss_54[temp_r31], HU3D_ATTR_DISPOFF); + Hu3DModelAttrSet(resultPlayerCubeMdlId[i], HU3D_ATTR_DISPOFF); } - HuSprGrpKill(lbl_1_bss_9C); - HuSprGrpKill(lbl_1_bss_52); - if (lbl_1_data_380 != -1) { - HuSprGrpKill(lbl_1_data_380); + HuSprGrpKill(resultCrownGrpId); + HuSprGrpKill(resultRankGrpId); + if (rankNewGrpId != -1) { + HuSprGrpKill(rankNewGrpId); } - sp28[0] = sp28[1] = 0; - sp24[0] = sp24[1] = 0; - sp1C[0] = 0; - sp1C[1] = 2; - for (temp_r31 = 0; temp_r31 < 4; temp_r31++) { - temp_r17 = GWPlayer[temp_r31].team; - sp28[temp_r17] += BoardPlayerCoinsGet(temp_r31); - sp24[temp_r17] += GWStarsGet(temp_r31); - sp2C[sp1C[temp_r17]++] = GWPlayerCfg[temp_r31].character; + coinNum[0] = coinNum[1] = 0; + starNum[0] = starNum[1] = 0; + teamPlayerNo[0] = 0; + teamPlayerNo[1] = 2; + for (i = 0; i < 4; i++) { + teamNo = GWPlayer[i].team; + coinNum[teamNo] += BoardPlayerCoinsGet(i); + starNum[teamNo] += GWStarsGet(i); + charNo[teamPlayerNo[teamNo]++] = GWPlayerCfg[i].character; } - sp18[0] = 0; - sp18[1] = 1; - if (sp24[0] > sp24[1]) { - lbl_1_bss_8 = 0; + rank[0] = 0; + rank[1] = 1; + if (starNum[0] > starNum[1]) { + resultTeamOrder = 0; } else { - if (sp24[0] == sp24[1]) { - if (sp28[0] > sp28[1]) { - lbl_1_bss_8 = 0; + if (starNum[0] == starNum[1]) { + if (coinNum[0] > coinNum[1]) { + resultTeamOrder = 0; } - else if (sp28[0] == sp28[1]) { - sp18[0] = sp18[1] = 0; - lbl_1_bss_8 = 0; + else if (coinNum[0] == coinNum[1]) { + rank[0] = rank[1] = 0; + resultTeamOrder = 0; } else { - lbl_1_bss_8 = 1; + resultTeamOrder = 1; } } else { - lbl_1_bss_8 = 1; + resultTeamOrder = 1; } } - HuSprAttrReset(lbl_1_bss_170, 0, 4); - HuSprAttrReset(lbl_1_bss_170, 1, 4); - HuSprPosSet(lbl_1_bss_170, 1, 0, -180); - HuSprAttrReset(lbl_1_bss_170, 2, 4); - HuSprAttrReset(lbl_1_bss_170, 3, 4); - if (lbl_1_bss_8 == 0) { - sp20[0] = -55; - sp20[1] = 115; + HuSprAttrReset(teamResultGrpId, 0, 4); + HuSprAttrReset(teamResultGrpId, 1, 4); + HuSprPosSet(teamResultGrpId, 1, 0, -180); + HuSprAttrReset(teamResultGrpId, 2, 4); + HuSprAttrReset(teamResultGrpId, 3, 4); + if (resultTeamOrder == 0) { + teamYPos[0] = -55; + teamYPos[1] = 115; } else { - sp20[0] = 115; - sp20[1] = -55; - temp_r24 = sp2C[0]; - sp2C[0] = sp2C[2]; - sp2C[2] = temp_r24; - temp_r24 = sp2C[1]; - sp2C[1] = sp2C[3]; - sp2C[3] = temp_r24; - temp_r24 = sp28[0]; - sp28[0] = sp28[1]; - sp28[1] = temp_r24; - temp_r24 = sp24[0]; - sp24[0] = sp24[1]; - sp24[1] = temp_r24; + teamYPos[0] = 115; + teamYPos[1] = -55; + temp = charNo[0]; + charNo[0] = charNo[2]; + charNo[2] = temp; + temp = charNo[1]; + charNo[1] = charNo[3]; + charNo[3] = temp; + temp = coinNum[0]; + coinNum[0] = coinNum[1]; + coinNum[1] = temp; + temp = starNum[0]; + starNum[0] = starNum[1]; + starNum[1] = temp; } - HuSprPosSet(lbl_1_bss_170, 2, 0, sp20[0]); - HuSprPosSet(lbl_1_bss_170, 3, 0, sp20[1]); - HuSprGrpPosSet(lbl_1_bss_170, 288, 240); - for (temp_r31 = 0; temp_r31 < 4; temp_r31++) { - if (temp_r31 < 2) { - sp10 = 0; + HuSprPosSet(teamResultGrpId, 2, 0, teamYPos[0]); + HuSprPosSet(teamResultGrpId, 3, 0, teamYPos[1]); + HuSprGrpPosSet(teamResultGrpId, 288, 240); + for (i = 0; i < 4; i++) { + if (i < 2) { + cubeNo = 0; } else { - sp10 = 1; + cubeNo = 1; } - temp_r18 = lbl_1_bss_5C[sp2C[temp_r31]][sp10]; - Hu3DAnimCreate(lbl_1_bss_E4[sp2C[temp_r31]][0], temp_r18, "ys22"); - Hu3DModelAttrReset(temp_r18, HU3D_ATTR_DISPOFF); - Hu3D2Dto3D(&lbl_1_data_488[temp_r31], 1, &sp40); - Hu3DModelPosSetV(temp_r18, &sp40); - Hu3DModelRotSet(temp_r18, 0, 0, 0); - sp34 = lbl_1_data_488[temp_r31]; - sp34.y += 5.0f; - sp34.x += 3.0f; - sp34.z += 200.0f; - Hu3D2Dto3D(&sp34, 1, &sp40); - Hu3DModelPosSetV(lbl_1_bss_168[temp_r31], &sp40); + cubeMdlId = resultCubeMdlId[charNo[i]][cubeNo]; + Hu3DAnimCreate(resultCharAnim[charNo[i]][0], cubeMdlId, "ys22"); + Hu3DModelAttrReset(cubeMdlId, HU3D_ATTR_DISPOFF); + Hu3D2Dto3D(&resultTeamCharPosTbl[i], 1, &pos3D); + Hu3DModelPosSetV(cubeMdlId, &pos3D); + Hu3DModelRotSet(cubeMdlId, 0, 0, 0); + pos2D = resultTeamCharPosTbl[i]; + pos2D.y += 5.0f; + pos2D.x += 3.0f; + pos2D.z += 200.0f; + Hu3D2Dto3D(&pos2D, 1, &pos3D); + Hu3DModelPosSetV(charShadowMdlId[i], &pos3D); } - spC = HuSprGrpCreate(2); - for (temp_r31 = 0; temp_r31 < 2; temp_r31++) { - sp14 = HuSprAnimReadFile(DATA_MAKE_NUM(DATADIR_RESULT, 0x16) + sp18[temp_r31]); - spA = HuSprCreate(sp14, temp_r31, 0); - HuSprGrpMemberSet(spC, temp_r31, spA); - HuSprPosSet(spC, temp_r31, (lbl_1_data_488[temp_r31 * 2].x) - 80.0f, lbl_1_data_488[temp_r31 * 2].y); - sp34 = lbl_1_data_488[temp_r31 * 2]; - sp34.x += 180.0f; - sp34.y -= 35.0f; - Hu3D2Dto3D(&sp34, 1, &sp40); - Hu3DModelPosSetV(lbl_1_bss_1A9C[temp_r31 + 4], &sp40); - sp34.y += 5.0f; - sp34.x += 3.0f; - sp34.z += 200.0f; - Hu3D2Dto3D(&sp34, 1, &sp40); - Hu3DModelPosSetV(lbl_1_bss_158[temp_r31 * 2], &sp40); - espPosSet(lbl_1_bss_1A1A[(temp_r31 * 2) + 2], 230.0f + lbl_1_data_488[temp_r31 * 2].x, lbl_1_data_488[temp_r31 * 2].y - 35.0f); - fn_1_3B50(lbl_1_bss_CE[temp_r31 * 2], sp24[temp_r31]); - HuSprGrpPosSet(lbl_1_bss_CE[temp_r31 * 2], 320.0f + lbl_1_data_488[temp_r31 * 2].x, lbl_1_data_488[temp_r31 * 2].y - 35.0f); - sp34 = lbl_1_data_488[temp_r31 * 2]; - sp34.x += 180.0f; - sp34.y += 35.0f; - Hu3D2Dto3D(&sp34, 1, &sp40); - Hu3DModelPosSetV(lbl_1_bss_1A9C[temp_r31 + 8], &sp40); - sp34.y += 5.0f; - sp34.x += 3.0f; - sp34.z += 200.0f; - Hu3D2Dto3D(&sp34, 1, &sp40); - Hu3DModelPosSetV(lbl_1_bss_158[(temp_r31 * 2) + 1], &sp40); - espPosSet(lbl_1_bss_1A1A[(temp_r31 * 2) + 3], 230.0f + lbl_1_data_488[temp_r31 * 2].x, 35.0f + lbl_1_data_488[temp_r31 * 2].y); - fn_1_3B50(lbl_1_bss_CE[(temp_r31 * 2) + 1], sp28[temp_r31]); - HuSprGrpPosSet(lbl_1_bss_CE[(temp_r31 * 2) + 1], 320.0f + lbl_1_data_488[temp_r31 * 2].x, 35.0f + lbl_1_data_488[temp_r31 * 2].y); + rankGrpId = HuSprGrpCreate(2); + for (i = 0; i < 2; i++) { + rankAnim = HuSprAnimReadFile(DATA_MAKE_NUM(DATADIR_RESULT, 0x16) + rank[i]); + rankSprId = HuSprCreate(rankAnim, i, 0); + HuSprGrpMemberSet(rankGrpId, i, rankSprId); + HuSprPosSet(rankGrpId, i, (resultTeamCharPosTbl[i * 2].x) - 80.0f, resultTeamCharPosTbl[i * 2].y); + pos2D = resultTeamCharPosTbl[i * 2]; + pos2D.x += 180.0f; + pos2D.y -= 35.0f; + Hu3D2Dto3D(&pos2D, 1, &pos3D); + Hu3DModelPosSetV(stageMdlId[i + 4], &pos3D); + pos2D.y += 5.0f; + pos2D.x += 3.0f; + pos2D.z += 200.0f; + Hu3D2Dto3D(&pos2D, 1, &pos3D); + Hu3DModelPosSetV(statShadowMdlId[i * 2], &pos3D); + espPosSet(stageSprId[(i * 2) + 2], 230.0f + resultTeamCharPosTbl[i * 2].x, resultTeamCharPosTbl[i * 2].y - 35.0f); + ResultSprNumSet(resultNumGrpId[i * 2], starNum[i]); + HuSprGrpPosSet(resultNumGrpId[i * 2], 320.0f + resultTeamCharPosTbl[i * 2].x, resultTeamCharPosTbl[i * 2].y - 35.0f); + pos2D = resultTeamCharPosTbl[i * 2]; + pos2D.x += 180.0f; + pos2D.y += 35.0f; + Hu3D2Dto3D(&pos2D, 1, &pos3D); + Hu3DModelPosSetV(stageMdlId[i + 8], &pos3D); + pos2D.y += 5.0f; + pos2D.x += 3.0f; + pos2D.z += 200.0f; + Hu3D2Dto3D(&pos2D, 1, &pos3D); + Hu3DModelPosSetV(statShadowMdlId[(i * 2) + 1], &pos3D); + espPosSet(stageSprId[(i * 2) + 3], 230.0f + resultTeamCharPosTbl[i * 2].x, 35.0f + resultTeamCharPosTbl[i * 2].y); + ResultSprNumSet(resultNumGrpId[(i * 2) + 1], coinNum[i]); + HuSprGrpPosSet(resultNumGrpId[(i * 2) + 1], 320.0f + resultTeamCharPosTbl[i * 2].x, 35.0f + resultTeamCharPosTbl[i * 2].y); } WipeCreate(WIPE_MODE_IN, WIPE_TYPE_NORMAL, 10); while (WipeStatGet()) { HuPrcVSleep(); } - temp_r21 = HuWinCreate(-10000.0f, 400.0f, 320, 40, 0); - HuWinMesSpeedSet(temp_r21, 0); - HuWinBGTPLvlSet(temp_r21, 0); - HuWinPriSet(temp_r21, 5); - HuWinAttrSet(temp_r21, 0x800); - HuWinMesSet(temp_r21, MAKE_MESSID(0x24, 0x07)); + winId = HuWinCreate(-10000.0f, 400.0f, 320, 40, 0); + HuWinMesSpeedSet(winId, 0); + HuWinBGTPLvlSet(winId, 0); + HuWinPriSet(winId, 5); + HuWinAttrSet(winId, 0x800); + HuWinMesSet(winId, MAKE_MESSID(0x24, 0x07)); HuPrcSleep(4); - temp_r31 = 0; + i = 0; while (1) { - if (lbl_1_bss_4 && temp_r31 > 120) { + if (resultSkipF && i > 120) { break; } - for (temp_r20 = sp8 = 0; temp_r20 < 4; temp_r20++) { - if (!GWPlayerCfg[temp_r20].iscom) { - sp8 |= HuPadBtnDown[GWPlayerCfg[temp_r20].pad_idx]; + for (player = btnDown = 0; player < 4; player++) { + if (!GWPlayerCfg[player].iscom) { + btnDown |= HuPadBtnDown[GWPlayerCfg[player].pad_idx]; } } - if (sp8 & PAD_BUTTON_A) { + if (btnDown & PAD_BUTTON_A) { HuAudFXPlay(28); break; } HuPrcVSleep(); - temp_r31++; + i++; } - HuWinKill(temp_r21); + HuWinKill(winId); } -void fn_1_5880(omObjData *object) +void CameraDebug(omObjData *object) { Vec pos; Vec offset; Vec dir; - Vec y_offset; + Vec yOfs; - f32 z_rot; - s8 stick_pos; + float z_rot; + s8 stickPos; if (HuPadBtn[0] & PAD_BUTTON_UP) { CRot.x += 2.0f; @@ -1274,31 +1273,31 @@ void fn_1_5880(omObjData *object) dir.y = cosd(CRot.x); dir.z = (cosd(CRot.y) * sind(CRot.x)); z_rot = CRot.z; - y_offset.x = dir.x * (offset.x * offset.x + (1.0f - offset.x * offset.x) * cosd(z_rot)) + yOfs.x = dir.x * (offset.x * offset.x + (1.0f - offset.x * offset.x) * cosd(z_rot)) + dir.y * (offset.x * offset.y * (1.0f - cosd(z_rot)) - offset.z * sind(z_rot)) + dir.z * (offset.x * offset.z * (1.0f - cosd(z_rot)) + offset.y * sind(z_rot)); - y_offset.y = dir.y * (offset.y * offset.y + (1.0f - offset.y * offset.y) * cosd(z_rot)) + yOfs.y = dir.y * (offset.y * offset.y + (1.0f - offset.y * offset.y) * cosd(z_rot)) + dir.x * (offset.x * offset.y * (1.0f - cosd(z_rot)) + offset.z * sind(z_rot)) + dir.z * (offset.y * offset.z * (1.0f - cosd(z_rot)) - offset.x * sind(z_rot)); - y_offset.z = dir.z * (offset.z * offset.z + (1.0f - offset.z * offset.z) * cosd(z_rot)) + yOfs.z = dir.z * (offset.z * offset.z + (1.0f - offset.z * offset.z) * cosd(z_rot)) + (dir.x * (offset.x * offset.z * (1.0 - cosd(z_rot)) - offset.y * sind(z_rot)) + dir.y * (offset.y * offset.z * (1.0 - cosd(z_rot)) + offset.x * sind(z_rot))); VECCrossProduct(&dir, &offset, &offset); VECNormalize(&offset, &offset); - stick_pos = (HuPadSubStkX[0] & 0xF8); - if (stick_pos != 0) { - Center.x += 0.05f * (offset.x * stick_pos); - Center.y += 0.05f * (offset.y * stick_pos); - Center.z += 0.05f * (offset.z * stick_pos); + stickPos = (HuPadSubStkX[0] & 0xF8); + if (stickPos != 0) { + Center.x += 0.05f * (offset.x * stickPos); + Center.y += 0.05f * (offset.y * stickPos); + Center.z += 0.05f * (offset.z * stickPos); } - VECNormalize(&y_offset, &offset); - stick_pos = -(HuPadSubStkY[0] & 0xF8); - if (stick_pos != 0) { - Center.x += 0.05f * (offset.x * stick_pos); - Center.y += 0.05f * (offset.y * stick_pos); - Center.z += 0.05f * (offset.z * stick_pos); + VECNormalize(&yOfs, &offset); + stickPos = -(HuPadSubStkY[0] & 0xF8); + if (stickPos != 0) { + Center.x += 0.05f * (offset.x * stickPos); + Center.y += 0.05f * (offset.y * stickPos); + Center.z += 0.05f * (offset.z * stickPos); } }