kobayashi90/marioparty4
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge branch 'main' of https://github.com/abnormalhare/mp4-dtk

Browse source
This commit is contained in:
CreateSource 2024-03-11 22:15:25 -04:00
commit 8564cca7b4
38 changed files with 3669 additions and 573 deletions
Download patch file Download diff file Expand all files Collapse all files

6
src/game/board/basic_space.c
View file

@ -40,7 +40,7 @@ extern void BoardCameraViewSet(s32);
extern void BoardPlayerPosGet(s32, Vec*);
extern void BoardPlayerMotionEndWait(s32);
extern void BoardPlayerCoinsAdd(s32, s32);
extern void BoardRotateDiceNumbers(s32);
extern void BoardPlayerIdleSet(s32);
extern void BoardCameraMotBlendSet(s32, s16, s16);
extern s32 BoardPlayerMotBlendCheck(s32);
@ -102,7 +102,7 @@ void BoardLandBlueExec(s32 player, s32 space) {
}
GWPlayer[player].color = 1;
BoardPlayerMotionEndWait(player);
BoardRotateDiceNumbers(player);
BoardPlayerIdleSet(player);
}
void BoardLandRedExec(s32 player, s32 space) {
@ -143,7 +143,7 @@ void BoardLandRedExec(s32 player, s32 space) {
}
GWPlayer[player].color = 2;
BoardPlayerMotionEndWait(player);
BoardRotateDiceNumbers(player);
BoardPlayerIdleSet(player);
}
s8 BoardCoinChgCreate(Vec *pos, s8 value) {

2
src/game/board/battle.c
View file

@ -320,7 +320,7 @@ static void ExecBattle(void) {
}
StopBattleBomb();
for (var_r31 = 0; var_r31 < 4; var_r31++) {
BoardRotateDiceNumbers(var_r31);
BoardPlayerIdleSet(var_r31);
BoardPlayerVoiceEnableSet(var_r31, 6, 1);
}
BoardAudSeqPause(0, 0, 1000);

6
src/game/board/block.c
View file

@ -97,7 +97,7 @@ static void BlockProc(void) {
player_character = GWPlayer[player].character;
jumpMot = BoardPlayerMotionCreate(player, sp14[player_character]);
BoardRotateDiceNumbers(player);
BoardPlayerIdleSet(player);
BoardPlayerMotBlendSet(player, 0, 0xF);
omVibrate(player, 12, 12, 0);
CreateBlockObj(player);
@ -122,7 +122,7 @@ static void BlockProc(void) {
while (BoardPlayerMotionEndCheck(player) == 0) {
HuPrcVSleep();
}
BoardRotateDiceNumbers(player);
BoardPlayerIdleSet(player);
if (work->contains_star != 0) {
SetBlockStop();
@ -162,7 +162,7 @@ static void BlockProc(void) {
KillCoinMdl();
work->kill = 1;
BoardRotateDiceNumbers((s32) player);
BoardPlayerIdleSet((s32) player);
HuPrcVSleep();
if ((_CheckFlag(0x1000B) != 0) && work->contains_star == 0) {

532
src/game/board/char_wheel.c Executable file
View file

@ -0,0 +1,532 @@
#include "game/board/char_wheel.h"
#include "game/audio.h"
#include "game/flag.h"
#include "game/gamework.h"
#include "game/object.h"
#include "game/pad.h"
#include "game/board/com.h"
#include "game/board/main.h"
#include "game/board/tutorial.h"
#include "game/board/ui.h"
#include "math.h"
typedef struct {
struct {
u8 unk00_field0 : 1;
u8 unk00_field1 : 1;
u8 unk00_field2 : 1;
u8 unk00_field3 : 4;
};
s8 unk01;
s8 unk02;
u8 unk03;
s16 unk04;
s16 unk06;
s16 unk08;
} CharWheelWork;
static void ExecCharWheel(omObjData *arg0);
static void InitCharWheel(CharWheelWork *arg0);
static void UpdateCharWheel(CharWheelWork *arg0);
static void StopCharWheel(CharWheelWork *arg0);
static void GrowCharWheel(CharWheelWork *arg0);
static void ShrinkCharWheel(CharWheelWork *arg0);
static void KillCharWheelSpr(void);
static void SetCharWheelChars(s32 arg0, s32 arg1, s8 *arg2);
static s32 GetInput(CharWheelWork *arg0);
static s16 GetComDelay(s32 arg0, s32 arg1);
static s32 GetComInput(CharWheelWork *arg0);
static s8 wheelChars[4];
static s16 comDelay;
static s16 wheelTimer;
static float wheelSpeed;
static s16 targetVal;
static float angleOfs;
static s16 targetF;
static omObjData *charWheelObj;
static s8 wheelPos = -1;
static s16 wheelSprGrp = -1;
static s32 wheelFXStat = -1;
static s32 wheelSprTbl[] = {
0x00070036,
0x00070038,
0x00070038,
0x00070038,
0x00070037,
0x00070037,
0x00070037,
0x00070037,
0x0007003A,
0x00070039
};
static s8 wheelSprPrio[] = {
0x3C, 0x50, 0x50, 0x50,
0x50, 0x50, 0x50, 0x50,
0x14, 0x1E,
// wheelCharIconPrioTbl
0x46, 0x46, 0x46, 0x46
};
static s32 wheelCharIconTbl[] = {
0x0007003B,
0x0007003C,
0x0007003D,
0x0007003E,
0x0007003F,
0x00070040,
0x00070041,
0x00070042
};
s32 BoardCharWheelInit(s32 arg0, s32 arg1) {
CharWheelWork *temp_r31;
arg1 = 3;
charWheelObj = omAddObjEx(boardObjMan, 0x104, 0, 0, -1, ExecCharWheel);
temp_r31 = OM_GET_WORK_PTR(charWheelObj, CharWheelWork);
temp_r31->unk00_field0 = 0;
temp_r31->unk00_field2 = 0;
temp_r31->unk00_field1 = (arg1 == 3) ? 0 : 1;
temp_r31->unk01 = arg0;
temp_r31->unk02 = 0;
temp_r31->unk03 = 0;
temp_r31->unk06 = 0;
wheelSpeed = 18.0f;
if (GWPlayer[temp_r31->unk01].com) {
temp_r31->unk04 = 360;
} else {
temp_r31->unk04 = 3600;
}
}
BOOL BoardCharWheelCheck(void) {
return (charWheelObj != NULL) ? FALSE : TRUE;
}
void BoardCharWheelWait(void) {
while (!BoardCharWheelCheck()) {
HuPrcVSleep();
}
}
s32 BoardCharWheelResultGet(void) {
return wheelChars[wheelPos];
}
void BoardCharWheelSpeedSet(float arg0) {
if (arg0 <= 0.0f) {
arg0 = 18.0f;
}
wheelSpeed = arg0;
}
static void ExecCharWheel(omObjData *arg0) {
CharWheelWork *temp_r31;
temp_r31 = OM_GET_WORK_PTR(arg0, CharWheelWork);;
if (temp_r31->unk00_field0 != 0 || BoardIsKill()) {
KillCharWheelSpr();
charWheelObj = NULL;
omDelObjEx(HuPrcCurrentGet(), arg0);
return;
}
if (wheelTimer < temp_r31->unk04) {
wheelTimer++;
}
switch (temp_r31->unk00_field3) {
case 0:
InitCharWheel(temp_r31);
break;
case 1:
GrowCharWheel(temp_r31);
break;
case 2:
UpdateCharWheel(temp_r31);
break;
case 3:
StopCharWheel(temp_r31);
break;
case 4:
ShrinkCharWheel(temp_r31);
break;
}
}
static void InitCharWheel(CharWheelWork *arg0) {
GXColor spE;
float temp_f29;
float temp_f28;
float temp_f27;
s32 var_r26;
s16 var_r27;
s16 var_r25;
s16 i;
s16 spA;
s16 sp8;
wheelChars[0] = wheelChars[1] = wheelChars[2] = wheelChars[3] = -1;
wheelFXStat = -1;
wheelTimer = 0;
if (arg0->unk00_field1 != 0) {
spA = 4;
var_r26 = 4;
temp_f27 = 45.0f;
} else {
spA = 3;
var_r26 = 1;
temp_f27 = 60.0f;
}
wheelSprGrp = HuSprGrpCreate(spA + 14);
SetCharWheelChars(arg0->unk00_field1, arg0->unk01, wheelChars);
if (GWPlayer[arg0->unk01].com) {
comDelay = GetComDelay(arg0->unk01, arg0->unk00_field1);
switch (GWPlayer[arg0->unk01].diff) {
case 0:
var_r27 = BoardRandMod(120);
break;
case 1:
var_r27 = BoardRandMod(60);
break;
case 2:
var_r27 = BoardRandMod(30);
break;
case 3:
var_r27 = 0;
break;
}
comDelay += var_r27;
if (comDelay > 360.0f) {
comDelay -= 360.0f;
}
if (comDelay < 0) {
comDelay += 360.0f;
}
} else {
comDelay = 0;
}
for (i = 0; i <= 9; i++) {
BoardSpriteCreate(wheelSprTbl[i], wheelSprPrio[i], 0, &sp8);
HuSprGrpMemberSet(wheelSprGrp, i, sp8);
HuSprAttrSet(wheelSprGrp, i, 8);
}
if (arg0->unk00_field1 == 0) {
for (i = 0; i < 4; i++) {
HuSprAttrSet(wheelSprGrp, i + 4, 4);
}
} else {
for (i = 0; i < 3; i++) {
HuSprAttrSet(wheelSprGrp, i + 1, 4);
}
}
for (i = 0; i < spA; i++) {
var_r25 = GWPlayer[wheelChars[i]].character;
BoardSpriteCreate(wheelCharIconTbl[var_r25], wheelSprPrio[i + 10], 0, &sp8);
HuSprGrpMemberSet(wheelSprGrp, i + 10, sp8);
HuSprAttrSet(wheelSprGrp, i + 10, 8);
}
HuSprPosSet(wheelSprGrp, 9, 3.0f, 3.0f);
HuSprColorSet(wheelSprGrp, 9, 0x40, 0x40, 0x40);
HuSprGrpPosSet(wheelSprGrp, 288.0f, 240.0f);
HuSprGrpScaleSet(wheelSprGrp, 0.01f, 0.01f);
OSs16tof32(&spA, &temp_f29);
temp_f29 = 360.0f / temp_f29;
for (i = 0; i < spA; i++) {
if (arg0->unk00_field1 != 0) {
switch (i) {
case 0:
HuSprPosSet(wheelSprGrp, i + 10, 50.0f, -57.0f);
break;
case 1:
HuSprPosSet(wheelSprGrp, i + 10, -50.0f, -57.0f);
break;
case 2:
HuSprPosSet(wheelSprGrp, i + 10, 50.0f, 57.0f);
break;
case 3:
HuSprPosSet(wheelSprGrp, i + 10, -50.0f, 57.0f);
break;
}
} else {
switch (i) {
case 0:
HuSprPosSet(wheelSprGrp, i + 10, 50.0f, -35.0f);
break;
case 1:
HuSprPosSet(wheelSprGrp, i + 10, 0.0f, 57.0f);
break;
case 2:
HuSprPosSet(wheelSprGrp, i + 10, -50.0f, -35.0f);
break;
}
}
OSs16tof32(&i, &temp_f28);
HuSprZRotSet(wheelSprGrp, var_r26 + i, temp_f29 * temp_f28);
GWCharColorGet(GWPlayer[wheelChars[i]].character, &spE);
HuSprColorSet(wheelSprGrp, var_r26 + i, spE.r, spE.g, spE.b);
}
for (i = 0; i < 3; i++) {
if (wheelChars[i] == targetVal) {
break;
}
}
angleOfs = 120.0f * i;
if (angleOfs > 180.0f) {
angleOfs -= 360.0f;
}
arg0->unk00_field3 = 1;
}
static void UpdateCharWheel(CharWheelWork *arg0) {
float var_f24;
float var_f25;
float var_f23;
u32 var_r18;
s16 temp_r20;
s16 var_r19;
s16 var_r17;
OSs16tof32(&arg0->unk06, &var_f24);
OSs16tof32(&arg0->unk08, &var_f25);
var_f24 = var_f24 * 0.0625f;
var_f25 = var_f25 * 0.0625f;
if (arg0->unk00_field2 == 0) {
if (var_f25 < 18.0f) {
var_f25 += 0.7f;
if (var_f25 > wheelSpeed) {
var_f25 = wheelSpeed;
}
} else {
var_r18 = GetInput(arg0);
if (var_r18 & 0x100) {
arg0->unk00_field2 = 1;
}
}
} else {
OSf32tos16(&var_f24, &temp_r20);
if (arg0->unk00_field1 == 0) {
var_r19 = 120;
} else {
var_r19 = 90;
}
temp_r20 %= var_r19;
if (var_f25 < 0.5f && (temp_r20 < 2 || temp_r20 >= var_r19 - 2)) {
var_f25 += var_f25 / 2;
}
var_f25 *= 0.92f;
}
var_f23 = 8191.0f - 8191.0f * (var_f25 / wheelSpeed);
OSf32tos16(&var_f23, &var_r17);
HuAudFXPitchSet(wheelFXStat, -var_r17);
if (var_f25 > -0.0000001f && var_f25 < 0.0000001f) {
arg0->unk00_field3 = 3;
if (wheelFXStat != -1) {
HuAudFXStop(wheelFXStat);
wheelFXStat = -1;
}
HuAudFXPlay(0x30B);
}
var_f24 += var_f25;
if (var_f24 > 360.0f) {
var_f24 -= 360.0f;
}
HuSprZRotSet(wheelSprGrp, 8, var_f24);
HuSprZRotSet(wheelSprGrp, 9, var_f24);
var_f24 *= 16.0f;
var_f25 *= 16.0f;
OSf32tos16(&var_f24, &arg0->unk06);
OSf32tos16(&var_f25, &arg0->unk08);
}
static void StopCharWheel(CharWheelWork *arg0) {
u8 var_r30;
if (arg0->unk03 == 0) {
arg0->unk06 >>= 4;
if (arg0->unk00_field1 == 0) {
wheelPos = arg0->unk06 / 120;
} else {
wheelPos = arg0->unk06 / 90;
}
}
var_r30 = arg0->unk03 % 6;
if (var_r30 < 3) {
HuSprAttrSet(wheelSprGrp, wheelPos + 10, 4);
} else {
HuSprAttrReset(wheelSprGrp, wheelPos + 10, 4);
}
if (arg0->unk03 < 90) {
arg0->unk03++;
} else {
HuSprAttrReset(wheelSprGrp, wheelPos + 10, 4);
arg0->unk00_field3 = 4;
}
}
static void GrowCharWheel(CharWheelWork *arg0) {
float temp_f30;
if (arg0->unk02 < 90) {
arg0->unk02 += 3;
} else {
if (_CheckFlag(0x1000B)) {
BoardTutorialHookExec(0x14, 0);
}
arg0->unk02 = 90;
arg0->unk00_field3 = 2;
wheelFXStat = HuAudFXPlay(0x30A);
}
OSs8tof32(&arg0->unk02, &temp_f30);
HuSprGrpScaleSet(wheelSprGrp, sin(temp_f30 * M_PI / 180.0), sin(temp_f30 * M_PI / 180.0));
}
static void ShrinkCharWheel(CharWheelWork *arg0) {
float temp_f30;
if (arg0->unk02 > 0) {
arg0->unk02 -= 3;
} else {
arg0->unk02 = 0;
arg0->unk00_field0 = 1;
arg0->unk00_field3 = -1;
targetF = 0;
}
OSs8tof32(&arg0->unk02, &temp_f30);
HuSprGrpScaleSet(wheelSprGrp, sin(temp_f30 * M_PI / 180.0), sin(temp_f30 * M_PI / 180.0));
}
static void KillCharWheelSpr(void) {
if (wheelSprGrp != -1) {
HuSprGrpKill(wheelSprGrp);
wheelSprGrp = -1;
}
}
static void SetCharWheelChars(s32 arg0, s32 arg1, s8 *arg2) {
s32 var_r29;
s32 var_r28;
s32 var_r31;
s32 var_r30;
for (var_r28 = var_r29 = 0; var_r29 < 4; var_r29++) {
if (var_r29 == arg1 && arg0 == 0) {
continue;
}
do {
do {
var_r30 = BoardRandMod(4);
} while (var_r30 == arg1 && arg0 == 0);
for (var_r31 = 0; var_r31 < 4; var_r31++) {
if (var_r30 == arg2[var_r31]) {
var_r30 = -1;
break;
}
}
} while (var_r30 == -1);
arg2[var_r28] = var_r30;
var_r28++;
}
}
static s32 GetInput(CharWheelWork *arg0) {
CharWheelWork *var_r27;
float temp_f26;
float temp_f27;
float var_f28;
float var_f29;
s32 var_r28;
if (wheelTimer >= arg0->unk04) {
return 0x100;
}
if (!GWPlayer[arg0->unk01].com) {
var_r28 = HuPadBtnDown[GWPlayer[arg0->unk01].port];
return var_r28;
}
var_r28 = GetComInput(arg0);
if (targetF != 0) {
var_r27 = OM_GET_WORK_PTR(charWheelObj, CharWheelWork);
OSs16tof32(&var_r27->unk06, &temp_f26);
OSs16tof32(&var_r27->unk08, &temp_f27);
temp_f26 = temp_f26 * 0.0625f;
temp_f27 = temp_f27 * 0.0625f;
var_f29 = temp_f26 + 46.0f * temp_f27;
var_f29 = fmod(var_f29, 360.0);
if (var_f29 > 180.0f) {
var_f29 -= 360.0f;
}
var_f28 = angleOfs - var_f29;
if (var_f28 >= 360.0f) {
var_f28 += 360.0f;
}
if (var_f28 >= 0.0f && var_f28 < 120.0f - 2.0f * temp_f27) {
var_r28 = 0x100;
} else {
var_r28 = 0;
}
OSReport("%f %f : %f %f\n", temp_f26, temp_f27, var_f29, var_f28);
}
return var_r28;
}
void BoardCharWheelTargetSet(s16 arg0) {
targetF = 1;
targetVal = arg0;
}
static s16 GetComDelay(s32 arg0, s32 arg1) {
float var_f30;
s16 var_r26;
s32 var_r27;
s32 var_r28;
s32 i;
var_r28 = BoardComFarPlayerFind();
if (var_r28 == -1 || var_r28 == arg0) {
do {
var_r28 = BoardRandMod(4);
} while (var_r28 == arg0);
}
if (arg1 != 0) {
var_r27 = 4;
} else {
var_r27 = 3;
}
for (var_r26 = i = 0; i < var_r27; i++) {
if (var_r28 == wheelChars[i]) {
var_f30 = i * (360 / var_r27);
var_f30 += 45.0f;
var_f30 -= 180.0f;
if (var_f30 < 0.0f) {
var_f30 += 360.0f;
}
if (var_f30 >= 360.0f) {
var_f30 -= 360.0f;
}
OSf32tos16(&var_f30, &var_r26);
break;
}
}
return var_r26;
}
static s32 GetComInput(CharWheelWork *arg0) {
s16 temp_r31;
s32 var_r29;
s32 var_r28;
s32 var_r27;
temp_r31 = (arg0->unk06 >> 4);
var_r27 = (arg0->unk00_field1 != 0) ? 90 : 120;
var_r28 = comDelay;
var_r29 = comDelay + var_r27;
if (temp_r31 >= var_r28 && temp_r31 < var_r29) {
return 0x100;
} else {
return 0;
}
}

18
src/game/board/item.c
View file

@ -12,6 +12,7 @@
#include "game/wipe.h"
#include "game/board/audio.h"
#include "game/board/boo.h"
#include "game/board/char_wheel.h"
#include "game/board/com.h"
#include "game/board/main.h"
#include "game/board/model.h"
@ -52,7 +53,6 @@ typedef struct {
extern u32 frandmod(u32);
extern void BoardBowserSuitInit(s32);
extern s16 BoardBowserSuitPlayerModelGet(void);
extern void BoardCharWheelWait(void);
static void ItemProcess(void);
static void RestoreProcess(void);
@ -440,7 +440,7 @@ static inline void BoardUiInlineFunc03(s32 arg0) {
while (!BoardPlayerMotBlendCheck(arg0)) {
HuPrcVSleep();
}
BoardRotateDiceNumbers(arg0);
BoardPlayerIdleSet(arg0);
}
static inline void BoardUiInlineFunc04(Process *arg0, s32 arg1) {
@ -943,7 +943,7 @@ static void ExecItemPipe(void) {
BoardPlayerMotionShiftSet(sp2C[1], 6, 0.0f, 8.0f, 0x40000001);
BoardModelVoiceEnableSet(BoardPlayerModelGet(sp2C[1]), 6, 0);
CharModelLayerSetAll(2);
BoardRotateDiceNumbers(sp2C[0]);
BoardPlayerIdleSet(sp2C[0]);
for (var_r31 = 0; var_r31 < 0x2D; var_r31++) {
sp9C.y -= 0.044444446f;
for (var_r30 = 0; var_r30 < 2; var_r30++) {
@ -960,7 +960,7 @@ static void ExecItemPipe(void) {
BoardWinInsertMesSet(GWPlayerCfg[sp2C[1]].character, 1);
BoardWinWait();
BoardWinKill();
BoardRotateDiceNumbers(sp2C[1]);
BoardPlayerIdleSet(sp2C[1]);
HuPrcSleep(8);
BoardModelVoiceEnableSet(BoardPlayerModelGet(sp2C[1]), 6, 1);
}
@ -1240,7 +1240,7 @@ static void ExecItemSpark(void) {
while (!BoardPlayerMotBlendCheck(currItemRestore)) {
HuPrcVSleep();
}
BoardRotateDiceNumbers(currItemRestore);
BoardPlayerIdleSet(currItemRestore);
BoardSpacePosGet(0, temp_r28, &sp5C);
BoardModelPosSetV(temp_r30, &sp5C);
sp5C.y += 106.0f;
@ -1423,7 +1423,7 @@ static void ExecItemWhistle(void) {
HuPrcVSleep();
}
BoardModelHookObjReset(sp8, temp_r22);
BoardRotateDiceNumbers(currItemRestore);
BoardPlayerIdleSet(currItemRestore);
BoardModelKill(suitMdl);
BoardCameraMoveSet(0);
temp_r18 = BoardSpaceStarGetCurr();
@ -2280,7 +2280,7 @@ static void GenieSceneExec(void) {
}
GenieCameraCalc(&cameraDataTbl[0], var_r26, 1.0f, &booCamPos, &booCamUp);
HuPrcSleep(0x96);
BoardRotateDiceNumbers(currItemRestore);
BoardPlayerIdleSet(currItemRestore);
sp2C = booCamPos;
sp20 = booCamUp;
booCamUp.x = sp38.x + (sp50.x - sp38.x) * 0.7f;
@ -2431,7 +2431,7 @@ static void ExecItemGenie(void) {
Hu3DModelKill(temp_r31);
BoardModelKill(suitMdl);
HuPrcKill(temp_r27);
BoardRotateDiceNumbers(currItemRestore);
BoardPlayerIdleSet(currItemRestore);
GenieSceneExec();
BoardCameraMoveSet(0);
BoardCameraViewSet(2);
@ -2482,7 +2482,7 @@ static void ExecItemGenie(void) {
BoardPlayerPosSetV(currItemRestore, &spC);
HuPrcVSleep();
}
BoardRotateDiceNumbers(currItemRestore);
BoardPlayerIdleSet(currItemRestore);
CharModelEffectEnableSet(GWPlayer[currItemRestore].character, 1);
HuSprAnimKill(genieParticleAnim);
BoardPlayerMotionKill(currItemRestore, geniePlayerMot[0]);

1989
src/game/board/last5.c Normal file
View file

File diff suppressed because it is too large Load diff

8
src/game/board/lottery.c
View file

@ -418,7 +418,7 @@ static void ExecLottery(void) {
temp_r29 = BoardDataDirReadAsync(0x50000);
temp_r31 = GWSystem.player_curr;
temp_r28 = GWPlayer[temp_r31].space_curr;
BoardRotateDiceNumbers(temp_r31);
BoardPlayerIdleSet(temp_r31);
BoardWinCreateChoice(0, 0x60000, -1, 0);
if (GWPlayer[temp_r31].com) {
if (BoardPlayerCoinsGet(temp_r31) >= 5) {
@ -503,7 +503,7 @@ static void ExecLottery(void) {
}
}
BoardMusStart(1, 2, 0x7F, 0);
BoardRotateDiceNumbers(temp_r31);
BoardPlayerIdleSet(temp_r31);
while (!BoardStatusStopCheck(temp_r31)) {
HuPrcVSleep();
}
@ -533,7 +533,7 @@ static void ExecLottery(void) {
while (GWPlayer[temp_r31].moving) {
HuPrcVSleep();
}
BoardRotateDiceNumbers(temp_r31);
BoardPlayerIdleSet(temp_r31);
BoardModelVisibilitySet(ballMdl[currPrize & 3], 0);
BoardAudSeqFadeOut(1, 1000);
BoardCameraTargetPlayerSet(temp_r31);
@ -591,7 +591,7 @@ static void DoMiniJumpUp(s32 arg0) {
}
sp1C.y = sp28.y;
BoardPlayerPosSetV(arg0, &sp1C);
BoardRotateDiceNumbers(arg0);
BoardPlayerIdleSet(arg0);
}
static void DoMiniJumpDown(s32 arg0) {

17
src/game/board/main.c
View file

@ -14,6 +14,7 @@
#include "game/board/model.h"
#include "game/board/pause.h"
#include "game/board/player.h"
#include "game/board/space.h"
#include "game/board/tutorial.h"
#include "game/board/ui.h"
#include "game/pad.h"
@ -60,8 +61,6 @@ static CameraView camViewTbl[] = {
};
extern s32 BoardSpacePosGet(s32 layer, s32 space, Vec *pos);
extern void BoardMGSetupPlayClear(void);
extern void BoardStartExec(void);
@ -2019,17 +2018,17 @@ void BoardLast5GfxInit(void)
}
BoardSpriteCreate(spr_file, prio, NULL, &work->sprites[i]);
HuSprGrpMemberSet(work->group, i, work->sprites[i]);
HuSprAttrSet(work->group, i, SPRITE_ATTR_BILINEAR);
HuSprAttrSet(work->group, i, HUSPR_ATTR_LINEAR);
HuSprPosSet(work->group, i, last5GfxPosTbl[lastF][i][0], last5GfxPosTbl[lastF][i][1]);
}
if(!work->is_last) {
SpriteData *sprite = &HuSprData[HuSprGrpData[work->group].members[1]];
HuSprite *sprite = &HuSprData[HuSprGrpData[work->group].members[1]];
HuSprBankSet(work->group, 1, 0);
sprite->frame = turn_remain;
} else {
HuSprAttrSet(work->group, 1, SPRITE_ATTR_HIDDEN);
HuSprAttrSet(work->group, 1, HUSPR_ATTR_DISPOFF);
}
HuSprAttrSet(work->group, 1, SPRITE_ATTR_PAUSED);
HuSprAttrSet(work->group, 1, HUSPR_ATTR_NOANIM);
object->trans.x = 0.0f;
HuSprGrpTPLvlSet(work->group, object->trans.x);
HuSprGrpPosSet(work->group, 288, 72);
@ -2106,12 +2105,12 @@ void BoardLast5GfxShowSet(s32 show)
work = OM_GET_WORK_PTR(last5GfxObj, Last5GfxWork);
for(i=0; i<3; i++) {
if(show) {
HuSprAttrReset(work->group, i, SPRITE_ATTR_HIDDEN);
HuSprAttrReset(work->group, i, HUSPR_ATTR_DISPOFF);
} else {
HuSprAttrSet(work->group, i, SPRITE_ATTR_HIDDEN);
HuSprAttrSet(work->group, i, HUSPR_ATTR_DISPOFF);
}
if(work->is_last) {
HuSprAttrSet(work->group, 1, SPRITE_ATTR_HIDDEN);
HuSprAttrSet(work->group, 1, HUSPR_ATTR_DISPOFF);
}
}
}

676
src/game/board/player.c
View file

@ -6,12 +6,44 @@
#include "game/board/com.h"
#include "game/board/main.h"
#include "game/board/roll.h"
#include "game/board/space.h"
#include "game/board/tutorial.h"
#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 void MegaSquishFunc(omObjData *object);
static s32 DoSparkSpace(s32 player, s32 pause_cam);
static void RemoveSparkSpace(s32 player);
static void SetRollPlayerSize(s32 player);
static s32 MegaPlayerPassFunc(s32 player, s32 space);
static s32 MegaExecJump(s32 player, s32 space);
//TODO: Give better name
typedef struct bitcopy {
struct {
@ -89,9 +121,12 @@ static s32 bowserSuitCharMdlTbl[] = {
static s32 bowserSuitMotTbl[] = {
0x40019, 0x4001A, 0x4001B, 0x4001E,
0x4001F, 0x70095, 0x70096, 0x70097,
0x70098, 0x70099, 0x7009A, 0x7009B,
0x7009C,
0x4001F
};
static s32 sparkMotTbl[] = {
0x70095, 0x70096, 0x70097, 0x70098,
0x70099, 0x7009A, 0x7009B, 0x7009C,
};
static s32 boardSparkSfxTbl[] = {
@ -104,7 +139,7 @@ static s32 boardSparkSfxTblAlt[] = {
0x223, 0x263, 0x2A3, 0x2E3,
};
static s32 megaSquishObj[] = {
static omObjData *megaSquishObj[] = {
0, 0, 0, 0,
};
@ -113,15 +148,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 +537,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 +619,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) {
@ -804,7 +831,7 @@ block_14:
} while (1);
BoardPauseDisableSet(1);
BoardDiceDigit2DUpdateEnable(arg0);
BoardRotateDiceNumbers(arg0);
BoardPlayerIdleSet(arg0);
if (GWPlayer[arg0].bowser_suit != 0) {
BoardCameraTargetPlayerSet(arg0);
}
@ -889,7 +916,7 @@ void BoardPlayerZoomRestore(s32 arg0) {
while (BoardPlayerMotBlendCheck(arg0) == 0) {
HuPrcVSleep();
}
BoardRotateDiceNumbers(arg0);
BoardPlayerIdleSet(arg0);
}
void BoardJunctionMaskSet(s32 arg0) {
@ -1221,7 +1248,7 @@ static s32 DoDebugMove(s32 arg0, s16* arg1) {
} else {
if (HuPadBtnDown[var_r20] == 0x10) {
BoardDiceDigit2DShowSet(0);
BoardRotateDiceNumbers(arg0);
BoardPlayerIdleSet(arg0);
StopJunctionPlayer(0);
BoardViewMapExec(arg0);
InitJunction(arg0, sp28->space_curr, -1.0f);
@ -1261,7 +1288,7 @@ static s32 DoDebugMove(s32 arg0, s16* arg1) {
}
} else {
if (BoardPlayerMotGet(arg0) != 1) {
BoardRotateDiceNumbers(arg0);
BoardPlayerIdleSet(arg0);
}
if (GWPlayer[arg0].bowser_suit != 0) {
BoardBowserSuitMotionSetWait();
@ -1375,7 +1402,7 @@ static s32 ExecJunction(s32 arg0, s16* arg1) {
var_f28 = -1.0f;
sp8 = 0;
InitJunction(arg0, sp30->space_curr, var_f28);
BoardRotateDiceNumbers(arg0);
BoardPlayerIdleSet(arg0);
HuPrcSleep(10);
while (1) {
@ -1418,7 +1445,7 @@ static s32 ExecJunction(s32 arg0, s16* arg1) {
} else if (var_r20 == 0x20 || var_r20 == 0x10) {
HuAudFXPlay(1);
BoardDiceDigit2DShowSet(0);
BoardRotateDiceNumbers(arg0);
BoardPlayerIdleSet(arg0);
StopJunctionPlayer(0);
if (var_r20 == 0x10) {
BoardViewMapExec(arg0);
@ -1453,7 +1480,7 @@ static s32 ExecJunction(s32 arg0, s16* arg1) {
}
} else {
if (BoardPlayerMotGet(arg0) != 1) {
BoardRotateDiceNumbers(arg0);
BoardPlayerIdleSet(arg0);
}
if (GWPlayer[arg0].bowser_suit != 0) {
BoardBowserSuitMotionSetWait();
@ -1684,7 +1711,7 @@ static void DiceJumpFunc(omObjData* arg0) {
temp_r31 = OM_GET_WORK_PTR(arg0, bitcopy2);
if ((temp_r31->field00_bit0 != 0) || (BoardIsKill() != 0)) {
GWPlayer[temp_r31->field00_bit1].field08_bit3 = 0;
BoardRotateDiceNumbers(temp_r31->field00_bit1);
BoardPlayerIdleSet(temp_r31->field00_bit1);
diceJumpObj[temp_r31->field00_bit1] = 0;
omDelObjEx(HuPrcCurrentGet(), arg0);
return;
@ -1725,21 +1752,14 @@ static void DiceJumpFunc(omObjData* arg0) {
}
}
void BoardRotateDiceNumbers(s32 arg0) {
PlayerState* temp_r27;
s32 var_r29;
if (GWPlayer[arg0].bowser_suit != 0) {
void BoardPlayerIdleSet(s32 arg0)
{
if (GWPlayer[arg0].bowser_suit) {
BoardBowserSuitMotionSetWait();
BoardBowserSuitPlayerModelKill();
}
temp_r27 = BoardPlayerGet(arg0);
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;
}
}
BoardPlayerMotionShiftSet(arg0, 1, 0.0f, 8.0f, 0x40000001);
}
void BoardPlayerMotBlendSet(s32 arg0, s16 arg1, s16 arg2) {
@ -2029,12 +2049,13 @@ void BoardPlayerAutoSizeSet(s32 player, s32 value) {
}
s32 BoardPlayerAutoSizeGet(s32 arg0) {
PlayerState* temp_r30 = BoardPlayerGet(arg0);
if (temp_r30 != 0 ) {
arg0 = temp_r30->auto_size;
PlayerState* player;
player = BoardPlayerGet(arg0);
if(!player) {
return;
}
return arg0;
return player->auto_size;
}
u32 BoardPlayerMoveAwayIsDone(void) {
@ -2239,10 +2260,578 @@ 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);
BoardPlayerIdleSet(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);
BoardPlayerIdleSet(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++) {
BoardPlayerIdleSet(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) {
return BoardModelIDGet(BoardPlayerModelGet(arg0));
static void RemoveSparkSpace(s32 player)
{
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);
}
typedef struct mega_squish_work {
struct {
u8 kill : 1;
u8 no_coinchg : 1;
u8 played_snd : 1;
u8 gain_player : 2;
};
s8 player;
s8 state;
s8 coinchg;
s8 loss;
s8 disappear_time;
s8 disappear_len;
u16 hide_time;
} MegaSquishWork;
static void MegaSquishFunc(omObjData *object)
{
MegaSquishWork *work = OM_GET_WORK_PTR(object, MegaSquishWork);
Vec pos;
if(work->kill || BoardIsKill()) {
if(work->coinchg != -1) {
BoardCoinChgHide(work->coinchg);
}
megaSquishObj[work->player] = NULL;
omDelObjEx(HuPrcCurrentGet(), object);
return;
}
if(work->hide_time != 0) {
work->hide_time--;
return;
}
switch(work->state) {
case 1:
if(!work->played_snd) {
HuAudFXPlay(798);
HuAudFXPlay(megaSquishSfxTbl[GWPlayer[work->player].character]);
work->played_snd = 1;
}
BoardPlayerMotionStart(work->player, 10, 0);
BoardPlayerMotionSpeedSet(work->player, 2.0f);
work->state = 2;
break;
case 2:
{
if(!BoardModelMotionTimeGet(BoardPlayerModelGet(work->player) >= 50.0f)) {
return;
}
BoardPlayerMotionSpeedSet(work->player, 0.0f);
BoardPlayerPosGet(work->player, &pos);
pos.y += 10.0f;
BoardPlayerPosSetV(work->player, &pos);
work->hide_time = 20;
work->state = 3;
work->coinchg = -1;
work->disappear_time = 0;
}
break;
case 3:
if(work->coinchg == -1) {
BoardPlayerPosGet(work->player, &pos);
pos.y += 250.0f;
if(!work->no_coinchg) {
work->coinchg = BoardCoinChgCreate(&pos, -work->loss);
} else {
work->state = 4;
work->hide_time = work->disappear_len;
}
}
if(work->disappear_time++ < work->disappear_len) {
return;
}
work->disappear_time = 0;
if(work->loss <= 0) {
work->state = 4;
HuAudFXPlay(15);
} else {
work->loss--;
BoardPlayerCoinsAdd(work->player, -1);
HuAudFXPlay(14);
BoardPlayerCoinsAdd(work->gain_player, 1);
}
break;
case 4:
BoardPlayerMotionSpeedSet(work->player, 2.0f);
BoardPlayerPosGet(work->player, &pos);
pos.y -= 10.0f;
BoardPlayerPosSetV(work->player, &pos);
work->state = 5;
break;
case 5:
if(!BoardPlayerMotionEndCheck(work->player)) {
return;
}
BoardPlayerIdleSet(work->player);
work->kill = 1;
break;
case 0:
break;
default:
break;
}
}
static s32 MegaPlayerPassFunc(s32 player, s32 space)
{
float temp_f30;
float temp_f29;
MegaSquishWork *temp_r31;
s32 temp_r29;
MegaSquishWork *temp_r28;
s32 temp_r27;
s32 temp_r26;
s32 temp_r24;
omObjData *temp_r23;
s32 spD0[4];
Vec spC4;
Vec spB8;
Vec spAC;
Vec spA0;
float sp98[2];
if(GWPlayer[player].bowser_suit) {
return MegaExecJump(player, space);
}
if(BoardPlayerSizeGet(player) != 2) {
return 0;
}
spD0[0] = spD0[1] = spD0[2] = -1;
for(temp_r26=temp_r29=0; temp_r29<4; temp_r29++) {
if(temp_r29 != player && GWPlayer[temp_r29].space_curr == space) {
spD0[temp_r26++] = temp_r29;
BoardPlayerPosGet(temp_r29, &spA0);
temp_r23 = omAddObjEx(boardObjMan, 256, 0, 0, -1, MegaSquishFunc);
megaSquishObj[temp_r29] = temp_r23;
temp_r31 = OM_GET_WORK_PTR(temp_r23, MegaSquishWork);
temp_r31->kill = 0;
temp_r31->player = temp_r29;
temp_r31->gain_player = player;
temp_r31->state = 0;
temp_r31->hide_time = 0;
temp_r31->loss = 0;
temp_r31->disappear_len = 3;
temp_r31->disappear_time = 0;
temp_r31->played_snd = 0;
if(BoardPlayerCoinsGet(temp_r31->player) <= 0) {
temp_r31->no_coinchg = 1;
} else {
temp_r31->no_coinchg = 0;
}
if(BoardPlayerCoinsGet(temp_r31->player) >= 10) {
temp_r31->loss = 10;
} else {
temp_r31->loss = BoardPlayerCoinsGet(temp_r31->player);
}
}
}
if(temp_r26 == 0) {
return 0;
}
if (_CheckFlag(0x1000BU) != 0) {
BoardTutorialHookExec(24, 0);
}
BoardPlayerPosGet(player, &spB8);
BoardSpacePosGet(0, space, &spC4);
sp98[0] = spB8.y;
if(spC4.y > spB8.y) {
spB8.y += 300.0f;
} else {
spB8.y += 200.0f;
}
VECSubtract(&spC4, &spB8, &spAC);
spAC.x /= 60.0f;
spAC.z /= 60.0f;
BoardPlayerRotYSet(player, 90.0-(180.0*(atan2(spAC.z, spAC.x)/M_PI)));
sp98[1] = BoardVecDistXZCalc(&spC4, &spB8);
BoardPlayerMotionShiftSet(player, 4, 0, 8, 0);
HuPrcSleep(8);
temp_r24 = 0;
for(temp_f30=0; temp_f30<60.0f; temp_f30++) {
temp_f29 = spB8.y;
spB8.x += spAC.x;
spB8.z += spAC.z;
spB8.y += 10.0f + (0.9f*(-0.020416668f * temp_f30 * temp_f30));
if(temp_f29 > spB8.y) {
temp_r24 = 1;
}
if(spB8.y <= 200.0f+spC4.y && temp_r24) {
for(temp_r27=0; temp_r27<4; temp_r27++) {
if(megaSquishObj[temp_r27]) {
temp_r28 = OM_GET_WORK_PTR(megaSquishObj[temp_r27], MegaSquishWork);
if((s16)space == GWPlayer[temp_r28->player].space_curr && temp_r28->state != 1) {
temp_r28->state = 1;
}
}
}
}
if(spB8.y <= spC4.y) {
spB8.y = spC4.y;
BoardPlayerMotionShiftSet(player, 5, 0, 4, 0);
}
BoardPlayerPosSetV(player, &spB8);
HuPrcVSleep();
}
BoardCameraQuakeSet(30, 500.0f);
omVibrate(0, 12, 4, 2);
omVibrate(1, 12, 4, 2);
omVibrate(2, 12, 4, 2);
omVibrate(3, 12, 4, 2);
BoardPlayerIdleSet(player);
HuPrcSleep(30);
}
static s32 MegaExecJump(s32 player, s32 space)
{
float temp_f30;
float temp_f29;
MegaSquishWork *temp_r31;
s32 temp_r29;
MegaSquishWork *temp_r28;
s32 temp_r27;
s32 temp_r26;
s32 temp_r25;
s32 temp_r24;
omObjData *temp_r23;
s32 spD0[4];
Vec spC4;
Vec spB8;
Vec spAC;
Vec spA0;
float sp90[2];
spD0[0] = spD0[1] = spD0[2] = -1;
for(temp_r26=temp_r29=0; temp_r29<4; temp_r29++) {
if(temp_r29 != player && GWPlayer[temp_r29].space_curr == space) {
spD0[temp_r26++] = temp_r29;
BoardPlayerPosGet(temp_r29, &spA0);
temp_r23 = omAddObjEx(boardObjMan, 256, 0, 0, -1, MegaSquishFunc);
megaSquishObj[temp_r29] = temp_r23;
temp_r31 = OM_GET_WORK_PTR(temp_r23, MegaSquishWork);
temp_r31->kill = 0;
temp_r31->player = temp_r29;
temp_r31->gain_player = player;
temp_r31->state = 0;
temp_r31->hide_time = 0;
temp_r31->loss = 0;
temp_r31->disappear_len = 3;
temp_r31->disappear_time = 0;
if(BoardPlayerCoinsGet(temp_r31->player) <= 0) {
temp_r31->no_coinchg = 1;
} else {
temp_r31->no_coinchg = 0;
}
if(BoardPlayerCoinsGet(temp_r31->player) >= 30) {
temp_r31->loss = 30;
} else {
temp_r31->loss = BoardPlayerCoinsGet(temp_r31->player);
}
}
}
if(temp_r26 == 0) {
return 0;
}
BoardPlayerPosGet(player, &spB8);
BoardSpacePosGet(0, space, &spC4);
sp90[0] = spB8.y;
if(spC4.y > spB8.y) {
spB8.y += 300.0f;
} else {
spB8.y += 200.0f;
}
VECSubtract(&spC4, &spB8, &spAC);
spAC.x /= 60.0f;
spAC.z /= 60.0f;
BoardPlayerRotYSet(player, 90.0-(180.0*(atan2(spAC.z, spAC.x)/M_PI)));
BoardPlayerIdleSet(player);
HuPrcSleep(10);
sp90[1] = BoardVecDistXZCalc(&spC4, &spB8);
BoardModelMotionShiftSet(suitMdl, bowserSuitMot[3], 0.0f, 8.0f, 0);
BoardModelMotionSpeedSet(suitMdl, 2.0f);
HuPrcSleep(8);
HuAudFXPlay(809);
temp_r24 = 0;
temp_r25 = 0;
for(temp_f30=0; temp_f30<60.0f; temp_f30++) {
temp_f29 = spB8.y;
spB8.x += spAC.x;
spB8.z += spAC.z;
spB8.y += 10.0f + (0.9f*(-0.020416668f * temp_f30 * temp_f30));
if(temp_f29 > spB8.y) {
temp_r25 = 1;
}
if(spB8.y <= 200.0f+spC4.y && temp_r25) {
for(temp_r27=0; temp_r27<4; temp_r27++) {
if(megaSquishObj[temp_r27]) {
temp_r28 = OM_GET_WORK_PTR(megaSquishObj[temp_r27], MegaSquishWork);
if((s16)space == GWPlayer[temp_r28->player].space_curr && temp_r28->state != 1) {
temp_r28->state = 1;
}
}
}
}
if(spB8.y <= spC4.y) {
spB8.y = spC4.y;
if(!temp_r24) {
BoardPlayerIdleSet(player);
HuAudFXPlay(810);
temp_r24 = 1;
}
}
BoardPlayerPosSetV(player, &spB8);
HuPrcVSleep();
}
BoardCameraQuakeSet(30, 500.0f);
omVibrate(0, 12, 4, 2);
omVibrate(1, 12, 4, 2);
omVibrate(2, 12, 4, 2);
omVibrate(3, 12, 4, 2);
BoardPlayerIdleSet(player);
HuPrcSleep(30);
}
void BoardPlayerCopyEyeMat(s32 arg0, s32 arg1) {
@ -2290,14 +2879,13 @@ void BoardPlayerCopyEyeMat(s32 arg0, s32 arg1) {
DCStoreRange(hsfData->material, hsfData->materialCnt * 0x3C);
}
void BoardPlayerCopyMat(s32 arg0) {
s16 modelID;
ModelData *model;
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);

14
src/game/board/space.c
View file

@ -639,7 +639,7 @@ s32 BoardSpaceWalkExec(s32 player, s32 space)
if(space_ptr->flag & 0x600000) {
s32 mg_param = GWSystem.unk_38;
if(BoardPlayerSizeGet(player) == 1) {
BoardRotateDiceNumbers(player);
BoardPlayerIdleSet(player);
BoardMGCreate(mg_param);
}
return 1;
@ -1000,15 +1000,15 @@ void BoardSpaceInit(s32 data_num)
size = bmp->sizeX;
spaceHiliteTexFmt = -1;
switch(bmp->dataFmt) {
case SPRITE_BMP_RGBA8:
case ANIM_BMP_RGBA8:
spaceHiliteTexFmt = GX_TF_RGBA8;
break;
case SPRITE_BMP_RGB5A3_DUPE:
case ANIM_BMP_RGB5A3_DUPE:
spaceHiliteTexFmt = GX_TF_RGB5A3;
break;
case SPRITE_BMP_CMPR:
case ANIM_BMP_CMPR:
spaceHiliteTexFmt = GX_TF_CMPR;
break;
}
@ -1032,15 +1032,15 @@ void BoardSpaceInit(s32 data_num)
size = bmp->sizeX;
spaceTexFmt = -1;
switch(bmp->dataFmt) {
case SPRITE_BMP_RGBA8:
case ANIM_BMP_RGBA8:
spaceTexFmt = GX_TF_RGBA8;
break;
case SPRITE_BMP_RGB5A3_DUPE:
case ANIM_BMP_RGB5A3_DUPE:
spaceTexFmt = GX_TF_RGB5A3;
break;
case SPRITE_BMP_CMPR:
case ANIM_BMP_CMPR:
spaceTexFmt = GX_TF_CMPR;
break;
}

5
src/game/board/star.c
View file

@ -14,6 +14,7 @@
#include "game/board/main.h"
#include "game/board/model.h"
#include "game/board/player.h"
#include "game/board/space.h"
#include "game/board/tutorial.h"
#include "game/board/ui.h"
#include "game/board/window.h"
@ -211,7 +212,7 @@ static void ExecStar(void) {
temp_f30 = 90.0 - 180.0 * (atan2(spC.z, spC.x) / M_PI);
temp_f30 = 90.0f * ((temp_f30 + 3.0f) / 90.0f);
temp_f29 = BoardPlayerRotYGet(temp_r31);
BoardRotateDiceNumbers(temp_r31);
BoardPlayerIdleSet(temp_r31);
if (BoardDAngleCalc(temp_f30 - temp_f29) < 0.0f) {
var_f28 = -BoardDAngleCalc(temp_f30 - temp_f29);
} else {
@ -689,7 +690,7 @@ void BoardStarShowNext(s32 arg0) {
BoardAudSeqFadeOut(0, 1000);
}
showNextObj = omAddObjEx(boardObjMan, 0x7E03, 0, 0, -1, ShowNextUpdate);
BoardRotateDiceNumbers(arg0);
BoardPlayerIdleSet(arg0);
BoardModelMotionStart(BoardStarHostMdlGet(), 1, 0x40000001);
BoardModelPosGet(BoardStarHostMdlGet(), &sp50);
showNextObj->scale.x = sp50.x;

2
src/game/board/ui.c
View file

@ -1152,7 +1152,7 @@ static void FinishItemUse(s16 arg0, s32 arg1) {
case 10:
HuPrcSleep(2);
BoardBowserSuitMotionCreate();
BoardRotateDiceNumbers(itemPlayer);
BoardPlayerIdleSet(itemPlayer);
BoardModelLayerSet(BoardBowserSuitModelGet(), 0);
BoardModelLayerSet(BoardBowserSuitPlayerModelGet(), 0);
break;

14
src/game/board/warp.c
View file

@ -1,7 +1,9 @@
#include "game/board/warp.h"
#include "game/board/char_wheel.h"
#include "game/board/main.h"
#include "game/board/model.h"
#include "game/board/player.h"
#include "game/board/space.h"
#include "game/board/tutorial.h"
#include "game/wipe.h"
#include "game/gamework_data.h"
@ -17,12 +19,6 @@ static void WarpStartImpact(s32);
static void WarpFall(s32);
static void WarpImpact(s32);
extern void BoardCharWheelInit(s32, s32);
extern void BoardCharWheelSpeedSet(f32);
extern void BoardCharWheelWait(void);
extern s32 BoardCharWheelResultGet(void);
static Vec warpPos;
static s8 warpState;
@ -66,7 +62,7 @@ void WarpProcess(void) {
HuPrcVSleep();
}
BoardRotateDiceNumbers(curr_player);
BoardPlayerIdleSet(curr_player);
if (_CheckFlag(0x1000B) != 0) {
BoardTutorialHookExec(18, 0);
boardTutorialData[0] = 0;
@ -144,7 +140,7 @@ static void WarpInit(s32 player) {
HuAudFXPlay(835);
BoardPlayerRotYSet(player, 0.0f);
BoardPlayerPosSet(player, 0.0f, 0.0f, 0.0f);
BoardRotateDiceNumbers(player);
BoardPlayerIdleSet(player);
}
static void WarpLaunch(s32 player) {
@ -245,7 +241,7 @@ static void WarpImpact(s32 player) {
HuPrcSleep(60);
for (i = 0; i < warpImpactCnt; i++) {
BoardRotateDiceNumbers(warpImpactPlayer[i]);
BoardPlayerIdleSet(warpImpactPlayer[i]);
}
warpState = 6;
}