Merge branch 'Rainchus:main' into main

config/GMPE01_00/symbols.txt

@@ -5184,7 +5184,8 @@ lbl_8013997C = .data:0x8013997C; // type:object size:0x20
 boardMotTbl = .data:0x8013999C; // type:object size:0x20 scope:local
 boardMotRevTbl = .data:0x801399BC; // type:object size:0x20 scope:local
 bowserSuitCharMdlTbl = .data:0x801399DC; // type:object size:0x20 scope:local
-bowserSuitMotTbl = .data:0x801399FC; // type:object size:0x34 scope:local
+bowserSuitMotTbl = .data:0x801399FC; // type:object size:0x14 scope:local
+sparkMotTbl = .data:0x80139A10; // type:object size:0x20 scope:local
 boardSparkSfxTbl = .data:0x80139A30; // type:object size:0x20 scope:local
 boardSparkSfxTblAlt = .data:0x80139A50; // type:object size:0x20 scope:local
 megaSquishObj = .data:0x80139A70; // type:object size:0x10 scope:local

include/game/board/player.h

@@ -115,32 +115,23 @@ void BoardJunctionMaskSet(s32);
 void BoardJunctionMaskReset(s32);
 void BoardJunctionMaskZero(void);
 void BoardPlayerVoiceEnableSet(s32, s32, s32);
-void InitJunction(s32, s32, f32);
+
-static void UpdateJunctionGfx(omObjData*);
+
-static void StopJunctionPlayer(s32);
-static void RestoreJunction(f32, s32);
-static s32 GetDefaultDirection(f32, f32*, s32);
-static s32 DoDebugMove(s32, s16*);
-static s32 ExecJunction(s32, s16*);
 void BoardPlayerMoveTo(s32, s32);
 void BoardPlayerMoveBetween(s32, s32, s32);
 void BoardPlayerMoveToAsync(s32, s32);
 void BoardPlayerPosLerpStart(s32, Vec*, Vec*, s16);
-static void PlayerPosLerpFunc(omObjData*);
 void BoardPlayerDiceJumpStart(s32);
 s32 BoardPlayerDiceJumpCheck(s32);
-static void DiceJumpFunc(omObjData*);
 void BoardRotateDiceNumbers(s32);
 void BoardPlayerMotBlendSet(s32 arg0, s16 arg1, s16 arg2);
-static void UpdateDiceDigitSprite(omObjData*);
+
-static void UpdateDiceDigit2D(omObjData*);
 void BoardPlayerBtnDownWait(s32, u32);
 void BoardPlayerAutoSizeSet(s32, s32);
 s32 BoardPlayerAutoSizeGet(s32);
 u32 BoardPlayerMoveAwayIsDone(void);
 void BoardPlayerMoveAwayStart(s32, s32, s32);
 void BoardPlayerMoveAwayStartCurr(s32, s32);
-static void MoveAwayObjFunc(omObjData*);
 void BoardPlayerCopyMat(s32);
 void BoardBowserSuitMotionSetJump(void);
 //...
@@ -149,21 +140,17 @@ s32 BoardPlayerAutoSizeGet(s32);
 void BoardPlayerAutoSizeSet(s32, s32);
 void BoardPlayerCopyMat(s32);
 void BoardBowserSuitKill(s32);
-void SetRollPlayerSize(s32);
 void BoardDiceDigit2DInit(s32, s32);
 void BoardDiceDigit2DUpdateEnable(s32);
-s32 DoSparkSpace(s32, s32);
+void BoardPlayerResizeAnimExec(s32 player, s32 size);
-s32 MegaPlayerPassFunc(s32, s16);
 s32 BoardPlayerAnimBlendCheck(s32);
 void BoardBowserSuitMotionSetWait(void);
 void BoardBowserSuitPlayerModelKill(void);
 void BoardDiceDigit2DShowSet(s32);
-s32 MegaPlayerPassFunc(s32, s16);
 s32 BoardPlayerMotBlendCheck(s32);
 void BoardPlayerMoveAwayStartCurr(s32, s32);
 void BoardBowserSuitMotionSetWalk(void);
 s16 BoardBowserSuitModelGet(void);
-void UpdateDiceDigit2D(omObjData*);
 void MoveAwayObjFunc(omObjData*);
 void UpdateBowserSuit(omObjData*);
 

include/game/chrman.h

@@ -42,6 +42,6 @@ void fn_8004F52C(s16 character, s32 arg1);
 void CharModelEffectEnableSet(s16 character, s32 arg1);
 s32 CharModelEffectNpcInit(s16 arg0, s16 arg1, s16 arg2, s16 arg3);
 s32 CharModelEffectNpcInitSilent(s16 arg0, s16 arg1, s16 arg2);
-void CharModelStepTypeSet(s16 character, s32 arg1);
+s32 CharModelStepTypeSet(s16 character, s32 arg1);
 
 #endif

src/game/board/player.c

@@ -10,8 +10,35 @@
 #include "game/board/ui.h"
 #include "game/board/view.h"
 #include "game/board/model.h"
+#include "game/board/item.h"
+#include "game/board/basic_space.h"
+#include "game/board/audio.h"
 #include "game/pad.h"
 
+static void InitJunction(s32, s32, f32);
+static void UpdateJunctionGfx(omObjData*);
+static void StopJunctionPlayer(s32);
+static void RestoreJunction(f32, s32);
+
+static s32 GetDefaultDirection(f32, f32*, s32);
+static s32 DoDebugMove(s32, s16*);
+static s32 ExecJunction(s32, s16*);
+
+static void PlayerPosLerpFunc(omObjData*);
+static void DiceJumpFunc(omObjData*);
+
+static void UpdateDiceDigitSprite(omObjData*);
+static void UpdateDiceDigit2D(omObjData*);
+static void MoveAwayObjFunc(omObjData*);
+
+static void MoveAwayObjFunc(omObjData*);
+static void UpdateBowserSuit(omObjData*);
+
+static s32 DoSparkSpace(s32 player, s32 pause_cam);
+static void RemoveSparkSpace(s32 player);
+static void SetRollPlayerSize(s32 player);
+static s32 MegaPlayerPassFunc(s32, s16);
+
 //TODO: Give better name
 typedef struct bitcopy {
     struct {
@@ -89,9 +116,12 @@ static s32 bowserSuitCharMdlTbl[] = {
 
 static s32 bowserSuitMotTbl[] = {
     0x40019, 0x4001A, 0x4001B, 0x4001E,
-    0x4001F, 0x70095, 0x70096, 0x70097,
+    0x4001F
-    0x70098, 0x70099, 0x7009A, 0x7009B,
+};
-    0x7009C,
+
+static s32 sparkMotTbl[] = {
+	0x70095, 0x70096, 0x70097, 0x70098,
+	0x70099, 0x7009A, 0x7009B, 0x7009C,
 };
 
 static s32 boardSparkSfxTbl[] = {
@@ -113,15 +143,6 @@ static s32 megaSquishSfxTbl[] = {
     0x228, 0x268, 0x2A8, 0x2E8,
 };
 
-inline PlayerState* GetPlayer(s32 index) {
-    return &GWPlayer[index];
-}
-
-inline s16 GetBoardPlayer(s32 index) {
-    PlayerState *player = GetPlayer(index);
-    return boardPlayerMdl[player->player_idx];
-}
-
 s32 BoardRollTypeGet(void) {
     return rollType;
 }
@@ -511,8 +532,9 @@ void BoardPlayerMotionStart(s32 arg0, s32 arg1, s32 arg2) {
 }
 
 void BoardPlayerMotionShiftSet(s32 arg0, s32 arg1, f32 arg8, f32 arg9, u32 arg2) {
+	s32 temp_r29;
     PlayerState* player;
-    s32 temp_r29;
+    
     
     player = BoardPlayerGet(arg0);
     if (arg1 == 0) {
@@ -592,7 +614,7 @@ void BoardPlayerSizeSet(s32 arg0, s32 arg1) {
     } else {
         CharModelStepTypeSet(GWPlayer[arg0].character, 0);
     }
-    BoardModelScaleSetV(BoardPlayerModelGet(arg0), &temp_r4[arg1]);
+    BoardPlayerScaleSetV(arg0, &temp_r4[arg1]);
 }
 
 s32 BoardPlayerSizeGet(s32 idx) {
@@ -1725,21 +1747,14 @@ static void DiceJumpFunc(omObjData* arg0) {
     }
 }
 
-void BoardRotateDiceNumbers(s32 arg0) {
-    PlayerState* temp_r27;
-    s32 var_r29;
 
-    if (GWPlayer[arg0].bowser_suit != 0) {
+void BoardRotateDiceNumbers(s32 arg0)
+{
+    if (GWPlayer[arg0].bowser_suit) {
         BoardBowserSuitMotionSetWait();
         BoardBowserSuitPlayerModelKill();
     }
-    temp_r27 = BoardPlayerGet(arg0);
+	BoardPlayerMotionShiftSet(arg0, 1, 0.0f, 8.0f, 0x40000001);
-    if (playerMot[temp_r27->player_idx] != 1) {
-        var_r29 = BoardModelMotionShiftSet(BoardPlayerModelGet(arg0), 1, 0.0f, 8.0f, 0x40000001);
-        if (var_r29 == 0) {
-            playerMot[temp_r27->player_idx] = 1;
-        }
-    }
 }
 
 void BoardPlayerMotBlendSet(s32 arg0, s16 arg1, s16 arg2) {
@@ -2029,12 +2044,13 @@ void BoardPlayerAutoSizeSet(s32 player, s32 value) {
 }
 
 s32 BoardPlayerAutoSizeGet(s32 arg0) {
-    PlayerState* temp_r30 = BoardPlayerGet(arg0);
+    PlayerState* player;
-    
+
-    if (temp_r30 != 0 ) {
+    player = BoardPlayerGet(arg0);
-        arg0 = temp_r30->auto_size;
+    if(!player) {
+        return;
     }
-    return arg0;
+    return player->auto_size;
 }
 
 u32 BoardPlayerMoveAwayIsDone(void) {
@@ -2239,10 +2255,247 @@ void BoardPlayerSparkSet(s32 arg0) {
     GWPlayer[arg0].space_shock = currSpace;
 }
 
-// ...
+static s32 DoSparkSpace(s32 player, s32 pause_cam)
+{
+	s32 i;
+	s16 temp_r28;
+	s32 coin;
+	s32 temp_r17;
+	Vec pos, rot;
+	Vec coin_pos;
+	s16 sp15C[4] = { -1, -1, -1, -1 };
+	s32 sp138;
+	s32 sp134;
+	s32 sp130;
+	s32 sp12C;
+	s32 sp128;
+	s8 sp124[4] = { -1, -1, -1, -1 };
+	s8 sp120[4] = { -1, -1, -1, -1 };
+	s16 sp34;
+	s16 sp32;
+	s16 sp30;
+	s16 sp2E;
+	s16 sp2C;
+	sp30 = GWSystem.player_curr;
+	sp138 = 0;
+	sp34 = GWPlayer[player].space_curr;
+	
+	BoardSpacePosGet(0, sp34, &pos);
+	BoardSpaceRotGet(0, sp34, &rot);
+	for(i=0; i<4; i++) {
+		if(GWPlayer[i].space_shock == sp34) {
+			sp32 = i;
+			sp138 = 1;
+		}
+	}
+	if(!sp138) {
+		return 0;
+	}
+	BoardDiceDigit2DShowSet(0);
+	if(pause_cam) {
+		BoardCameraMoveSet(0);
+	} else {
+		BoardCameraMoveSet(1);
+	}
+	BoardCameraMotionWait();
+	BoardCameraTargetPlayerSet(player);
+	BoardRotateDiceNumbers(player);
+	temp_r28 = BoardModelCreate(0x70074, NULL, 0);
+	BoardModelMotionStart(temp_r28, 0, 0x40000002);
+	BoardModelMotionTimeSet(temp_r28, 30.0f);
+	BoardModelAttrSet(temp_r28, 0x40000002);
+	BoardModelRotSet(temp_r28, rot.x-90.0f, rot.y, rot.z);
+	BoardModelScaleSet(temp_r28, 2.0f, 2.0f, 2.0f);
+	BoardModelVisibilitySet(temp_r28, 0);
+	BoardModelLayerSet(temp_r28, 1);
+	sp2E = BoardModelCreate(0x70067, NULL, 0);
+	BoardModelLayerSet(sp2E, 1);
+	BoardModelMotionStart(sp2E, 0, 0);
+	HuAudFXPlay(796);
+	HuPrcSleep(2);
+	BoardModelAttrReset(temp_r28, 0x40000002);
+	BoardModelVisibilitySet(temp_r28, 1);
+	BoardModelPosSet(temp_r28, pos.x, 8.0f+pos.y, pos.z);
+	BoardModelPosSetV(sp2E, &pos);
+	sp128 = -1;
+	for(sp134=i=0; i<4; i++) {
+		if(GWPlayer[i].space_curr == sp34) {
+			sp124[sp134++] = i;
+			sp15C[i] = BoardPlayerMotionCreate(i, sparkMotTbl[GWPlayer[i].character]);
+			BoardPlayerMotionShiftSet(i, sp15C[i], 0, 8, 0);
+			HuAudFXPlay(boardSparkSfxTblAlt[GWPlayer[i].character]);
+			if(GWPlayer[i].bowser_suit) {
+				BoardModelMotionShiftSet(suitMdl, bowserSuitMot[4], 0.0f, 4.0f, 0);
+				sp128 = i;
+			}
+		}
+	}
+	sp130 = sp134;
+	HuPrcSleep(60);
+	while(!BoardModelMotionEndCheck(sp2E)) {
+		HuPrcVSleep();
+	}
+	sp2C = 255;
+	for(i=0; i<45; i++) {
+		sp2C -= 5;
+		if(sp2C < 0) {
+			sp2C = 0;
+		}
+		BoardModelAlphaSet(temp_r28, sp2C);
+		BoardModelAlphaSet(sp2E, sp2C);
+		HuPrcVSleep();
+	}
+	temp_r17 = BoardRollTypeGet();
+	if(temp_r17 == 0 || temp_r17 == 1 || temp_r17 == 2 || temp_r17 == 3 || temp_r17 == 10) {
+		BoardCameraTargetPlayerSet(player);
+		BoardRotateDiceNumbers(player);
+		HuPrcSleep(12);
+		BoardItemPlayerRestore(player, temp_r17);
+		while(!BoardItemDoneCheck()) {
+			HuPrcVSleep();
+		}
+		rollType = -1;
+	}
+	if(rollResized) {
+		BoardPlayerSizeRestore(player);
+		rollResized = 0;
+	}
+	if(sp128 != -1) {
+		HuAudFXPlay(boardSparkSfxTbl[GWPlayer[sp128].character]);
+	}
+	for(i=0; i<sp130; i++) {
+		coin = BoardPlayerCoinsGet(sp124[i]);
+		if(coin > 10) {
+			coin = 10;
+		}
+		if(coin > 0) {
+			
+			BoardPlayerPosGet(sp124[i], &coin_pos);
+			coin_pos.y += 250.0f;
+			sp120[i] = BoardCoinChgCreate(&coin_pos, -coin);
+		}
+	}
+	for(sp12C=i=0; i<sp130; i++) {
+		sp12C += BoardPlayerCoinsGet(sp124[i]);
+	}
+	if(sp12C) {
+		HuAudFXPlay(840);
+		for(coin=0; coin<10; coin++) {
+			for(i=0; i<sp130; i++) {
+				BoardPlayerCoinsAdd(sp124[i], -1);
+			}
+			HuAudFXPlay(14);
+			HuPrcSleep(6);
+		}
+		HuAudFXPlay(15);
+		HuPrcSleep(90);
+	}
+	BoardModelKill(temp_r28);
+	BoardModelKill(sp2E);
+	for(i=0; i<4; i++) {
+		BoardRotateDiceNumbers(sp124[i]);
+	}
+	HuPrcSleep(10);
+	GWSystem.player_curr = -1;
+	RemoveSparkSpace(sp32);
+	GWSystem.player_curr = sp30;
+	for(i=0; i<4; i++) {
+		if(sp15C[i] != -1) {
+			BoardPlayerMotionKill(i, sp15C[i]);
+		}
+	}
+	if(pause_cam) {
+		BoardCameraMoveSet(0);
+		BoardCameraMotionWait();
+	}
+	
+	BoardCameraTargetPlayerSet(sp30);
+	BoardCameraMotionWait();
+	BoardCameraMoveSet(1);
+	BoardDiceDigit2DShowSet(1);
+	return 1;
+}
 
-static inline s32 test(s32 arg0) {
+static void RemoveSparkSpace(s32 player)
-    return BoardModelIDGet(BoardPlayerModelGet(arg0));
+{
+	if(GWPlayer[player].field02_bit1) {
+		BoardWinCreate(0, 0x12001C, -1);
+		BoardWinWait();
+		BoardWinKill();
+		GWPlayer[player].field02_bit1 = 0;
+		GWPlayer[player].space_shock = 0;
+	}
+}
+
+static void SetRollPlayerSize(s32 player)
+{
+	s32 auto_size = BoardPlayerAutoSizeGet(player);
+	if(auto_size != 0) {
+		BoardStatusHammerKill(player);
+		BoardPlayerAutoSizeSet(player, 0);
+		HuPrcSleep(30);
+		omVibrate(player, 90, 6, 6);
+		if(auto_size == 1) {
+			HuAudFXPlay(788);
+			HuAudFXPlay(787);
+		} else if(auto_size == 2) {
+			HuAudFXPlay(786);
+			HuAudFXPlay(785);
+		}
+		BoardPlayerResizeAnimExec(player, auto_size);
+		BoardPlayerSizeSet(player, auto_size);
+		HuPrcSleep(30);
+		rollResized = 1;
+	}
+	
+}
+
+s32 BoardRollResizeCheck(void)
+{
+	return rollResized;
+}
+
+void BoardPlayerResizeAnimExec(s32 player, s32 size)
+{
+	s32 j;
+	s32 i;
+	s16 modelid;
+	s32 frame;
+	s16 model;
+	float mdl_size;
+	float frame_data[9];
+	float steps[4];
+	float player_sizes[] = { 1, 0.3, 2.5 };
+	
+	mdl_size = player_sizes[BoardPlayerSizeGet(player)];
+	steps[0] = mdl_size;
+	steps[1] = mdl_size+((player_sizes[size]-mdl_size)/3);
+	steps[2] = mdl_size+((player_sizes[size]-mdl_size)/1.5f);
+	steps[3] = player_sizes[size];
+	frame_data[0] = steps[1];
+	frame_data[1] = steps[0];
+	frame_data[2] = steps[1];
+	frame_data[3] = steps[2];
+	frame_data[4] = steps[1];
+	frame_data[5] = steps[2];
+	frame_data[6] = steps[3];
+	frame_data[7] = steps[2];
+	frame_data[8] = steps[3];
+	model = BoardPlayerModelGet(player);
+	modelid = BoardModelIDGet(model);
+	Hu3DModelAttrSet(modelid, 0x40000002);
+	frame = 0;
+	for(j=0; j<9; j++) {
+		float size_vel;
+		size_vel = (frame_data[frame++]-mdl_size)/10.0f;
+		for(i=0; i<10; i++) {
+			BoardPlayerScaleSet(player, mdl_size, mdl_size, mdl_size);
+			mdl_size += size_vel;
+			HuPrcVSleep();
+		}
+	}
+	Hu3DModelAttrReset(modelid, 0x40000002);
+	BoardPlayerSizeSet(player, size);
 }
 
 void BoardPlayerCopyEyeMat(s32 arg0, s32 arg1) {
@@ -2297,7 +2550,7 @@ void BoardPlayerCopyMat(s32 arg0) {
     void* temp_r3;
     HsfData* temp_r31;
 
-    modelID = BoardModelIDGet(GetBoardPlayer(arg0));
+    modelID = BoardModelIDGet(BoardPlayerModelGet(arg0));
     model = &Hu3DData[modelID];
     temp_r31 = model->hsfData;
     temp_r3 = HuMemDirectMallocNum(HEAP_SYSTEM, temp_r31->materialCnt * 0x3C, 0x10000000U);

src/game/chrman.c

@@ -2050,7 +2050,7 @@ static void UpdateNpcEffect(void) {
     }
 }
 
-void CharModelStepTypeSet(s16 character, s32 arg1) {
+s32 CharModelStepTypeSet(s16 character, s32 arg1) {
     UnkCharInstanceStruct *temp_r31 = &charInstance[character];
 
     temp_r31->unkB0 = arg1;