From 10cf70ab2293ffe4e1e10bd47322a0036233de0d Mon Sep 17 00:00:00 2001 From: gamemasterplc Date: Tue, 23 Jan 2024 20:59:22 -0600 Subject: [PATCH 1/6] Various Board Symbol Fixes --- config/GMPE01_00/symbols.txt | 8 ++++---- include/game/board/player.h | 2 +- src/game/board/player.c | 2 +- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/config/GMPE01_00/symbols.txt b/config/GMPE01_00/symbols.txt index 59d67ca6..18cebb77 100644 --- a/config/GMPE01_00/symbols.txt +++ b/config/GMPE01_00/symbols.txt @@ -1166,7 +1166,7 @@ BoardPlayerZoomRestore = .text:0x80064C50; // type:function size:0x134 BoardJunctionMaskSet = .text:0x80064D84; // type:function size:0x10 BoardJunctionMaskReset = .text:0x80064D94; // type:function size:0x10 BoardJunctionMaskZero = .text:0x80064DA4; // type:function size:0xC -InitJunction = .text:0x80064DB0; // type:function size:0x634 +InitJunction = .text:0x80064DB0; // type:function size:0x634 scope:local UpdateJunctionGfx = .text:0x800653E4; // type:function size:0x1A0 scope:local StopJunctionPlayer = .text:0x80065584; // type:function size:0x70 scope:local RestoreJunction = .text:0x800655F4; // type:function size:0x180 scope:local @@ -1208,15 +1208,15 @@ BoardBowserSuitMotionSetWin = .text:0x800696B8; // type:function size:0x44 BoardBowserSuitMotionSetJump = .text:0x800696FC; // type:function size:0x44 BoardBowserSuitPlayerModelKill = .text:0x80069740; // type:function size:0x44 UpdateBowserSuit = .text:0x80069784; // type:function size:0x1F0 scope:local -BoardSpaceShockSpaceSet = .text:0x80069974; // type:function size:0x5C +BoardPlayerSparkSet = .text:0x80069974; // type:function size:0x5C DoSparkSpace = .text:0x800699D0; // type:function size:0x1294 scope:local RemoveSparkSpace = .text:0x8006AC64; // type:function size:0xA0 scope:local SetRollPlayerSize = .text:0x8006AD04; // type:function size:0x24C scope:local -BoardRollResizeCheck = .text:0x8006AF50; // type:function size:0x8 scope:local +BoardRollResizeCheck = .text:0x8006AF50; // type:function size:0x8 BoardPlayerResizeAnimExec = .text:0x8006AF58; // type:function size:0x38C MegaSquishFunc = .text:0x8006B2E4; // type:function size:0x950 scope:local MegaPlayerPassFunc = .text:0x8006BC34; // type:function size:0x980 scope:local -MegaExecJump = .text:0x8006C5B4; // type:function size:0xA48 +MegaExecJump = .text:0x8006C5B4; // type:function size:0xA48 scope:local BoardPlayerCopyEyeMat = .text:0x8006CFFC; // type:function size:0x24C BoardPlayerCopyMat = .text:0x8006D248; // type:function size:0xC0 BoardModelInit = .text:0x8006D308; // type:function size:0xF0 diff --git a/include/game/board/player.h b/include/game/board/player.h index cce446c9..6ca4c694 100644 --- a/include/game/board/player.h +++ b/include/game/board/player.h @@ -16,7 +16,7 @@ extern s16 boardPlayerMdl[4]; -static inline s16 BoardPlayerHandicapGet(s32 player) +static inline s32 BoardPlayerHandicapGet(s32 player) { return GWPlayer[player].handicap; } diff --git a/src/game/board/player.c b/src/game/board/player.c index 0da38a9c..59e7ee51 100644 --- a/src/game/board/player.c +++ b/src/game/board/player.c @@ -1029,7 +1029,7 @@ static inline GetLinkCount(s32 playerIdx, s32 boardIdx) { return linkCount; } -void InitJunction(s32 arg0, s32 arg1, f32 arg8) { +static void InitJunction(s32 arg0, s32 arg1, f32 arg8) { Point3d sp68; Point3d sp5C; Point3d sp50; From 44a6066f08d5fe4c8888948c0df71f1c50b5d834 Mon Sep 17 00:00:00 2001 From: mrshigure Date: Tue, 23 Jan 2024 20:43:24 -0800 Subject: [PATCH 2/6] Matched board/ui --- config/GMPE01_00/config.yml | 2 +- configure.py | 2 +- include/dolphin/os/OSFastCast.h | 20 +- include/game/board/ui.h | 36 + include/game/gamework.h | 1 + include/game/gamework_data.h | 29 +- src/game/board/main.c | 4 +- src/game/board/ui.c | 1997 +++++++++++++++++++++++++++++++ 8 files changed, 2075 insertions(+), 16 deletions(-) create mode 100755 include/game/board/ui.h create mode 100755 src/game/board/ui.c diff --git a/config/GMPE01_00/config.yml b/config/GMPE01_00/config.yml index ff0d6914..2c8e44d5 100644 --- a/config/GMPE01_00/config.yml +++ b/config/GMPE01_00/config.yml @@ -4,7 +4,7 @@ symbols: config/GMPE01_00/symbols.txt splits: config/GMPE01_00/splits.txt quick_analysis: true # Faster re-runs after initial analysis mw_comment_version: 10 # GC 2.6 linker -force_active: [__register_global_object] +force_active: [__register_global_object, lbl_801D40D0] modules: - object: orig/GMPE01_00/files/dll/_minigameDll.rel diff --git a/configure.py b/configure.py index 7402118f..4efe8efe 100644 --- a/configure.py +++ b/configure.py @@ -375,7 +375,7 @@ config.libs = [ Object(NonMatching, "game/board/mushroom.c"), Object(NonMatching, "game/board/star.c"), Object(NonMatching, "game/board/roll.c"), - Object(NonMatching, "game/board/ui.c"), + Object(Matching, "game/board/ui.c"), Object(NonMatching, "game/board/block.c"), Object(NonMatching, "game/board/item.c"), Object(NonMatching, "game/board/bowser.c"), diff --git a/include/dolphin/os/OSFastCast.h b/include/dolphin/os/OSFastCast.h index 696b7953..b52cabfe 100644 --- a/include/dolphin/os/OSFastCast.h +++ b/include/dolphin/os/OSFastCast.h @@ -111,13 +111,25 @@ static inline u16 __OSf32tou16(register f32 inF) static inline void OSf32tou16(f32 *f, u16 *out) { *out = __OSf32tou16(*f); } +static inline float __OSs8tof32(register const s8* arg) { + register float ret; + + asm { + psq_l ret, 0(arg), 1, OS_FASTCAST_S8 + } + + return ret; +} + +static inline void OSs8tof32(const s8* in, float* out) { *out = __OSs8tof32(in); } + static inline float __OSs16tof32(register const s16* arg) { register float ret; - asm { + asm { psq_l ret, 0(arg), 1, OS_FASTCAST_S16 } - + return ret; } @@ -129,7 +141,7 @@ static inline float __OSu8tof32(register const u8* arg) { asm { psq_l ret, 0(arg), 1, OS_FASTCAST_U8 } - + return ret; } @@ -141,7 +153,7 @@ static inline float __OSu16tof32(register const u16* arg) { asm { psq_l ret, 0(arg), 1, OS_FASTCAST_U16 } - + return ret; } diff --git a/include/game/board/ui.h b/include/game/board/ui.h new file mode 100755 index 00000000..ba99e7e1 --- /dev/null +++ b/include/game/board/ui.h @@ -0,0 +1,36 @@ +#ifndef _BOARD_UI_H +#define _BOARD_UI_H + +#include "game/sprite.h" + +s32 BoardItemModelGet(s32 arg0); +s32 BoardItemNameGet(s32 arg0); +BOOL BoardStatusStopCheck(s32 arg0); +s32 BoardStatusVisibleGet(s32 arg0); +void BoardStatusShowSetAll(s32 arg0); +void BoardStatusItemSet(s32 arg0); +void BoardStatusShowSetForce(s32 arg0); +void BoardStatusGraySet(s32 arg0, s32 arg1); +void BoardStatusShowSet(s32 arg0, s32 arg1); +void BoardStatusItemHideSet(s32 arg0, s32 arg1); +void BoardStatusTargetPosSet(s32 arg0, Vec *arg1); +void BoardStatusPosGet(s32 arg0, float *arg1); +void BoardStatusPosSet(s32 arg0, Vec *arg1); +void BoardStatusHammerCreate(s32 arg0); +void BoardStatusHammerShowSet(s32 arg0, s32 arg1); +void BoardStatusHammerKill(s32 arg0); +void BoardStatusKill(void); +void BoardStatusCreate(void); +void BoardSpriteCreate(s32 file, s32 prio, AnimData **anim, s16 *sprite); +void BoardSpriteDigitUpdate(s16 arg0, s16 arg1, s32 arg2); +void BoardPickerCreate(s32 arg0, s8 arg1, void *arg2, s8 arg3); +void BoardPickerBackFlagSet(s32 arg0); +BOOL BoardPickerDoneCheck(void); +s32 BoardPickerPosGet(Vec *arg0); +s32 BoardPickerChoiceGet(void); +s32 BoardItemUseExec(s32 arg0); +void BoardMakeRandomItem(void); +void BoardItemGetDestPos(s32 arg0, Vec *arg1); +void BoardItemStatusKill(s32 arg0); + +#endif diff --git a/include/game/gamework.h b/include/game/gamework.h index dd391afa..12da26f5 100644 --- a/include/game/gamework.h +++ b/include/game/gamework.h @@ -6,6 +6,7 @@ void GWInit(void); void GWGameStatReset(void); s32 GWMessSpeedGet(void); +s32 GWMessDelayGet(void); void GWMGRecordSet(int index, s32 value); s32 GWMGRecordGet(int index); void GWCharColorGet(int character, GXColor *color); diff --git a/include/game/gamework_data.h b/include/game/gamework_data.h index ab0e3ad3..529f9439 100644 --- a/include/game/gamework_data.h +++ b/include/game/gamework_data.h @@ -41,7 +41,7 @@ typedef struct system_state { /* 0x30 */ u8 mess_delay; /* 0x31 */ struct { u8 field31_bit0 : 4; - u8 field31_bit4 : 4; + u8 field31_bit4 : 4; }; /* 0x32 */ s8 unk_32; /* 0x34 */ u16 mg_next; @@ -57,7 +57,7 @@ typedef struct player_state { u16 com : 1; u16 character : 4; u16 auto_size : 2; - u16 field00_bit9 : 1; + u16 field00_bit9 : 1; }; /* 0x02 */ struct { u8 team : 1; @@ -147,19 +147,34 @@ extern PlayerState GWPlayer[4]; extern SystemState GWSystem; extern GameStat GWGameStat; +static inline s32 GWTeamGet(void) +{ + return GWSystem.team; +} + static inline s32 GWLanguageGet(void) { - return GWGameStat.language; + return GWGameStat.language; } -static inline s32 GWMGTypeGet() +static inline s32 GWMGTypeGet(void) { - return GWSystem.mg_type; + return GWSystem.mg_type; } -static inline s32 GWMessSpeedGet() +static inline s32 GWMessSpeedGet(void) { - return GWSystem.mess_speed; + return GWSystem.mess_speed; +} + +static inline s32 GWBoardGet(void) +{ + return GWSystem.board; +} + +static inline s32 GWPlayerTeamGet(s32 player) +{ + return GWPlayer[player].team; } #endif diff --git a/src/game/board/main.c b/src/game/board/main.c index a0ad3272..27d7992b 100644 --- a/src/game/board/main.c +++ b/src/game/board/main.c @@ -1982,8 +1982,6 @@ static float last5GfxPosTbl[2][3][2] = { static void UpdateLast5Gfx(omObjData *object); -void BoardSpriteCreate(s32 file, s16 prio, AnimData **anim, s16 *sprite); - void BoardLast5GfxInit(void) { Last5GfxWork *work; @@ -2011,7 +2009,7 @@ void BoardLast5GfxInit(void) lastF = 0; } for(i=0; i<3; i++) { - s16 prio; + s32 prio; s32 spr_file; if(i == 1) { diff --git a/src/game/board/ui.c b/src/game/board/ui.c new file mode 100755 index 00000000..bb7d2ded --- /dev/null +++ b/src/game/board/ui.c @@ -0,0 +1,1997 @@ +#include "game/board/ui.h" +#include "game/audio.h" +#include "game/data.h" +#include "game/gamework.h" +#include "game/gamework_data.h" +#include "game/hsfex.h" +#include "game/hsfman.h" +#include "game/object.h" +#include "game/pad.h" +#include "game/process.h" +#include "game/window.h" +#include "game/board/main.h" +#include "game/board/player.h" +#include "board_unsplit.h" + +#include "math.h" + +#define ABS(x) ((x < 0) ? -x : x) + +typedef struct { + /* 0x00 */ struct { + u8 unk00_bit0 : 1; + u8 unk00_bit1 : 1; + u8 unk00_bit2 : 1; + u8 unk00_bit3 : 1; + u8 unk00_bit4 : 1; + u8 unk00_bit5 : 1; + u8 unk00_bit6 : 1; + }; + /* 0x01 */ s8 unk01; + /* 0x02 */ s16 unk02; + /* 0x04 */ Vec unk04; + /* 0x10 */ Vec unk10; +} UnkUiStatusStruct; // Size 0x1C + +typedef struct { + /* 0x00 */ s8 unk00[6]; + /* 0x06 */ s16 unk06[6]; + /* 0x12 */ s16 unk12[6]; + /* 0x1E */ s16 unk1E[6]; + /* 0x2A */ char unk2A[2]; + /* 0x2C */ Vec unk2C[6]; + /* 0x74 */ Vec unk74[6]; +} UnkUiWindowStruct; // Size 0xBC + +typedef struct { + struct { + u8 unk00_bit0 : 1; + u8 unk00_bit3 : 3; + u8 unk00_bit5 : 2; + u8 unk00_bit6 : 1; + u8 unk00_bit7 : 1; + }; + s8 unk01; + s8 unk02; + u8 unk03; + s16 unk04; + s16 unk06; +} UnkUiWork01; + +typedef struct { + struct { + u8 unk00_bit0 : 1; + u8 unk00_bit3 : 3; + u8 unk00_bit5 : 2; + }; + s8 unk01; + char unk02[2]; + float unk04; +} UnkUiWork02; + +typedef struct { + struct { + u8 unk00_bit0 : 1; + u8 unk00_bit1 : 1; + }; + s8 unk01; + s8 unk02; + s8 unk03; + Vec *unk04; +} UnkUiWork03; + +typedef struct { + struct { + u8 unk00_bit0 : 1; + }; + s8 unk01; + s8 unk02; + s8 unk03; + UnkUiWindowStruct *unk04; +} UnkUiWork04; + +void BoardPlayerSparkSet(s32); +s32 BoardItemDoneCheck(void); +void BoardItemStart(s32, s32); +void BoardTutorialHookExec(s16, s32); +s16 BoardBowserSuitModelGet(void); +void BoardBowserSuitMotionCreate(void); +s16 BoardBowserSuitPlayerModelGet(void); +void CharModelLayerSetAll(s32); +void BoardItemBagItemSet(void*); +float BoardModelMotionTimeGet(s16); +void BoardModelMotionStartEndSet(s16, s16, s16); +void BoardModelMotionTimeSet(s16, float); +void BoardModelPosGet(s16, Vec*); +s32 BoardComTutorialItemGet(s32); +void BoardTutorialHostHide(s32); + +static void KillAllBoardStatus(void); +static void CreateBoardStatusSprite(s32 arg0, UnkUiStatusStruct *arg1); +static s32 UpdateBoardStatus(void); +static void BoardStatusProc(void); +static void MoveBoardStatus(s32 arg0); +static void UpdateStatusItem(UnkUiStatusStruct *arg0, s32 arg1, s32 arg2); +static void UpdatePicker(omObjData *arg0); +static void UpdatePickerInput(UnkUiWork01 *arg0, omObjData *arg1); +static void MovePicker(UnkUiWork01 *arg0, omObjData *arg1); +static void UpdateComPickerButton(UnkUiWork01 *arg0, omObjData *arg1, s32 *arg2); +static BOOL CheckPickerButton(UnkUiWork01 *arg0, omObjData *arg1, u32 arg2); +static void UpdateYourTurn(omObjData *arg0); +static void GrowYourTurn(UnkUiWork02 *arg0, omObjData *arg1); +static void WaitYourTurn(UnkUiWork02 *arg0, omObjData *arg1); +static void ShrinkYourTurn(UnkUiWork02 *arg0, omObjData *arg1); +static void ItemUseTeamProc(s32 arg0); +static void ItemUseProc(void); +static void FinishItemUse(s16 arg0, s32 arg1); +static void DestroyItemUse(void); +static void TeamItemPosSet(s32 arg0, s32 arg1, Vec *arg2); +static void ExecItemPick(void); +static void UpdateItemPick(omObjData *arg0); +static void MakeItemPickSpace(UnkUiWork03 *arg0); +static void SetItemUIStatus(s32 arg0); +static void ItemGetPos(s32 arg0, Vec *arg1); +static void UpdateItemPickGfx(omObjData *arg0); +static void UpdateItemPickup(omObjData *arg0); +static BOOL CheckItemWindow(void); +static void HideItemWindow(void); +static void CreateItemWindow(s32 arg0, s32 arg1); +static BOOL CheckItemWindowSlide(void); +static void KillItemWindow(void); +static void SetItemWindowCurr(s32 arg0); +static void UpdateItemWindow(omObjData *arg0); +static void CreatePickerWindow(UnkUiWork01 *arg0, s32 arg1); +static void KillPickerWindow(UnkUiWork01 *arg0); + +static s16 itemMdlId[4][3]; +static Vec pickerPos[4]; +static Vec itemPosTemp[6]; + +static s8 itemTeam; +static s8 itemTeamF; +s8 boardItemUser; +static s8 pickerChoice; +static s8 pickerChoiceDefault; +static s32 pickerBackF; +s32 lbl_801D40D0; +static s16 yourTurnSpr; +static s8 itemPlayer; +static s8 itemUsed; +static s8 teamItemPlayer; +static s16 itemRandTbl[3]; +static float itemPickupPos; +static omObjData *itemPickObj; +static Process *itemUseProc; +static omObjData *yourTurnObj; +static omObjData *pickerObj; +static omObjData *itemWindowObj; +static Process *statusProc; + +static s16 itemPickupMdlId = -1; +static s16 yourTurnSprGrp = -1; + +static UnkUiStatusStruct uiStatus[4] = { 0 }; + +static s32 statusSprTbl[11] = { + 0x00070027, + 0x00070026, + 0x00070029, + 0x00070028, + 0x00070028, + 0x00070028, + 0x0007002D, + 0x00070028, + 0x00070028, + 0x00070028, + 0x0007002C +}; + +static s16 statusSprPrioTbl[12] = { + 0x05F0, 0x05E6, 0x05DC, 0x05D2, + 0x05DC, 0x05DC, 0x05DC, 0x05DC, + 0x05DC, 0x05DC, 0x05DC, 0x05DC +}; + +static float statusHideOfsTbl[4] = { + -230.0f, 230.0f, -230.0f, 230.0f +}; + +static float statusPosTbl[4][2] = { + { 114.0f, 84.0f }, + { 462.0f, 84.0f }, + { 114.0f, 396.0f }, + { 462.0f, 396.0f } +}; + +static u8 statusColTbl[4][4] = { + { 0x80, 0x80, 0x80, 0x00 }, + { 0x1A, 0x84, 0xFF, 0x00 }, + { 0xFF, 0x1A, 0x2D, 0x00 }, + { 0x0A, 0xB4, 0x3C, 0x00 } +}; + +static float statusSprPosTbl[17][2] = { + { 0.0f, 0.0f }, + { 0.0f, 0.0f }, + { -68.0f, 0.0f }, + { 80.0f, 14.0f }, + { 64.0f, 14.0f }, + { 48.0f, 14.0f }, + { 26.0f, 14.0f }, + { 80.0f, -12.0f }, + { 64.0f, -12.0f }, + { 48.0f, -12.0f }, + { 26.0f, -12.0f }, + { -16.0f, 0.0f }, + { -18.0f, 32.0f }, + { 24.0f, -34.0f }, + { 48.0f, -34.0f }, + { 72.0f, -34.0f }, + { -32.0f, -16.0f } +}; + +static float statusItemPosTbl[6][2] = { + { -56.0f, 0.0f }, + { -58.0f, 32.0f }, + { -2.0f, 4.0f }, + { 34.0f, -8.0f }, + { 70.0f, 4.0f }, + { -56.0f, -16.0f } +}; + +static s32 itemMdlTbl[14] = { + 0x00070083, + 0x00070084, + 0x00070085, + 0x00070086, + 0x00070087, + 0x00070088, + 0x00070089, + 0x0007008A, + 0x0007008B, + 0x0007008C, + 0x0007008D, + 0x0007008E, + 0x0007008F, + 0x00070090 +}; + +static Vec teamItemStatusPosTbl[2] = { + { 190.0f, 116.0f, 0.0f }, + { 386.0f, 116.0f, 0.0f } +}; + +s32 BoardItemModelGet(s32 arg0) { + s32 sp8[14] = { + 0x0007006D, + 0x0007006E, + 0x0007006F, + 0x00070070, + 0x00070071, + 0x00070072, + 0x00070073, + 0x00070074, + 0x00070076, + 0x00070077, + 0x00070078, + 0x00070079, + 0x0007007A, + 0x0007007B + }; + + return sp8[arg0]; +} + +s32 BoardItemNameGet(s32 arg0) { + s32 sp8[15] = { + 0x00120000, + 0x00120001, + 0x00120002, + 0x00120003, + 0x00120004, + 0x00120005, + 0x00120006, + 0x00120007, + 0x00120008, + 0x00120009, + 0x0012000A, + 0x0012000B, + 0x0012000C, + 0x0012000D, + 0x0012000E + }; + + return sp8[arg0]; +} + +BOOL BoardStatusStopCheck(s32 arg0) { + return (uiStatus[arg0].unk00_bit2) ? FALSE : TRUE; +} + +s32 BoardStatusVisibleGet(s32 arg0) { + return uiStatus[arg0].unk00_bit1; +} + +void BoardStatusShowSetAll(s32 arg0) { + s32 i; + + for (i = 0; i < 4; i++) { + BoardStatusShowSet(i, arg0); + } +} + +void BoardStatusItemSet(s32 arg0) { + UnkUiStatusStruct *temp_r31; + s32 i; + s32 j; + + for (i = 0; i < 4; i++) { + temp_r31 = &uiStatus[i]; + BoardStatusShowSet(i, arg0); + temp_r31->unk04.x = temp_r31->unk10.x; + temp_r31->unk04.y = temp_r31->unk10.y; + temp_r31->unk00_bit2 = 0; + HuSprGrpPosSet(temp_r31->unk02, temp_r31->unk04.x, temp_r31->unk04.y); + for (j = 0; j < 3; j++) { + if (itemMdlId[i][j] != -1) { + BoardModelVisibilitySet(itemMdlId[i][j], arg0); + } + } + } +} + +void BoardStatusShowSetForce(s32 arg0) { + uiStatus[arg0].unk00_bit3 = 1; +} + +void BoardStatusGraySet(s32 arg0, s32 arg1) { + UnkUiStatusStruct *temp_r31; + s16 sp10[9] = { 3, 4, 5, 7, 8, 9, 2, 6, 10 }; + s16 var_r28; + u8 var_r29; + s32 i; + + temp_r31 = &uiStatus[arg0]; + if (arg1 != 0) { + var_r29 = 0xFF; + temp_r31->unk00_bit4 = 1; + var_r28 = 1500; + } else { + var_r29 = 0x3F; + temp_r31->unk00_bit4 = 0; + var_r28 = 1530; + } + for (i = 0; i < 9; i++) { + HuSprPriSet(temp_r31->unk02, sp10[i], var_r28); + HuSprColorSet(temp_r31->unk02, sp10[i], var_r29, var_r29, var_r29); + } +} + +void BoardStatusShowSet(s32 arg0, s32 arg1) { + UnkUiStatusStruct *temp_r31 = &uiStatus[arg0]; + + if (temp_r31->unk00_bit3) { + arg0 = 0; + } + if (arg1 == 0) { + if (temp_r31->unk00_bit1) { + temp_r31->unk00_bit1 = 0; + temp_r31->unk10.x = statusPosTbl[arg0][0] + statusHideOfsTbl[arg0]; + temp_r31->unk10.y = statusPosTbl[arg0][1]; + temp_r31->unk00_bit3 = 0; + } + } else { + if (!temp_r31->unk00_bit1) { + temp_r31->unk00_bit1 = 1; + temp_r31->unk10.x = statusPosTbl[arg0][0]; + temp_r31->unk10.y = statusPosTbl[arg0][1]; + temp_r31->unk04.x = statusPosTbl[arg0][0] + statusHideOfsTbl[arg0]; + temp_r31->unk04.y = statusPosTbl[arg0][1]; + } + } +} + +void BoardStatusItemHideSet(s32 arg0, s32 arg1) { + UnkUiStatusStruct *temp_r31 = &uiStatus[arg0]; + + if (arg1 != 0) { + temp_r31->unk00_bit5 = 1; + } else { + temp_r31->unk00_bit5 = 0; + } +} + +void BoardStatusTargetPosSet(s32 arg0, Vec *arg1) { + UnkUiStatusStruct *temp_r31 = &uiStatus[arg0]; + + temp_r31->unk10.x = arg1->x; + temp_r31->unk10.y = arg1->y; + temp_r31->unk00_bit2 = 1; +} + +void BoardStatusPosGet(s32 arg0, float *arg1) { + UnkUiStatusStruct *temp_r31 = &uiStatus[arg0]; + + arg1[0] = temp_r31->unk04.x; + arg1[1] = temp_r31->unk04.y; +} + +void BoardStatusPosSet(s32 arg0, Vec *arg1) { + UnkUiStatusStruct *temp_r30 = &uiStatus[arg0]; + + temp_r30->unk04.x = arg1->x; + temp_r30->unk04.y = arg1->y; + BoardStatusTargetPosSet(arg0, arg1); +} + +void BoardStatusHammerCreate(s32 arg0) { + UnkUiStatusStruct *temp_r31 = &uiStatus[arg0]; + float spC[2]; + s32 var_r30; + s32 temp_r29; + s16 sp8; + + temp_r29 = BoardPlayerAutoSizeGet(arg0); + switch (temp_r29) { + case 0: + return; + case 2: + var_r30 = 0x70093; + break; + case 1: + var_r30 = 0x70092; + break; + } + if (!temp_r31->unk00_bit6) { + BoardSpriteCreate(var_r30, 0x5DC, NULL, &sp8); + spC[0] = statusSprPosTbl[16][0]; + spC[1] = statusSprPosTbl[16][1]; + HuSprGrpMemberSet(temp_r31->unk02, 0x10, sp8); + HuSprPosSet(temp_r31->unk02, 0x10, spC[0], spC[1]); + HuSprScaleSet(temp_r31->unk02, 0x10, 2.0f, 2.0f); + HuSprAttrSet(temp_r31->unk02, 0x10, 2); + HuSprAttrSet(temp_r31->unk02, 0x10, 8); + HuSprDrawNoSet(temp_r31->unk02, 0x10, 0x40); + temp_r31->unk00_bit6 = 1; + } +} + +void BoardStatusHammerShowSet(s32 arg0, s32 arg1) { + UnkUiStatusStruct *temp_r31 = &uiStatus[arg0]; + + if (temp_r31->unk00_bit6) { + if (arg1 != 0) { + HuSprAttrSet(temp_r31->unk02, 0x10, 2); + } else { + HuSprAttrReset(temp_r31->unk02, 0x10, 2); + HuSprAttrSet(temp_r31->unk02, 0x10, 1); + } + } +} + +void BoardStatusHammerKill(s32 arg0) { + UnkUiStatusStruct *temp_r31 = &uiStatus[arg0]; + + if (temp_r31->unk00_bit6) { + HuSprGrpMemberKill(temp_r31->unk02, 0x10); + temp_r31->unk00_bit6 = 0; + } +} + +void BoardStatusKill(void) { + UnkUiStatusStruct *temp_r31; + s32 i; + + for (i = 0; i < 4; i++) { + temp_r31 = &uiStatus[i]; + if (temp_r31->unk00_bit0) { + if (temp_r31->unk02 != -1) { + HuSprGrpKill(temp_r31->unk02); + temp_r31->unk02 = -1; + } + temp_r31->unk00_bit6 = 0; + } + } +} + +void BoardStatusCreate(void) { + s32 i; + + memset(uiStatus, 0, 0x70); + for (i = 0; i < 4; i++) { + CreateBoardStatusSprite(i, &uiStatus[i]); + uiStatus[i].unk00_bit0 = 1; + uiStatus[i].unk00_bit2 = 0; + uiStatus[i].unk00_bit3 = 0; + uiStatus[i].unk00_bit4 = 1; + uiStatus[i].unk00_bit5 = 1; + uiStatus[i].unk00_bit6 = 0; + uiStatus[i].unk01 = 9; + uiStatus[i].unk04.x = statusPosTbl[i][0] + statusHideOfsTbl[i]; + uiStatus[i].unk04.y = statusPosTbl[i][1]; + uiStatus[i].unk04.z = 0.0f; + uiStatus[i].unk10 = uiStatus[i].unk04; + HuSprGrpDrawNoSet(uiStatus[i].unk02, 0x40); + } + HuSprExecLayerSet(0x40, 5); + if (statusProc == 0) { + statusProc = HuPrcChildCreate(BoardStatusProc, 0x1FFF, 0x4000, 0, HuPrcCurrentGet()); + HuPrcDestructorSet2(statusProc, KillAllBoardStatus); + } +} + +static void KillAllBoardStatus(void) { + BoardStatusKill(); + statusProc = NULL; +} + +static void CreateBoardStatusSprite(s32 arg0, UnkUiStatusStruct *arg1) { + float var_f31; + float var_f30; + s16 sp8; + s32 temp_r28; + s32 temp_r27; + s16 temp_r26; + s32 spC[] = { + 0x0007002E, + 0x0007002F, + 0x00070030, + 0x00070031, + 0x00070032, + 0x00070033, + 0x00070034, + 0x00070035 + }; + s32 i; + + temp_r28 = GWPlayerCfg[arg0].character; + arg1->unk02 = HuSprGrpCreate(0x11); + for (i = 0; i < 11; i++) { + temp_r27 = statusSprTbl[i]; + temp_r26 = statusSprPrioTbl[i]; + BoardSpriteCreate(temp_r27, temp_r26, NULL, &sp8); + HuSprGrpMemberSet(arg1->unk02, i, sp8); + HuSprAttrSet(arg1->unk02, i, 1); + HuSprAttrSet(arg1->unk02, i, 8); + HuSprPosSet(arg1->unk02, i, statusSprPosTbl[i][0], statusSprPosTbl[i][1]); + } + if ((s32) GWSystem.team != 0) { + if (GWPlayerTeamGet(arg0) == 0) { + HuSprBankSet(arg1->unk02, 1, 2); + } else { + HuSprBankSet(arg1->unk02, 1, 1); + } + } + BoardSpriteCreate(spC[temp_r28], 0x5DC, NULL, &sp8); + HuSprGrpMemberSet(arg1->unk02, 0xB, sp8); + HuSprAttrSet(arg1->unk02, 0xB, 8); + var_f31 = statusSprPosTbl[11][0]; + var_f30 = statusSprPosTbl[11][1]; + HuSprPosSet(arg1->unk02, 11, var_f31, var_f30); + BoardSpriteCreate(0x7002A, 0x5DC, NULL, &sp8); + HuSprGrpMemberSet(arg1->unk02, 0xC, sp8); + var_f31 = statusSprPosTbl[12][0]; + var_f30 = statusSprPosTbl[12][1]; + HuSprPosSet(arg1->unk02, 12, var_f31, var_f30); + HuSprAttrSet(arg1->unk02, 0xC, 8); + for (i = 0; i < 3; i++) { + BoardSpriteCreate(0x70091, 0x5DC, NULL, &sp8); + HuSprGrpMemberSet(arg1->unk02, i + 0xD, sp8); + HuSprAttrSet(arg1->unk02, i + 0xD, 1); + HuSprAttrSet(arg1->unk02, i + 0xD, 8); + } + arg1->unk00_bit6 = 0; + HuSprTPLvlSet(arg1->unk02, 0, 0.7f); + if (GWBoardGet() == 7 || GWBoardGet() == 8) { + HuSprAttrSet(arg1->unk02, 7, 4); + HuSprAttrSet(arg1->unk02, 8, 4); + HuSprAttrSet(arg1->unk02, 9, 4); + HuSprAttrSet(arg1->unk02, 0xA, 4); + } +} + +void BoardSpriteCreate(s32 file, s32 prio, AnimData **anim, s16 *sprite) { + s16 temp_r28; + void *temp_r27; + AnimData *temp_r31; + + temp_r27 = HuDataSelHeapReadNum(file, MEMORY_DEFAULT_NUM, HEAP_DATA); + temp_r31 = HuSprAnimRead(temp_r27); + temp_r28 = HuSprCreate(temp_r31, prio, 0); + if (anim) { + *anim = temp_r31; + } + if (sprite) { + *sprite = temp_r28; + } +} + +static s32 UpdateBoardStatus(void) { + UnkUiStatusStruct *temp_r31; + u8 *temp_r28; + s32 temp_r27; + s32 i; + s32 j; + + for (i = 0; i < 4; i++) { + temp_r31 = &uiStatus[i]; + if (temp_r31->unk02 == -1) { + return -1; + } + GWPlayer[i].rank = BoardPlayerRankCalc(i); + HuSprBankSet(temp_r31->unk02, 2, GWPlayer[i].rank); + BoardSpriteDigitUpdate(temp_r31->unk02, 3, BoardPlayerCoinsGet(i)); + BoardSpriteDigitUpdate(temp_r31->unk02, 7, GWStarsGet(i)); + for (j = 0; j < 3; j++) { + temp_r27 = GWPlayer[i].items[j]; + if (temp_r27 != -1 && temp_r31->unk00_bit5) { + UpdateStatusItem(temp_r31, j, temp_r27); + HuSprAttrReset(temp_r31->unk02, j + 0xD, 4); + } else { + HuSprAttrSet(temp_r31->unk02, j + 0xD, 4); + } + } + if (GWPlayer[i].com) { + HuSprAttrReset(temp_r31->unk02, 0xC, 4); + } else { + HuSprAttrSet(temp_r31->unk02, 0xC, 4); + } + temp_r28 = statusColTbl[GWPlayer[i].color]; + HuSprColorSet(temp_r31->unk02, 0, temp_r28[0], temp_r28[1], temp_r28[2]); + MoveBoardStatus(i); + HuSprGrpPosSet(temp_r31->unk02, temp_r31->unk04.x, temp_r31->unk04.y); + } + return 0; +} + +static void BoardStatusProc(void) { + while (1) { + if (omSysExitReq != 0 || UpdateBoardStatus() != 0) { + break; + } + HuPrcVSleep(); + } + HuPrcEnd(); +} + +static void MoveBoardStatus(s32 arg0) { + UnkUiStatusStruct *temp_r30 = &uiStatus[arg0]; + float var_f30; + Vec spC; + + PSVECSubtract(&temp_r30->unk10, &temp_r30->unk04, &spC); + if (ABS(spC.x) < 1.0f && ABS(spC.y) < 1.0f) { + spC = temp_r30->unk10; + temp_r30->unk00_bit2 = 0; + } else { + OSs8tof32(&temp_r30->unk01, &var_f30); + var_f30 /= 32; + PSVECScale(&spC, &spC, var_f30); + PSVECAdd(&temp_r30->unk04, &spC, &spC); + temp_r30->unk00_bit2 = 1; + } + temp_r30->unk04.x = spC.x; + temp_r30->unk04.y = spC.y; +} + +void BoardSpriteDigitUpdate(s16 arg0, s16 arg1, s32 arg2) { + s32 temp_r29; + s32 temp_r28; + s32 temp_r27; + + temp_r29 = arg2 / 100; + temp_r28 = (arg2 - temp_r29 * 100) / 10; + temp_r27 = (arg2 - (temp_r29 * 100 + temp_r28 * 10)) % 10; + if (temp_r29 == 0) { + HuSprBankSet(arg0, arg1 + 2, 0xA); + } else { + HuSprBankSet(arg0, arg1 + 2, temp_r29); + } + if (temp_r28 == 0 && temp_r29 == 0) { + HuSprBankSet(arg0, arg1 + 1, temp_r27); + HuSprAttrSet(arg0, arg1, 4); + } else { + HuSprBankSet(arg0, arg1 + 1, temp_r28); + HuSprBankSet(arg0, arg1, temp_r27); + HuSprAttrReset(arg0, arg1, 4); + } +} + +static void UpdateStatusItem(UnkUiStatusStruct *arg0, s32 arg1, s32 arg2) { + float temp_f31; + float temp_f30; + + temp_f31 = statusSprPosTbl[arg1 + 0xD][0]; + temp_f30 = statusSprPosTbl[arg1 + 0xD][1]; + HuSprBankSet(arg0->unk02, arg1 + 0xD, arg2); + HuSprPosSet(arg0->unk02, arg1 + 0xD, temp_f31, temp_f30); +} + +void BoardPickerCreate(s32 arg0, s8 arg1, void *arg2, s8 arg3) { + UnkUiWork01 *temp_r31; + omObjData *temp_r30; + s32 temp_r28; + s16 sp12; + s32 sp14[] = { + 0x0007001E, + 0x0007001F, + 0x00070020, + 0x00070021, + 0x00070022, + 0x00070023, + 0x00070024, + 0x00070025 + }; + + temp_r28 = GWPlayer[arg0].character; + temp_r30 = omAddObjEx(boardObjMan, 0x107, 0, 0, -1, &UpdatePicker); + pickerObj = temp_r30; + temp_r31 = OM_GET_WORK_PTR(temp_r30, UnkUiWork01); + temp_r31->unk00_bit0 = 0; + temp_r31->unk00_bit6 = 0; + temp_r31->unk00_bit5 = arg0; + temp_r31->unk01 = arg3; + temp_r31->unk00_bit7 = 0; + temp_r31->unk02 = 0; + temp_r31->unk00_bit3 = 0; + temp_r31->unk03 = 0xA; + pickerBackF = 0; + pickerChoiceDefault = arg1; + memset(&pickerPos, 0, sizeof(pickerPos)); + memcpy(&pickerPos, arg2, pickerChoiceDefault * sizeof(Vec)); + temp_r31->unk04 = HuSprGrpCreate(1); + pickerChoice = -1; + temp_r30->trans.x = temp_r30->rot.x = pickerPos[temp_r31->unk02].x; + temp_r30->trans.y = temp_r30->rot.y = pickerPos[temp_r31->unk02].y; + temp_r30->trans.z = temp_r30->rot.z = 0.0f; + BoardSpriteCreate(sp14[temp_r28], 90, NULL, &sp12); + HuSprGrpMemberSet(temp_r31->unk04, 0, sp12); + HuSprPosSet(temp_r31->unk04, 0, temp_r30->trans.x, temp_r30->trans.y); + HuSprBankSet(temp_r31->unk04, 0, 0); + HuSprAttrSet(temp_r31->unk04, 0, 1); + HuSprAttrSet(temp_r31->unk04, 0, 2); + HuSprAttrSet(temp_r31->unk04, 0, 8); + CreatePickerWindow(temp_r31, 1); +} + +void BoardPickerBackFlagSet(s32 arg0) { + if (pickerObj) { + if (arg0 != 0) { + pickerBackF = 0; + } else { + pickerBackF = 1; + } + if (arg0 == 0) { + KillPickerWindow(OM_GET_WORK_PTR(pickerObj, UnkUiWork01)); + CreatePickerWindow(OM_GET_WORK_PTR(pickerObj, UnkUiWork01), 0); + } + } +} + +BOOL BoardPickerDoneCheck(void) { + if (pickerObj) { + return FALSE; + } else { + return TRUE; + } +} + +s32 BoardPickerPosGet(Vec *arg0) { + if (pickerObj == 0 || arg0 == 0) { + return -1; + } + arg0->x = pickerObj->trans.x; + arg0->y = pickerObj->trans.y; + arg0->z = pickerObj->trans.z; + return 0; +} + +s32 BoardPickerChoiceGet(void) { + return pickerChoice; +} + +static void UpdatePicker(omObjData *arg0) { + UnkUiWork01 *temp_r31 = OM_GET_WORK_PTR(arg0, UnkUiWork01); + + if (temp_r31->unk00_bit0 || BoardIsKill()) { + HuWinKill(temp_r31->unk06); + HuSprGrpKill(temp_r31->unk04); + pickerObj = NULL; + omDelObjEx(HuPrcCurrentGet(), arg0); + } else { + if (temp_r31->unk03 != 0) { + temp_r31->unk03--; + } else if (pickerChoice != -1 || temp_r31->unk00_bit7) { + temp_r31->unk00_bit0 = 1; + } else { + UpdatePickerInput(temp_r31, arg0); + } + MovePicker(temp_r31, arg0); + HuSprPosSet(temp_r31->unk04, 0, arg0->trans.x, arg0->trans.y); + } +} + +static void UpdatePickerInput(UnkUiWork01 *arg0, omObjData *arg1) { + s32 sp8; + s32 temp_r29; + + if (!arg0->unk00_bit6) { + sp8 = 0; + if (GWPlayer[arg0->unk00_bit5].com && arg0->unk01 != -1) { + UpdateComPickerButton(arg0, arg1, &sp8); + } else { + temp_r29 = GWPlayer[arg0->unk00_bit5].port; + sp8 = HuPadDStkRep[temp_r29] | HuPadBtnDown[temp_r29]; + } + if (CheckPickerButton(arg0, arg1, sp8) != 0) { + arg1->rot.x = pickerPos[arg0->unk02].x; + arg1->rot.y = pickerPos[arg0->unk02].y; + arg1->rot.z = pickerPos[arg0->unk02].z; + } + } +} + +static void MovePicker(UnkUiWork01 *arg0, omObjData *arg1) { + float temp_f31 = 0.5f; + Vec sp14; + Vec sp8; + + sp8.x = arg1->rot.x; + sp8.y = arg1->rot.y; + sp8.z = arg1->rot.z; + sp14.x = arg1->trans.x; + sp14.y = arg1->trans.y; + sp14.z = arg1->trans.z; + PSVECSubtract(&sp8, &sp14, &sp8); + if (PSVECMag(&sp8) < 1.0f) { + arg1->trans.x = arg1->rot.x; + arg1->trans.y = arg1->rot.y; + arg1->trans.z = arg1->rot.z; + arg0->unk00_bit6 = 0; + } else { + PSVECScale(&sp8, &sp8, temp_f31); + PSVECAdd(&sp14, &sp8, &sp8); + arg1->trans.x = sp8.x; + arg1->trans.y = sp8.y; + arg1->trans.z = sp8.z; + arg0->unk00_bit6 = 1; + } +} + +static void UpdateComPickerButton(UnkUiWork01 *arg0, omObjData *arg1, s32 *arg2) { + if (arg0->unk02 == arg0->unk01) { + *arg2 = 0x100; + } else { + *arg2 = 2; + } +} + +static BOOL CheckPickerButton(UnkUiWork01 *arg0, omObjData *arg1, u32 arg2) { + BOOL var_r30 = FALSE; + + if (arg2 == 0x100) { + pickerChoice = arg0->unk02; + HuAudFXPlay(2); + var_r30 = TRUE; + } else if (arg2 == 0x200 && pickerBackF == 0) { + arg0->unk00_bit0 = 1; + arg0->unk00_bit7 = 1; + pickerChoice = -1; + HuAudFXPlay(3); + var_r30 = TRUE; + } else if (arg2 & 1) { + var_r30 = TRUE; + if (pickerChoiceDefault > 1) { + HuAudFXPlay(0); + } + arg0->unk02--; + } else if (arg2 & 2) { + var_r30 = TRUE; + if (pickerChoiceDefault > 1) { + HuAudFXPlay(0); + } + arg0->unk02++; + } + if (arg0->unk02 < 0) { + arg0->unk02 = pickerChoiceDefault - 1; + } + if (arg0->unk02 >= pickerChoiceDefault) { + arg0->unk02 = 0; + } + if (GWPlayer[arg0->unk00_bit5].com && var_r30 != 0) { + arg0->unk03 = GWMessDelayGet(); + } + return var_r30; +} + +void BoardYourTurnExec(s32 arg0) { + s32 temp_r29; + UnkUiWork02 *temp_r31; + s32 sp8[] = { + 0x00070043, + 0x00070044, + 0x00070045, + 0x00070046, + 0x00070047, + 0x00070048, + 0x00070049, + 0x0007004A + }; + + temp_r29 = GWPlayer[arg0].character; + yourTurnObj = omAddObjEx(boardObjMan, 0x10B, 0, 0, -1, &UpdateYourTurn); + temp_r31 = OM_GET_WORK_PTR(yourTurnObj, UnkUiWork02); + temp_r31->unk00_bit0 = 0; + temp_r31->unk00_bit5 = arg0; + temp_r31->unk00_bit3 = 0; + temp_r31->unk01 = 0; + yourTurnSprGrp = HuSprGrpCreate(3); + BoardSpriteCreate(sp8[temp_r29], 0x5DC, NULL, &yourTurnSpr); + HuSprGrpMemberSet(yourTurnSprGrp, 0, yourTurnSpr); + HuSprPosSet(yourTurnSprGrp, 0, 0.0f, 0.0f); + HuSprAttrSet(yourTurnSprGrp, 0, 1); + HuSprScaleSet(yourTurnSprGrp, 0, 0.001f, 0.001f); + HuSprAttrSet(yourTurnSprGrp, 0, 8); + HuSprGrpPosSet(yourTurnSprGrp, 288.0f, 240.0f); + HuAudFXPlay(0x307); + while (yourTurnObj) { + HuPrcVSleep(); + } +} + +static void UpdateYourTurn(omObjData *arg0) { + UnkUiWork02 *temp_r31 = OM_GET_WORK_PTR(arg0, UnkUiWork02); + + if (temp_r31->unk00_bit0 || BoardIsKill()) { + HuSprGrpKill(yourTurnSprGrp); + yourTurnSprGrp = -1; + yourTurnObj = NULL; + omDelObjEx(HuPrcCurrentGet(), arg0); + } else { + switch (temp_r31->unk00_bit3) { + case 0: + GrowYourTurn(temp_r31, arg0); + break; + case 2: + WaitYourTurn(temp_r31, arg0); + break; + case 1: + ShrinkYourTurn(temp_r31, arg0); + break; + } + } +} + +static void GrowYourTurn(UnkUiWork02 *arg0, omObjData *arg1) { + float temp_f30; + + arg0->unk01 += 7; + if (arg0->unk01 > 90) { + arg0->unk01 = 90; + arg0->unk00_bit3 = 1; + } + OSs8tof32(&arg0->unk01, &temp_f30); + temp_f30 = 1.2999999523162842 * sin(M_PI * temp_f30 / 180.0); + HuSprScaleSet(yourTurnSprGrp, 0, temp_f30, temp_f30); +} + +static void WaitYourTurn(UnkUiWork02 *arg0, omObjData *arg1) { + float temp_f30; + + arg0->unk01 += 7; + if (arg0->unk01 > 90) { + arg0->unk01 = 90; + arg0->unk00_bit0 = 1; + } + OSs8tof32(&arg0->unk01, &temp_f30); + temp_f30 = sin(M_PI * temp_f30 / 180.0); + HuSprScaleSet(yourTurnSprGrp, 0, 1.3f + temp_f30, 1.3f + temp_f30); + HuSprTPLvlSet(yourTurnSprGrp, 0, 1.0f - temp_f30); +} + +static void ShrinkYourTurn(UnkUiWork02 *arg0, omObjData *arg1) { + s32 temp_r30 = GWPlayer[arg0->unk00_bit5].port; + + if ((HuPadBtnDown[temp_r30] & 0x100) || GWPlayer[arg0->unk00_bit5].com || _CheckFlag(0x1000B)) { + arg0->unk00_bit3 = 2; + arg0->unk01 = 0; + arg0->unk04 = 1.0f; + } +} + +s32 BoardItemUseExec(s32 arg0) { + BoardPauseDisableSet(1); + itemPlayer = arg0; + itemUseProc = HuPrcChildCreate(ItemUseProc, 0x2004, 0x4000, 0, boardMainProc); + HuPrcDestructorSet2(itemUseProc, DestroyItemUse); + while (itemUseProc) { + HuPrcVSleep(); + } + return itemUsed; +} + +static void ItemUseTeamProc(s32 arg0) { + UnkUiStatusStruct *temp_r22; + Vec sp40; + Vec sp34; + s32 sp2C[2]; + s32 i; + s32 j; + + if (GWTeamGet()) { + if (arg0 != 0) { + teamItemPlayer = BoardPlayerSameTeamFind(itemPlayer); + if (itemTeamF != 0) { + BoardStatusTargetPosSet(itemPlayer, &teamItemStatusPosTbl[0]); + BoardStatusTargetPosSet(teamItemPlayer, &teamItemStatusPosTbl[1]); + } else { + BoardStatusTargetPosSet(itemPlayer, (Vec*) statusPosTbl[0]); + BoardStatusTargetPosSet(teamItemPlayer, (Vec*) statusPosTbl[1]); + } + sp2C[0] = BoardPlayerTeamFind(itemPlayer); + sp2C[1] = BoardPlayerSameTeamFind(sp2C[0]); + for (i = 0; i < 2; i++) { + sp40.x = statusPosTbl[sp2C[i]][0] + statusHideOfsTbl[sp2C[i]]; + sp40.y = statusPosTbl[sp2C[i]][1]; + BoardStatusTargetPosSet(sp2C[i], &sp40); + } + while (!BoardStatusStopCheck(itemPlayer) || !BoardStatusStopCheck(teamItemPlayer)) { + HuPrcVSleep(); + } + } else { + for (i = 0; i < 4; i++) { + sp40.x = statusPosTbl[i][0]; + sp40.y = statusPosTbl[i][1]; + BoardStatusTargetPosSet(i, &sp40); + } + while (!BoardStatusStopCheck(0) + || !BoardStatusStopCheck(1) + || !BoardStatusStopCheck(2) + || !BoardStatusStopCheck(3)) { + sp34.z = 0.0f; + for (i = 0; i < 4; i++) { + temp_r22 = &uiStatus[i]; + sp40.x = temp_r22->unk04.x; + sp40.y = temp_r22->unk04.y; + for (j = 0; j < BoardPlayerItemCount(i); j++) { + sp34.x = sp40.x + statusItemPosTbl[j + 2][0]; + sp34.y = sp40.y + statusItemPosTbl[j + 2][1]; + TeamItemPosSet(i, j, &sp34); + } + } + HuPrcVSleep(); + } + } + } +} + +static void ItemUseProc(void) { + s32 var_r24; + s16 temp_r23; + s32 var_r25; + s32 var_r27; + s32 i; + + var_r27 = -1; + itemTeam = GWPlayerTeamGet(itemPlayer); + if (GWTeamGet()) { + itemTeamF = 1; + } else { + itemTeamF = 0; + } + for (i = 0; i < 4; i++) { + GWPlayer[i].show_next = 0; + } + for (var_r25 = i = 0; i < 3; i++) { + if (GWPlayer[itemPlayer].items[i] == 8) { + var_r25++; + } + } + temp_r23 = GWPlayer[itemPlayer].space_curr; + ItemUseTeamProc(1); + BoardFilterFadeInit(0x1E, 0xA0); + ExecItemPick(); + ItemUseTeamProc(0); + itemTeamF = 0; + BoardFilterFadeOut(0x1E); + if (itemUsed == 0xA) { + var_r27 = 0x40000; + } + if (itemUsed == 0xB) { + var_r27 = 0x90000; + } + if (var_r27 != -1) { + var_r24 = BoardDataDirReadAsync(var_r27); + BoardDataAsyncWait(var_r24); + } + HideItemWindow(); + BoardRollTypeSet(itemUsed); + if (itemUsed != -1) { + switch (itemUsed) { + case 13: + BoardMakeRandomItem(); + break; + case 11: + SetItemUIStatus(3); + break; + case 12: + SetItemUIStatus(3); + HuPrcSleep(0xA); + BoardStatusShowSetAll(0); + _SetFlag(0x1001C); + _SetFlag(0x1000E); + break; + } + BoardItemStart(itemPlayer, itemUsed); + while (BoardItemDoneCheck() == 0) { + HuPrcVSleep(); + } + if (_CheckFlag(0x1000B) != 0) { + BoardTutorialHookExec(0x17, 0); + } + FinishItemUse(temp_r23, var_r25); + } + if (itemUsed != 0xB && itemUsed != 0xC) { + SetItemUIStatus(3); + } + while (itemPickObj) { + HuPrcVSleep(); + } + while (!BoardFilterFadePauseCheck()) { + HuPrcVSleep(); + } + HuPrcEnd(); +} + +static void FinishItemUse(s16 arg0, s32 arg1) { + s32 var_r30; + s32 var_r31; + s16 temp_r29; + + switch (itemUsed) { + case 12: + temp_r29 = BoardModelIDGet(BoardPlayerModelGet(itemPlayer)); + Hu3DModelShadowReset(temp_r29); + _ClearFlag(0x1001C); + _ClearFlag(0x1000E); + Hu3DShadowF = 0; + break; + case 10: + HuPrcSleep(2); + BoardBowserSuitMotionCreate(); + BoardRotateDiceNumbers(itemPlayer); + BoardModelLayerSet(BoardBowserSuitModelGet(), 0); + BoardModelLayerSet(BoardBowserSuitPlayerModelGet(), 0); + break; + case 7: + BoardPlayerSparkSet(itemPlayer); + break; + case 8: + for (var_r30 = var_r31 = 0; var_r31 < 3; var_r31++) { + if (GWPlayer[itemPlayer].items[var_r31] == 8) { + var_r30++; + } + } + if (var_r30 == arg1) { + itemUsed = -1; + } + break; + } +} + +static void DestroyItemUse(void) { + s32 i; + + CharModelLayerSetAll(1); + for (i = 0; i < 4; i++) { + GWPlayer[i].show_next = 1; + } + HuDataDirClose(0x40000); + HuDataDirClose(0x90000); + itemUseProc = NULL; +} + +void BoardMakeRandomItem(void) { + s32 temp_r3; + s32 i; + + for (i = 0; i < 3; i++) { + temp_r3 = BoardRandMod(0xE); + if (temp_r3 != 0xA && temp_r3 != 0xD) { + itemRandTbl[i] = temp_r3; + } + } + BoardItemBagItemSet(&itemRandTbl); +} + +static inline void TeamItemPosSetInlineFunc01(s32 arg0, s32 arg1, Vec *arg2) { + UnkUiWork03 *temp_r29 = OM_GET_WORK_PTR(itemPickObj, UnkUiWork03); + Vec (*temp_r31)[6] = (void*) temp_r29->unk04; + + temp_r31[arg0][arg1 + 2].x = arg2->x; + temp_r31[arg0][arg1 + 2].y = arg2->y; + temp_r31[arg0][arg1 + 2].z = arg2->z; +} + +static inline void TeamItemPosSetInlineFunc02(s32 arg0, s32 arg1, Vec *arg2) { + UnkUiWork03 *temp_r29 = OM_GET_WORK_PTR(itemPickObj, UnkUiWork03); + Vec (*temp_r31)[6] = (void*) temp_r29->unk04; + + (temp_r31 + 4)[arg0][arg1 + 2].x = arg2->x; + (temp_r31 + 4)[arg0][arg1 + 2].y = arg2->y; + (temp_r31 + 4)[arg0][arg1 + 2].z = arg2->z; +} + +static void TeamItemPosSet(s32 arg0, s32 arg1, Vec *arg2) { + TeamItemPosSetInlineFunc01(arg0, arg1, arg2); + TeamItemPosSetInlineFunc02(arg0, arg1, arg2); +} + +static inline void ExecItemPickInlineFunc01(Vec (*arg0)[6]) { + Vec sp1C; + Vec sp28; + Vec sp34; + s16 temp_r24; + s32 sp14; + s32 i; + s32 j; + + for (i = 0; i < 4; i++) { + for (j = 0; j < 3; j++) { + sp14 = GWPlayer[i].items[j]; + if (sp14 == -1) { + itemMdlId[i][j] = -1; + } else { + BoardCameraRotGet(&sp1C); + temp_r24 = BoardModelCreate(itemMdlTbl[sp14], 0, 0); + itemMdlId[i][j] = temp_r24; + sp28.x = arg0[i][j + 2].x; + sp28.y = arg0[i][j + 2].y; + sp28.z = 4000.0f; + Hu3D2Dto3D(&sp28, 1, &sp34); + BoardModelPosSetV(temp_r24, &sp34); + BoardModelLayerSet(temp_r24, 5); + BoardModelRotSet(temp_r24, sp1C.x, 0.0f, 0.0f); + BoardModelScaleSet(temp_r24, 1.0f, 1.0f, 1.0f); + BoardModelMotionStart(temp_r24, 0, 0x400000); + BoardModelMotionStartEndSet(temp_r24, 0, 0x27); + BoardModelMotionSpeedSet(temp_r24, 0.0f); + } + } + } +} + +static inline void ExecItemPickInlineFunc02(s32 arg0, s8 arg1, s32 arg2) { + UnkUiWork03 *sp10; + + BoardPickerCreate(arg0, arg1, itemPosTemp, arg2); + CreateItemWindow(arg0, arg1); + sp10 = OM_GET_WORK_PTR(pickerObj, UnkUiWork03); + pickerObj->func = UpdateItemPickGfx; + while (!CheckItemWindow()) { + HuPrcVSleep(); + } + if (_CheckFlag(0x1000B)) { + BoardTutorialHostHide(1); + } +} + +static void ExecItemPick(void) { + Vec sp40; + s32 sp18; + s32 var_r22; + s32 var_r23; + s32 i; + s32 j; + UnkUiWork03 *temp_r27; + Vec (*temp_r28)[6]; + + if (_CheckFlag(0x1000B)) { + BoardTutorialHostHide(0); + } + itemPickObj = omAddObjEx(boardObjMan, 0x7E03, 0, 0, -1, &UpdateItemPick); + temp_r27 = OM_GET_WORK_PTR(itemPickObj, UnkUiWork03); + temp_r27->unk04 = HuMemDirectMallocNum(HEAP_SYSTEM, 0x240, MEMORY_DEFAULT_NUM); + temp_r27->unk00_bit0 = 0; + temp_r27->unk01 = 0; + temp_r27->unk02 = 0; + temp_r27->unk03 = 0; + temp_r27->unk00_bit1 = 0; + BoardStatusItemHideSet(0, 0); + BoardStatusItemHideSet(1, 0); + BoardStatusItemHideSet(2, 0); + BoardStatusItemHideSet(3, 0); + temp_r28 = (void*) temp_r27->unk04; + for (var_r22 = i = 0; i < 4; i++) { + if (itemTeamF != 0) { + if (itemTeam == GWPlayerTeamGet(i)) { + if (itemPlayer == i) { + var_r22 = 0; + } else { + var_r22 = 1; + } + sp40.x = teamItemStatusPosTbl[var_r22].x; + sp40.y = teamItemStatusPosTbl[var_r22].y; + } else { + sp40.x = statusPosTbl[i][0] + statusHideOfsTbl[i]; + sp40.y = statusPosTbl[i][1]; + } + } else { + sp40.x = statusPosTbl[i][0]; + sp40.y = statusPosTbl[i][1]; + } + for (j = 0; j < 6; j++) { + temp_r28[i][j].x = statusSprPosTbl[j + 0xB][0]; + temp_r28[i][j].y = statusSprPosTbl[j + 0xB][1]; + (temp_r28 + 4)[i][j].x = statusItemPosTbl[j][0]; + (temp_r28 + 4)[i][j].y = statusItemPosTbl[j][1]; + if (j >= 2 && j <= 4) { + temp_r28[i][j].x += sp40.x; + temp_r28[i][j].y += sp40.y; + (temp_r28 + 4)[i][j].x += sp40.x; + (temp_r28 + 4)[i][j].y += sp40.y; + } + (temp_r28 + 4)[i][j].z = temp_r28[i][j].z = 0.0f; + } + } + ExecItemPickInlineFunc01((void*) temp_r27->unk04); + memset(itemPosTemp, 0, 0x48); + var_r23 = BoardPlayerItemCount(itemPlayer); + ItemGetPos(itemPlayer, &itemPosTemp[0]); + if (GWTeamGet()) { + ItemGetPos(teamItemPlayer, &itemPosTemp[var_r23]); + var_r23 += BoardPlayerItemCount(teamItemPlayer); + } + for (j = 0; j < var_r23; j++) { + itemPosTemp[j].x -= 8.0f; + itemPosTemp[j].y += 16.0f; + } + sp18 = BoardComTutorialItemGet(itemPlayer); + ExecItemPickInlineFunc02(itemPlayer, var_r23, sp18); +} + +static void UpdateItemPick(omObjData *arg0) { + UnkUiWork03 *temp_r28 = OM_GET_WORK_PTR(arg0, UnkUiWork03); + UnkUiStatusStruct *temp_r26; + Vec (*temp_r27)[6]; + Vec sp14; + Vec sp8; + float temp_f30; + s32 i; + s32 j; + + if (temp_r28->unk00_bit0 || BoardIsKill()) { + for (i = 0; i < 4; i++) { + for (j = 0; j < 3; j++) { + if (itemMdlId[i][j] != -1) { + BoardModelKill(itemMdlId[i][j]); + itemMdlId[i][j] = -1; + } + } + } + BoardStatusItemHideSet(0, 1); + BoardStatusItemHideSet(1, 1); + BoardStatusItemHideSet(2, 1); + BoardStatusItemHideSet(3, 1); + HuMemDirectFree(temp_r28->unk04); + itemPickObj = NULL; + omDelObjEx(HuPrcCurrentGet(), arg0); + } else { + if (temp_r28->unk02 != 0) { + temp_r28->unk02--; + } else { + switch (temp_r28->unk01) { + case 3: + temp_r28->unk00_bit1 = 1; + /* fallthrough */ + case 0: + temp_r28->unk01 = 1; + break; + case 1: + break; + default: + return; + } + } + MakeItemPickSpace(temp_r28); + temp_r27 = (void*) temp_r28->unk04; + for (i = 0; i < 4; i++) { + temp_r26 = &uiStatus[i]; + for (j = 0; j < 6; j++) { + if (j != 5 || temp_r26->unk00_bit6) { + HuSprPosSet(temp_r26->unk02, j + 0xB, temp_r27[i][j].x, temp_r27[i][j].y); + } + } + for (j = 0; j < 3; j++) { + if (itemMdlId[i][j] != -1) { + OSs8tof32(&temp_r28->unk03, &temp_f30); + temp_f30 = 1.0 + 0.5 * sin(M_PI * temp_f30 / 180.0); + BoardModelScaleSet(itemMdlId[i][j], temp_f30, temp_f30, temp_f30); + sp14.x = temp_r27[i][j + 2].x; + sp14.y = temp_r27[i][j + 2].y; + sp14.z = 4000.0f; + Hu3D2Dto3D(&sp14, 1, &sp8); + BoardModelPosSetV(itemMdlId[i][j], &sp8); + } + } + } + } +} + +static void MakeItemPickSpace(UnkUiWork03 *arg0) { + Vec sp8; + float var_f29; + s32 i; + s32 j; + Vec (*temp_r28)[6]; + + temp_r28 = (void*) arg0->unk04; + if (!arg0->unk00_bit1) { + if (arg0->unk03 < 90) { + if (arg0->unk03 == 0) { + for (j = 0; j < 4; j++) { + BoardStatusGraySet(j, 0); + } + } + arg0->unk03 += 6; + if (arg0->unk03 > 90) { + arg0->unk03 = 90; + } + } + } else { + if (arg0->unk03 > 0) { + arg0->unk03 -= 6; + if (arg0->unk03 < 0) { + arg0->unk03 = 0; + } + if (arg0->unk03 == 0) { + for (j = 0; j < 4; j++) { + BoardStatusGraySet(j, 1); + } + } + } + } + for (i = 0; i < 4; i++) { + for (j = 0; j < 6; j++) { + PSVECSubtract(&(temp_r28 + 4)[i][j], &temp_r28[i][j], &sp8); + if (ABS(sp8.x) < 1.0f && ABS(sp8.y) < 1.0f) { + sp8 = (temp_r28 + 4)[i][j]; + if (arg0->unk00_bit1 && arg0->unk03 == 0) { + arg0->unk00_bit0 = 1; + } + } else { + var_f29 = 0.3f; + PSVECScale(&sp8, &sp8, var_f29); + PSVECAdd(&temp_r28[i][j], &sp8, &sp8); + } + temp_r28[i][j].x = sp8.x; + temp_r28[i][j].y = sp8.y; + } + } +} + +static void SetItemUIStatus(s32 arg0) { + UnkUiWork03 *temp_r27 = OM_GET_WORK_PTR(itemPickObj, UnkUiWork03); + Vec (*temp_r28)[6] = (void*) temp_r27->unk04; + float var_f31; + float var_f30; + s32 i; + s32 j; + + switch (arg0) { + case 3: + case 0: + for (i = 0; i < 4; i++) { + var_f31 = statusPosTbl[i][0]; + var_f30 = statusPosTbl[i][1]; + for (j = 0; j < 6; j++) { + (temp_r28 + 4)[i][j].x = statusSprPosTbl[j + 0xB][0]; + (temp_r28 + 4)[i][j].y = statusSprPosTbl[j + 0xB][1]; + if (j + 0xB >= 0xD && j + 0xB <= 0xF) { + (temp_r28 + 4)[i][j].x += var_f31; + (temp_r28 + 4)[i][j].y += var_f30; + } + } + } + break; + case 2: + for (i = 0; i < 4; i++) { + var_f31 = statusPosTbl[i][0]; + var_f30 = statusPosTbl[i][1]; + for (j = 0; j < 6; j++) { + (temp_r28 + 4)[i][j].x = statusItemPosTbl[j][0]; + (temp_r28 + 4)[i][j].y = statusItemPosTbl[j][1]; + if ((j >= 2) && (j <= 4)) { + (temp_r28 + 4)[i][j].x += var_f31; + (temp_r28 + 4)[i][j].y += var_f30; + } + } + } + break; + default: + return; + } + temp_r27->unk01 = arg0; +} + +void BoardItemGetDestPos(s32 arg0, Vec *arg1) { + Vec spC; + s32 i; + + spC.x = statusPosTbl[arg0][0]; + spC.y = statusPosTbl[arg0][1]; + spC.z = 0.0f; + for (i = 0; i < 3; i++) { + PSVECAdd((Vec*) &statusItemPosTbl[i + 2], &spC, &arg1[i]); + } +} + +static void ItemGetPos(s32 arg0, Vec *arg1) { + Vec spC; + s32 var_r29; + s32 i; + + if (itemTeamF != 0) { + if (itemPlayer == arg0) { + var_r29 = 0; + } else { + var_r29 = 1; + } + spC.x = teamItemStatusPosTbl[var_r29].x; + spC.y = teamItemStatusPosTbl[var_r29].y; + } else { + spC.x = statusPosTbl[arg0][0]; + spC.y = statusPosTbl[arg0][1]; + } + spC.z = 0.0f; + for (i = 0; i < 3; i++) { + PSVECAdd((Vec*) statusItemPosTbl[i + 2], &spC, &arg1[i]); + } +} + +void BoardItemStatusKill(s32 arg0) { + Vec sp68[3]; + Vec sp44[3]; + Vec sp20[3]; + Vec sp14; + Vec sp8; + s16 temp_r28; + s16 temp_r25; + s16 i; + + if (itemPickObj) { + if (itemTeamF != 0) { + if (arg0 == itemPlayer) { + sp8.x = teamItemStatusPosTbl[0].x; + sp8.y = teamItemStatusPosTbl[0].y; + } else { + sp8.x = teamItemStatusPosTbl[1].x; + sp8.y = teamItemStatusPosTbl[1].y; + } + } else { + sp8.x = statusPosTbl[arg0][0]; + sp8.y = statusPosTbl[arg0][1]; + } + sp8.z = 0.0f; + for (i = 0; i < 3; i++) { + PSVECAdd((Vec*) statusItemPosTbl[i + 2], &sp8, &sp68[i]); + if (itemMdlId[arg0][i] != -1) { + BoardModelRotGet(itemMdlId[arg0][i], &sp44[i]); + BoardModelScaleGet(itemMdlId[arg0][i], &sp20[i]); + BoardModelKill(itemMdlId[arg0][i]); + itemMdlId[arg0][i] = -1; + } + } + for (i = 0; i < 3; i++) { + temp_r25 = GWPlayer[arg0].items[i]; + if (temp_r25 != -1) { + temp_r28 = BoardModelCreate(itemMdlTbl[temp_r25], 0, 0); + itemMdlId[arg0][i] = temp_r28; + BoardCameraRotGet(&sp14); + BoardModelPosSetV(temp_r28, &sp68[i]); + BoardModelRotSet(temp_r28, sp14.x, 0.0f, 0.0f); + BoardModelScaleSetV(temp_r28, &sp20[i]); + BoardModelLayerSet(temp_r28, 6); + BoardModelMotionStart(temp_r28, 0, 0x400000); + BoardModelMotionSpeedSet(temp_r28, 0.0f); + TeamItemPosSet(arg0, i, &sp68[i]); + } + } + } +} + +static void UpdateItemPickGfx(omObjData *arg0) { + UnkUiWork01 *temp_r30 = OM_GET_WORK_PTR(arg0, UnkUiWork01); + + if (temp_r30->unk00_bit0 || BoardIsKill()) { + HuWinKill(temp_r30->unk06); + HuSprGrpKill(temp_r30->unk04); + pickerObj = NULL; + omDelObjEx(HuPrcCurrentGet(), arg0); + } else { + if (temp_r30->unk03 != 0) { + temp_r30->unk03--; + } else { + if (!CheckItemWindowSlide()) { + temp_r30->unk00_bit6 = 1; + } + UpdatePickerInput(temp_r30, arg0); + } + MovePicker(temp_r30, arg0); + SetItemWindowCurr(temp_r30->unk02); + if (pickerChoice != -1 || temp_r30->unk00_bit7) { + KillItemWindow(); + if (!temp_r30->unk00_bit7) { + temp_r30->unk00_bit3 = 1; + HuSprBankSet(temp_r30->unk04, 0, 1); + HuSprAttrSet(temp_r30->unk04, 0, 2); + HuSprAttrReset(temp_r30->unk04, 0, 1); + arg0->func = UpdateItemPickup; + HuWinDispOff(temp_r30->unk06); + } else { + itemUsed = -1; + } + } + HuSprPosSet(temp_r30->unk04, 0, arg0->trans.x, arg0->trans.y); + } +} + +static void UpdateItemPickup(omObjData *arg0) { + UnkUiWork01 *temp_r31 = OM_GET_WORK_PTR(arg0, UnkUiWork01); + Vec sp50; + Vec sp44; + Vec sp38; + Vec sp2C; + Vec sp20; + Vec sp14; + Vec sp8; + s16 var_r29; + s16 var_r28; + s16 var_r27; + s16 var_r25; + s16 var_r26; + + if (temp_r31->unk00_bit0 || BoardIsKill()) { + HuWinKill(temp_r31->unk06); + BoardModelKill(itemPickupMdlId); + itemPickupMdlId = -1; + HuSprGrpKill(temp_r31->unk04); + pickerObj = NULL; + omDelObjEx(HuPrcCurrentGet(), arg0); + } else if (temp_r31->unk03 != 0) { + temp_r31->unk03--; + } else if (pickerChoice == -1) { + temp_r31->unk00_bit0 = 1; + } else { + var_r29 = temp_r31->unk00_bit5; + var_r28 = pickerChoice; + if (GWTeamGet() && pickerChoice >= BoardPlayerItemCount(temp_r31->unk00_bit5)) { + var_r29 = teamItemPlayer; + var_r28 -= BoardPlayerItemCount(temp_r31->unk00_bit5); + } + switch (temp_r31->unk00_bit3) { + case 1: + BoardModelVisibilitySet(itemMdlId[var_r29][var_r28], 0); + BoardModelPosGet(itemMdlId[var_r29][var_r28], &sp50); + BoardModelRotGet(itemMdlId[var_r29][var_r28], &sp38); + BoardModelScaleGet(itemMdlId[var_r29][var_r28], &sp44); + itemUsed = GWPlayer[var_r29].items[var_r28]; + boardItemUser = var_r29; + itemPickupMdlId = BoardModelCreate(itemMdlTbl[itemUsed], NULL, 0); + BoardModelPosSetV(itemPickupMdlId, &sp50); + BoardModelRotSetV(itemPickupMdlId, &sp38); + BoardModelScaleSetV(itemPickupMdlId, &sp44); + BoardModelLayerSet(itemPickupMdlId, 6); + BoardModelMotionStart(itemPickupMdlId, 0, 0x400000); + BoardModelMotionSpeedSet(itemPickupMdlId, 0.0f); + temp_r31->unk00_bit3 = 2; + break; + case 2: + var_r27 = 0x27; + var_r25 = var_r27 + 0x27; + BoardModelMotionStart(itemPickupMdlId, 0, 0); + BoardModelMotionTimeSet(itemPickupMdlId, var_r27); + BoardModelMotionStartEndSet(itemPickupMdlId, var_r27, var_r25); + HuSprBankSet(temp_r31->unk04, 0, 1); + HuSprAttrSet(temp_r31->unk04, 0, 2); + HuSprSpeedSet(temp_r31->unk04, 0, 1.0f); + itemPickupPos = 1.0f; + temp_r31->unk00_bit3 = 3; + HuAudFXPlay(0x30E); + break; + case 3: + var_r26 = 0x27; + if (BoardModelMotionTimeGet(itemPickupMdlId) < var_r26 + 0x17) { + arg0->trans.x -= itemPickupPos; + arg0->trans.y += itemPickupPos; + itemPickupPos *= 0.98f; + } else { + sp50.x = arg0->trans.x; + sp50.y = arg0->trans.y; + sp50.z = 3200.0f; + Hu3D2Dto3D(&sp50, 1, &sp50); + BoardModelPosSetV(itemPickupMdlId, &sp50); + itemPickupPos = 4.0f; + temp_r31->unk00_bit3 = 4; + HuAudFXPlay(0x30F); + } + break; + case 4: + var_r26 = 0x4E; + if (BoardModelMotionTimeGet(itemPickupMdlId) >= var_r26) { + temp_r31->unk03 = 0x12; + BoardPlayerItemRemove(var_r29, var_r28); + temp_r31->unk00_bit3 = 5; + } else { + arg0->trans.x -= itemPickupPos; + arg0->trans.y += itemPickupPos; + itemPickupPos *= 0.9f; + sp50.x = arg0->trans.x; + sp50.y = arg0->trans.y; + sp50.z = 3200.0f; + Hu3D2Dto3D(&sp50, 1, &sp50); + BoardModelPosSetV(itemPickupMdlId, &sp50); + } + break; + case 5: + BoardPlayerPosGet(temp_r31->unk00_bit5, &sp2C); + sp2C.y += 300.0f; + sp8 = sp2C; + Hu3D3Dto2D(&sp2C, 1, &sp2C); + sp20.x = arg0->trans.x; + sp20.y = arg0->trans.y; + PSVECSubtract(&sp2C, &sp20, &sp14); + if (ABS(sp14.x) < 1.0f && ABS(sp14.y) < 1.0f) { + HuSprAttrSet(temp_r31->unk04, 0, 4); + temp_r31->unk00_bit3 = 6; + } else { + PSVECScale(&sp14, &sp14, 0.1f); + PSVECAdd(&sp20, &sp14, &sp50); + sp50.z = 3200.0f; + arg0->trans.x = sp50.x; + arg0->trans.y = sp50.y; + Hu3D2Dto3D(&sp50, 1, &sp50); + BoardModelPosSetV(itemPickupMdlId, &sp50); + } + break; + case 6: + break; + } + HuSprPosSet(temp_r31->unk04, 0, arg0->trans.x, arg0->trans.y); + } +} + +static BOOL CheckItemWindow(void) { + UnkUiWork01 *temp_r31; + + if (pickerObj == 0) { + return TRUE; + } + temp_r31 = OM_GET_WORK_PTR(pickerObj, UnkUiWork01); + if (temp_r31->unk00_bit3 == 6) { + return TRUE; + } else { + return FALSE; + } +} + +static void HideItemWindow(void) { + UnkUiWork01 *temp_r31; + + if (pickerObj) { + temp_r31 = OM_GET_WORK_PTR(pickerObj, UnkUiWork01); + temp_r31->unk00_bit0 = 1; + } +} + +static void CreateItemWindow(s32 arg0, s32 arg1) { + Vec sp10; + float sp8[2]; + float temp_f31; + float var_f30; + s32 var_r27; + s32 temp_r28; + s32 i; + omObjData *temp_r26; + UnkUiWork04 *temp_r29; + UnkUiWindowStruct *temp_r31; + + temp_f31 = 0.25f; + temp_r26 = omAddObjEx(boardObjMan, 0x107, 0, 0, -1, UpdateItemWindow); + itemWindowObj = temp_r26; + temp_r29 = OM_GET_WORK_PTR(temp_r26, UnkUiWork04); + temp_r29->unk00_bit0 = 0; + temp_r29->unk01 = 0; + temp_r29->unk03 = 0; + temp_r29->unk02 = arg1; + temp_r29->unk04 = HuMemDirectMallocNum(HEAP_SYSTEM, sizeof(UnkUiWindowStruct), MEMORY_DEFAULT_NUM); + temp_r26->trans.x = 0.0f; + if (GWTeamGet()) { + var_f30 = 32.0f; + } else { + var_f30 = 0.0f; + } + temp_r31 = temp_r29->unk04; + for (i = 0; i < arg1; i++) { + var_r27 = i; + if (GWTeamGet() && i >= BoardPlayerItemCount(itemPlayer)) { + arg0 = teamItemPlayer; + var_r27 -= BoardPlayerItemCount(itemPlayer); + } + temp_r28 = GWPlayer[arg0].items[var_r27]; + if (temp_r28 == -1) { + temp_r31->unk12[i] = temp_r31->unk1E[i] + = temp_r31->unk06[i] = temp_r31->unk00[i] = -1; + } else { + temp_r31->unk00[i] = temp_r28; + temp_r31->unk74[i].x = i * 576.0f + 36.0f; + temp_r31->unk74[i].y = var_f30 + 240.0f; + temp_r31->unk74[i].z = 0.0f; + temp_r31->unk2C[i] = temp_r31->unk74[i]; + temp_r31->unk12[i] = HuWinCreate(temp_r31->unk2C[i].x, temp_r31->unk2C[i].y, 0x1F8, 0x60, 0); + HuWinDrawNoSet(temp_r31->unk12[i], 0x40); + HuWinCenterPosSet(temp_r31->unk12[i], 0.0f, 48.0f); + HuWinMesSpeedSet(temp_r31->unk12[i], 0); + HuWinMesSet(temp_r31->unk12[i], BoardItemNameGet(temp_r28)); + HuWinMesMaxSizeGet(1, sp8, temp_r28 + 0x8000E); + temp_r31->unk1E[i] = HuWinCreate(temp_r31->unk2C[i].x, temp_r31->unk2C[i].y - (-94.0f), sp8[0], sp8[1], 0); + HuWinDrawNoSet(temp_r31->unk1E[i], 0x40); + HuWinMesSpeedSet(temp_r31->unk1E[i], 0); + HuWinMesSet(temp_r31->unk1E[i], temp_r28 + 0x8000E); + sp10.x = temp_r31->unk2C[i].x + 48.0f; + sp10.y = temp_r31->unk2C[i].y; + sp10.z = 400.0f; + Hu3D2Dto3D(&sp10, 1, &sp10); + temp_r31->unk06[i] = BoardModelCreate(BoardItemModelGet(temp_r28), NULL, 0); + BoardModelLayerSet(temp_r31->unk06[i], 6); + BoardModelPosSetV(temp_r31->unk06[i], &sp10); + BoardModelScaleSet(temp_r31->unk06[i], temp_f31, temp_f31, temp_f31); + if (temp_r28 == 4) { + BoardModelMotionStart(temp_r31->unk06[i], 0, 0x40000001); + BoardModelMotionSpeedSet(temp_r31->unk06[i], 0.033333335f); + } + } + } + for (; i < 6; i++) { + temp_r31->unk06[i] = -1; + temp_r31->unk12[i] = -1; + temp_r31->unk1E[i] = -1; + } +} + +static BOOL CheckItemWindowSlide(void) { + UnkUiWork04 *temp_r31; + + if (itemWindowObj == 0) { + return TRUE; + } + temp_r31 = OM_GET_WORK_PTR(itemWindowObj, UnkUiWork04); + return (temp_r31->unk03 != 0) ? FALSE : TRUE; +} + +static void KillItemWindow(void) { + UnkUiWork04 *temp_r31; + + if (itemWindowObj) { + temp_r31 = OM_GET_WORK_PTR(itemWindowObj, UnkUiWork04); + temp_r31->unk00_bit0 = 1; + } +} + +static void SetItemWindowCurr(s32 arg0) { + UnkUiWork04 *temp_r31; + UnkUiWindowStruct *temp_r30; + + if (itemWindowObj) { + temp_r31 = OM_GET_WORK_PTR(itemWindowObj, UnkUiWork04); + if (temp_r31->unk02 > 1 && arg0 != temp_r31->unk01) { + temp_r30 = temp_r31->unk04; + temp_r30->unk74[temp_r31->unk01].x = -576.0f; + temp_r30->unk74[arg0].x = temp_r30->unk2C[temp_r31->unk01].x; + temp_r30->unk2C[arg0].x = 576.0f; + temp_r31->unk01 = arg0; + } + } +} + +static void UpdateItemWindow(omObjData *arg0) { + Vec sp20; + Vec sp14; + Vec sp8; + UnkUiWork04 *temp_r29; + UnkUiWindowStruct *temp_r31; + s32 var_r27; + s32 i; + Mtx sp5C; + Mtx sp2C; + + temp_r29 = OM_GET_WORK_PTR(arg0, UnkUiWork04); + temp_r31 = temp_r29->unk04; + if (temp_r29->unk00_bit0 || (BoardIsKill() != 0)) { + for (i = 0; i < temp_r29->unk02; i++) { + if (temp_r31->unk12[i] != -1) { + HuWinKill(temp_r31->unk12[i]); + } + if (temp_r31->unk1E[i] != -1) { + HuWinKill(temp_r31->unk1E[i]); + } + if (temp_r31->unk06[i] != -1) { + BoardModelKill(temp_r31->unk06[i]); + } + } + HuMemDirectFree(temp_r29->unk04); + itemWindowObj = NULL; + omDelObjEx(HuPrcCurrentGet(), arg0); + } else { + var_r27 = 0; + for (i = 0; i < temp_r29->unk02; i++) { + if ((temp_r31->unk06[i] != -1) && (temp_r31->unk12[i] != -1)) { + PSVECSubtract(&temp_r31->unk74[i], &temp_r31->unk2C[i], &sp20); + if (PSVECMag(&sp20) <= 1.0f) { + temp_r31->unk2C[i] = temp_r31->unk74[i]; + } else { + PSVECScale(&sp20, &sp20, 0.3f); + PSVECAdd(&sp20, &temp_r31->unk2C[i], &temp_r31->unk2C[i]); + var_r27 = 1; + } + HuWinPosSet(temp_r31->unk12[i], temp_r31->unk2C[i].x, temp_r31->unk2C[i].y); + HuWinPosSet(temp_r31->unk1E[i], temp_r31->unk2C[i].x, temp_r31->unk2C[i].y + (-94.0f)); + sp14.x = temp_r31->unk2C[i].x + 48.0f; + sp14.y = temp_r31->unk2C[i].y; + sp14.z = 400.0f; + if (temp_r31->unk00[i] == 5) { + sp14.y += 35.0f; + } + Hu3D2Dto3D(&sp14, 1, &sp14); + BoardModelPosSetV(temp_r31->unk06[i], &sp14); + BoardCameraRotGet(&sp8); + PSMTXRotRad(sp2C, 'y', MTXDegToRad(arg0->trans.x)); + PSMTXRotRad(sp5C, 'x', MTXDegToRad(sp8.x + 10.0f)); + PSMTXConcat(sp5C, sp2C, sp2C); + BoardModelMtxSet(temp_r31->unk06[i], &sp2C); + BoardModelRotSet(temp_r31->unk06[i], 0.0f, 0.0f, 0.0f); + } + } + temp_r29->unk03 = var_r27; + arg0->trans.x = BoardDAngleCalc(arg0->trans.x + 2.0f); + } +} + +static void CreatePickerWindow(UnkUiWork01 *arg0, s32 arg1) { + float spC[2]; + float var_f31; + float var_f30; + float var_f29; + s32 var_r30; + + switch (GWGameStat.language) { + case 1: + var_f31 = 0.0f; + break; + case 0: + var_f31 = 0.0f; + break; + } + if (arg1 != 0) { + var_r30 = 0x10001A; + } else { + var_r30 = 0x10001B; + } + HuWinMesMaxSizeGet(1, spC, var_r30); + var_f30 = -10000.0f; + var_f29 = var_f31 + 352.0f; + arg0->unk06 = HuWinCreate(var_f30, var_f29, spC[0], spC[1], 0); + HuWinBGTPLvlSet(arg0->unk06, 0.0f); + HuWinMesSpeedSet(arg0->unk06, 0); + HuWinMesSet(arg0->unk06, var_r30); + if (_CheckFlag(0x1000B)) { + HuWinDispOff(arg0->unk06); + } +} + +static void KillPickerWindow(UnkUiWork01 *arg0) { + if (arg0->unk06 != -1) { + HuWinKill(arg0->unk06); + arg0->unk06 = -1; + } +} From c08453c49d014163a96eec42b03cf0bdfff9375d Mon Sep 17 00:00:00 2001 From: gamemasterplc Date: Tue, 23 Jan 2024 23:21:49 -0600 Subject: [PATCH 3/6] Rename some symbols in minigame_seq.c --- config/GMPE01_00/symbols.txt | 102 +++++++++++++++++------------------ include/unsplit.h | 2 +- src/REL/w03Dll/mg_item.c | 10 ++-- src/game/objmain.c | 2 +- 4 files changed, 57 insertions(+), 59 deletions(-) diff --git a/config/GMPE01_00/symbols.txt b/config/GMPE01_00/symbols.txt index 18cebb77..0520abba 100644 --- a/config/GMPE01_00/symbols.txt +++ b/config/GMPE01_00/symbols.txt @@ -658,18 +658,18 @@ MGSeqInit = .text:0x800353AC; // type:function size:0xBC MGSeqMain = .text:0x80035468; // type:function size:0x188 CreateSeq = .text:0x800355F0; // type:function size:0x1A4 scope:local MGSeqCreate = .text:0x80035794; // type:function size:0x100 -MGSeqGetStat = .text:0x80035894; // type:function size:0x88 -MGSeqSetPos = .text:0x8003591C; // type:function size:0x4C -MGSeqSetParam = .text:0x80035968; // type:function size:0x4C +MGSeqStatGet = .text:0x80035894; // type:function size:0x88 +MGSeqPosSet = .text:0x8003591C; // type:function size:0x4C +MGSeqParamSet = .text:0x80035968; // type:function size:0x4C MGSeqKill = .text:0x800359B4; // type:function size:0x58 MGSeqKillAll = .text:0x80035A0C; // type:function size:0x3C -MGSeqIsDone = .text:0x80035A48; // type:function size:0xA4 +MGSeqDoneCheck = .text:0x80035A48; // type:function size:0xA4 MGSeqStub = .text:0x80035AEC; // type:function size:0x4 MGSeqSprKill = .text:0x80035AF0; // type:function size:0x8C SeqInitTimer = .text:0x80035B7C; // type:function size:0x2E0 scope:local SeqUpdateTimer = .text:0x80035E5C; // type:function size:0x69C scope:local -fn_800364F8 = .text:0x800364F8; // type:function size:0x3D8 -fn_800368D0 = .text:0x800368D0; // type:function size:0x2F8 +SeqInitType2 = .text:0x800364F8; // type:function size:0x3D8 scope:local +SeqUpdateType2 = .text:0x800368D0; // type:function size:0x2F8 scope:local fn_80036BC8 = .text:0x80036BC8; // type:function size:0x188 SeqMakeWord = .text:0x80036D50; // type:function size:0x1D0 scope:local SeqLoadFontChar = .text:0x80036F20; // type:function size:0x26C scope:local @@ -680,21 +680,21 @@ SeqUpdateMGBattle = .text:0x80037F94; // type:function size:0xDA4 scope:local SeqUpdateMG1vs3 = .text:0x80038D38; // type:function size:0xDA4 scope:local SeqUpdateMGStory = .text:0x80039ADC; // type:function size:0xBB8 scope:local SeqUpdateMG2vs2 = .text:0x8003A694; // type:function size:0xAB4 scope:local -fn_8003B148 = .text:0x8003B148; // type:function size:0x3C4 -fn_8003B50C = .text:0x8003B50C; // type:function size:0x91C +SeqInitFlip = .text:0x8003B148; // type:function size:0x3C4 scope:local +SeqUpdateFlip = .text:0x8003B50C; // type:function size:0x91C scope:local SeqUpdateMGBowser = .text:0x8003BE28; // type:function size:0xC84 scope:local -fn_8003CAAC = .text:0x8003CAAC; // type:function size:0xDC -fn_8003CB88 = .text:0x8003CB88; // type:function size:0x3DC +SeqInitDraw = .text:0x8003CAAC; // type:function size:0xDC scope:local +SeqUpdateDraw = .text:0x8003CB88; // type:function size:0x3DC scope:local SeqInitWin = .text:0x8003CF64; // type:function size:0x8A0 scope:local SeqUpdateWin = .text:0x8003D804; // type:function size:0x72C scope:local SeqInitRecord = .text:0x8003DF30; // type:function size:0x774 scope:local SeqUpdateRecord = .text:0x8003E6A4; // type:function size:0x304 scope:local -MGSeqPauseStart = .text:0x8003E9A8; // type:function size:0x6C -SeqPauseProcFunc = .text:0x8003EA14; // type:function size:0x94C scope:local -MGSeqPauseStop = .text:0x8003F360; // type:function size:0xC +MGSeqPauseInit = .text:0x8003E9A8; // type:function size:0x6C +PauseProc = .text:0x8003EA14; // type:function size:0x94C scope:local +MGSeqPauseKill = .text:0x8003F360; // type:function size:0xC MGSeqPauseEnableCtrl = .text:0x8003F36C; // type:function size:0x40 -MGSeqPracticeStart = .text:0x8003F3AC; // type:function size:0xDC -SeqPracticeProcFunc = .text:0x8003F488; // type:function size:0x234 scope:local +MGSeqPracticeInit = .text:0x8003F3AC; // type:function size:0xDC +PracticeProc = .text:0x8003F488; // type:function size:0x234 scope:local SeqSEPlay = .text:0x8003F6BC; // type:function size:0xD4 scope:local MGSeqPracticeExitCheck = .text:0x8003F790; // type:function size:0x128 espInit = .text:0x8003F8B8; // type:function size:0xA0 @@ -4932,28 +4932,28 @@ lbl_8012F020 = .data:0x8012F020; // type:object size:0x94 lbl_8012F0B4 = .data:0x8012F0B4; // type:object size:0x11 data:string lbl_8012F0C5 = .data:0x8012F0C5; // type:object size:0x3A lbl_8012F0FF = .data:0x8012F0FF; // type:object size:0x31 -SeqTable = .data:0x8012F130; // type:object size:0x1DC scope:local -lbl_8012F30C = .data:0x8012F30C; // type:object size:0x18 -SeqTypeTable = .data:0x8012F324; // type:object size:0x12 scope:local +seqInfo = .data:0x8012F130; // type:object size:0x1DC scope:local +seqType2SprTbl = .data:0x8012F30C; // type:object size:0x18 scope:local +seqTypeTbl = .data:0x8012F324; // type:object size:0x12 scope:local lbl_8012F336 = .data:0x8012F336; // type:object size:0x53 scope:local data:string lbl_8012F389 = .data:0x8012F389; // type:object size:0x9 scope:local data:string lbl_8012F392 = .data:0x8012F392; // type:object size:0x9 scope:local data:string -SeqFontAlphaTbl = .data:0x8012F39B; // type:object size:0x35 scope:local data:string -SeqFontKanaTbl = .data:0x8012F3D0; // type:object size:0x52 scope:local data:string -SeqFontNumTbl = .data:0x8012F422; // type:object size:0xB scope:local data:string +seqFontAlphaTbl = .data:0x8012F39B; // type:object size:0x35 scope:local data:string +seqFontKanaTbl = .data:0x8012F3D0; // type:object size:0x52 scope:local data:string +seqFontNumTbl = .data:0x8012F422; // type:object size:0xB scope:local data:string lbl_8012F430 = .data:0x8012F430; // type:object size:0x14 -WordTbl = .data:0x8012F444; // type:object size:0x18 scope:local -LetterBattleOfs = .data:0x8012F45C; // type:object size:0x40 scope:local -Letter2vs2Ofs = .data:0x8012F49C; // type:object size:0x1C scope:local -LetterBowserOfs = .data:0x8012F4B8; // type:object size:0x38 scope:local -lbl_8012F4F0 = .data:0x8012F4F0; // type:object size:0xC -CharNameTbl = .data:0x8012F4FC; // type:object size:0x78 scope:local -lbl_8012F574 = .data:0x8012F574; // type:object size:0xC -WinStrTbl = .data:0x8012F580; // type:object size:0x18 scope:local -WinPosOfs = .data:0x8012F598; // type:object size:0x50 scope:local -PracticeTbl = .data:0x8012F5E8; // type:object size:0xAC scope:local -PracticePosTbl = .data:0x8012F694; // type:object size:0xC scope:local -SeqFXTable = .data:0x8012F6A0; // type:object size:0xF0 scope:local +wordTbl = .data:0x8012F444; // type:object size:0x18 scope:local +letterBattleOfs = .data:0x8012F45C; // type:object size:0x40 scope:local +letter2vs2Ofs = .data:0x8012F49C; // type:object size:0x1C scope:local +letterBowserOfs = .data:0x8012F4B8; // type:object size:0x38 scope:local +lbl_8012F4F0 = .data:0x8012F4F0; // type:object size:0xA data:string +charNameTbl = .data:0x8012F4FC; // type:object size:0x78 scope:local +lbl_8012F574 = .data:0x8012F574; // type:object size:0xA data:string +winStrTbl = .data:0x8012F580; // type:object size:0x18 scope:local +winPosOfs = .data:0x8012F598; // type:object size:0x50 scope:local +practiceTbl = .data:0x8012F5E8; // type:object size:0xAC scope:local +practiceData = .data:0x8012F694; // type:object size:0xC scope:local +seqFXTbl = .data:0x8012F6A0; // type:object size:0xF0 scope:local lbl_8012F790 = .data:0x8012F790; // type:object size:0x15 data:string lbl_8012F7A5 = .data:0x8012F7A5; // type:object size:0x10 data:string lbl_8012F7B5 = .data:0x8012F7B5; // type:object size:0x13 data:string @@ -5521,8 +5521,8 @@ CZoomM = .bss:0x801901A0; // type:object size:0x40 omDLLinfoTbl = .bss:0x801901E0; // type:object size:0x50 sndFXBuf = .bss:0x80190230; // type:object size:0x200 scope:local charVoiceGroupStat = .bss:0x80190430; // type:object size:0x20 scope:local -SeqData = .bss:0x80190450; // type:object size:0x400 scope:local data:4byte -SeqDuration = .bss:0x80190850; // type:object size:0x10 scope:local data:2byte +seqStat = .bss:0x80190450; // type:object size:0x400 scope:local data:4byte +seqMaxTime = .bss:0x80190850; // type:object size:0x10 scope:local data:2byte esprite = .bss:0x80190860; // type:object size:0x600 data:2byte espanim = .bss:0x80190E60; // type:object size:0x1200 data:4byte lbl_80192060 = .bss:0x80192060; // type:object size:0x100 @@ -5782,9 +5782,9 @@ lbl_801D34A0 = .sdata:0x801D34A0; // type:object size:0x4 data:4byte lbl_801D34A4 = .sdata:0x801D34A4; // type:object size:0xC lbl_801D34B0 = .sdata:0x801D34B0; // type:object size:0x1 lbl_801D34B1 = .sdata:0x801D34B1; // type:object size:0x7 -MGSeqInitFlag = .sdata:0x801D34B8; // type:object size:0x4 data:4byte +mgSeqInitF = .sdata:0x801D34B8; // type:object size:0x4 data:4byte lbl_801D34BC = .sdata:0x801D34BC; // type:object size:0x7 data:string -lbl_801D34C3 = .sdata:0x801D34C3; // type:object size:0x1 data:byte +lbl_801D34C3 = .sdata:0x801D34C3; // type:object size:0x3 data:byte lbl_801D34C6 = .sdata:0x801D34C6; // type:object size:0x6 lbl_801D34CC = .sdata:0x801D34CC; // type:object size:0x8 lbl_801D34D4 = .sdata:0x801D34D4; // type:object size:0x6 @@ -5825,8 +5825,8 @@ lbl_801D3598 = .sdata:0x801D3598; // type:object size:0x6 lbl_801D359E = .sdata:0x801D359E; // type:object size:0x5 data:string lbl_801D35A3 = .sdata:0x801D35A3; // type:object size:0x7 lbl_801D35AA = .sdata:0x801D35AA; // type:object size:0x6 -lbl_801D35B0 = .sdata:0x801D35B0; // type:object size:0x8 -PauseStrTbl = .sdata:0x801D35B8; // type:object size:0x8 scope:local +lbl_801D35B0 = .sdata:0x801D35B0; // type:object size:0x6 data:string +pauseStrTbl = .sdata:0x801D35B8; // type:object size:0x8 scope:local lbl_801D35C0 = .sdata:0x801D35C0; // type:object size:0x8 lbl_801D35C8 = .sdata:0x801D35C8; // type:object size:0x8 lbl_801D35D0 = .sdata:0x801D35D0; // type:object size:0x8 @@ -6245,17 +6245,17 @@ nMesh = .sbss:0x801D3D64; // type:object size:0x4 scope:local data:4byte nObj = .sbss:0x801D3D68; // type:object size:0x4 scope:local data:4byte MtxTop = .sbss:0x801D3D6C; // type:object size:0x4 data:4byte Vertextop = .sbss:0x801D3D70; // type:object size:0x4 data:4byte -SeqLanguage = .sbss:0x801D3D78; // type:object size:0x4 scope:local data:4byte -PauseProcess = .sbss:0x801D3D7C; // type:object size:0x4 scope:local data:4byte -PauseActive = .sbss:0x801D3D80; // type:object size:0x4 scope:local data:4byte -PauseExit = .sbss:0x801D3D84; // type:object size:0x4 scope:local data:4byte -PauseWait = .sbss:0x801D3D88; // type:object size:0x4 scope:local data:4byte -SeqRecordValue = .sbss:0x801D3D8C; // type:object size:0x4 scope:local data:4byte -PauseSeq = .sbss:0x801D3D90; // type:object size:0x2 scope:local data:2byte -SeqSpeed = .sbss:0x801D3D92; // type:object size:0x2 scope:local data:2byte +seqLanguage = .sbss:0x801D3D78; // type:object size:0x4 scope:local data:4byte +pauseProcess = .sbss:0x801D3D7C; // type:object size:0x4 scope:local data:4byte +pauseActiveF = .sbss:0x801D3D80; // type:object size:0x4 scope:local data:4byte +pauseExitF = .sbss:0x801D3D84; // type:object size:0x4 scope:local data:4byte +pauseWaitF = .sbss:0x801D3D88; // type:object size:0x4 scope:local data:4byte +seqRecordVal = .sbss:0x801D3D8C; // type:object size:0x4 scope:local data:4byte +seqPauseF = .sbss:0x801D3D90; // type:object size:0x2 scope:local data:2byte +seqSpeed = .sbss:0x801D3D92; // type:object size:0x2 scope:local data:2byte lbl_801D3D94 = .sbss:0x801D3D94; // type:object size:0x1 data:byte -SeqDone = .sbss:0x801D3D95; // type:object size:0x1 scope:local data:byte -SeqTimer = .sbss:0x801D3D96; // type:object size:0x2 scope:local data:2byte +seqDoneF = .sbss:0x801D3D95; // type:object size:0x1 scope:local data:byte +seqTimer = .sbss:0x801D3D96; // type:object size:0x2 scope:local data:2byte gid = .sbss:0x801D3D98; // type:object size:0x2 scope:local data:2byte lbl_801D3DA0 = .sbss:0x801D3DA0; // type:object size:0x8 wipeFadeInF = .sbss:0x801D3DA8; // type:object size:0x8 data:4byte @@ -7152,9 +7152,7 @@ lbl_801D4E44 = .sdata2:0x801D4E44; // type:object size:0x4 data:float lbl_801D4E48 = .sdata2:0x801D4E48; // type:object size:0x8 data:double lbl_801D4E50 = .sdata2:0x801D4E50; // type:object size:0x8 data:double lbl_801D4E58 = .sdata2:0x801D4E58; // type:object size:0x8 data:double -lbl_801D4E60 = .sdata2:0x801D4E60; // type:object size:0x2 data:2byte -lbl_801D4E62 = .sdata2:0x801D4E62; // type:object size:0x2 data:2byte -lbl_801D4E64 = .sdata2:0x801D4E64; // type:object size:0x2 data:2byte +lbl_801D4E60 = .sdata2:0x801D4E60; // type:object size:0x6 data:2byte lbl_801D4E68 = .sdata2:0x801D4E68; // type:object size:0x4 data:float lbl_801D4E6C = .sdata2:0x801D4E6C; // type:object size:0x4 data:float lbl_801D4E70 = .sdata2:0x801D4E70; // type:object size:0x4 data:float diff --git a/include/unsplit.h b/include/unsplit.h index b1f96683..7f4e6841 100644 --- a/include/unsplit.h +++ b/include/unsplit.h @@ -5,7 +5,7 @@ void MGSeqKillAll(void); -void MGSeqPracticeStart(void); +void MGSeqPracticeInit(void); void CharMotionClose(s16 character); void CharModelClose(s16 character); void CharModelKill(s16 character); diff --git a/src/REL/w03Dll/mg_item.c b/src/REL/w03Dll/mg_item.c index 9efb1210..7a32b5d2 100644 --- a/src/REL/w03Dll/mg_item.c +++ b/src/REL/w03Dll/mg_item.c @@ -66,7 +66,7 @@ s32 BoardModelMotionShiftSet(s16, s32, f32, f32, u32); s32 BoardVecDAngleCalcRange(float *value, float min, float range); void BoardCameraQuakeSet(s32 duration, float strength); s16 MGSeqCreate(s32, ...); -u8 MGSeqGetStat(s16); +u8 MGSeqStatGet(s16); void omVibrate(s16, s16, s16, s16); void BoardPlayerMotBlendSet(s32, s32, s32); f32 BoardPlayerRotYGet(s32); @@ -339,7 +339,7 @@ void fn_1_A44C(s32 arg0) { BoardMusStart(1, 0x17, 0x7F, 0); temp_r30 = MGSeqCreate(3, 0); - while (MGSeqGetStat(temp_r30) != 0) { + while (MGSeqStatGet(temp_r30) != 0) { HuPrcVSleep(); } fn_1_A7A0(arg0); @@ -448,7 +448,7 @@ void fn_1_A994(omObjData* arg0) { temp_r31 = (someBits*)&lbl_1_bss_188->work[0]; if ((temp_r31->unk00_bit0 != 0)|| (BoardIsKill() != 0)) { if (temp_r31->unk4 != -1) { - MGSeqSetParam(temp_r31->unk4, 2, -1U); + MGSeqParamSet(temp_r31->unk4, 2, -1U); temp_r31->unk4 = -1; } lbl_1_bss_188 = NULL; @@ -465,7 +465,7 @@ void fn_1_A994(omObjData* arg0) { } else { fn_1_ACD8(2); } - MGSeqSetParam(temp_r31->unk4, 1, temp_r31->unk1); + MGSeqParamSet(temp_r31->unk4, 1, temp_r31->unk1); temp_r31->unk2 = 0x3CU; } } @@ -544,7 +544,7 @@ void fn_1_ACD8(s32 arg0) { lbl_1_data_4D8 = -1; } if (temp_r31->unk4 != -1) { - MGSeqSetParam(temp_r31->unk4, 2, -1U); + MGSeqParamSet(temp_r31->unk4, 2, -1U); temp_r31->unk4 = -1; } BoardPlayerMotionShiftSet(temp_r31->unk00_bit4, 0xB, 0.0f, 10.0f, 0); diff --git a/src/game/objmain.c b/src/game/objmain.c index ce30d3d7..5712f4d5 100644 --- a/src/game/objmain.c +++ b/src/game/objmain.c @@ -85,7 +85,7 @@ static void omWatchOverlayProc(void) omovlstat = omnextovlstat; omnextovl = OVL_INVALID; if(_CheckFlag(FLAG_ID_MAKE(1, 12))) { - MGSeqPracticeStart(); + MGSeqPracticeInit(); } omSysPauseEnable(TRUE); omcurdll = omDLLStart(omcurovl, 0); From 4962ae7ee64a8594238d009588c093b3eb567d8d Mon Sep 17 00:00:00 2001 From: Rainchus Date: Wed, 24 Jan 2024 04:35:33 -0600 Subject: [PATCH 4/6] match w03Dll mg_coin.c --- config/GMPE01_00/rels/w03Dll/symbols.txt | 80 +-- configure.py | 2 +- src/REL/w03Dll/mg_coin.c | 733 +++++++++++++++++++++++ 3 files changed, 774 insertions(+), 41 deletions(-) create mode 100644 src/REL/w03Dll/mg_coin.c diff --git a/config/GMPE01_00/rels/w03Dll/symbols.txt b/config/GMPE01_00/rels/w03Dll/symbols.txt index 4efe98c4..460d60e3 100644 --- a/config/GMPE01_00/rels/w03Dll/symbols.txt +++ b/config/GMPE01_00/rels/w03Dll/symbols.txt @@ -252,44 +252,44 @@ lbl_1_rodata_298 = .rodata:0x00000298; // type:object size:0x8 scope:local data: lbl_1_rodata_2A0 = .rodata:0x000002A0; // type:object size:0x8 scope:local data:double lbl_1_rodata_2A8 = .rodata:0x000002A8; // type:object size:0x4 scope:local data:float lbl_1_rodata_2AC = .rodata:0x000002AC; // type:object size:0x4 scope:local data:float -lbl_1_rodata_2B0 = .rodata:0x000002B0; // type:object size:0x4 data:float -lbl_1_rodata_2B4 = .rodata:0x000002B4; // type:object size:0x4 data:float -lbl_1_rodata_2B8 = .rodata:0x000002B8; // type:object size:0x4 data:float -lbl_1_rodata_2BC = .rodata:0x000002BC; // type:object size:0x4 data:float -lbl_1_rodata_2C0 = .rodata:0x000002C0; // type:object size:0x4 data:float -lbl_1_rodata_2C4 = .rodata:0x000002C4; // type:object size:0x4 data:float -lbl_1_rodata_2C8 = .rodata:0x000002C8; // type:object size:0x8 data:double -lbl_1_rodata_2D0 = .rodata:0x000002D0; // type:object size:0x8 data:double -lbl_1_rodata_2D8 = .rodata:0x000002D8; // type:object size:0x4 data:float -lbl_1_rodata_2DC = .rodata:0x000002DC; // type:object size:0x4 data:float -lbl_1_rodata_2E0 = .rodata:0x000002E0; // type:object size:0x4 data:float -lbl_1_rodata_2E4 = .rodata:0x000002E4; // type:object size:0x4 data:float -lbl_1_rodata_2E8 = .rodata:0x000002E8; // type:object size:0x4 data:float -lbl_1_rodata_2EC = .rodata:0x000002EC; // type:object size:0x4 data:float -lbl_1_rodata_2F0 = .rodata:0x000002F0; // type:object size:0x4 data:float -lbl_1_rodata_2F4 = .rodata:0x000002F4; // type:object size:0x4 data:float -lbl_1_rodata_2F8 = .rodata:0x000002F8; // type:object size:0x4 data:float -lbl_1_rodata_2FC = .rodata:0x000002FC; // type:object size:0x4 data:float -lbl_1_rodata_300 = .rodata:0x00000300; // type:object size:0x4 data:float -lbl_1_rodata_304 = .rodata:0x00000304; // type:object size:0x4 data:float -lbl_1_rodata_308 = .rodata:0x00000308; // type:object size:0x4 data:float -lbl_1_rodata_30C = .rodata:0x0000030C; // type:object size:0x4 data:float -lbl_1_rodata_310 = .rodata:0x00000310; // type:object size:0x8 data:double -lbl_1_rodata_318 = .rodata:0x00000318; // type:object size:0x4 data:float -lbl_1_rodata_31C = .rodata:0x0000031C; // type:object size:0x4 data:float -lbl_1_rodata_320 = .rodata:0x00000320; // type:object size:0x4 data:float -lbl_1_rodata_328 = .rodata:0x00000328; // type:object size:0x8 data:double -lbl_1_rodata_330 = .rodata:0x00000330; // type:object size:0x4 data:float -lbl_1_rodata_334 = .rodata:0x00000334; // type:object size:0x4 data:float -lbl_1_rodata_338 = .rodata:0x00000338; // type:object size:0x4 data:float -lbl_1_rodata_33C = .rodata:0x0000033C; // type:object size:0x4 data:float -lbl_1_rodata_340 = .rodata:0x00000340; // type:object size:0x4 data:float -lbl_1_rodata_344 = .rodata:0x00000344; // type:object size:0x4 data:float -lbl_1_rodata_348 = .rodata:0x00000348; // type:object size:0x4 data:float -lbl_1_rodata_34C = .rodata:0x0000034C; // type:object size:0x4 data:float -lbl_1_rodata_350 = .rodata:0x00000350; // type:object size:0x8 data:double -lbl_1_rodata_358 = .rodata:0x00000358; // type:object size:0x4 data:float -lbl_1_rodata_35C = .rodata:0x0000035C; // type:object size:0x4 data:float +lbl_1_rodata_2B0 = .rodata:0x000002B0; // type:object size:0x4 scope:local data:float +lbl_1_rodata_2B4 = .rodata:0x000002B4; // type:object size:0x4 scope:local data:float +lbl_1_rodata_2B8 = .rodata:0x000002B8; // type:object size:0x4 scope:local data:float +lbl_1_rodata_2BC = .rodata:0x000002BC; // type:object size:0x4 scope:local data:float +lbl_1_rodata_2C0 = .rodata:0x000002C0; // type:object size:0x4 scope:local data:float +lbl_1_rodata_2C4 = .rodata:0x000002C4; // type:object size:0x4 scope:local data:float +lbl_1_rodata_2C8 = .rodata:0x000002C8; // type:object size:0x8 scope:local data:double +lbl_1_rodata_2D0 = .rodata:0x000002D0; // type:object size:0x8 scope:local data:double +lbl_1_rodata_2D8 = .rodata:0x000002D8; // type:object size:0x4 scope:local data:float +lbl_1_rodata_2DC = .rodata:0x000002DC; // type:object size:0x4 scope:local data:float +lbl_1_rodata_2E0 = .rodata:0x000002E0; // type:object size:0x4 scope:local data:float +lbl_1_rodata_2E4 = .rodata:0x000002E4; // type:object size:0x4 scope:local data:float +lbl_1_rodata_2E8 = .rodata:0x000002E8; // type:object size:0x4 scope:local data:float +lbl_1_rodata_2EC = .rodata:0x000002EC; // type:object size:0x4 scope:local data:float +lbl_1_rodata_2F0 = .rodata:0x000002F0; // type:object size:0x4 scope:local data:float +lbl_1_rodata_2F4 = .rodata:0x000002F4; // type:object size:0x4 scope:local data:float +lbl_1_rodata_2F8 = .rodata:0x000002F8; // type:object size:0x4 scope:local data:float +lbl_1_rodata_2FC = .rodata:0x000002FC; // type:object size:0x4 scope:local data:float +lbl_1_rodata_300 = .rodata:0x00000300; // type:object size:0x4 scope:local data:float +lbl_1_rodata_304 = .rodata:0x00000304; // type:object size:0x4 scope:local data:float +lbl_1_rodata_308 = .rodata:0x00000308; // type:object size:0x4 scope:local data:float +lbl_1_rodata_30C = .rodata:0x0000030C; // type:object size:0x4 scope:local data:float +lbl_1_rodata_310 = .rodata:0x00000310; // type:object size:0x8 scope:local data:double +lbl_1_rodata_318 = .rodata:0x00000318; // type:object size:0x4 scope:local data:float +lbl_1_rodata_31C = .rodata:0x0000031C; // type:object size:0x4 scope:local data:float +lbl_1_rodata_320 = .rodata:0x00000320; // type:object size:0x4 scope:local data:float +lbl_1_rodata_328 = .rodata:0x00000328; // type:object size:0x8 scope:local data:double +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:0x4 scope:local data:float +lbl_1_rodata_340 = .rodata:0x00000340; // type:object size:0x4 scope:local data:float +lbl_1_rodata_344 = .rodata:0x00000344; // type:object size:0x4 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:0x8 scope:local data:double +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 lbl_1_rodata_364 = .rodata:0x00000364; // type:object size:0x4 scope:local data:float lbl_1_rodata_368 = .rodata:0x00000368; // type:object size:0x4 scope:local data:float @@ -383,13 +383,13 @@ lbl_1_data_454 = .data:0x00000454; // type:object size:0x2 data:2byte lbl_1_data_456 = .data:0x00000456; // type:object size:0x2 data:2byte lbl_1_data_458 = .data:0x00000458; // type:object size:0x2 data:2byte lbl_1_data_45C = .data:0x0000045C; // type:object size:0xC -lbl_1_data_468 = .data:0x00000468; // type:object size:0x8 +lbl_1_data_468 = .data:0x00000468; // type:object size:0x8 scope:local lbl_1_data_470 = .data:0x00000470; // type:object size:0x20 lbl_1_data_490 = .data:0x00000490; // type:object size:0x20 lbl_1_data_4B0 = .data:0x000004B0; // type:object size:0x1 data:byte lbl_1_data_4B4 = .data:0x000004B4; // type:object size:0x14 lbl_1_data_4C8 = .data:0x000004C8; // type:object size:0x6 -lbl_1_data_4CE = .data:0x000004CE; // type:object size:0xA +lbl_1_data_4CE = .data:0x000004CE; // type:object size:0xA scope:local lbl_1_data_4D8 = .data:0x000004D8; // type:object size:0x2 data:2byte lbl_1_data_4DA = .data:0x000004DA; // type:object size:0x2 data:2byte lbl_1_data_4DC = .data:0x000004DC; // type:object size:0x2 data:2byte diff --git a/configure.py b/configure.py index 4efe8efe..7881fae4 100644 --- a/configure.py +++ b/configure.py @@ -996,7 +996,7 @@ config.libs = [ Object(NonMatching, "REL/w03Dll/condor.c"), Object(Matching, "REL/w03Dll/river.c"), Object(Matching, "REL/w03Dll/smoke.c"), - Object(NonMatching, "REL/w03Dll/mg_coin.c"), + Object(Matching, "REL/w03Dll/mg_coin.c"), Object(Matching, "REL/w03Dll/mg_item.c"), } ), diff --git a/src/REL/w03Dll/mg_coin.c b/src/REL/w03Dll/mg_coin.c new file mode 100644 index 00000000..d6e5d8ce --- /dev/null +++ b/src/REL/w03Dll/mg_coin.c @@ -0,0 +1,733 @@ +#include "dolphin.h" +#include "game/object.h" +#include "REL/w03Dll.h" +#include "board_unsplit.h" +#include "game/board/main.h" +#include "game/board/player.h" + +extern u16 HuPadBtnDown[4]; +extern s16 lbl_1_bss_C[14]; + +typedef struct someBits3 { //make sure this is defined correctly + /* 0x00 */ struct { + u8 unk00_bit0 : 1; + u8 unk00_bit1 : 4; + u8 unk00_bit5 : 2; + u8 unk00_bit7 : 1; + }; + u8 unk1; + u8 unk2; + u8 unk3; + s16 unk_04; + s16 unk_06[3]; + s32 unk_0C; +} someBits3; + +typedef struct unkTemp { + s8 unk0; + u8 unk1; + s16 unk_02; + f32 unk4; + Vec unk8; +} unkTemp; + +typedef struct unkTemp2 { + /* 0x00 */ struct { + u8 unk00_bit0 : 1; + }; + char unk_01[3]; + s8 unk4; + char unk_05[3]; + f32 unk8; + unkTemp* unk_0C; +} unkTemp2; + +//function signatures +void fn_1_7C98(void); +void fn_1_7C38(void); +s32 fn_1_7D18(s32 arg0); +void fn_1_8140(s32 arg0); +void fn_1_81E0(s32 arg0); +void fn_1_8530(omObjData* arg0); +void fn_1_84A8(s32 arg0); +void fn_1_8698(omObjData* arg0, someBits3* arg1); +void fn_1_8C08(omObjData* arg0, someBits3* arg1); +void fn_1_8E44(omObjData* arg0, someBits3* arg1); +void fn_1_9044(omObjData* arg0, someBits3* arg1); +void fn_1_91B8(void); +void fn_1_9230(s32 arg0); +void fn_1_9384(void); +void fn_1_9474(s32 arg0); +void fn_1_97F8(s32 arg0); +void fn_1_9A1C(unkTemp2* arg0); + +double sin(double x); +double cos(double x); +double atan2(double y, double x); +extern s16 MGSeqCreate(s32, ...); +u8 MGSeqGetStat(s16); +float BoardModelMotionTimeGet(s16 model); +float BoardModelMotionMaxTimeGet(s16 model); +s32 BoardModelMotionShiftSet(s16 model, s32 motion, float time, float shift_time, u32 attr); +void Hu3DModelObjPosGet(s16 arg0, char *arg1, Vec *arg2); + +//DATA +s32 lbl_1_data_450 = -1; +s16 lbl_1_data_454 = -1; +s16 lbl_1_data_456 = -1; +s16 lbl_1_data_458 = -1; +s32 lbl_1_data_45C[] = {0x00770021, 0x00770022, -1}; +char phei_str[] = "phei"; +s32 lbl_1_data_470[] = { + 0x005F0066, + 0x001A0066, + 0x006D0066, + 0x008A0066, + 0x00850066, + 0x00110066, + 0x000D0066, + 0x00810066 +}; + +s32 lbl_1_data_490[] = { + 0x005F0067, + 0x001A0067, + 0x006D0067, + 0x008A0067, + 0x00850067, + 0x00110067, + 0x000D0067, + 0x00810067 +}; + +s8 lbl_1_data_4B0 = -1; + +s32 lbl_1_data_4B4[] = { + 0x00000440, + 0x00000441, + 0x00000442, + 0x00000443, + 0x00000444 +}; + +s8 lbl_1_data_4C8[] = {1, 5, 10, 15, 20, 20}; + +//BSS +char lbl_1_bss_150[0x30]; +s16 lbl_1_bss_14E; +s8 lbl_1_bss_14C; +omObjData* lbl_1_bss_148; +omObjData* lbl_1_bss_144; +Process* lbl_1_bss_140; + + +void fn_1_7ABC(void) { + lbl_1_data_456 = BoardModelCreate(0x770020, lbl_1_data_45C, 0); + BoardModelHookSet(lbl_1_bss_C[7], phei_str, lbl_1_data_456); + BoardModelMotionStart(lbl_1_data_456, 2, 0x40000002); + BoardModelRotYSet(lbl_1_data_456, -45.0f); +} + +void fn_1_7B58(void) { + if (lbl_1_data_456 != -1) { + BoardModelKill(lbl_1_data_456); + lbl_1_data_456 = -1; + } +} + +void fn_1_7BA8(void) { + BoardDiceDigit2DShowSet(0); + lbl_1_bss_140 = HuPrcChildCreate(&fn_1_7C98, 0x2003, 0x2000, 0, boardMainProc); + HuPrcDestructorSet2(lbl_1_bss_140, &fn_1_7C38); + while (lbl_1_bss_140) { + HuPrcVSleep(); + } + BoardDiceDigit2DShowSet(1); +} + +void fn_1_7C38(void) { + if (lbl_1_data_454 != -1) { + HuWinKill(lbl_1_data_454); + lbl_1_data_454 = -1; + } + lbl_1_bss_140 = 0; +} + +void fn_1_7C98(void) { + s32 temp_r31; + + temp_r31 = GWSystem.player_curr; + lbl_1_bss_14C = 0; + lbl_1_bss_14E = 0; + if (fn_1_7D18(temp_r31) != 0) { + fn_1_8140(temp_r31); + fn_1_9474(temp_r31); + fn_1_9230(temp_r31); + } + HuPrcEnd(); +} + +s32 fn_1_7D18(s32 arg0) { + Point3d sp38; + Point3d sp2C; + Point3d sp20; + Vec sp14; + Vec sp8; + f32 var_f31; + s16 model; + s16 space; + s16 temp_r28; + f32 arctan; + + BoardWinCreateChoice(2, 0x160015, 2, 0); + if (GWPlayer[arg0].com != 0) { + BoardComKeySetLeft(); + } + BoardWinWait(); + BoardWinKill(); + if (BoardWinChoiceGet() != 0) { + BoardWinCreate(2, 0x160018, 2); + BoardWinWait(); + BoardWinKill(); + return 0; + } + BoardAudSeqPause(0, 1, 1000); + sp14.x = 0.0f; + sp14.y = 200.0f; + sp14.z = 0.0f; + sp8.x = -10.0f; + sp8.y = 0.0f; + sp8.z = 0.0f; + BoardCameraMotionStartEx(lbl_1_bss_C[7], &sp8, &sp14, 1500.0f, -1.0f, 0x15); + space = GWPlayer[arg0].space_curr; + temp_r28 = BoardSpaceLinkFlagSearch(0, space, 0x02000000); + BoardPlayerPosGet(arg0, &sp2C); + BoardSpacePosGet(0, temp_r28, &sp38); + PSVECSubtract(&sp38, &sp2C, &sp20); + PSVECNormalize(&sp20, &sp20); + BoardPlayerRotYSet(arg0, 180.0 * (atan2(-sp20.x, -sp20.z) / 3.141592653589793)); + HuPrcSleep(0x1E); + model = BoardModelIDGet(lbl_1_bss_C[7]); + Hu3DModelObjPosGet(model, phei_str, &sp38); + if (GWPlayer[arg0].character == 5) { + var_f31 = 54.000004f; + } else { + var_f31 = 39.0f; + } + sp38.x = sp38.x + (var_f31 * sin((3.141592653589793 * (180.0f + BoardModelRotYGet(lbl_1_data_456))) / 180.0)); + sp38.z = sp38.z + (var_f31 * cos((3.141592653589793 * (180.0f + BoardModelRotYGet(lbl_1_data_456))) / 180.0)); + BoardPlayerPosGet(arg0, &sp2C); + BoardPlayerPosLerpStart(arg0, &sp2C, &sp38, 0x14); + while (GWPlayer[arg0].moving != 0) { + BoardModelPosGet(lbl_1_bss_C[10], &sp2C); + BoardPlayerPosGet(arg0, &sp38); + PSVECSubtract(&sp38, &sp2C, &sp20); + arctan = atan2(sp20.x, sp20.z) / 3.141592653589793 * 180.0; + BoardModelRotYSet(lbl_1_bss_C[10], arctan); + HuPrcVSleep(); + } + BoardPlayerMotBlendSet(arg0, -0x2D, 7); + while (BoardPlayerMotBlendCheck(arg0) == 0) { + HuPrcVSleep(); + } + return 1; +} + +void fn_1_8140(s32 arg0) { + s16 temp_r31; + + fn_1_81E0(arg0); + BoardMusStart(1, 0x16, 0x7F, 0); + temp_r31 = MGSeqCreate(3, 0); + while (MGSeqGetStat(temp_r31)) { + HuPrcVSleep(); + } + fn_1_9384(); + fn_1_84A8(0); + while (lbl_1_bss_144) { + HuPrcVSleep(); + } + fn_1_91B8(); +} + +void fn_1_81E0(s32 arg0) { + Point3d sp8; + omObjData* temp_r3; + f32 temp_f31; + s32 temp_r28; + s32 temp_r5; + s32 temp_r5_2; + someBits3* temp_r31; + + temp_r3 = omAddObjEx(boardObjMan, 0x101, 0U, 0U, -1, fn_1_8530); + lbl_1_bss_144 = temp_r3; + temp_r31 = OM_GET_WORK_PTR(temp_r3, someBits3); + temp_r31->unk00_bit0 = 0; + temp_r31->unk00_bit5 = arg0; + temp_r31->unk00_bit1 = 4; //? + temp_r31->unk1 = 0; + temp_r31->unk2 = 5; + temp_r31->unk3 = 0x3C; + temp_r31->unk_0C = -1; + lbl_1_data_450 = -1; + temp_r3->trans.x = 0.0f; + temp_r3->trans.y = 0.0f; + temp_r28 = GWPlayer[arg0].character; + temp_r31->unk_06[1] = BoardPlayerMotionCreate(arg0, lbl_1_data_470[temp_r28]); + temp_r31->unk_06[2] = BoardPlayerMotionCreate(arg0, lbl_1_data_490[temp_r28]); + temp_f31 = 0.3f; + temp_r31->unk_06[0] = BoardModelCreate(0x770009, NULL, 0); + BoardModelVisibilitySet(temp_r31->unk_06[0], 0); + BoardPlayerPosGet(arg0, &sp8); + BoardModelPosSetV(temp_r31->unk_06[0], &sp8); + BoardModelScaleSet(temp_r31->unk_06[0], temp_f31, temp_f31, temp_f31); + BoardModelMotionStart(temp_r31->unk_06[0], 0, 0x40000001); + BoardModelMotionStart(lbl_1_data_456, 0, 0x40000001); + BoardModelMotionSpeedSet(lbl_1_data_456, temp_r3->trans.x); + BoardPlayerMotionStart(arg0, temp_r31->unk_06[1], 0x40000001); + BoardPlayerMotionSpeedSet(arg0, temp_r3->trans.x); + lbl_1_data_458 = BoardModelMotionCreate(lbl_1_bss_C[10], 0x770025); +} + +void fn_1_8434(someBits3* arg0) { + if (arg0->unk_06[1] != -1) { + BoardPlayerMotionKill(arg0->unk00_bit5, arg0->unk_06[1]); + } + if (arg0->unk_06[2] != -1) { + BoardPlayerMotionKill(arg0->unk00_bit5, arg0->unk_06[2]); + } + if (arg0->unk_06[0] != -1) { + BoardModelKill(arg0->unk_06[0]); + } +} + +void fn_1_84A8(s32 arg0) { + someBits3* temp_r31; + + if (lbl_1_bss_144) { + temp_r31 = OM_GET_WORK_PTR(lbl_1_bss_144, someBits3); + temp_r31->unk00_bit1 = arg0; + if (arg0 == 0) { + temp_r31->unk_04 = MGSeqCreate(1, temp_r31->unk2, 0x120, 0x40); + } + } +} + +void fn_1_8530(omObjData* arg0) { + s32 temp_r0; + someBits3* temp_r31; + + temp_r31 = OM_GET_WORK_PTR(arg0, someBits3); + + if ((temp_r31->unk00_bit0 != 0) || (BoardIsKill() != 0)) { + if (temp_r31->unk_04 != -1) { + MGSeqSetParam(temp_r31->unk_04, 2, -1); + } + if (temp_r31->unk_06[1] != -1) { + BoardPlayerMotionKill(temp_r31->unk00_bit5, temp_r31->unk_06[1]); + } + if (temp_r31->unk_06[2] != -1) { + BoardPlayerMotionKill(temp_r31->unk00_bit5, temp_r31->unk_06[2]); + } + if (temp_r31->unk_06[0] != -1) { + BoardModelKill(temp_r31->unk_06[0]); + } + lbl_1_bss_144 = NULL; + + omDelObjEx(HuPrcCurrentGet(), arg0); + return; + } + if (temp_r31->unk1 != 0) { + temp_r31->unk1--; + return; + } + switch (temp_r31->unk00_bit1) { + case 0: + fn_1_8698(arg0, temp_r31); + return; + case 1: + fn_1_8C08(arg0, temp_r31); + return; + case 2: + fn_1_8E44(arg0, temp_r31); + return; + case 3: + fn_1_9044(arg0, temp_r31); + /* fallthrough */ + case 4: + break; + } +} + +void fn_1_8698(omObjData* arg0, someBits3* arg1) { + s32 temp_r27; + u32 var_r28; + u32 var_r26; + f32 temp; + Vec sp8; + + if (arg1->unk3 != 0) { + arg1->unk3--; + } else { + if (arg1->unk2 != 0) { + arg1->unk2--; + } else { + MGSeqSetParam(arg1->unk_04, 2, -1); + arg1->unk_04 = -1; + arg1->unk00_bit1 = 1; + temp = BoardModelMotionTimeGet(lbl_1_bss_C[7]); + if (temp == 0.0f) { + temp = 1.0f; + } + if (lbl_1_bss_14E > 30) { + lbl_1_bss_14E = 30; + } + //temp2 = + OSu16tof32((u16*)&lbl_1_bss_14E, &arg0->rot.x); //?? + BoardModelAttrReset(lbl_1_data_456, 0x40000002); + BoardModelAttrReset(lbl_1_bss_C[7], 0x40000002); + BoardModelAttrReset(lbl_1_bss_C[10], 0x40000002); + BoardPlayerModelAttrReset(arg1->unk00_bit5, 0x40000002); + BoardModelMotionStart(lbl_1_data_456, 1, 0x40000001); + BoardModelMotionStart(lbl_1_bss_C[7], 0, 0); + BoardModelMotionStart(lbl_1_bss_C[10], lbl_1_data_458, 0); + BoardPlayerMotionStart(arg1->unk00_bit5, arg1->unk_06[2], 0); + BoardModelVisibilitySet(arg1->unk_06[0], 0); + arg1->unk_0C = HuAudFXPlay(0x43F); + BoardModelPosGet(lbl_1_data_456, &sp8); + arg0->trans.z = sp8.y; + arg0->rot.y = 16.666666f * arg0->rot.x; + arg0->scale.x = BoardModelMotionMaxTimeGet(lbl_1_bss_C[7]); + HuWinDispOff(lbl_1_data_454); + BoardCameraMotionStartEx(-1, 0, 0, 1900.0f, -1.0f, 0x15); + return; + } + MGSeqSetParam(arg1->unk_04, 1, arg1->unk2); + arg1->unk3 = 60; + } + + + var_r26 = GWPlayer[arg1->unk00_bit5].port; + var_r28 = 0; + if ((GWPlayer[arg1->unk00_bit5].com) != 0) { + temp_r27 = BoardRandMod(100); + switch (GWPlayer[arg1->unk00_bit5].diff) { + case 0: + if (temp_r27 < 12) { + var_r28 = 0x100; + } + break; + case 1: + if (temp_r27 < 22) { + var_r28 = 0x100; + } + break; + case 2: + if (temp_r27 < 50) { + var_r28 = 0x100; + } + break; + case 3: + var_r28 = 0x100; + break; + } + } else { + var_r28 = HuPadBtnDown[var_r26] & 0x100; + } + if ((var_r28 & 0x100)) { + arg0->trans.y += 0.5f; + if (arg0->trans.y > 2.0f) { + arg0->trans.y = 2.0f; + } + if (lbl_1_data_450 == -1) { + lbl_1_data_450 = HuAudFXPlay(0x43E); + } + lbl_1_bss_14E += 1; + BoardModelVisibilitySet(arg1->unk_06[0], 1); + BoardModelRotYSet(arg1->unk_06[0], BoardPlayerRotYGet(arg1->unk00_bit5)); + } else { + arg0->trans.x *= 0.98f; + arg0->trans.y = 0.0f; + if (arg0->trans.x <= 1.0f) { + BoardModelVisibilitySet(arg1->unk_06[0], 0); + if (lbl_1_data_450 != -1) { + HuAudFXStop(lbl_1_data_450); + lbl_1_data_450 = -1; + } + } + } + if ((lbl_1_data_450 != -1) && (HuAudFXStatusGet(lbl_1_data_450) == 0)) { + lbl_1_data_450 = -1; + } + arg0->trans.x += arg0->trans.y; + if (arg0->trans.x > 3.0f) { + arg0->trans.x = 3.0f; + } + BoardPlayerMotionSpeedSet(arg1->unk00_bit5, arg0->trans.x); + BoardModelMotionSpeedSet(lbl_1_data_456, arg0->trans.x); +} + +void fn_1_8C08(omObjData* arg0, someBits3* arg1) { + Point3d spC; + f32 temp_f31; + f32 temp_f30; + s8 temp_r27; + + BoardModelPosGet(lbl_1_data_456, &spC); + spC.y += 1.6666666f; + if (spC.y >= (arg0->trans.z + arg0->rot.y)) { + spC.y = arg0->trans.z + arg0->rot.y; + BoardModelMotionSpeedSet(lbl_1_bss_C[10], 0.0f); + BoardPlayerMotionSpeedSet(arg1->unk00_bit5, 0.0f); + BoardModelAttrSet(lbl_1_bss_C[7], 0x40000002); + BoardModelAttrSet(lbl_1_data_456, 0x40000002); + arg1->unk00_bit1 = 2; + arg1->unk1 = 0x3C; + arg1->unk2 = 0; + } + BoardModelPosSetV(lbl_1_data_456, &spC); + temp_f30 = arg0->scale.x * ((spC.y - arg0->trans.z) / 500.0f); + OSf32tos8(&temp_f30, &temp_r27); + temp_r27 = temp_r27 / 30; + if (lbl_1_data_4B0 != temp_r27) { + lbl_1_data_4B0 = temp_r27; + HuAudFXPlay(lbl_1_data_4B4[temp_r27]); + } + BoardModelMotionTimeSet(lbl_1_bss_C[7], temp_f30); + BoardModelMotionTimeSet(lbl_1_bss_C[10], 0.2f * temp_f30); + BoardPlayerMotionTimeSet(arg1->unk00_bit5, 2.0f * temp_f30); +} + +void fn_1_8E44(omObjData* arg0, someBits3* arg1) { + Point3d sp8; + f32 temp_f1; + f32 temp_f31; + + if (arg1->unk00_bit7 == 0) { + HuAudFXPlay(0x448); + arg1->unk00_bit7 = 1; + if (arg1->unk_0C != -1) { + HuAudFXStop(arg1->unk_0C); + arg1->unk_0C = -1; + } + BoardAudSeqFadeOut(1, 0x3E8); + } + OSu8tof32(&arg1->unk2, &temp_f31); + BoardModelPosGet(lbl_1_data_456, &sp8); + sp8.y = (sp8.y + (-0.08166666666666668 * temp_f31 * temp_f31)); + if (sp8.y < arg0->trans.z) { + sp8.y = arg0->trans.z; + arg1->unk00_bit1 = 3; + arg0->trans.x = arg0->rot.y / 20.0f; + arg0->trans.y = 0.0f; + arg0->trans.z = 24.0f; + BoardModelAttrReset(lbl_1_bss_C[10], 0x40000003); + BoardModelMotionSpeedSet(lbl_1_bss_C[10], -2.0f); + BoardPlayerModelAttrReset(arg1->unk00_bit5, 0x40000003); + BoardPlayerMotionSpeedSet(arg1->unk00_bit5, -2.0f); + HuAudFXPlay(0x449); + BoardAudSeqPause(0, 0, 0x3E8); + } + arg1->unk2 += 1; + BoardModelPosSetV(lbl_1_data_456, &sp8); +} + +void fn_1_9044(omObjData* arg0, someBits3* arg1) { + Vec sp8; + + BoardModelRotGet(lbl_1_data_456, &sp8); + arg0->trans.y = BoardDAngleCalc(arg0->trans.y + arg0->trans.z); + if (arg0->trans.y <= 2.0f) { + if (arg0->trans.y >= -2.0) { + arg0->trans.x *= 0.5f; + if (arg0->trans.x <= 1.0f) { + arg0->trans.y = 0.0f; + BoardRotateDiceNumbers(arg1->unk00_bit5); + BoardModelMotionShiftSet(lbl_1_bss_C[10], 1, 0.0f, 10.0f, 0x40000001U); + arg1->unk00_bit0 = 1; + } + } + } + sp8.z = arg0->trans.x * sin((3.141592653589793 * arg0->trans.y) / 180.0); + BoardModelRotSetV(lbl_1_data_456, &sp8); +} + +void fn_1_91B8(void) { + s8 temp_r3; + + if (lbl_1_bss_14E == 0) { + lbl_1_bss_14E = 1; + } + temp_r3 = lbl_1_bss_14E / 6; + lbl_1_bss_14C = lbl_1_data_4C8[temp_r3]; +} + +void fn_1_9230(s32 arg0) { + Point3d sp20; + Point3d sp14; + Point3d sp8; + s16 temp_r30; + f32 rotY; + + temp_r30 = GWPlayer[arg0].space_curr; + BoardPlayerPosGet(arg0, &sp20); + BoardSpacePosGet(0, temp_r30, &sp14); + BoardCameraTargetPlayerSet(arg0); + BoardCameraViewSet(1); + BoardPlayerPosLerpStart(arg0, &sp20, &sp14, 0x14); + while (GWPlayer[arg0].moving != 0) { + BoardModelPosGet(lbl_1_bss_C[10], &sp20); + BoardPlayerPosGet(arg0, &sp14); + PSVECSubtract(&sp14, &sp20, &sp8); + rotY = atan2(sp8.x, sp8.z) / 3.141592653589793 * 180.0; + BoardModelRotYSet(lbl_1_bss_C[10], rotY); + HuPrcVSleep(); + } + BoardModelRotYSet(lbl_1_bss_C[10], 0.0f); + BoardCameraMotionWait(); +} + +void fn_1_9384(void) { + f32 widthHeight[2]; + f32 x, y; + + HuWinMesMaxSizeGet(1, widthHeight, 0x160019); + x = -10000.0f; + y = 288.0f; + lbl_1_data_454 = HuWinCreate(x, y, widthHeight[0], widthHeight[1], 0); + HuWinBGTPLvlSet(lbl_1_data_454, 0.0f); + HuWinMesSpeedSet(lbl_1_data_454, 0); + HuWinMesSet(lbl_1_data_454, 0x160019U); +} + +void fn_1_9474(s32 arg0) { + sprintf(lbl_1_bss_150, "%d", lbl_1_bss_14C); + BoardWinCreate(2, 0x160017U, 2); + BoardWinInsertMesSet((u32)lbl_1_bss_150, 4); + BoardWinWait(); + BoardWinKill(); + BoardPlayerMotBlendSet(arg0, 0, 0xF); + while (BoardPlayerMotBlendCheck(arg0) == 0) { + HuPrcVSleep(); + } + fn_1_97F8(arg0); + while (lbl_1_bss_148) { + HuPrcVSleep(); + } + BoardPlayerMotionShiftSet(arg0, 7, 0.0f, 8.0f, 0U); + HuPrcSleep(8); + while (BoardPlayerMotionEndCheck(arg0) == 0) { + HuPrcVSleep(); + } + BoardWinCreate(2, 0x160018U, 2); + BoardWinWait(); + BoardWinKill(); + BoardModelMotionStart(lbl_1_bss_C[7], 0, 0x40000002); +} + +void fn_1_95B8(omObjData* arg0) { + f32 temp_f31; + s32 var_r25; + s32 var_r26; + s32 var_r27; + s32 var_r28; + unkTemp* var_r30; + unkTemp2* temp_r29; + s32 i; + s32 temp; + + temp_r29 = OM_GET_WORK_PTR(arg0, unkTemp2); + if ((temp_r29->unk00_bit0 != 0) || (BoardIsKill() != 0)) { + fn_1_9A1C(temp_r29); + HuMemDirectFree((void*)temp_r29->unk_0C); + lbl_1_bss_148 = 0; + omDelObjEx(HuPrcCurrentGet(), arg0); + return; + } + var_r30 = temp_r29->unk_0C; + + for (var_r27 = i = 0; i < 20; i++, var_r30++) { + if (var_r30->unk0 == 0) { + var_r27++; + } + } + + if (var_r27 == 20) { + temp_r29->unk00_bit0 = 1; + return; + } + var_r25 = 0; + for (i = 0; i < 20; i++) { + var_r30 = &temp_r29->unk_0C[i]; + if ((var_r30->unk0 == 1) && (var_r25 == 0)) { + var_r30->unk0 = 2U; + var_r25 = 1; + } + if (var_r30->unk0 == 2) { + var_r30->unk1++; + OSu8tof32(&var_r30->unk1, &temp_f31); + var_r30->unk4 += 45.0f; + var_r30->unk8.y += -0.08166667f * temp_f31 * temp_f31 * 0.75f; + if (var_r30->unk8.y < temp_r29->unk8) { + var_r30->unk8.y = temp_r29->unk8; + CharModelCreateCoinParticle(1, &var_r30->unk8); + BoardModelVisibilitySet(var_r30->unk_02, 0); + HuAudFXPlay(7); + BoardPlayerCoinsAdd(temp_r29->unk4, 1); + omVibrate(temp_r29->unk4, 0xC, 6, 6); + var_r30->unk0 = 0; + } + BoardModelPosSetV(var_r30->unk_02, &var_r30->unk8); + BoardModelRotYSet(var_r30->unk_02, var_r30->unk4); + } + } +} + + +void fn_1_97F8(s32 arg0) { + Point3d sp8; + f32 temp_f2; + f32 var_f31; + f64 temp_f1; + omObjData* temp_r3; + s32 i; + unkTemp2* temp_r30; + unkTemp* temp_r31; + + temp_r3 = omAddObjEx(boardObjMan, 0x101, 0U, 0U, -1, fn_1_95B8); + lbl_1_bss_148 = temp_r3; + temp_r30 = OM_GET_WORK_PTR(temp_r3, unkTemp2); + temp_r30->unk00_bit0 = 0; + temp_r30->unk4 = arg0; + temp_r30->unk_0C = HuMemDirectMallocNum(0, 0x190, 0x10000000); + BoardPlayerPosGet(arg0, &sp8); + temp_r30->unk8 = (80.0f + sp8.y); + memset(temp_r30->unk_0C, 0, 0x190); + for (i = 0; i < lbl_1_bss_14C; i++) { + if (i == 0) { + var_f31 = 0.0f; + } else { + var_f31 = BoardRandFloat(); + } + temp_r31 = &temp_r30->unk_0C[i]; + temp_r31->unk0 = 1; + temp_r31->unk8.x = sp8.x + (50.0f * sin((3.141592653589793 * var_f31) / 180.0)); + temp_r31->unk8.z = sp8.z + (50.0f * cos((3.141592653589793 * var_f31) / 180.0)); + temp_r31->unk8.y = 600.0f + sp8.y + (500.0f * BoardRandFloat()); + temp_r31->unk1 = 0; + temp_r31->unk4 = BoardRandFloat() * 360.0f; + temp_r31->unk_02 = BoardModelCreate(0x7000A, NULL, 1); + } +} + +void fn_1_9A1C(unkTemp2* arg0) { + s32 i; + unkTemp* temp; + + for (i = 0; i < 20; i++) { + temp = &arg0->unk_0C[i]; + BoardModelKill(temp->unk_02); + } +} + +char mg_pad[] = "\0\0\0\0\0\0"; \ No newline at end of file From 3d0d946f2751fd633e53bc2dae2539fd53df71e3 Mon Sep 17 00:00:00 2001 From: Rainchus Date: Wed, 24 Jan 2024 04:37:42 -0600 Subject: [PATCH 5/6] fix symbol names in mg_coin.c --- src/REL/w03Dll/mg_coin.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/REL/w03Dll/mg_coin.c b/src/REL/w03Dll/mg_coin.c index d6e5d8ce..d8b3f52f 100644 --- a/src/REL/w03Dll/mg_coin.c +++ b/src/REL/w03Dll/mg_coin.c @@ -65,7 +65,7 @@ double sin(double x); double cos(double x); double atan2(double y, double x); extern s16 MGSeqCreate(s32, ...); -u8 MGSeqGetStat(s16); +u8 MGSeqStatGet(s16); float BoardModelMotionTimeGet(s16 model); float BoardModelMotionMaxTimeGet(s16 model); s32 BoardModelMotionShiftSet(s16 model, s32 motion, float time, float shift_time, u32 attr); @@ -239,7 +239,7 @@ void fn_1_8140(s32 arg0) { fn_1_81E0(arg0); BoardMusStart(1, 0x16, 0x7F, 0); temp_r31 = MGSeqCreate(3, 0); - while (MGSeqGetStat(temp_r31)) { + while (MGSeqStatGet(temp_r31)) { HuPrcVSleep(); } fn_1_9384(); @@ -321,7 +321,7 @@ void fn_1_8530(omObjData* arg0) { if ((temp_r31->unk00_bit0 != 0) || (BoardIsKill() != 0)) { if (temp_r31->unk_04 != -1) { - MGSeqSetParam(temp_r31->unk_04, 2, -1); + MGSeqParamSet(temp_r31->unk_04, 2, -1); } if (temp_r31->unk_06[1] != -1) { BoardPlayerMotionKill(temp_r31->unk00_bit5, temp_r31->unk_06[1]); @@ -372,7 +372,7 @@ void fn_1_8698(omObjData* arg0, someBits3* arg1) { if (arg1->unk2 != 0) { arg1->unk2--; } else { - MGSeqSetParam(arg1->unk_04, 2, -1); + MGSeqParamSet(arg1->unk_04, 2, -1); arg1->unk_04 = -1; arg1->unk00_bit1 = 1; temp = BoardModelMotionTimeGet(lbl_1_bss_C[7]); @@ -402,7 +402,7 @@ void fn_1_8698(omObjData* arg0, someBits3* arg1) { BoardCameraMotionStartEx(-1, 0, 0, 1900.0f, -1.0f, 0x15); return; } - MGSeqSetParam(arg1->unk_04, 1, arg1->unk2); + MGSeqParamSet(arg1->unk_04, 1, arg1->unk2); arg1->unk3 = 60; } From d24ff2851e865ad694d2e7ee312b88a99cc84efd Mon Sep 17 00:00:00 2001 From: gamemasterplc Date: Wed, 24 Jan 2024 06:39:30 -0600 Subject: [PATCH 6/6] Fix HuSprGrpDrawNoSet type --- include/game/sprite.h | 2 +- src/game/sprman.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/include/game/sprite.h b/include/game/sprite.h index d1b87064..9a9d27f8 100644 --- a/include/game/sprite.h +++ b/include/game/sprite.h @@ -188,7 +188,7 @@ void HuSprGrpCenterSet(short group, float x, float y); void HuSprGrpZRotSet(short group, float z_rot); void HuSprGrpScaleSet(short group, float x, float y); void HuSprGrpTPLvlSet(short group, float tp_lvl); -void HuSprGrpDrawNoSet(short group, int draw_no); +s32 HuSprGrpDrawNoSet(short group, int draw_no); void HuSprDrawNoSet(short group, short member, int draw_no); void HuSprPriSet(short group, short member, short prio); void HuSprGrpScissorSet(short group, short x, short y, short w, short h); diff --git a/src/game/sprman.c b/src/game/sprman.c index 5728d60b..5f5c25d4 100644 --- a/src/game/sprman.c +++ b/src/game/sprman.c @@ -555,7 +555,7 @@ void HuSprGrpTPLvlSet(short group, float tp_lvl) } } -void HuSprGrpDrawNoSet(short group, int draw_no) +s32 HuSprGrpDrawNoSet(short group, int draw_no) { SpriteGroupData *group_ptr = &HuSprGrpData[group]; short i;