Merge branch 'Rainchus:main' into main
This commit is contained in:
CreateSource
GitHub
commit
ecf2b20a15
116 changed files with 21323 additions and 1302 deletions
158
src/game/board/audio.c
Executable file
158
src/game/board/audio.c
Executable file
|
|
@ -0,0 +1,158 @@
|
|||
#include "game/board/audio.h"
|
||||
#include "game/audio.h"
|
||||
#include "game/gamework_data.h"
|
||||
#include "game/msm.h"
|
||||
|
||||
static s16 boardSeq[2][2];
|
||||
|
||||
static s32 boardFX = -1;
|
||||
|
||||
static s16 boardMusTbl[] = {
|
||||
0x000D, 0x0011, 0x0015,
|
||||
0x001C, 0x0021, 0x0025,
|
||||
0x0028, 0x0029, 0x002A
|
||||
};
|
||||
|
||||
void BoardMusStartBoard(void) {
|
||||
s16 temp_r31 = boardMusTbl[GWBoardGet()];
|
||||
|
||||
BoardMusStart(0, temp_r31, 0x7F, 0);
|
||||
BoardAudFXPlay();
|
||||
}
|
||||
|
||||
void BoardMusStart(s32 arg0, s32 arg1, s8 arg2, u16 arg3) {
|
||||
s16 *temp_r31 = boardSeq[arg0];
|
||||
UnkMsmStruct_03 sp8;
|
||||
|
||||
if (arg1 == temp_r31[1]) {
|
||||
return;
|
||||
}
|
||||
if (temp_r31[0] != -1) {
|
||||
BoardAudSeqFadeOutFast(temp_r31[0]);
|
||||
}
|
||||
sp8.unk00 = 1;
|
||||
if (arg3 != 0) {
|
||||
sp8.unk00 |= 8;
|
||||
}
|
||||
if (arg2 < 0) {
|
||||
sp8.unk00 |= 2;
|
||||
arg2 = 0x7F;
|
||||
}
|
||||
sp8.unk06 = arg3;
|
||||
sp8.unk05 = arg2;
|
||||
sp8.unk04 = arg0;
|
||||
temp_r31[0] = msmMusPlay(arg1, &sp8);
|
||||
temp_r31[1] = arg1;
|
||||
}
|
||||
|
||||
void BoardAudSeqFadeOutFast(s32 arg0) {
|
||||
BoardAudSeqFadeOut(arg0, 0x64);
|
||||
}
|
||||
|
||||
void BoardAudSeqFadeOut(s32 arg0, u16 arg1) {
|
||||
s16 *temp_r31 = boardSeq[arg0];
|
||||
|
||||
if (temp_r31[0] == -1) {
|
||||
return;
|
||||
}
|
||||
HuAudSeqFadeOut(temp_r31[0], arg1);
|
||||
temp_r31[1] = temp_r31[0] = -1;
|
||||
}
|
||||
|
||||
void BoardMusLoudSet(s32 arg0, s32 arg1) {
|
||||
if (arg1 != 0) {
|
||||
BoardMusVolPanSet(arg0, 0x60, 0x1F4);
|
||||
} else {
|
||||
BoardMusVolPanSet(arg0, 0x7F, 0x1F4);
|
||||
}
|
||||
}
|
||||
|
||||
void BoardMusVolPanSet(s32 arg0, s8 arg1, u16 arg2) {
|
||||
s16 *temp_r31 = boardSeq[arg0];
|
||||
UnkMsmStruct_04 sp10;
|
||||
|
||||
if (temp_r31[0] == -1) {
|
||||
return;
|
||||
}
|
||||
sp10.unk00 = 1;
|
||||
sp10.unk00 |= 2;
|
||||
if (arg1 < 0) {
|
||||
arg1 = 0x7F;
|
||||
}
|
||||
sp10.unk06 = arg2;
|
||||
sp10.unk05 = arg1;
|
||||
msmMusSetParam(temp_r31[0], &sp10);
|
||||
}
|
||||
|
||||
void BoardAudSeqPause(s32 arg0, s32 arg1, u16 arg2) {
|
||||
s16 *temp_r31 = boardSeq[arg0];
|
||||
|
||||
if (temp_r31[0] == -1) {
|
||||
return;
|
||||
}
|
||||
if (arg1 != 0) {
|
||||
if (BoardMusStatusGet(arg0) == 3) {
|
||||
return;
|
||||
}
|
||||
} else if (BoardMusStatusGet(arg0) != 3) {
|
||||
return;
|
||||
}
|
||||
HuAudSeqPause(temp_r31[0], arg1, arg2);
|
||||
}
|
||||
|
||||
s32 BoardMusStatusGet(s32 arg0) {
|
||||
s16 *temp_r31 = boardSeq[arg0];
|
||||
|
||||
if (temp_r31[0] == -1) {
|
||||
return 0;
|
||||
}
|
||||
return msmMusGetStatus(temp_r31[0]);
|
||||
}
|
||||
|
||||
void BoardAudSeqClear(void) {
|
||||
s32 i;
|
||||
|
||||
for (i = 0; i < 2; i++) {
|
||||
boardSeq[i][0] = boardSeq[i][1] = -1;
|
||||
}
|
||||
boardFX = -1;
|
||||
}
|
||||
|
||||
void BoardAudSeqFadeOutAll(void) {
|
||||
s16 *temp_r31;
|
||||
s32 i;
|
||||
|
||||
for (i = 0; i < 2; i++) {
|
||||
temp_r31 = boardSeq[i];
|
||||
if (temp_r31[0] != -1) {
|
||||
HuAudSeqFadeOut(temp_r31[0], 0x64);
|
||||
temp_r31[1] = temp_r31[0] = -1;
|
||||
}
|
||||
}
|
||||
BoardAudFXStop();
|
||||
}
|
||||
|
||||
void BoardAudFXPlay(void) {
|
||||
s32 var_r31;
|
||||
|
||||
switch (GWBoardGet()) {
|
||||
case 4:
|
||||
var_r31 = 0x48D;
|
||||
break;
|
||||
case 5:
|
||||
var_r31 = 0x4A2;
|
||||
break;
|
||||
default:
|
||||
return;
|
||||
}
|
||||
if (boardFX == -1) {
|
||||
boardFX = HuAudFXPlay(var_r31);
|
||||
}
|
||||
}
|
||||
|
||||
void BoardAudFXStop(void) {
|
||||
if (boardFX != -1) {
|
||||
HuAudFXStop(boardFX);
|
||||
boardFX = -1;
|
||||
}
|
||||
}
|
||||
|
|
@ -1,9 +1,11 @@
|
|||
#include "game/board/basic_space.h"
|
||||
#include "game/board/main.h"
|
||||
#include "game/board/player.h"
|
||||
#include "game/board/tutorial.h"
|
||||
#include "game/data.h"
|
||||
#include "game/flag.h"
|
||||
#include "game/object.h"
|
||||
#include "game/objsub.h"
|
||||
#include "game/gamework_data.h"
|
||||
#include "board_unsplit.h"
|
||||
#include "math.h"
|
||||
|
|
@ -33,9 +35,7 @@ static void CoinChgSeparate(omObjData*, coinChg*);
|
|||
static void CoinChgShow(omObjData*, coinChg*);
|
||||
static void CoinChgDisappear(omObjData*, coinChg*);
|
||||
|
||||
extern void BoardTutorialHookExec(s16, s32);
|
||||
extern void BoardCameraViewSet(s32);
|
||||
extern void omVibrate(s16, s16, s16, s16);
|
||||
extern void BoardPlayerPosGet(s32, Vec*);
|
||||
extern void BoardModelPosGet(s16, Vec*);
|
||||
extern void BoardPlayerMotionEndWait(s32);
|
||||
|
|
@ -52,16 +52,16 @@ static omObjData *coinChgObj[4] = {
|
|||
};
|
||||
|
||||
static s32 coinDigitMdl[10] = {
|
||||
MAKE_DATA_NUM(DATADIR_BOARD, 12),
|
||||
MAKE_DATA_NUM(DATADIR_BOARD, 13),
|
||||
MAKE_DATA_NUM(DATADIR_BOARD, 14),
|
||||
MAKE_DATA_NUM(DATADIR_BOARD, 15),
|
||||
MAKE_DATA_NUM(DATADIR_BOARD, 16),
|
||||
MAKE_DATA_NUM(DATADIR_BOARD, 17),
|
||||
MAKE_DATA_NUM(DATADIR_BOARD, 18),
|
||||
MAKE_DATA_NUM(DATADIR_BOARD, 19),
|
||||
MAKE_DATA_NUM(DATADIR_BOARD, 20),
|
||||
MAKE_DATA_NUM(DATADIR_BOARD, 21),
|
||||
DATA_MAKE_NUM(DATADIR_BOARD, 12),
|
||||
DATA_MAKE_NUM(DATADIR_BOARD, 13),
|
||||
DATA_MAKE_NUM(DATADIR_BOARD, 14),
|
||||
DATA_MAKE_NUM(DATADIR_BOARD, 15),
|
||||
DATA_MAKE_NUM(DATADIR_BOARD, 16),
|
||||
DATA_MAKE_NUM(DATADIR_BOARD, 17),
|
||||
DATA_MAKE_NUM(DATADIR_BOARD, 18),
|
||||
DATA_MAKE_NUM(DATADIR_BOARD, 19),
|
||||
DATA_MAKE_NUM(DATADIR_BOARD, 20),
|
||||
DATA_MAKE_NUM(DATADIR_BOARD, 21),
|
||||
};
|
||||
|
||||
void BoardLandBlueExec(s32 player, s32 space) {
|
||||
|
|
@ -206,8 +206,8 @@ void BoardCoinChgHide(s32 index) {
|
|||
}
|
||||
|
||||
static const s32 coinSignMdl[2] = {
|
||||
MAKE_DATA_NUM(DATADIR_BOARD, 22),
|
||||
MAKE_DATA_NUM(DATADIR_BOARD, 23)
|
||||
DATA_MAKE_NUM(DATADIR_BOARD, 22),
|
||||
DATA_MAKE_NUM(DATADIR_BOARD, 23)
|
||||
};
|
||||
|
||||
static void CreateCoinChg(coinChg *coin_chg, Vec *pos) {
|
||||
|
|
@ -221,7 +221,7 @@ static void CreateCoinChg(coinChg *coin_chg, Vec *pos) {
|
|||
coin_chg->sign_model = BoardModelCreate(coinSignMdl[coin_chg->minus], NULL, 0);
|
||||
coin_chg->tens_model = BoardModelCreate(coinDigitMdl[coin_chg->tens], NULL, 0);
|
||||
coin_chg->ones_model = BoardModelCreate(coinDigitMdl[coin_chg->ones], NULL, 0);
|
||||
coin_chg->coin_model = BoardModelCreate(MAKE_DATA_NUM(DATADIR_BOARD, 10), NULL, 0);
|
||||
coin_chg->coin_model = BoardModelCreate(DATA_MAKE_NUM(DATADIR_BOARD, 10), NULL, 0);
|
||||
BoardModelPosSetV(coin_chg->sign_model, pos);
|
||||
BoardModelPosSetV(coin_chg->tens_model, pos);
|
||||
BoardModelPosSetV(coin_chg->ones_model, pos);
|
||||
|
|
|
|||
462
src/game/board/block.c
Normal file
462
src/game/board/block.c
Normal file
|
|
@ -0,0 +1,462 @@
|
|||
#include "game/flag.h"
|
||||
#include "game/objsub.h"
|
||||
#include "game/process.h"
|
||||
#include "game/board/main.h"
|
||||
#include "game/board/player.h"
|
||||
#include "game/board/model.h"
|
||||
#include "game/board/star.h"
|
||||
#include "game/board/window.h"
|
||||
#include "math.h"
|
||||
|
||||
#define BLOCK_SPAWN 0
|
||||
#define BLOCK_HIT 2
|
||||
#define BLOCK_OPEN 3
|
||||
|
||||
typedef struct {
|
||||
struct {
|
||||
u8 kill : 1;
|
||||
u8 state : 3;
|
||||
u8 unk00_field2 : 1;
|
||||
u8 contains_star : 1;
|
||||
u8 opened : 1;
|
||||
u8 unk00_field5 : 1;
|
||||
};
|
||||
|
||||
s16 hit_y_velocity;
|
||||
s16 target_y_pos;
|
||||
} BlockWork;
|
||||
|
||||
typedef struct {
|
||||
struct {
|
||||
u8 kill : 1;
|
||||
};
|
||||
|
||||
u8 lifetime;
|
||||
s8 model_index;
|
||||
s16 model;
|
||||
} CoinWork;
|
||||
|
||||
static void BlockProc(void);
|
||||
static void DestroyBlock(void);
|
||||
static void ExecBlockObj(omObjData* arg0);
|
||||
static void CreateBlockObj(s32 arg0);
|
||||
static void DestroyBlockObj(BlockWork* unused0, omObjData* unused1);
|
||||
static void SpawnBlock(BlockWork* arg0, omObjData* arg1);
|
||||
static void HitBlock(BlockWork* arg0, omObjData* arg1);
|
||||
static void OpenBlock(BlockWork* arg0, omObjData* arg1);
|
||||
static void SetBlockOpen(void);
|
||||
static void SetBlockStop(void);
|
||||
static void WaitBlockHit(void);
|
||||
static void CreateCoinMdl(void);
|
||||
static void KillCoinMdl(void);
|
||||
static void PopupCoin(void);
|
||||
static void PopupCoinExec(omObjData* arg0);
|
||||
|
||||
extern s8 boardTutorialBlockF;
|
||||
extern s8 boardTutorialBlockItem;
|
||||
|
||||
static s16 jumpMot = -1;
|
||||
static s16 starMdl = -1;
|
||||
|
||||
static f32 rotMax;
|
||||
static f32 scaleAngle;
|
||||
static f32 rotY;
|
||||
|
||||
static omObjData* blockObj;
|
||||
static Process* blockProc;
|
||||
|
||||
static s16 coinMdl[10] = { -1, -1, -1, -1 };
|
||||
static s32 coinF[10];
|
||||
|
||||
s32 BoardBlockExec(s32 arg0) {
|
||||
if (BoardPlayerSizeGet(arg0) == 2) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
blockProc = HuPrcChildCreate(BlockProc, 0x2003, 0x3800U, 0, boardMainProc);
|
||||
HuPrcDestructorSet2(blockProc, DestroyBlock);
|
||||
|
||||
while (blockProc != NULL) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void BlockProc(void) {
|
||||
s32 sp14[8] = {0x005F0060, 0x001A0060, 0x006D0060, 0x008A0060, 0x00850060, 0x00110060, 0x000D0060, 0x00810060};
|
||||
Point3d sp8;
|
||||
s32 var_r28;
|
||||
s32 i;
|
||||
s32 player;
|
||||
BlockWork* work;
|
||||
s32* temp_r4;
|
||||
s32 player_character;
|
||||
|
||||
player = GWSystem.player_curr;
|
||||
|
||||
player_character = GWPlayer[player].character;
|
||||
jumpMot = BoardPlayerMotionCreate(player, sp14[player_character]);
|
||||
BoardRotateDiceNumbers(player);
|
||||
BoardPlayerMotBlendSet(player, 0, 0xF);
|
||||
omVibrate(player, 12, 12, 0);
|
||||
CreateBlockObj(player);
|
||||
|
||||
work = OM_GET_WORK_PTR(blockObj, BlockWork);
|
||||
while (work->state != BLOCK_HIT) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
|
||||
BoardCameraViewSet(3);
|
||||
BoardCameraMotionWait();
|
||||
BoardWinCreate(0, 0x10000, -1);
|
||||
BoardWinWait();
|
||||
BoardWinKill();
|
||||
BoardPlayerMotionShiftSet(player, 0xB, 0, 8.0, 0.0);
|
||||
HuPrcSleep(9);
|
||||
while (BoardPlayerMotionTimeGet(player) < 30.0f) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
HuAudFXPlay(0x30C);
|
||||
SetBlockOpen();
|
||||
while (BoardPlayerMotionEndCheck(player) == 0) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
BoardRotateDiceNumbers(player);
|
||||
|
||||
if (work->contains_star != 0) {
|
||||
SetBlockStop();
|
||||
BoardModelPosGet(starMdl, &sp8);
|
||||
if (_CheckFlag(0x1000B) == 0) {
|
||||
BoardAudSeqPause(0, 1, 0x3E8);
|
||||
}
|
||||
BoardStarGive(player, &sp8);
|
||||
if (_CheckFlag(0x1000B) == 0) {
|
||||
BoardAudSeqPause(0, 0, 0x3E8);
|
||||
}
|
||||
} else {
|
||||
for (i = 0; i < 0x14; i++) {
|
||||
WaitBlockHit();
|
||||
BoardPlayerMotionStart(player, (s32) jumpMot, 0);
|
||||
BoardPlayerMotionSpeedSet(player, 2);
|
||||
while (BoardPlayerMotionTimeGet(player) < 4) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
SetBlockOpen();
|
||||
PopupCoin();
|
||||
while (BoardPlayerMotionEndCheck(player) == 0) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
BoardPlayerMotionStart(player, 1, 0);
|
||||
BoardPlayerCoinsAdd(player, 1);
|
||||
HuAudFXPlay(7);
|
||||
HuPrcVSleep();
|
||||
}
|
||||
|
||||
SetBlockStop();
|
||||
}
|
||||
|
||||
BoardWinCreate(0, work->contains_star != 0 ? 0x10001 : 0x10002, -1);
|
||||
BoardWinWait();
|
||||
BoardWinKill();
|
||||
KillCoinMdl();
|
||||
work->kill = 1;
|
||||
|
||||
BoardRotateDiceNumbers((s32) player);
|
||||
HuPrcVSleep();
|
||||
|
||||
if ((_CheckFlag(0x1000B) != 0) && work->contains_star == 0) {
|
||||
BoardTutorialHookExec(0x16, 0);
|
||||
}
|
||||
|
||||
BoardCameraViewSet(2);
|
||||
BoardCameraMotionWait();
|
||||
HuPrcEnd();
|
||||
}
|
||||
|
||||
static void DestroyBlock(void) {
|
||||
if (jumpMot != -1) {
|
||||
BoardPlayerMotionKill(GWSystem.player_curr, jumpMot);
|
||||
jumpMot = -1;
|
||||
}
|
||||
KillCoinMdl();
|
||||
blockProc = 0;
|
||||
}
|
||||
|
||||
static void CreateBlockObj(s32 arg0) {
|
||||
Point3d player_pos;
|
||||
BlockWork* work;
|
||||
s8 contains_star;
|
||||
|
||||
BoardPlayerPosGet(arg0, &player_pos);
|
||||
starMdl = BoardModelCreate(0x70004, NULL, 0);
|
||||
BoardModelVisibilitySet(starMdl, 0);
|
||||
BoardModelMotionSpeedSet(starMdl, 0);
|
||||
BoardModelLayerSet(starMdl, 2U);
|
||||
|
||||
blockObj = omAddObjEx(boardObjMan, 0x101, 0U, 0U, -1, ExecBlockObj);
|
||||
|
||||
work = OM_GET_WORK_PTR(blockObj, BlockWork);
|
||||
work->kill = 0;
|
||||
work->unk00_field2 = 0;
|
||||
work->opened = 0;
|
||||
work->unk00_field5 = 0;
|
||||
work->state = BLOCK_SPAWN;
|
||||
|
||||
blockObj->trans.x = player_pos.x;
|
||||
blockObj->trans.y = 270 + player_pos.y;
|
||||
blockObj->trans.z = player_pos.z;
|
||||
|
||||
blockObj->scale.x = blockObj->scale.y = blockObj->scale.z = 0.01;
|
||||
blockObj->rot.x = blockObj->rot.y = blockObj->rot.z = 0.0;
|
||||
|
||||
scaleAngle = 0;
|
||||
rotY = 0;
|
||||
rotMax = 30;
|
||||
|
||||
BoardModelVisibilitySet(starMdl, 1);
|
||||
|
||||
if (BoardRandFloat() > 0.5f) {
|
||||
contains_star = 0;
|
||||
} else {
|
||||
contains_star = 1;
|
||||
}
|
||||
|
||||
work->contains_star = contains_star;
|
||||
|
||||
if (boardTutorialBlockF != 0) {
|
||||
work->contains_star = boardTutorialBlockItem;
|
||||
boardTutorialBlockF = 0;
|
||||
}
|
||||
|
||||
HuAudFXPlay(0x302);
|
||||
|
||||
if (work->contains_star == 0) {
|
||||
CreateCoinMdl();
|
||||
}
|
||||
}
|
||||
|
||||
static void ExecBlockObj(omObjData* arg0) {
|
||||
BlockWork* work;
|
||||
|
||||
work = OM_GET_WORK_PTR(arg0, BlockWork);
|
||||
|
||||
if (work->kill != 0 || BoardIsKill() != 0) {
|
||||
DestroyBlockObj(work, arg0);
|
||||
blockObj = 0;
|
||||
omDelObjEx(HuPrcCurrentGet(), arg0);
|
||||
return;
|
||||
}
|
||||
|
||||
switch (work->state) {
|
||||
case BLOCK_SPAWN:
|
||||
SpawnBlock(work, arg0);
|
||||
break;
|
||||
case BLOCK_HIT:
|
||||
HitBlock(work, arg0);
|
||||
break;
|
||||
case BLOCK_OPEN:
|
||||
OpenBlock(work, arg0);
|
||||
break;
|
||||
}
|
||||
|
||||
if (work->unk00_field5 != 0) {
|
||||
BoardModelVisibilitySet(starMdl, 0);
|
||||
}
|
||||
|
||||
BoardModelPosSet(starMdl, arg0->trans.x, arg0->trans.y, arg0->trans.z);
|
||||
BoardModelRotSet(starMdl, arg0->rot.x, arg0->rot.y, arg0->rot.z);
|
||||
BoardModelScaleSet(starMdl, arg0->scale.x, arg0->scale.y, arg0->scale.z);
|
||||
}
|
||||
|
||||
static void DestroyBlockObj(BlockWork* unused0, omObjData* unused1) {
|
||||
if (starMdl != -1) {
|
||||
BoardModelKill(starMdl);
|
||||
starMdl = -1;
|
||||
}
|
||||
}
|
||||
|
||||
static void SpawnBlock(BlockWork* arg0, omObjData* arg1) {
|
||||
if (scaleAngle < 90.0f) {
|
||||
scaleAngle += 3.75f;
|
||||
if (scaleAngle > 90.0f) {
|
||||
scaleAngle = 90.0f;
|
||||
}
|
||||
} else {
|
||||
rotMax *= 0.5f;
|
||||
if (rotMax < 0.8f) {
|
||||
rotY = 0.0f;
|
||||
rotMax = 0.0f;
|
||||
arg0->hit_y_velocity = 0;
|
||||
arg0->state = BLOCK_HIT;
|
||||
}
|
||||
}
|
||||
|
||||
if (rotY < 360.0f) {
|
||||
rotY += rotMax;
|
||||
if (rotY > 360.0f) {
|
||||
rotY = 360.0f;
|
||||
}
|
||||
}
|
||||
|
||||
arg1->rot.y = rotY;
|
||||
arg1->scale.x = arg1->scale.y = arg1->scale.z = sin(M_PI * scaleAngle / 180.0);
|
||||
}
|
||||
|
||||
static void HitBlock(BlockWork* arg0, omObjData* arg1) {
|
||||
float var_f30;
|
||||
|
||||
arg0->hit_y_velocity += 3;
|
||||
if (arg0->hit_y_velocity > 0x168) {
|
||||
arg0->hit_y_velocity -= 0x168;
|
||||
}
|
||||
|
||||
OSs16tof32(&arg0->hit_y_velocity, &var_f30);
|
||||
arg1->trans.y += 0.2f * sin((M_PI * var_f30) / 180.0);
|
||||
}
|
||||
|
||||
static void OpenBlock(BlockWork* arg0, omObjData* arg1) {
|
||||
f32 target_y_pos;
|
||||
|
||||
if (arg0->opened == 0) {
|
||||
arg0->opened = 1;
|
||||
HuAudFXPlay(0x33B);
|
||||
BoardModelMotionStart(starMdl, 0, 0);
|
||||
}
|
||||
|
||||
if (arg0->unk00_field2 == 0) {
|
||||
OSf32tos16(&arg1->trans.y, &arg0->target_y_pos);
|
||||
|
||||
arg1->trans.y += 80.0f;
|
||||
arg0->unk00_field2 = 1;
|
||||
} else {
|
||||
OSs16tof32(&arg0->target_y_pos, &target_y_pos);
|
||||
arg1->trans.y += -8.0f;
|
||||
|
||||
if (arg1->trans.y < target_y_pos) {
|
||||
arg1->trans.y = target_y_pos;
|
||||
arg0->state = BLOCK_HIT;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void SetBlockOpen(void) {
|
||||
BlockWork* work;
|
||||
|
||||
work = OM_GET_WORK_PTR(blockObj, BlockWork);
|
||||
work->state = BLOCK_OPEN;
|
||||
}
|
||||
|
||||
static void SetBlockStop(void) {
|
||||
BlockWork* work;
|
||||
|
||||
work = OM_GET_WORK_PTR(blockObj, BlockWork);
|
||||
work->unk00_field5 = 1;
|
||||
}
|
||||
|
||||
static void WaitBlockHit(void) {
|
||||
BlockWork* work;
|
||||
|
||||
work = OM_GET_WORK_PTR(blockObj, BlockWork);
|
||||
|
||||
while (work->state != BLOCK_HIT) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
}
|
||||
|
||||
static void CreateCoinMdl(void) {
|
||||
s32 i;
|
||||
|
||||
for (i = 0; i < 10; i += 1) {
|
||||
coinMdl[i] = BoardModelCreate(0x7000A, NULL, 1);
|
||||
BoardModelVisibilitySet(coinMdl[i], 0);
|
||||
coinF[i] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
static void KillCoinMdl(void) {
|
||||
s32 i;
|
||||
|
||||
for (i = 0; i < 0xA; i += 1) {
|
||||
if (coinMdl[i] != -1) {
|
||||
BoardModelKill(coinMdl[i]);
|
||||
coinMdl[i] = -1;
|
||||
}
|
||||
coinF[i] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
static inline s32 FindCoinModel(s16 *out_model) {
|
||||
s32 i;
|
||||
|
||||
for (i = 0; i < 10; i++) {
|
||||
if (coinF[i] == 0) {
|
||||
*out_model = coinMdl[i];
|
||||
return i;
|
||||
}
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
static void PopupCoin(void) {
|
||||
Point3d star_pos;
|
||||
omObjData* coinObj;
|
||||
s32 model_index;
|
||||
s16 model;
|
||||
CoinWork* work;
|
||||
|
||||
do {
|
||||
HuPrcVSleep();
|
||||
model_index = FindCoinModel(&model);
|
||||
} while (model_index == -1);
|
||||
|
||||
coinObj = omAddObjEx(boardObjMan, 0x101, 0, 0, -1, PopupCoinExec);
|
||||
work = OM_GET_WORK_PTR(coinObj, CoinWork);
|
||||
|
||||
work->kill = 0;
|
||||
work->lifetime = 10;
|
||||
work->model = model;
|
||||
work->model_index = model_index;
|
||||
|
||||
coinObj->trans.x = 15.0f;
|
||||
coinObj->trans.y = 40.0f;
|
||||
|
||||
BoardModelPosGet(starMdl, &star_pos);
|
||||
BoardModelPosSetV(work->model, &star_pos);
|
||||
BoardModelVisibilitySet(work->model, 1);
|
||||
}
|
||||
|
||||
static void PopupCoinExec(omObjData* obj) {
|
||||
Point3d coin_pos;
|
||||
Point3d coin_rot;
|
||||
CoinWork* work;
|
||||
|
||||
work = OM_GET_WORK_PTR(obj, CoinWork);
|
||||
|
||||
if (work->kill != 0 || BoardIsKill() != 0) {
|
||||
BoardModelVisibilitySet(work->model, 0);
|
||||
coinF[work->model_index] = 0;
|
||||
omDelObjEx(HuPrcCurrentGet(), obj);
|
||||
return;
|
||||
}
|
||||
|
||||
if (work->lifetime != 0) {
|
||||
work->lifetime -= 1;
|
||||
} else {
|
||||
work->kill = 1;
|
||||
return;
|
||||
}
|
||||
|
||||
BoardModelPosGet(work->model, &coin_pos);
|
||||
coin_pos.y += obj->trans.y;
|
||||
BoardModelPosSetV(work->model, &coin_pos);
|
||||
BoardModelRotGet(work->model, &coin_rot);
|
||||
coin_rot.y += obj->trans.x;
|
||||
|
||||
if (coin_rot.y > 360.0f) {
|
||||
coin_rot.y -= 360.0f;
|
||||
}
|
||||
|
||||
BoardModelRotSetV(work->model, &coin_rot);
|
||||
}
|
||||
1487
src/game/board/boo.c
Executable file
1487
src/game/board/boo.c
Executable file
File diff suppressed because it is too large
Load diff
677
src/game/board/com.c
Executable file
677
src/game/board/com.c
Executable file
|
|
@ -0,0 +1,677 @@
|
|||
#include "game/board/com.h"
|
||||
#include "game/gamework.h"
|
||||
#include "game/gamework_data.h"
|
||||
#include "game/board/com_path.h"
|
||||
#include "game/board/main.h"
|
||||
#include "game/board/player.h"
|
||||
#include "game/board/space.h"
|
||||
#include "game/board/tutorial.h"
|
||||
#include "game/board/window.h"
|
||||
|
||||
#include "math.h"
|
||||
|
||||
s32 BoardBooComUseCheck(s32);
|
||||
|
||||
static void ExecComKeyLeft(void);
|
||||
static void ExecComKeyRight(void);
|
||||
static void ExecComKeyUp(void);
|
||||
static void ExecComKeyDown(void);
|
||||
static void ExecComKey(s32 arg0, s32 arg1, s32 arg2);
|
||||
static s32 ChooseUseItem(s32 arg0);
|
||||
static BOOL CheckMiniUse(s32 arg0, s32 arg1);
|
||||
static BOOL CheckMegaUse(s32 arg0, s32 arg1);
|
||||
static BOOL CheckSparkUse(s32 arg0, s32 arg1);
|
||||
static BOOL CheckBoardChangeUse(s32 arg0, s32 arg1);
|
||||
static BOOL CheckSwapUse(s32 arg0, s32 arg1);
|
||||
static BOOL CheckBooUse(s32 arg0, s32 arg1);
|
||||
static BOOL CheckLampUse(s32 arg0, s32 arg1);
|
||||
|
||||
static s8 itemUse = -1;
|
||||
|
||||
static s8 comItemWeightTbl[8][12] = {
|
||||
{ 0x0C, 0x0B, 0x05, 0x03, 0x01, 0x02, 0x06, 0x04, 0x00, 0x07, 0x09, 0x0A },
|
||||
{ 0x0C, 0x0B, 0x05, 0x0A, 0x03, 0x01, 0x02, 0x00, 0x06, 0x04, 0x07, 0x09 },
|
||||
{ 0x0C, 0x0B, 0x05, 0x06, 0x03, 0x01, 0x02, 0x0A, 0x07, 0x09, 0x00, 0x04 },
|
||||
{ 0x0C, 0x05, 0x0B, 0x09, 0x03, 0x01, 0x02, 0x06, 0x00, 0x04, 0x0A, 0x07 },
|
||||
{ 0x0C, 0x0B, 0x04, 0x09, 0x0A, 0x03, 0x01, 0x05, 0x02, 0x06, 0x00, 0x07 },
|
||||
{ 0x0C, 0x0B, 0x05, 0x03, 0x01, 0x0A, 0x06, 0x02, 0x00, 0x04, 0x09, 0x07 },
|
||||
{ 0x0C, 0x05, 0x0B, 0x04, 0x07, 0x09, 0x03, 0x01, 0x0A, 0x06, 0x02, 0x00 },
|
||||
{ 0x0C, 0x05, 0x07, 0x0B, 0x0A, 0x09, 0x04, 0x06, 0x03, 0x01, 0x02, 0x00 }
|
||||
};
|
||||
|
||||
static BOOL (*comItemUseCheckFuncTbl[])(s32, s32) = {
|
||||
CheckMiniUse,
|
||||
CheckMegaUse,
|
||||
CheckMiniUse,
|
||||
CheckMegaUse,
|
||||
CheckBoardChangeUse,
|
||||
CheckBoardChangeUse,
|
||||
CheckSwapUse,
|
||||
CheckSparkUse,
|
||||
NULL,
|
||||
CheckBoardChangeUse,
|
||||
NULL,
|
||||
CheckBooUse,
|
||||
CheckLampUse,
|
||||
NULL
|
||||
};
|
||||
|
||||
static Vec comJunctionDirTbl[] = {
|
||||
{ 0.0f, 0.0f, -72.0f },
|
||||
{ 90.0f, 72.0f, 0.0f },
|
||||
{ 180.0f, 0.0f, 72.0f },
|
||||
{ 270.0f, -72.0f, 0.0f }
|
||||
};
|
||||
|
||||
static void ExecComKeyLeft(void) {
|
||||
ExecComKey(GWSystem.player_curr, 0, 1);
|
||||
}
|
||||
|
||||
void BoardComKeySetLeft(void) {
|
||||
BoardWinComKeyFuncSet(ExecComKeyLeft);
|
||||
}
|
||||
|
||||
static void ExecComKeyRight(void) {
|
||||
ExecComKey(GWSystem.player_curr, 1, 1);
|
||||
}
|
||||
|
||||
void BoardComKeySetRight(void) {
|
||||
BoardWinComKeyFuncSet(ExecComKeyRight);
|
||||
}
|
||||
|
||||
static void ExecComKeyUp(void) {
|
||||
ExecComKey(GWSystem.player_curr, 0, 0);
|
||||
}
|
||||
|
||||
void BoardComKeySetUp(void) {
|
||||
BoardWinComKeyFuncSet(ExecComKeyUp);
|
||||
}
|
||||
|
||||
static void ExecComKeyDown(void) {
|
||||
ExecComKey(GWSystem.player_curr, 1, 0);
|
||||
}
|
||||
|
||||
void BoardComKeySetDown(void) {
|
||||
BoardWinComKeyFuncSet(ExecComKeyDown);
|
||||
}
|
||||
|
||||
static void ExecComKey(s32 arg0, s32 arg1, s32 arg2) {
|
||||
s32 sp14[4];
|
||||
s32 temp_r31;
|
||||
s16 temp_r30;
|
||||
s32 var_r29;
|
||||
|
||||
sp14[0] = sp14[1] = sp14[2] = sp14[3] = 0;
|
||||
temp_r31 = GWPlayer[arg0].port;
|
||||
temp_r30 = GWMessDelayGet();
|
||||
if (arg2 == 0) {
|
||||
var_r29 = 4;
|
||||
} else {
|
||||
var_r29 = 2;
|
||||
}
|
||||
if (arg1 == 1) {
|
||||
sp14[temp_r31] = var_r29;
|
||||
HuWinComKeyWait(sp14[0], sp14[1], sp14[2], sp14[3], temp_r30);
|
||||
}
|
||||
sp14[temp_r31] = 0x100;
|
||||
HuWinComKeyWait(sp14[0], sp14[1], sp14[2], sp14[3], temp_r30);
|
||||
}
|
||||
|
||||
s8 BoardComPreferItemGet(s32 arg0, s8 *arg1, s8 arg2) {
|
||||
s32 temp_r26;
|
||||
s32 var_r28;
|
||||
s32 temp_r29;
|
||||
s32 var_r27;
|
||||
s32 i;
|
||||
s32 j;
|
||||
|
||||
temp_r26 = GWPlayer[arg0].character;
|
||||
var_r27 = -1;
|
||||
var_r28 = 0x64;
|
||||
for (i = 0; i < arg2; i++) {
|
||||
temp_r29 = arg1[i];
|
||||
for (j = 0; j < 0xC; j++) {
|
||||
if (temp_r29 == comItemWeightTbl[temp_r26][j]) {
|
||||
if (j < var_r28 && (BoardPlayerItemFind(arg0, temp_r29) == -1 || temp_r29 == 0xC || temp_r29 == 0xB)) {
|
||||
var_r28 = j;
|
||||
var_r27 = i;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (var_r28 == 0x64) {
|
||||
return -1;
|
||||
}
|
||||
return var_r27;
|
||||
}
|
||||
|
||||
s8 BoardComPreferItemCheck(s32 arg0, s8 arg1, s8 arg2, s8 arg3) {
|
||||
s8 spB[3];
|
||||
s8 temp_r25;
|
||||
|
||||
spB[0] = arg1;
|
||||
spB[1] = arg2;
|
||||
spB[2] = arg3;
|
||||
temp_r25 = BoardComPreferItemGet(arg0, spB, 3);
|
||||
return temp_r25;
|
||||
}
|
||||
|
||||
s32 BoardComItemWeightGet(s32 arg0, s32 arg1) {
|
||||
s32 var_r30;
|
||||
s32 i;
|
||||
|
||||
for (i = 0; i < 0xC; i++) {
|
||||
if (arg1 == comItemWeightTbl[GWPlayer[arg0].character][i]) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
var_r30 = 0xB - i;
|
||||
return var_r30;
|
||||
}
|
||||
|
||||
s32 BoardComTutorialItemGet(s32 arg0) {
|
||||
s32 var_r30;
|
||||
s32 var_r31;
|
||||
|
||||
if (!GWPlayer[arg0].com) {
|
||||
return -1;
|
||||
}
|
||||
if (itemUse != -1) {
|
||||
var_r31 = itemUse;
|
||||
}
|
||||
if (boardTutorialUseItem >= 0 && boardTutorialUseItem <= 0xD) {
|
||||
var_r31 = boardTutorialUseItem;
|
||||
boardTutorialUseItem = -1;
|
||||
}
|
||||
if (var_r31 != -1) {
|
||||
var_r30 = BoardPlayerItemFind(arg0, var_r31);
|
||||
} else {
|
||||
var_r30 = -1;
|
||||
}
|
||||
return var_r30;
|
||||
}
|
||||
|
||||
s32 BoardComUseItemSet(s32 arg0, s32 arg1) {
|
||||
if (arg1 == -1) {
|
||||
itemUse = -1;
|
||||
return 1;
|
||||
}
|
||||
if (BoardPlayerItemFind(arg0, arg1) != -1) {
|
||||
itemUse = arg1;
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
BOOL BoardComUseItemCheck(s32 arg0) {
|
||||
s32 var_r31;
|
||||
|
||||
var_r31 = BoardPlayerItemCount(arg0);
|
||||
if (var_r31 <= 0) {
|
||||
return FALSE;
|
||||
}
|
||||
if (ChooseUseItem(arg0) != -1) {
|
||||
return TRUE;
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
static s32 ChooseUseItem(s32 arg0) {
|
||||
s32 i;
|
||||
s32 j;
|
||||
s32 temp_r29;
|
||||
s32 var_r28;
|
||||
s32 temp_r27;
|
||||
s32 temp_r25;
|
||||
BOOL (*temp_r24)(s32, s32);
|
||||
s8 temp_r23;
|
||||
|
||||
temp_r29 = -1;
|
||||
temp_r25 = GWPlayer[arg0].character;
|
||||
var_r28 = 0x64;
|
||||
for (i = 0; i < 3; i++) {
|
||||
temp_r27 = GWPlayer[arg0].items[i];
|
||||
if (temp_r27 == -1) {
|
||||
continue;
|
||||
}
|
||||
temp_r24 = comItemUseCheckFuncTbl[temp_r27];
|
||||
if (!temp_r24) {
|
||||
continue;
|
||||
}
|
||||
temp_r23 = temp_r24(arg0, temp_r27);
|
||||
if (temp_r23) {
|
||||
for (j = 0; j < 0xC; j++) {
|
||||
if (temp_r27 == comItemWeightTbl[temp_r25][j]) {
|
||||
if (j < var_r28) {
|
||||
var_r28 = j;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (var_r28 == 0x64) {
|
||||
return -1;
|
||||
}
|
||||
temp_r29 = comItemWeightTbl[temp_r25][var_r28];
|
||||
if (temp_r29 == -1) {
|
||||
itemUse = -1;
|
||||
} else if (BoardPlayerItemFind(arg0, temp_r29) != -1) {
|
||||
itemUse = temp_r29;
|
||||
}
|
||||
return temp_r29;
|
||||
}
|
||||
|
||||
static BOOL CheckMiniUse(s32 arg0, s32 arg1) {
|
||||
s32 temp_r29;
|
||||
s32 var_r26;
|
||||
s32 var_r25;
|
||||
s32 temp_r28;
|
||||
s32 temp_r23;
|
||||
s32 var_r24;
|
||||
s32 var_r31;
|
||||
s32 var_r30;
|
||||
|
||||
var_r24 = 0;
|
||||
temp_r29 = GWPlayer[arg0].space_curr;
|
||||
temp_r28 = GWPlayer[arg0].diff;
|
||||
temp_r23 = GWPlayer[arg0].character;
|
||||
switch (temp_r28) {
|
||||
case 0:
|
||||
var_r30 = 0x32;
|
||||
break;
|
||||
case 1:
|
||||
var_r30 = 0x19;
|
||||
break;
|
||||
case 2:
|
||||
var_r30 = 5;
|
||||
break;
|
||||
case 3:
|
||||
var_r30 = 0;
|
||||
break;
|
||||
}
|
||||
if ((temp_r28 == 0 || temp_r28 == 1) && temp_r23 == 1) {
|
||||
var_r30 = 7;
|
||||
}
|
||||
if (GWBoardGet() != 7 && GWBoardGet() != 8) {
|
||||
var_r26 = BoardComPathReachCheck(temp_r29, 8, 0);
|
||||
var_r25 = BoardComPathReachCheck(temp_r29, 8, 1);
|
||||
} else {
|
||||
var_r26 = 0x3E7;
|
||||
var_r25 = BoardComPathW20BestGet(temp_r29, 0x10000000, 0xA);
|
||||
if ((GWBoardGet() == 8 || GWBoardGet() == 7) && BoardRandMod(0x64) < 0x3C) {
|
||||
var_r24 = 1;
|
||||
}
|
||||
}
|
||||
switch (GWPlayer[arg0].diff) {
|
||||
case 0:
|
||||
var_r31 = 5;
|
||||
break;
|
||||
case 1:
|
||||
var_r31 = 7;
|
||||
break;
|
||||
case 2:
|
||||
var_r31 = 9;
|
||||
break;
|
||||
case 3:
|
||||
var_r31 = 0xA;
|
||||
break;
|
||||
}
|
||||
if ((var_r25 < var_r31 || var_r26 < var_r31 || var_r24 != 0) && BoardRandMod(0x64) >= var_r30) {
|
||||
return TRUE;
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
static BOOL CheckMegaUse(s32 arg0, s32 arg1) {
|
||||
s32 temp_r27;
|
||||
s32 temp_r26;
|
||||
s32 temp_r24;
|
||||
s32 temp_r29;
|
||||
s16 temp_r25;
|
||||
s16 var_r28;
|
||||
s16 temp_r23;
|
||||
s16 temp_r22;
|
||||
s16 i;
|
||||
|
||||
temp_r29 = GWPlayer[arg0].diff;
|
||||
temp_r26 = GWPlayer[arg0].character;
|
||||
switch (temp_r29) {
|
||||
case 0:
|
||||
var_r28 = 5;
|
||||
break;
|
||||
case 1:
|
||||
var_r28 = 7;
|
||||
break;
|
||||
case 2:
|
||||
var_r28 = 9;
|
||||
break;
|
||||
case 3:
|
||||
var_r28 = 0xA;
|
||||
break;
|
||||
}
|
||||
if (((temp_r29 == 0 || temp_r29 == 1) && temp_r26 == 0) || ((temp_r29 == 0 || temp_r29 == 1) && temp_r26 == 5)) {
|
||||
var_r28 = 8;
|
||||
}
|
||||
if (GWBoardGet() != 7 || BoardRandMod(0x64) >= 0x3C) {
|
||||
temp_r24 = GWPlayer[arg0].space_curr;
|
||||
temp_r27 = BoardComPathReachCheck(temp_r24, 8, 0);
|
||||
temp_r23 = GWPlayer[arg0].space_curr;
|
||||
for (i = 0; i < 4; i++) {
|
||||
if (i != arg0) {
|
||||
temp_r22 = GWPlayer[i].space_curr;
|
||||
temp_r25 = BoardComPathLenGet(temp_r23, temp_r22);
|
||||
if (temp_r25 < var_r28 + 0x14 && temp_r25 > 0 && GWTeamGet() && i == BoardPlayerSameTeamFind(arg0)) {
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (GWBoardGet() != 7 && GWBoardGet() != 8 && temp_r27 < 0xA && temp_r27 > 0) {
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
if (BoardPlayerItemFind(arg0, arg1) != -1) {
|
||||
return TRUE;
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
static BOOL CheckSparkUse(s32 arg0, s32 arg1) {
|
||||
s32 temp_r27;
|
||||
s32 temp_r28;
|
||||
s32 temp_r26;
|
||||
s32 temp_r25;
|
||||
s32 temp_r24;
|
||||
s32 i;
|
||||
s32 var_r30;
|
||||
|
||||
temp_r25 = GWPlayer[arg0].space_curr;
|
||||
temp_r28 = GWPlayer[arg0].diff;
|
||||
temp_r24 = GWPlayer[arg0].character;
|
||||
switch (temp_r28) {
|
||||
case 0:
|
||||
var_r30 = 0x32;
|
||||
break;
|
||||
case 1:
|
||||
var_r30 = 0x19;
|
||||
break;
|
||||
case 2:
|
||||
var_r30 = 5;
|
||||
break;
|
||||
case 3:
|
||||
var_r30 = 0;
|
||||
break;
|
||||
}
|
||||
if ((temp_r28 == 0 || temp_r28 == 1) && temp_r24 == 7) {
|
||||
var_r30 = 7;
|
||||
}
|
||||
for (i = 0; i < 4; i++) {
|
||||
if (i != arg0) {
|
||||
temp_r26 = GWPlayer[i].space_curr;
|
||||
temp_r27 = BoardComPathLenGet(temp_r26, temp_r25);
|
||||
if (temp_r27 > 0 && temp_r27 <= 0xF && BoardPlayerItemFind(arg0, arg1) != -1 && BoardRandMod(0x64) >= var_r30) {
|
||||
return TRUE;
|
||||
}
|
||||
}
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
static BOOL CheckBoardChangeUse(s32 arg0, s32 arg1) {
|
||||
s32 temp_r25;
|
||||
s32 temp_r24;
|
||||
s32 temp_r23;
|
||||
s32 temp_r22;
|
||||
s32 temp_r21;
|
||||
s32 temp_r26;
|
||||
s32 var_r30;
|
||||
s32 var_r29;
|
||||
s32 var_r27;
|
||||
s32 i;
|
||||
|
||||
temp_r25 = GWPlayer[arg0].diff;
|
||||
temp_r24 = GWPlayer[arg0].character;
|
||||
switch (temp_r25) {
|
||||
case 0:
|
||||
var_r27 = 0x32;
|
||||
break;
|
||||
case 1:
|
||||
var_r27 = 0x19;
|
||||
break;
|
||||
case 2:
|
||||
var_r27 = 5;
|
||||
break;
|
||||
case 3:
|
||||
var_r27 = 0;
|
||||
break;
|
||||
}
|
||||
if (((arg1 == 4 && temp_r24 == 4) || (arg1 == 5 && (temp_r24 == 6 || temp_r24 == 3))) && (temp_r25 == 0 || temp_r25 == 1)) {
|
||||
var_r27 = 7;
|
||||
}
|
||||
var_r30 = 0x3E7;
|
||||
for (i = 0; i < 4; i++) {
|
||||
if (arg0 == i) {
|
||||
continue;
|
||||
}
|
||||
temp_r21 = GWPlayer[i].space_curr;
|
||||
if (!GWTeamGet() || i != BoardPlayerSameTeamFind(arg0)) {
|
||||
temp_r26 = GWPlayer[i].space_curr;
|
||||
if (GWBoardGet() == 7) {
|
||||
if (BoardComPathW20BestGet(temp_r21, 0x10000000, 0xA) != -1) {
|
||||
var_r29 = 0xA;
|
||||
} else {
|
||||
var_r29 = 0;
|
||||
}
|
||||
} else if (GWBoardGet() == 8) {
|
||||
if (BoardComPathW20BestGet(temp_r21, 0x200000, 0xA) != -1 || BoardComPathW20BestGet(temp_r21, 0x400000, 0xA) != -1) {
|
||||
var_r29 = 0xA;
|
||||
} else {
|
||||
var_r29 = 0;
|
||||
}
|
||||
} else {
|
||||
var_r29 = BoardComPathReachCheck(temp_r26, 8, 0);
|
||||
}
|
||||
if (var_r29 != 0 && var_r29 < var_r30) {
|
||||
var_r30 = var_r29;
|
||||
}
|
||||
}
|
||||
}
|
||||
if ((var_r30 > 0xF && var_r30 != 0x3E7) || (GWTeamGet() && i == BoardPlayerSameTeamFind(arg0))) {
|
||||
return FALSE;
|
||||
}
|
||||
temp_r26 = GWPlayer[arg0].space_curr;
|
||||
temp_r23 = BoardComPathReachCheck(temp_r26, 8, 0);
|
||||
temp_r22 = BoardComPathReachCheck(temp_r26, 8, 1);
|
||||
if (BoardPlayerItemFind(arg0, arg1) != -1 && BoardRandMod(0x64) >= var_r27) {
|
||||
if ((temp_r23 == 0 || temp_r22 == 0) && var_r30 == 0x3E7) {
|
||||
return TRUE;
|
||||
}
|
||||
if (temp_r23 > var_r30 || temp_r22 > var_r30) {
|
||||
return TRUE;
|
||||
}
|
||||
if (temp_r23 > 0xA || temp_r22 > 0xA) {
|
||||
return TRUE;
|
||||
}
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
BOOL CheckSwapUse(s32 arg0, s32 arg1) {
|
||||
s32 temp_r27;
|
||||
s32 temp_r26;
|
||||
s32 temp_r25;
|
||||
s32 var_r30;
|
||||
s32 var_r29;
|
||||
s32 i;
|
||||
|
||||
temp_r27 = GWPlayer[arg0].diff;
|
||||
temp_r25 = GWPlayer[arg0].character;
|
||||
switch (temp_r27) {
|
||||
case 0:
|
||||
var_r29 = 0x32;
|
||||
break;
|
||||
case 1:
|
||||
var_r29 = 0x19;
|
||||
break;
|
||||
case 2:
|
||||
var_r29 = 5;
|
||||
break;
|
||||
case 3:
|
||||
var_r29 = 0;
|
||||
break;
|
||||
}
|
||||
if ((temp_r27 == 0 || temp_r27 == 1) && temp_r25 == 2) {
|
||||
var_r29 = 7;
|
||||
}
|
||||
for (var_r30 = i = 0; i < 4; i++) {
|
||||
if (i != arg0) {
|
||||
var_r30 += BoardPlayerItemCount(i);
|
||||
}
|
||||
}
|
||||
if (var_r30 == 0) {
|
||||
return FALSE;
|
||||
}
|
||||
if (GWTeamGet()) {
|
||||
temp_r26 = BoardPlayerSameTeamFind(arg0);
|
||||
for (var_r30 = i = 0; i < 4; i++) {
|
||||
if (temp_r26 != i && i != arg0) {
|
||||
var_r30 += BoardPlayerItemCount(i);
|
||||
}
|
||||
}
|
||||
if (var_r30 == 0) {
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
if (BoardPlayerItemFind(arg0, arg1) != -1 && BoardRandMod(0x64) >= var_r29) {
|
||||
return TRUE;
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
static BOOL CheckBooUse(s32 arg0, s32 arg1) {
|
||||
if (BoardPlayerCoinsGet(arg0) < 5) {
|
||||
return FALSE;
|
||||
}
|
||||
if (BoardBooComUseCheck(arg0) == 0) {
|
||||
return FALSE;
|
||||
}
|
||||
if (BoardPlayerItemFind(arg0, arg1) == -1) {
|
||||
return FALSE;
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static BOOL CheckLampUse(s32 arg0, s32 arg1) {
|
||||
if ((BoardPlayerCoinsGet(arg0) >= 0x14 || GWSystem.last5_effect == 4) && BoardPlayerItemFind(arg0, arg1) != -1) {
|
||||
return TRUE;
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
s32 BoardComJunctionInputGet(s32 arg0, Vec *arg1, s32 arg2, float *arg3) {
|
||||
Vec sp28;
|
||||
Vec sp1C;
|
||||
Vec sp10;
|
||||
float var_f30;
|
||||
float var_f29;
|
||||
float var_f31;
|
||||
s32 var_r29;
|
||||
s32 var_r27;
|
||||
s32 temp_r26;
|
||||
s32 var_r24;
|
||||
s32 var_r23;
|
||||
s32 var_r21;
|
||||
s32 i;
|
||||
s16 var_r28;
|
||||
s16 temp_r25;
|
||||
s16 spC;
|
||||
|
||||
temp_r26 = GWBoardGet();
|
||||
var_r24 = 0;
|
||||
temp_r25 = GWPlayer[arg0].space_curr;
|
||||
var_r28 = -1;
|
||||
spC = GWPlayer[arg0].roll;
|
||||
switch (GWPlayer[arg0].diff) {
|
||||
case 3:
|
||||
var_r29 = 0;
|
||||
break;
|
||||
case 2:
|
||||
var_r29 = 0;
|
||||
break;
|
||||
case 1:
|
||||
var_r29 = 0xA;
|
||||
break;
|
||||
default:
|
||||
case 0:
|
||||
var_r29 = 0x1E;
|
||||
break;
|
||||
}
|
||||
if (BoardRandMod(0x64) >= var_r29) {
|
||||
var_r23 = 1;
|
||||
} else {
|
||||
var_r23 = 0;
|
||||
}
|
||||
if (var_r23 != 0) {
|
||||
if (temp_r26 >= 0 && temp_r26 <= 5) {
|
||||
var_r28 = BoardComPathBestGet(temp_r25);
|
||||
} else if (temp_r26 == 7) {
|
||||
var_r28 = BoardComPathW20BestGet(temp_r25, 0x10000000, 0xA);
|
||||
}
|
||||
if (var_r28 == -1) {
|
||||
var_r24 = 1;
|
||||
} else {
|
||||
BoardSpacePosGet(0, temp_r25, &sp1C);
|
||||
BoardSpacePosGet(0, var_r28, &sp28);
|
||||
PSVECSubtract(&sp28, &sp1C, &sp10);
|
||||
var_f31 = BoardDAngleCalc(90.0 - 180.0 * (atan2(sp10.z, sp10.x) / M_PI));
|
||||
if (var_f31 < 0.0f) {
|
||||
var_f31 += 360.0f;
|
||||
}
|
||||
if (var_f31 > 360.0f) {
|
||||
var_f31 -= 360.0f;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (var_r24 != 0) {
|
||||
var_r21 = BoardRandMod(arg2);
|
||||
var_f31 = arg3[var_r21];
|
||||
}
|
||||
var_f30 = 999.0f;
|
||||
for (var_r27 = i = 0; i < 4; i++) {
|
||||
var_f29 = (comJunctionDirTbl[i].x - var_f31 < 0.0f)
|
||||
? -(comJunctionDirTbl[i].x - var_f31)
|
||||
: (comJunctionDirTbl[i].x - var_f31);
|
||||
if (var_f29 < var_f30) {
|
||||
var_r27 = i;
|
||||
var_f30 = var_f29;
|
||||
}
|
||||
}
|
||||
arg1->x = comJunctionDirTbl[var_r27].y;
|
||||
arg1->z = comJunctionDirTbl[var_r27].z;
|
||||
arg1->y = 0.0f;
|
||||
return 0;
|
||||
}
|
||||
|
||||
s32 BoardComBestPlayerFind(void) {
|
||||
s32 temp_r30;
|
||||
s32 var_r29;
|
||||
s32 var_r28;
|
||||
s32 var_r27;
|
||||
s32 i;
|
||||
|
||||
if (_CheckFlag(0x1000B) != 0) {
|
||||
return -1;
|
||||
}
|
||||
var_r28 = -1;
|
||||
var_r29 = -1;
|
||||
for (i = 0; i < 4; i++) {
|
||||
var_r27 = GWPlayer[i].space_curr;
|
||||
temp_r30 = BoardComPathReachCheck(var_r27, 8, 0);
|
||||
if (temp_r30 > 0 && temp_r30 > var_r29) {
|
||||
var_r29 = temp_r30;
|
||||
var_r28 = i;
|
||||
}
|
||||
}
|
||||
return var_r28;
|
||||
}
|
||||
545
src/game/board/com_path.c
Executable file
545
src/game/board/com_path.c
Executable file
|
|
@ -0,0 +1,545 @@
|
|||
#include "game/board/com_path.h"
|
||||
#include "game/board/space.h"
|
||||
|
||||
#define NODE_INDEX(x) ((x) ? ((x) - pathNodeData) : -1)
|
||||
|
||||
typedef struct {
|
||||
/* 0x00 */ struct {
|
||||
u8 unk00_field0 : 1;
|
||||
u8 unk00_field1 : 1;
|
||||
s8 unk00_field2 : 1;
|
||||
s8 unk00_field3 : 1;
|
||||
u8 unk00_field4 : 1;
|
||||
u8 unk00_field5 : 1;
|
||||
};
|
||||
/* 0x01 */ s8 unk01;
|
||||
/* 0x02 */ s8 unk02;
|
||||
/* 0x03 */ s8 unk03;
|
||||
/* 0x04 */ s16 unk04;
|
||||
/* 0x06 */ s16 unk06[2]; // array size unknown
|
||||
/* 0x0A */ char unk0A[0x3C];
|
||||
/* 0x46 */ s16 unk46[5];
|
||||
} PathNode; // Size 0x50
|
||||
|
||||
static PathNode *SearchPathNodeSpace(s16 arg0);
|
||||
static s16 InitPathNode(PathNode *arg0);
|
||||
static PathNode *FindChildNode(s16 arg0, PathNode *arg1);
|
||||
static s32 GetNumValidLinks(BoardSpace *arg0, PathNode *arg1);
|
||||
static void AddValidLinks(BoardSpace *arg0, PathNode *arg1);
|
||||
static BOOL CheckPathSpace(BoardSpace *arg0);
|
||||
static s16 FindValidLink(BoardSpace *arg0);
|
||||
static BOOL CheckEndSpace(BoardSpace *arg0, PathNode *arg1);
|
||||
static BOOL CheckPath(PathNode *arg0);
|
||||
static BOOL CheckW20Path(PathNode *arg0, u32 arg1);
|
||||
|
||||
static PathNode pathNodeData[16];
|
||||
static PathNode *candidateNodes[16];
|
||||
static s16 startPathSpaceSearch[16];
|
||||
static s16 startPathSpace[16];
|
||||
|
||||
static s16 numCandidates;
|
||||
static s16 childNodeCnt;
|
||||
|
||||
static PathNode *SearchPathNodeSpace(s16 arg0) {
|
||||
PathNode *var_r31;
|
||||
s32 i;
|
||||
|
||||
for (var_r31 = pathNodeData, i = 0; i < 16; i++, var_r31++) {
|
||||
if (var_r31->unk04 == arg0) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (i == 16) {
|
||||
var_r31 = NULL;
|
||||
}
|
||||
return var_r31;
|
||||
}
|
||||
|
||||
static s16 InitPathNode(PathNode *arg0) {
|
||||
BoardSpace *temp_r30;
|
||||
PathNode *var_r23;
|
||||
s32 var_r29;
|
||||
s16 i;
|
||||
s16 var_r27;
|
||||
s16 var_r26;
|
||||
s16 var_r25;
|
||||
s16 var_r24;
|
||||
|
||||
var_r24 = arg0->unk04;
|
||||
var_r29 = 0;
|
||||
arg0->unk02 = var_r25 = 0;
|
||||
do {
|
||||
var_r27 = var_r24;
|
||||
temp_r30 = BoardSpaceGet(0, var_r27);
|
||||
arg0->unk06[arg0->unk02] = var_r27;
|
||||
var_r23 = FindChildNode(var_r27, arg0);
|
||||
if (var_r23) {
|
||||
AddValidLinks(temp_r30, arg0);
|
||||
arg0->unk01 = 1;
|
||||
arg0->unk46[0] = var_r27;
|
||||
for (i = 1; i < 5; i++) {
|
||||
arg0->unk46[i] = 0;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
if (temp_r30->link_cnt == 0) {
|
||||
var_r26 = 0;
|
||||
var_r29 = 1;
|
||||
} else {
|
||||
var_r26 = GetNumValidLinks(temp_r30, arg0);
|
||||
if (var_r26 == 1) {
|
||||
var_r24 = FindValidLink(temp_r30);
|
||||
} else {
|
||||
var_r29 = 1;
|
||||
}
|
||||
}
|
||||
if (CheckEndSpace(temp_r30, arg0)) {
|
||||
var_r25++;
|
||||
if (var_r25 >= arg0->unk03) {
|
||||
var_r26 = 0;
|
||||
var_r29 = 1;
|
||||
}
|
||||
}
|
||||
arg0->unk02++;
|
||||
} while (var_r29 == 0);
|
||||
AddValidLinks(temp_r30, arg0);
|
||||
arg0->unk01 = var_r26;
|
||||
return arg0->unk03 - var_r25;
|
||||
}
|
||||
|
||||
static PathNode *FindChildNode(s16 arg0, PathNode *arg1) {
|
||||
PathNode *temp_r31;
|
||||
s32 var_r28;
|
||||
s32 i;
|
||||
s32 j;
|
||||
|
||||
var_r28 = NODE_INDEX(arg1);
|
||||
if (var_r28 == -1) {
|
||||
return NULL;
|
||||
}
|
||||
for (i = 0; i < childNodeCnt; i++) {
|
||||
temp_r31 = &pathNodeData[i];
|
||||
if (temp_r31 != arg1) {
|
||||
for (j = 0; j < temp_r31->unk02; j++) {
|
||||
if (arg0 == temp_r31->unk06[j]) {
|
||||
return temp_r31;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static s32 GetNumValidLinks(BoardSpace *arg0, PathNode *arg1) {
|
||||
BoardSpace *var_r28;
|
||||
s16 i;
|
||||
s16 var_r29;
|
||||
|
||||
for (var_r29 = i = 0; i < arg0->link_cnt; i++) {
|
||||
var_r28 = BoardSpaceGet(0, arg0->link[i]);
|
||||
if (!CheckPathSpace(var_r28)) {
|
||||
var_r29++;
|
||||
}
|
||||
}
|
||||
if (var_r29 >= arg0->link_cnt) {
|
||||
return 0;
|
||||
}
|
||||
return arg0->link_cnt - var_r29;
|
||||
}
|
||||
|
||||
static void AddValidLinks(BoardSpace *arg0, PathNode *arg1) {
|
||||
BoardSpace *var_r27;
|
||||
s16 var_r30;
|
||||
s16 var_r31;
|
||||
|
||||
for (var_r31 = var_r30 = 0; var_r30 < arg0->link_cnt; var_r30++) {
|
||||
var_r27 = BoardSpaceGet(0, arg0->link[var_r30]);
|
||||
if (CheckPathSpace(var_r27)) {
|
||||
arg1->unk46[var_r31] = arg0->link[var_r30];
|
||||
var_r31++;
|
||||
}
|
||||
}
|
||||
for (; var_r31 < 5; var_r31++) {
|
||||
arg1->unk46[var_r31] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
static BOOL CheckPathSpace(BoardSpace *arg0) {
|
||||
if ((arg0->flag & 0x02000000) || (arg0->flag & 0x04000000)) {
|
||||
return FALSE;
|
||||
} else {
|
||||
return TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
static s16 FindValidLink(BoardSpace *arg0) {
|
||||
s16 var_r29;
|
||||
s16 i;
|
||||
BoardSpace *temp_r30;
|
||||
|
||||
for (var_r29 = i = 0; i < arg0->link_cnt; i++) {
|
||||
var_r29 = arg0->link[i];
|
||||
temp_r30 = BoardSpaceGet(0, var_r29);
|
||||
if (CheckPathSpace(temp_r30)) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
return var_r29;
|
||||
}
|
||||
|
||||
static BOOL CheckEndSpace(BoardSpace *arg0, PathNode *arg1) {
|
||||
if (arg0->flag & 0x80000000) {
|
||||
}
|
||||
if (arg0->flag & 0x4000000) {
|
||||
}
|
||||
if (arg0->flag & 0x2000000) {
|
||||
}
|
||||
if (arg0->flag & 0x180000) {
|
||||
arg1->unk00_field3 = 1;
|
||||
}
|
||||
if (arg0->flag & 0x48000000) {
|
||||
arg1->unk00_field4 = 1;
|
||||
}
|
||||
if (arg0->flag & 0x20000000) {
|
||||
arg1->unk00_field2 = 1;
|
||||
}
|
||||
if (arg0->flag & 0x10000000) {
|
||||
arg1->unk00_field5 = 1;
|
||||
}
|
||||
switch (arg0->type) {
|
||||
case 8:
|
||||
arg1->unk00_field1 = 1;
|
||||
return FALSE;
|
||||
case 10:
|
||||
return FALSE;
|
||||
case 0:
|
||||
return FALSE;
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static inline void ComPathInlineFunc02(PathNode *arg0) {
|
||||
if (numCandidates < 16) {
|
||||
candidateNodes[numCandidates] = arg0;
|
||||
numCandidates++;
|
||||
}
|
||||
}
|
||||
|
||||
static inline PathNode *ComPathInlineFunc03(void) {
|
||||
PathNode *ret;
|
||||
|
||||
numCandidates--;
|
||||
if (numCandidates < 0) {
|
||||
return NULL;
|
||||
} else {
|
||||
ret = candidateNodes[numCandidates];
|
||||
candidateNodes[numCandidates] = NULL;
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
static inline PathNode *ComPathInlineFunc04(s16 arg0, s16 arg1) {
|
||||
PathNode *var_r26;
|
||||
s32 i;
|
||||
|
||||
var_r26 = pathNodeData;
|
||||
for (i = 0; i < 16; i++, var_r26++) {
|
||||
if (var_r26->unk00_field0 == 0) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (i == 16) {
|
||||
return NULL;
|
||||
} else {
|
||||
var_r26->unk00_field0 = 1;
|
||||
var_r26->unk04 = arg0;
|
||||
var_r26->unk03 = arg1;
|
||||
childNodeCnt++;
|
||||
return var_r26;
|
||||
}
|
||||
}
|
||||
|
||||
static inline void ComPathInlineFunc05(s16 arg0, s16 arg1) {
|
||||
PathNode *var_r28;
|
||||
s32 var_r24;
|
||||
s32 temp_r17;
|
||||
s32 i;
|
||||
PathNode *var_r23;
|
||||
|
||||
memset(pathNodeData, 0, sizeof(pathNodeData));
|
||||
memset(candidateNodes, 0, sizeof(candidateNodes));
|
||||
numCandidates = 0;
|
||||
childNodeCnt = 0;
|
||||
var_r23 = ComPathInlineFunc04(arg0, arg1);
|
||||
ComPathInlineFunc02(var_r23);
|
||||
var_r24 = 1;
|
||||
temp_r17 = arg1;
|
||||
while (1) {
|
||||
if (var_r24 <= 0) {
|
||||
break;
|
||||
}
|
||||
var_r28 = ComPathInlineFunc03();
|
||||
if (!var_r28) {
|
||||
break;
|
||||
}
|
||||
var_r24--;
|
||||
temp_r17 = InitPathNode(var_r28);
|
||||
if (temp_r17 != 0) {
|
||||
if (var_r28->unk01 <= 1) {
|
||||
break;
|
||||
}
|
||||
for (i = 0; i < var_r28->unk01; var_r24++, i++) {
|
||||
var_r23 = ComPathInlineFunc04(var_r28->unk46[i], temp_r17);
|
||||
if (!var_r23) {
|
||||
break;
|
||||
}
|
||||
ComPathInlineFunc02(var_r23);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
s16 BoardComPathReachCheck(s16 arg0, u32 arg1, s32 arg2) {
|
||||
s16 sp80[10];
|
||||
s16 sp6C[10];
|
||||
PathNode *sp68;
|
||||
PathNode *var_r29;
|
||||
s16 sp1C;
|
||||
s16 sp1A;
|
||||
s16 temp_r20;
|
||||
s16 var_r22;
|
||||
s16 var_r28;
|
||||
s16 i;
|
||||
s32 var_r19;
|
||||
|
||||
if (_CheckFlag(0x1000B)) {
|
||||
return 0;
|
||||
}
|
||||
ComPathInlineFunc05(arg0, 0x1E);
|
||||
memset(startPathSpaceSearch, 0, sizeof(startPathSpaceSearch));
|
||||
memset(sp80, 0, sizeof(sp80));
|
||||
memset(candidateNodes, 0, sizeof(candidateNodes));
|
||||
numCandidates = 0;
|
||||
var_r29 = SearchPathNodeSpace(arg0);
|
||||
sp1A = NODE_INDEX(var_r29);
|
||||
ComPathInlineFunc02(var_r29);
|
||||
var_r28 = 0;
|
||||
var_r22 = 0;
|
||||
startPathSpaceSearch[sp1A] = var_r28;
|
||||
var_r19 = 0;
|
||||
while (1) {
|
||||
var_r29 = ComPathInlineFunc03();
|
||||
sp1C = NODE_INDEX(var_r29);
|
||||
if (sp1C == -1) {
|
||||
if (var_r22 != 0) {
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
var_r19 = 0;
|
||||
var_r28 = startPathSpaceSearch[sp1C];
|
||||
for (i = 0; i < var_r29->unk02; i++) {
|
||||
if (arg2 == 0 && (BoardSpaceFlagGet(0, var_r29->unk06[i]) & 0x20000000)) {
|
||||
break;
|
||||
}
|
||||
if (arg1 == BoardSpaceTypeGet(0, var_r29->unk06[i])) {
|
||||
sp80[var_r22] = var_r28;
|
||||
sp6C[var_r22] = sp1C;
|
||||
if (++var_r22 < 0xA) {
|
||||
var_r19 = 1;
|
||||
break;
|
||||
} else {
|
||||
goto return_r28;
|
||||
}
|
||||
}
|
||||
if (var_r28++ >= 0x1E) {
|
||||
var_r19 = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (var_r19 == 0) {
|
||||
for (i = 0; i < var_r29->unk01; i++) {
|
||||
sp68 = SearchPathNodeSpace(var_r29->unk46[i]);
|
||||
temp_r20 = NODE_INDEX(sp68);
|
||||
if (temp_r20 != -1 && temp_r20 >= 0 && temp_r20 < 16) {
|
||||
startPathSpaceSearch[temp_r20] = var_r28;
|
||||
ComPathInlineFunc02(sp68);
|
||||
}
|
||||
}
|
||||
}
|
||||
continue;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
return_r28:
|
||||
var_r28 = 10000;
|
||||
for (i = 0; i < 10; i++) {
|
||||
if (var_r28 > sp80[i] && sp80[i] != 0) {
|
||||
var_r28 = sp80[i];
|
||||
}
|
||||
}
|
||||
return var_r28;
|
||||
}
|
||||
|
||||
s16 BoardComPathBestGet(s16 arg0) {
|
||||
PathNode *sp30;
|
||||
PathNode *sp2C;
|
||||
s32 i;
|
||||
|
||||
ComPathInlineFunc05(arg0, 0x1E);
|
||||
sp2C = SearchPathNodeSpace(arg0);
|
||||
if (sp2C->unk00_field1 != 0) {
|
||||
return -1;
|
||||
}
|
||||
if (sp2C->unk01 <= 1) {
|
||||
return -1;
|
||||
}
|
||||
for (i = 0; i < sp2C->unk01; i++) {
|
||||
sp30 = SearchPathNodeSpace(sp2C->unk46[i]);
|
||||
if (sp30 && CheckPath(sp30)) {
|
||||
return sp2C->unk46[i];
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
s16 BoardComPathLenGet(s16 arg0, s16 arg1) {
|
||||
PathNode *var_r30;
|
||||
s16 temp_r21;
|
||||
s16 var_r25;
|
||||
s16 sp16;
|
||||
s16 sp14;
|
||||
s16 sp12;
|
||||
s16 i;
|
||||
s32 sp5C;
|
||||
PathNode *sp58;
|
||||
|
||||
ComPathInlineFunc05(arg0, 0x1E);
|
||||
memset(startPathSpace, 0, sizeof(startPathSpace));
|
||||
memset(candidateNodes, 0, sizeof(candidateNodes));
|
||||
numCandidates = 0;
|
||||
var_r30 = SearchPathNodeSpace(arg0);
|
||||
sp12 = NODE_INDEX(var_r30);
|
||||
ComPathInlineFunc02(var_r30);
|
||||
var_r25 = 0;
|
||||
sp16 = 0;
|
||||
startPathSpace[sp12] = var_r25;
|
||||
sp5C = 0;
|
||||
while (1) {
|
||||
var_r30 = ComPathInlineFunc03();
|
||||
sp14 = NODE_INDEX(var_r30);
|
||||
if (sp14 == -1) {
|
||||
if (sp16 != 0) {
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
sp5C = 0;
|
||||
var_r25 = startPathSpace[sp14];
|
||||
for (i = 0; i < var_r30->unk02; i++) {
|
||||
if (BoardSpaceFlagGet(0, var_r30->unk06[i]) & 0x20000000) {
|
||||
break;
|
||||
}
|
||||
if (var_r30->unk06[i] == arg1) {
|
||||
goto return_r25;
|
||||
}
|
||||
if (var_r25++ >= 0x1E) {
|
||||
sp5C = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (sp5C == 0) {
|
||||
for (i = 0; i < var_r30->unk01; i++) {
|
||||
sp58 = SearchPathNodeSpace(var_r30->unk46[i]);
|
||||
temp_r21 = NODE_INDEX(sp58);
|
||||
if (temp_r21 != -1 && temp_r21 >= 0 && temp_r21 < 16) {
|
||||
startPathSpace[temp_r21] = var_r25;
|
||||
ComPathInlineFunc02(sp58);
|
||||
}
|
||||
}
|
||||
}
|
||||
continue;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
return_r25:
|
||||
return var_r25;
|
||||
}
|
||||
|
||||
static BOOL CheckPath(PathNode *arg0) {
|
||||
s32 i;
|
||||
PathNode *sp1C;
|
||||
|
||||
if (arg0->unk00_field1 != 0) {
|
||||
return TRUE;
|
||||
}
|
||||
if (arg0->unk01 <= 1) {
|
||||
return FALSE;
|
||||
}
|
||||
for (i = 0; i < arg0->unk01; i++) {
|
||||
sp1C = SearchPathNodeSpace(arg0->unk46[i]);
|
||||
if (sp1C && CheckPath(sp1C)) {
|
||||
return TRUE;
|
||||
}
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
s16 BoardComPathW20BestGet(s16 arg0, u32 arg1, s16 arg2) {
|
||||
PathNode *var_r31;
|
||||
PathNode *sp38;
|
||||
s32 i;
|
||||
|
||||
ComPathInlineFunc05(arg0, arg2);
|
||||
var_r31 = SearchPathNodeSpace(arg0);
|
||||
if (arg1 & 0x180000) {
|
||||
if (var_r31->unk00_field1 != 0) {
|
||||
return -1;
|
||||
}
|
||||
} else if (arg1 & 0x08000000) {
|
||||
if (var_r31->unk00_field4 != 0) {
|
||||
return -1;
|
||||
}
|
||||
} else if (arg1 & 0x10000000) {
|
||||
if (var_r31->unk00_field5 != 0) {
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
if (var_r31->unk01 <= 1) {
|
||||
return -1;
|
||||
}
|
||||
for (i = 0; i < var_r31->unk01; i++) {
|
||||
sp38 = SearchPathNodeSpace(var_r31->unk46[i]);
|
||||
if (sp38 && CheckW20Path(sp38, arg1)) {
|
||||
return var_r31->unk46[i];
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
static BOOL CheckW20Path(PathNode *arg0, u32 arg1) {
|
||||
s32 i;
|
||||
PathNode *sp1C;
|
||||
|
||||
if (arg1 & 0x180000) {
|
||||
if (arg0->unk00_field1 != 0) {
|
||||
return TRUE;
|
||||
}
|
||||
} else if (arg1 & 0x08000000) {
|
||||
if (arg0->unk00_field4 != 0) {
|
||||
return TRUE;
|
||||
}
|
||||
} else if (arg1 & 0x10000000) {
|
||||
if (arg0->unk00_field5 != 0) {
|
||||
return TRUE;
|
||||
}
|
||||
}
|
||||
if (arg0->unk01 <= 1) {
|
||||
return FALSE;
|
||||
}
|
||||
for (i = 0; i < arg0->unk01; i++) {
|
||||
sp1C = SearchPathNodeSpace(arg0->unk46[i]);
|
||||
if (sp1C && CheckW20Path(sp1C, arg1)) {
|
||||
return TRUE;
|
||||
}
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
1902
src/game/board/item.c
Executable file
1902
src/game/board/item.c
Executable file
File diff suppressed because it is too large
Load diff
|
|
@ -9,7 +9,10 @@
|
|||
#include "game/hsfman.h"
|
||||
#include "game/hsfdraw.h"
|
||||
#include "game/board/main.h"
|
||||
#include "game/board/pause.h"
|
||||
#include "game/board/player.h"
|
||||
#include "game/board/tutorial.h"
|
||||
#include "game/board/ui.h"
|
||||
#include "game/pad.h"
|
||||
#include "game/msm.h"
|
||||
|
||||
|
|
@ -27,8 +30,8 @@ static omObjData *confettiObj;
|
|||
static omObjData *filterObj;
|
||||
BoardTurnStartHook boardTurnStartFunc;
|
||||
void *boardBowserHook;
|
||||
void *boardStarShowNextHook;
|
||||
void *boardStarGiveHook;
|
||||
void (*boardStarShowNextHook)(void);
|
||||
void (*boardStarGiveHook)(void);
|
||||
BoardFunc boardTurnFunc;
|
||||
BoardLightHook boardLightResetHook;
|
||||
BoardLightHook boardLightSetHook;
|
||||
|
|
@ -61,8 +64,6 @@ extern s32 BoardSpacePosGet(s32 layer, s32 space, Vec *pos);
|
|||
extern void BoardMGSetupPlayClear(void);
|
||||
extern void BoardStartExec(void);
|
||||
|
||||
extern s8 boardTutorialF;
|
||||
|
||||
static void InitBoardFunc(omObjData *object);
|
||||
static void ExecBoardFunc(omObjData *object);
|
||||
static void KillBoardFunc(omObjData *object);
|
||||
|
|
@ -210,7 +211,7 @@ static void KillBoardFunc(omObjData *object)
|
|||
BoardTutorialWorkRestore();
|
||||
}
|
||||
_ClearFlag(FLAG_ID_MAKE(1, 0));
|
||||
HuARDirFree(MAKE_DIR_NUM(DATADIR_BOARD));
|
||||
HuARDirFree(DATADIR_BOARD);
|
||||
if(_CheckFlag(FLAG_ID_MAKE(1, 27))) {
|
||||
omOvlReturnEx(2, 1);
|
||||
} else {
|
||||
|
|
@ -290,7 +291,7 @@ void BoardSaveInit(s32 board)
|
|||
GWSystem.field31_bit4 = 0;
|
||||
GWSystem.unk_32 = 1;
|
||||
GWSystem.mg_next = 0;
|
||||
GWSystem.mg_next_extra = 0;
|
||||
GWSystem.mg_next_type = 0;
|
||||
GWSystem.unk_38 = 0;
|
||||
GWSystem.block_pos = 0;
|
||||
memset(GWSystem.board_data, 0, 32);
|
||||
|
|
@ -334,13 +335,13 @@ void BoardSaveInit(s32 board)
|
|||
}
|
||||
}
|
||||
|
||||
void BoardStoryConfigSet(s32 mg_type, s32 diff_story)
|
||||
void BoardStoryConfigSet(s32 mg_list, s32 diff_story)
|
||||
{
|
||||
GWSystem.party = 0;
|
||||
GWSystem.team = 0;
|
||||
GWSystem.diff_story = diff_story;
|
||||
GWSystem.bonus_star = 0;
|
||||
GWSystem.mg_type = mg_type;
|
||||
GWSystem.mg_list = mg_list;
|
||||
GWPlayer[0].handicap = 0;
|
||||
GWPlayer[1].handicap = 0;
|
||||
GWPlayer[2].handicap = 0;
|
||||
|
|
@ -358,13 +359,13 @@ void BoardStoryConfigSet(s32 mg_type, s32 diff_story)
|
|||
_SetFlag(FLAG_ID_MAKE(1, 10));
|
||||
}
|
||||
|
||||
void BoardPartyConfigSet(s32 team, s32 bonus_star, s32 mg_type, s32 max_turn, s32 p1_handicap, s32 p2_handicap, s32 p3_handicap, s32 p4_handicap)
|
||||
void BoardPartyConfigSet(s32 team, s32 bonus_star, s32 mg_list, s32 max_turn, s32 p1_handicap, s32 p2_handicap, s32 p3_handicap, s32 p4_handicap)
|
||||
{
|
||||
GWSystem.party = 1;
|
||||
GWSystem.team = team;
|
||||
GWSystem.diff_story = 0;
|
||||
GWSystem.bonus_star = bonus_star;
|
||||
GWSystem.mg_type = mg_type;
|
||||
GWSystem.mg_list = mg_list;
|
||||
GWSystem.max_turn = max_turn;
|
||||
memset(GWPlayer, 0, 4*sizeof(PlayerState));
|
||||
GWPlayer[0].handicap = p1_handicap;
|
||||
|
|
@ -617,11 +618,11 @@ static void CreateBoard(void)
|
|||
GWSystem.mg_next = -1;
|
||||
if(!GWGameStat.field10E_bit5) {
|
||||
s32 type_temp;
|
||||
if(GWSystem.mg_type == 3) {
|
||||
GWSystem.mg_type = 0;
|
||||
if(GWSystem.mg_list == 3) {
|
||||
GWSystem.mg_list = 0;
|
||||
}
|
||||
if(GWMGTypeGet() == 2) {
|
||||
GWSystem.mg_type = 0;
|
||||
if(GWMGListGet() == 2) {
|
||||
GWSystem.mg_list = 0;
|
||||
}
|
||||
}
|
||||
if(GWSystem.mess_speed == 3) {
|
||||
|
|
@ -668,7 +669,7 @@ static void CreateBoard(void)
|
|||
if(!reset_unk32) {
|
||||
GWSystem.unk_32 = 1;
|
||||
}
|
||||
guest_status = BoardDataDirReadAsync(MAKE_DIR_NUM(DATADIR_BGUEST));
|
||||
guest_status = BoardDataDirReadAsync(DATADIR_BGUEST);
|
||||
if(guest_status != -1) {
|
||||
BoardDataAsyncWait(guest_status);
|
||||
}
|
||||
|
|
@ -698,29 +699,29 @@ static void CreateBoard(void)
|
|||
BoardCameraMotionWait();
|
||||
BoardTauntInit();
|
||||
_SetFlag(FLAG_ID_MAKE(1, 14));
|
||||
HuDataDirClose(MAKE_DIR_NUM(DATADIR_BKOOPASUIT));
|
||||
HuDataDirClose(MAKE_DIR_NUM(DATADIR_BBATTLE));
|
||||
HuDataDirClose(MAKE_DIR_NUM(DATADIR_BKOOPA));
|
||||
HuDataDirClose(MAKE_DIR_NUM(DATADIR_BKUJIYA));
|
||||
HuDataDirClose(MAKE_DIR_NUM(DATADIR_BYOKODORI));
|
||||
HuDataDirClose(MAKE_DIR_NUM(DATADIR_BPAUSE));
|
||||
HuDataDirClose(MAKE_DIR_NUM(DATADIR_BLAST5));
|
||||
HuDataDirClose(MAKE_DIR_NUM(DATADIR_EFFECT));
|
||||
HuDataDirClose(DATADIR_BKOOPASUIT);
|
||||
HuDataDirClose(DATADIR_BBATTLE);
|
||||
HuDataDirClose(DATADIR_BKOOPA);
|
||||
HuDataDirClose(DATADIR_BKUJIYA);
|
||||
HuDataDirClose(DATADIR_BYOKODORI);
|
||||
HuDataDirClose(DATADIR_BPAUSE);
|
||||
HuDataDirClose(DATADIR_BLAST5);
|
||||
HuDataDirClose(DATADIR_EFFECT);
|
||||
_SetFlag(FLAG_ID_MAKE(1, 16));
|
||||
}
|
||||
|
||||
static void DestroyBoard(void)
|
||||
{
|
||||
s32 dir_table[] = {
|
||||
MAKE_DIR_NUM(DATADIR_W01),
|
||||
MAKE_DIR_NUM(DATADIR_W02),
|
||||
MAKE_DIR_NUM(DATADIR_W03),
|
||||
MAKE_DIR_NUM(DATADIR_W04),
|
||||
MAKE_DIR_NUM(DATADIR_W05),
|
||||
MAKE_DIR_NUM(DATADIR_W06),
|
||||
MAKE_DIR_NUM(DATADIR_W10),
|
||||
MAKE_DIR_NUM(DATADIR_W20),
|
||||
MAKE_DIR_NUM(DATADIR_W21),
|
||||
DATADIR_W01,
|
||||
DATADIR_W02,
|
||||
DATADIR_W03,
|
||||
DATADIR_W04,
|
||||
DATADIR_W05,
|
||||
DATADIR_W06,
|
||||
DATADIR_W10,
|
||||
DATADIR_W20,
|
||||
DATADIR_W21
|
||||
};
|
||||
BoardTauntKill();
|
||||
BoardAudSeqFadeOutAll();
|
||||
|
|
@ -738,14 +739,14 @@ static void DestroyBoard(void)
|
|||
BoardModelKillAll();
|
||||
BoardWinKillAll();
|
||||
HuDataDirClose(dir_table[BoardCurrGet()]);
|
||||
HuDataDirClose(MAKE_DIR_NUM(DATADIR_EFFECT));
|
||||
HuDataDirClose(MAKE_DIR_NUM(DATADIR_BGUEST));
|
||||
HuDataDirClose(MAKE_DIR_NUM(DATADIR_BKOOPASUIT));
|
||||
HuDataDirClose(MAKE_DIR_NUM(DATADIR_BBATTLE));
|
||||
HuDataDirClose(MAKE_DIR_NUM(DATADIR_BKOOPA));
|
||||
HuDataDirClose(MAKE_DIR_NUM(DATADIR_BKUJIYA));
|
||||
HuDataDirClose(MAKE_DIR_NUM(DATADIR_BYOKODORI));
|
||||
HuDataDirClose(MAKE_DIR_NUM(DATADIR_BOARD));
|
||||
HuDataDirClose(DATADIR_EFFECT);
|
||||
HuDataDirClose(DATADIR_BGUEST);
|
||||
HuDataDirClose(DATADIR_BKOOPASUIT);
|
||||
HuDataDirClose(DATADIR_BBATTLE);
|
||||
HuDataDirClose(DATADIR_BKOOPA);
|
||||
HuDataDirClose(DATADIR_BKUJIYA);
|
||||
HuDataDirClose(DATADIR_BYOKODORI);
|
||||
HuDataDirClose(DATADIR_BOARD);
|
||||
createFunc = destroyFunc = NULL;
|
||||
}
|
||||
|
||||
|
|
@ -1760,7 +1761,7 @@ void BoardConfettiCreate(Vec *pos, s16 count, float range)
|
|||
object->trans.y = pos->y;
|
||||
object->trans.z = pos->z;
|
||||
object->rot.x = range;
|
||||
work->gfx_mdl = BoardModelCreate(MAKE_DATA_NUM(DATADIR_BOARD, 7), NULL, 0);
|
||||
work->gfx_mdl = BoardModelCreate(DATA_MAKE_NUM(DATADIR_BOARD, 7), NULL, 0);
|
||||
BoardModelLayerSet(work->gfx_mdl, 2);
|
||||
BoardModelVisibilitySet(work->gfx_mdl, 0);
|
||||
{
|
||||
|
|
@ -1962,9 +1963,9 @@ typedef struct last5_gfx_work {
|
|||
} Last5GfxWork;
|
||||
|
||||
static s32 last5GfxSprTbl[3] = {
|
||||
MAKE_DATA_NUM(DATADIR_BOARD, 95),
|
||||
MAKE_DATA_NUM(DATADIR_BOARD, 97),
|
||||
MAKE_DATA_NUM(DATADIR_BOARD, 96),
|
||||
DATA_MAKE_NUM(DATADIR_BOARD, 95),
|
||||
DATA_MAKE_NUM(DATADIR_BOARD, 97),
|
||||
DATA_MAKE_NUM(DATADIR_BOARD, 96),
|
||||
};
|
||||
|
||||
static float last5GfxPosTbl[2][3][2] = {
|
||||
|
|
@ -2019,11 +2020,11 @@ void BoardLast5GfxInit(void)
|
|||
}
|
||||
spr_file = last5GfxSprTbl[i];
|
||||
if(i == 2 && work->is_last && GWLanguageGet() != 0) {
|
||||
spr_file = MAKE_DATA_NUM(DATADIR_BOARD, 98);
|
||||
spr_file = DATA_MAKE_NUM(DATADIR_BOARD, 98);
|
||||
}
|
||||
BoardSpriteCreate(spr_file, prio, NULL, &work->sprites[i]);
|
||||
HuSprGrpMemberSet(work->group, i, work->sprites[i]);
|
||||
HuSprAttrSet(work->group, i, SPIRTE_ATTR_BILINEAR);
|
||||
HuSprAttrSet(work->group, i, SPRITE_ATTR_BILINEAR);
|
||||
HuSprPosSet(work->group, i, last5GfxPosTbl[lastF][i][0], last5GfxPosTbl[lastF][i][1]);
|
||||
}
|
||||
if(!work->is_last) {
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
#include "game/board/main.h"
|
||||
#include "game/board/model.h"
|
||||
#include "game/chrman.h"
|
||||
#include "game/hsfman.h"
|
||||
#include "game/hsfmotion.h"
|
||||
#include "game/memory.h"
|
||||
|
|
@ -381,8 +382,8 @@ s32 BoardModelMotionCreate(s16 model, s32 data_num)
|
|||
}
|
||||
model = Hu3DJointMotion(model_ptr->id, model_ptr->mot_data[i]);
|
||||
} else {
|
||||
model = CharMotionCreate(model_ptr->character, data_num);
|
||||
CharMotionDataClose(model_ptr->character);
|
||||
model = CharModelMotionCreate(model_ptr->character, data_num);
|
||||
CharModelMotionDataClose(model_ptr->character);
|
||||
}
|
||||
model_ptr->mot_id[i] = model;
|
||||
model_ptr->mot_count++;
|
||||
|
|
@ -406,7 +407,7 @@ s32 BoardModelMotionKill(s16 model, s32 motion)
|
|||
if(model_ptr->character == -1) {
|
||||
Hu3DMotionKill(model_ptr->mot_id[motion]);
|
||||
} else {
|
||||
CharMotionKill(model_ptr->character, model_ptr->mot_id[motion]);
|
||||
CharModelMotionKill(model_ptr->character, model_ptr->mot_id[motion]);
|
||||
}
|
||||
model_ptr->mot_id[motion] = -1;
|
||||
}
|
||||
|
|
@ -1170,7 +1171,7 @@ static s32 CreateBoardModelMotion(BoardModel *model, s32 count, s32 *data_num)
|
|||
}
|
||||
index = Hu3DJointMotion(model->id, data);
|
||||
} else {
|
||||
index = CharMotionCreate(model->character, data_num[i]);
|
||||
index = CharModelMotionCreate(model->character, data_num[i]);
|
||||
}
|
||||
if(index < 0) {
|
||||
return -1;
|
||||
|
|
|
|||
1556
src/game/board/pause.c
Executable file
1556
src/game/board/pause.c
Executable file
File diff suppressed because it is too large
Load diff
|
|
@ -1,13 +1,13 @@
|
|||
#include "game/board/player.h"
|
||||
#include "game/chrman.h"
|
||||
#include "game/objsub.h"
|
||||
#include "game/board/com.h"
|
||||
#include "game/board/main.h"
|
||||
#include "game/board/roll.h"
|
||||
#include "game/board/tutorial.h"
|
||||
#include "game/board/ui.h"
|
||||
#include "game/board/view.h"
|
||||
|
||||
//// #include "game/objsub.h"
|
||||
extern void omVibrate(s16, s16, s16, s16);
|
||||
//// #include "game/board/ui.h"
|
||||
extern void BoardStatusHammerShowSet(s32, s32);
|
||||
extern void BoardYourTurnExec(s32);
|
||||
extern s32 BoardItemUseExec(s32);
|
||||
//// #include "game/board/main.h"
|
||||
extern f32 BoardDAngleCalc(f32);
|
||||
//// #include "game/board/model.h"
|
||||
extern s16 BoardModelCreateCharacter(s32, s32, s32*, s32);
|
||||
extern void BoardModelExistCheck(s16, s32);
|
||||
|
|
@ -15,53 +15,27 @@ extern void BoardModelExistDupe(s16, s32);
|
|||
extern void BoardModelCameraSet(s16, u16);
|
||||
extern void BoardItemStatusKill(s32);
|
||||
extern void BoardModelAmbSet(s16, f32, f32, f32);
|
||||
extern void BoardModelPosSetV(s16, Vec*);
|
||||
extern void BoardModelPosSet(s16, f32, f32, f32);
|
||||
extern s32 BoardModelPosGet(s16, Vec*);
|
||||
extern void BoardModelRotSetV(s16, Vec*);
|
||||
extern void BoardModelRotSet(s16, f32, f32, f32);
|
||||
extern s32 BoardModelRotGet(s16, Vec*);
|
||||
extern void BoardModelRotYSet(s16, f32);
|
||||
extern f32 BoardModelRotYGet(s16);
|
||||
extern void BoardModelScaleSetV(s16, Vec*);
|
||||
extern void BoardModelScaleSet(s16, f32, f32, f32);
|
||||
extern void BoardModelScaleGet(s16, s32*);
|
||||
extern void BoardModelVoiceEnableSet(s16, s32, s32);
|
||||
extern s32 BoardModelMotionCreate(s16, s32);
|
||||
extern void BoardModelMotionKill(s16, s32);
|
||||
extern s32 BoardModelMotionEndCheck(s16);
|
||||
extern s32 BoardModelMotionStart(s16, s32, s32);
|
||||
extern s32 BoardModelMotionShiftSet(s16, s32, f32, f32, u32);
|
||||
extern void BoardModelMotionSpeedSet(s16, f32);
|
||||
extern void BoardModelMotionTimeSet(s16, f32);
|
||||
extern f32 BoardModelMotionTimeGet(s16);
|
||||
extern f32 BoardModelMotionMaxTimeGet(s16);
|
||||
extern void BoardModelMotionTimeRangeSet(s16, s32, s32);
|
||||
extern void BoardModelAttrSet(s16, s32);
|
||||
extern void BoardModelAttrReset(s16, s32);
|
||||
//// #include "game/board/tutorial.h"
|
||||
extern BoardTutorialHookExec(s16, s32);
|
||||
//// #include "game/board/com.h"
|
||||
extern void BoardComUseItemSet(s32, s32);
|
||||
//// #include "game/board/overhead.h"
|
||||
extern void BoardViewOverheadExec(s32);
|
||||
extern void BoardViewMapExec(s32);
|
||||
//// #include "game/board/roll.h"
|
||||
extern s32 BoardRollExec(s32);
|
||||
extern void BoardRollKill(void);
|
||||
//// #include "game/chrman.h"
|
||||
extern void CharModelDataClose(s16);
|
||||
extern void CharModelStepTypeSet(s16, s32);
|
||||
//// #include "game/board/pad.h"
|
||||
extern s8 HuPadStkX[4];
|
||||
extern s8 HuPadStkY[4];
|
||||
extern u16 HuPadBtnDown[4];
|
||||
extern u8 HuPadDStk[4];
|
||||
extern s16 boardTutorialDirInputTime;
|
||||
extern s8 boardTutorialDirInputX;
|
||||
extern s8 boardTutorialDirInputY;
|
||||
//// #include "game/board/view.h"
|
||||
void BoardViewMapExec(s32);
|
||||
////
|
||||
|
||||
typedef struct bitcopy {
|
||||
|
|
|
|||
935
src/game/board/roll.c
Executable file
935
src/game/board/roll.c
Executable file
|
|
@ -0,0 +1,935 @@
|
|||
#include "game/board/roll.h"
|
||||
#include "game/audio.h"
|
||||
#include "game/gamework_data.h"
|
||||
#include "game/hsfanim.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/model.h"
|
||||
#include "game/board/pause.h"
|
||||
#include "game/board/player.h"
|
||||
#include "game/board/tutorial.h"
|
||||
|
||||
typedef struct {
|
||||
struct {
|
||||
u8 unk00_field0 : 1;
|
||||
u8 unk00_field1 : 1;
|
||||
u8 unk00_field2 : 3;
|
||||
u8 unk00_field3 : 2;
|
||||
};
|
||||
s8 unk01;
|
||||
s8 unk02;
|
||||
char unk03[1];
|
||||
s16 unk04;
|
||||
s16 unk06;
|
||||
} DiceWork;
|
||||
|
||||
typedef struct {
|
||||
struct {
|
||||
u8 unk00_field0 : 1;
|
||||
u8 unk00_field1 : 1;
|
||||
u8 unk00_field2 : 1;
|
||||
u8 unk00_field3 : 2;
|
||||
};
|
||||
s8 unk01;
|
||||
s16 unk02;
|
||||
s16 unk04[2];
|
||||
float unk08;
|
||||
} DiceDigitWork;
|
||||
|
||||
s32 BoardRollResizeCheck(void);
|
||||
|
||||
static void RollMain(void);
|
||||
static void DiceCreate(s32 arg0);
|
||||
static void DoInput(s32 arg0);
|
||||
static void DiceWaitFull(s32 arg0);
|
||||
static void DiceSetHit(s32 arg0);
|
||||
static void RollDestroy(void);
|
||||
static void DiceMain(omObjData *arg0);
|
||||
static void DicePause(s32 arg0);
|
||||
static void DicePauseAll(void);
|
||||
static void DiceHideEffect(s32 arg0, s32 arg1);
|
||||
static void DiceDigitMain(omObjData *arg0);
|
||||
static void DiceDigitKill(DiceDigitWork *arg0);
|
||||
static void DiceKill(void);
|
||||
static void DiceDigitMove(DiceDigitWork *arg0, s32 arg1);
|
||||
static void DiceDigitRotate(DiceDigitWork *arg0, s32 arg1);
|
||||
static void SameRollExec(void);
|
||||
static s32 GetBtnRoll(s32 arg0);
|
||||
static s32 GetComBtnRoll(s32 arg0);
|
||||
|
||||
static s32 tutorialRoll[3];
|
||||
|
||||
static s8 diceValue[3];
|
||||
static s8 rollPlayer;
|
||||
static s8 numDice;
|
||||
static s8 inputTimer;
|
||||
static s8 maxRoll;
|
||||
static s8 destMode;
|
||||
static s8 diceSize;
|
||||
s32 lbl_801D4098;
|
||||
static char sameRollCoinStr[8];
|
||||
static s8 tutorialRollF;
|
||||
static Process *rollProc;
|
||||
|
||||
static s16 diceMdl[3] = { -1, -1, -1 };
|
||||
static s16 diceEff[3] = { -1, -1, -1 };
|
||||
static s16 rollWin = -1;
|
||||
|
||||
static omObjData *diceObj[3] = { NULL, NULL, NULL };
|
||||
static omObjData *diceDigitObj[3] = { NULL, NULL, NULL };
|
||||
static s32 diceSndStatus[3] = { -1, -1, -1 };
|
||||
|
||||
static HsfanimStruct00 diceEffParam = {
|
||||
0x0096,
|
||||
{ 0x00, 0x00 }, // padding?
|
||||
50.0f,
|
||||
0.0f,
|
||||
65.0f,
|
||||
{ 0.0f, -0.195f, 0.0f },
|
||||
100.0f,
|
||||
0.99f,
|
||||
40.0f,
|
||||
0.999f,
|
||||
0x0004,
|
||||
{
|
||||
{ 0xFF, 0xFF, 0x20, 0xFF },
|
||||
{ 0xFF, 0xFF, 0x00, 0xFF },
|
||||
{ 0xFF, 0xFF, 0x80, 0xFF },
|
||||
{ 0xFF, 0xFF, 0xFF, 0xFF }
|
||||
},
|
||||
{
|
||||
{ 0xFF, 0xFF, 0xFF, 0x00 },
|
||||
{ 0xFF, 0xFF, 0xFF, 0x00 },
|
||||
{ 0xFF, 0xFF, 0xFF, 0x00 },
|
||||
{ 0xFF, 0xFF, 0xFF, 0x00 }
|
||||
}
|
||||
};
|
||||
|
||||
static s32 diceDigitMdlTbl[10] = {
|
||||
0x0007000C,
|
||||
0x0007000D,
|
||||
0x0007000E,
|
||||
0x0007000F,
|
||||
0x00070010,
|
||||
0x00070011,
|
||||
0x00070012,
|
||||
0x00070013,
|
||||
0x00070014,
|
||||
0x00070015
|
||||
};
|
||||
|
||||
s32 BoardRollExec(s32 arg0) {
|
||||
rollPlayer = arg0;
|
||||
inputTimer = 0;
|
||||
numDice = 1;
|
||||
diceSize = 0;
|
||||
maxRoll = 0xA;
|
||||
switch (BoardRollTypeGet()) {
|
||||
case 0:
|
||||
numDice = 1;
|
||||
break;
|
||||
case 2:
|
||||
numDice = 2;
|
||||
break;
|
||||
case 1:
|
||||
numDice = 2;
|
||||
break;
|
||||
case 3:
|
||||
numDice = 3;
|
||||
break;
|
||||
}
|
||||
if (BoardPlayerSizeGet(arg0) == 1) {
|
||||
diceSize = 1;
|
||||
maxRoll = 5;
|
||||
} else if (BoardPlayerSizeGet(arg0) == 2) {
|
||||
diceSize = 2;
|
||||
maxRoll = 10;
|
||||
if (BoardRollResizeCheck() != 0) {
|
||||
numDice = 2;
|
||||
}
|
||||
}
|
||||
if (GWPlayer[rollPlayer].bowser_suit != 0) {
|
||||
diceSize = 3;
|
||||
}
|
||||
GWPlayer[arg0].field08_bit7 = numDice;
|
||||
rollProc = HuPrcChildCreate(RollMain, 0x2005, 0x6000, 0, boardMainProc);
|
||||
HuPrcDestructorSet2(rollProc, RollDestroy);
|
||||
while (rollProc != NULL) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
while (diceObj[0] || diceObj[1] || diceObj[2]) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
return destMode;
|
||||
}
|
||||
|
||||
void BoardRollKill(void) {
|
||||
if (rollProc) {
|
||||
HuPrcKill(rollProc);
|
||||
}
|
||||
DicePauseAll();
|
||||
DiceKill();
|
||||
}
|
||||
|
||||
void BoardRollUPauseSet(s32 arg0) {
|
||||
if (!rollProc) {
|
||||
return;
|
||||
}
|
||||
BoardRollWinDispSet(arg0);
|
||||
BoardDiceVisibleSet(0, arg0);
|
||||
BoardDiceVisibleSet(1, arg0);
|
||||
BoardDiceVisibleSet(2, arg0);
|
||||
DiceHideEffect(0, arg0);
|
||||
DiceHideEffect(1, arg0);
|
||||
DiceHideEffect(2, arg0);
|
||||
}
|
||||
|
||||
void BoardRollWinDispSet(s32 arg0) {
|
||||
if (rollWin == -1) {
|
||||
return;
|
||||
}
|
||||
if (arg0 != 0) {
|
||||
HuWinDispOn(rollWin);
|
||||
} else {
|
||||
HuWinDispOff(rollWin);
|
||||
}
|
||||
}
|
||||
|
||||
static void RollMain(void) {
|
||||
float sp8[2];
|
||||
float var_f31;
|
||||
float var_f30;
|
||||
s32 var_r28;
|
||||
s32 var_r27;
|
||||
s32 temp_r26;
|
||||
s32 temp_r25;
|
||||
s32 var_r30;
|
||||
s32 var_r29;
|
||||
s32 i;
|
||||
|
||||
diceValue[0] = diceValue[1] = diceValue[2] = 0;
|
||||
if (BoardPlayerSizeGet(rollPlayer) == 2 || GWPlayer[rollPlayer].bowser_suit != 0) {
|
||||
BoardCameraViewSet(2);
|
||||
}
|
||||
BoardCameraMotionWait();
|
||||
BoardCameraTargetModelSet(-1);
|
||||
for (i = 0; i < numDice; i++) {
|
||||
temp_r26 = rollPlayer;
|
||||
if (!_CheckFlag(0x1000B)) {
|
||||
var_r27 = BoardPlayerItemCount(temp_r26);
|
||||
if (GWTeamGet()) {
|
||||
temp_r25 = BoardPlayerSameTeamFind(temp_r26);
|
||||
var_r27 += BoardPlayerItemCount(temp_r25);
|
||||
}
|
||||
if (BoardRollTypeGet() != -1 || var_r27 == 0 || _CheckFlag(0x10009) || BoardRollResizeCheck()) {
|
||||
var_r29 = 0x90004;
|
||||
} else {
|
||||
var_r29 = 0x90002;
|
||||
}
|
||||
if (inputTimer != 0) {
|
||||
var_r29 = 0x300025;
|
||||
}
|
||||
HuWinMesMaxSizeGet(1, sp8, var_r29);
|
||||
switch (GWGameStat.language) {
|
||||
case 0:
|
||||
var_f31 = -10000.0f;
|
||||
break;
|
||||
case 1:
|
||||
var_f31 = 288.0f - (sp8[0] / 2 - 16.0f);
|
||||
break;
|
||||
}
|
||||
var_f30 = 304.0f;
|
||||
rollWin = HuWinCreate(var_f31, var_f30, sp8[0], sp8[1], 0);
|
||||
HuWinBGTPLvlSet(rollWin, 0.0f);
|
||||
HuWinMesSpeedSet(rollWin, 0);
|
||||
HuWinMesSet(rollWin, var_r29);
|
||||
}
|
||||
DiceCreate(i);
|
||||
DiceWaitFull(i);
|
||||
DoInput(i);
|
||||
if (rollWin != -1) {
|
||||
HuWinKill(rollWin);
|
||||
rollWin = -1;
|
||||
}
|
||||
if (destMode == -2 || destMode == -1 || destMode == -3 || destMode == -4) {
|
||||
HuPrcEnd();
|
||||
}
|
||||
BoardPlayerDiceJumpStart(rollPlayer);
|
||||
while (!BoardPlayerDiceJumpCheck(rollPlayer)) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
DiceSetHit(i);
|
||||
while (GWPlayer[rollPlayer].field08_bit3 != 0) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
}
|
||||
for (var_r30 = i = 0; i < numDice; i++) {
|
||||
var_r30 += diceValue[i];
|
||||
}
|
||||
var_r28 = 0;
|
||||
switch (numDice) {
|
||||
case 2:
|
||||
if (diceValue[0] == diceValue[1]) {
|
||||
var_r28 = 1;
|
||||
}
|
||||
break;
|
||||
case 3:
|
||||
if (diceValue[0] == diceValue[1] && diceValue[0] == diceValue[2]) {
|
||||
var_r28 = 1;
|
||||
}
|
||||
break;
|
||||
}
|
||||
if (var_r28 != 0) {
|
||||
SameRollExec();
|
||||
}
|
||||
BoardDicePauseAll();
|
||||
while (!BoardDiceDoneCheck()) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
for (i = 0; i < numDice; i++) {
|
||||
BoardDiceStop(i);
|
||||
}
|
||||
destMode = var_r30;
|
||||
GWPlayer[rollPlayer].roll = var_r30;
|
||||
BoardDiceDigit2DInit(rollPlayer, 1);
|
||||
if (_CheckFlag(0x1000B)) {
|
||||
BoardTutorialHookExec(6, 0);
|
||||
}
|
||||
if (tutorialRollF != 0) {
|
||||
tutorialRollF = 0;
|
||||
}
|
||||
HuPrcEnd();
|
||||
}
|
||||
|
||||
static void DiceCreate(s32 arg0) {
|
||||
Vec sp1C;
|
||||
float temp_f30;
|
||||
float var_f31;
|
||||
omObjData *temp_r31;
|
||||
DiceWork *temp_r30;
|
||||
s32 sp8;
|
||||
s32 spC[4] = {
|
||||
0x00070018,
|
||||
0x00070019,
|
||||
0x0007001A,
|
||||
0x0007001B
|
||||
};
|
||||
|
||||
sp8 = 0;
|
||||
diceMdl[arg0] = BoardModelCreate(spC[diceSize], NULL, 0);
|
||||
temp_f30 = BoardRandMod(maxRoll) + 0.5f;
|
||||
BoardPlayerPosGet(rollPlayer, &sp1C);
|
||||
HuAudFXPlay(0x302);
|
||||
BoardModelMotionStart(diceMdl[arg0], 0, 0);
|
||||
BoardModelMotionSpeedSet(diceMdl[arg0], 0.0f);
|
||||
BoardModelMotionTimeSet(diceMdl[arg0], temp_f30);
|
||||
BoardModelScaleSet(diceMdl[arg0], 0.001f, 0.001f, 0.001f);
|
||||
temp_r31 = omAddObjEx(boardObjMan, 0x102, 0, 0, -1, DiceMain);
|
||||
temp_r30 = OM_GET_WORK_PTR(temp_r31, DiceWork);
|
||||
temp_r30->unk00_field0 = 0;
|
||||
temp_r30->unk00_field1 = 0;
|
||||
temp_r30->unk00_field2 = 0;
|
||||
temp_r30->unk00_field3 = arg0;
|
||||
temp_r30->unk04 = 0;
|
||||
temp_r30->unk01 = 4;
|
||||
temp_r30->unk02 = 0;
|
||||
diceObj[arg0] = temp_r31;
|
||||
var_f31 = 250.0f;
|
||||
if (diceSize == 2) {
|
||||
var_f31 = 625.0f;
|
||||
} else if (GWPlayer[rollPlayer].bowser_suit != 0) {
|
||||
var_f31 = 575.0f;
|
||||
}
|
||||
sp1C.y += var_f31;
|
||||
temp_r31->trans.x = sp1C.x;
|
||||
temp_r31->trans.y = sp1C.y;
|
||||
temp_r31->trans.z = sp1C.z;
|
||||
temp_r31->scale.x = 0.1f;
|
||||
temp_r31->scale.y = 0.1f;
|
||||
temp_r31->scale.z = 0.1f;
|
||||
sp1C.z += 70.0f;
|
||||
}
|
||||
|
||||
static void DoInput(s32 arg0) {
|
||||
s32 var_r31;
|
||||
s32 var_r30;
|
||||
u16 sp8[1];
|
||||
|
||||
destMode = 0;
|
||||
lbl_801D4098 = 0;
|
||||
while (1) {
|
||||
HuPrcVSleep();
|
||||
*sp8 = GetBtnRoll(rollPlayer);
|
||||
if (BoardPauseActiveCheck()) {
|
||||
*sp8 = 0;
|
||||
continue;
|
||||
}
|
||||
if (*sp8 == 0x100) {
|
||||
inputTimer++;
|
||||
break;
|
||||
}
|
||||
if (inputTimer == 0) {
|
||||
if (*sp8 == 0x10) {
|
||||
destMode = -3;
|
||||
HuAudFXPlay(1);
|
||||
break;
|
||||
}
|
||||
if (*sp8 == 0x20) {
|
||||
destMode = -4;
|
||||
HuAudFXPlay(1);
|
||||
break;
|
||||
}
|
||||
var_r31 = BoardPlayerItemCount(rollPlayer);
|
||||
if (GWTeamGet()) {
|
||||
var_r30 = BoardPlayerSameTeamFind(rollPlayer);
|
||||
var_r31 += BoardPlayerItemCount(var_r30);
|
||||
}
|
||||
if (var_r31 == 0 || BoardRollTypeGet() != -1 || BoardRollResizeCheck() || _CheckFlag(0x10009)) {
|
||||
if (_CheckFlag(0x10009) && GWBoardGet() == 5 && *sp8 == 0x200 && var_r31 != 0) {
|
||||
HuAudFXPlay(4);
|
||||
}
|
||||
} else if (*sp8 == 0x200) {
|
||||
destMode = -2;
|
||||
HuAudFXPlay(3);
|
||||
BoardPauseDisableSet(1);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void DiceWaitFull(s32 arg0) {
|
||||
DiceWork *temp_r31 = OM_GET_WORK_PTR(diceObj[arg0], DiceWork);
|
||||
|
||||
while (temp_r31->unk00_field2 != 1) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
}
|
||||
|
||||
static void DiceSetHit(s32 arg0) {
|
||||
DiceWork *temp_r30 = OM_GET_WORK_PTR(diceObj[arg0], DiceWork);
|
||||
|
||||
temp_r30->unk00_field2 = 2;
|
||||
temp_r30->unk04 = 0;
|
||||
BoardModelMotionSpeedSet(diceMdl[arg0], 0.0f);
|
||||
diceValue[arg0] = (s32) BoardModelMotionTimeGet(diceMdl[arg0]) + 1;
|
||||
if (tutorialRollF != 0 && tutorialRoll[arg0] != -1) {
|
||||
BoardModelMotionTimeSet(diceMdl[arg0], tutorialRoll[arg0] - 1);
|
||||
diceValue[arg0] = tutorialRoll[arg0];
|
||||
}
|
||||
}
|
||||
|
||||
static void RollDestroy(void) {
|
||||
if (rollWin != -1) {
|
||||
HuWinKill(rollWin);
|
||||
rollWin = -1;
|
||||
}
|
||||
if (rollProc) {
|
||||
HuPrcKill(rollProc);
|
||||
}
|
||||
DicePauseAll();
|
||||
DiceKill();
|
||||
BoardConfettiKill();
|
||||
rollProc = NULL;
|
||||
}
|
||||
|
||||
static void DiceMain(omObjData *arg0) {
|
||||
DiceWork *temp_r29 = OM_GET_WORK_PTR(arg0, DiceWork);
|
||||
float temp_f29;
|
||||
float var_f28;
|
||||
float var_f27;
|
||||
s16 temp_r26;
|
||||
s16 temp_r27;
|
||||
|
||||
if (temp_r29->unk00_field0 != 0 || BoardIsKill()) {
|
||||
if (diceSndStatus[temp_r29->unk00_field3] != -1) {
|
||||
HuAudFXStop(diceSndStatus[temp_r29->unk00_field3]);
|
||||
diceSndStatus[temp_r29->unk00_field3] = -1;
|
||||
}
|
||||
if (diceMdl[temp_r29->unk00_field3] != -1) {
|
||||
BoardModelKill(diceMdl[temp_r29->unk00_field3]);
|
||||
diceMdl[temp_r29->unk00_field3] = -1;
|
||||
}
|
||||
if (diceEff[temp_r29->unk00_field3] != -1) {
|
||||
Hu3DParManKill(diceEff[temp_r29->unk00_field3]);
|
||||
diceEff[temp_r29->unk00_field3] = -1;
|
||||
}
|
||||
DicePause(temp_r29->unk00_field3);
|
||||
diceObj[temp_r29->unk00_field3] = NULL;
|
||||
omDelObjEx(HuPrcCurrentGet(), arg0);
|
||||
return;
|
||||
}
|
||||
switch (temp_r29->unk00_field2) {
|
||||
case 0:
|
||||
if (temp_r29->unk06 >= 0x438) {
|
||||
temp_r29->unk00_field2 = 1;
|
||||
arg0->scale.x = arg0->scale.y = arg0->scale.z = 1.0f;
|
||||
arg0->rot.y = temp_r29->unk04 = 0;
|
||||
} else {
|
||||
if (temp_r29->unk04 == 0 && diceSndStatus[temp_r29->unk00_field3] == -1) {
|
||||
diceSndStatus[temp_r29->unk00_field3] = HuAudFXPlay(0x300);
|
||||
}
|
||||
arg0->rot.y = temp_r29->unk06 % 360;
|
||||
temp_r29->unk06 += 0x19;
|
||||
if (temp_r29->unk04 < 0xB4) {
|
||||
var_f27 = 0.0f;
|
||||
var_f28 = 1.0f;
|
||||
} else {
|
||||
var_f27 = 1.0f;
|
||||
var_f28 = 0.5f;
|
||||
}
|
||||
arg0->scale.x = var_f27 + var_f28 * sin((float) (temp_r29->unk04 % 180) * M_PI / 180.0);
|
||||
arg0->scale.y = arg0->scale.x;
|
||||
arg0->scale.z = arg0->scale.x;
|
||||
if (temp_r29->unk04 <= 360) {
|
||||
if (temp_r29->unk04 < 0xB4) {
|
||||
temp_r29->unk04 += 6;
|
||||
} else {
|
||||
temp_r29->unk04 += 0x12;
|
||||
}
|
||||
if (temp_r29->unk04 > 360) {
|
||||
temp_r29->unk04 = 360;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 1:
|
||||
temp_r29->unk04 += 4;
|
||||
if (temp_r29->unk04 > 360) {
|
||||
temp_r29->unk04 -= 360;
|
||||
}
|
||||
OSs16tof32(&temp_r29->unk04, &temp_f29);
|
||||
arg0->trans.y += 0.20000000298023224 * sin(temp_f29 * M_PI / 180.0);
|
||||
break;
|
||||
case 2:
|
||||
temp_r29->unk04++;
|
||||
if (temp_r29->unk04 >= 8) {
|
||||
if (diceSndStatus[temp_r29->unk00_field3] != -1) {
|
||||
HuAudFXStop(diceSndStatus[temp_r29->unk00_field3]);
|
||||
diceSndStatus[temp_r29->unk00_field3] = -1;
|
||||
}
|
||||
HuAudFXPlay(0x303);
|
||||
HuAudFXPlay(0x30C);
|
||||
temp_r29->unk00_field2 = 3;
|
||||
temp_r29->unk04 = 0;
|
||||
BoardDiceValueSet(temp_r29->unk00_field3, diceValue[temp_r29->unk00_field3]);
|
||||
diceEff[temp_r29->unk00_field3] = BoardDiceEffectCreate();
|
||||
Hu3DParManPosSet(diceEff[temp_r29->unk00_field3], arg0->trans.x, arg0->trans.y, arg0->trans.z);
|
||||
BoardModelVisibilitySet(diceMdl[temp_r29->unk00_field3], 0);
|
||||
} else {
|
||||
OSs16tof32(&temp_r29->unk04, &temp_f29);
|
||||
if (temp_r29->unk04 < 4) {
|
||||
arg0->trans.y += 10.0f + (0.5f * temp_f29);
|
||||
arg0->scale.x = (arg0->scale.x + (0.10000000149011612 * sin((M_PI * (4.0f * temp_f29)) / 180.0)));
|
||||
arg0->scale.y = arg0->scale.x;
|
||||
arg0->scale.z = arg0->scale.x;
|
||||
} else {
|
||||
BoardModelAlphaSet(diceMdl[temp_r29->unk00_field3], 0xFF - (temp_r29->unk04 << 5));
|
||||
}
|
||||
arg0->trans.y += -0.49f * temp_f29 * temp_f29;
|
||||
}
|
||||
break;
|
||||
case 3:
|
||||
break;
|
||||
}
|
||||
if (diceEff[temp_r29->unk00_field3] != -1 && ++temp_r29->unk04 >= 150) {
|
||||
temp_r29->unk00_field0 = 1;
|
||||
DiceHideEffect(temp_r29->unk00_field3, 0);
|
||||
}
|
||||
if (temp_r29->unk00_field1 == 0 || temp_r29->unk00_field2 != 3) {
|
||||
if (temp_r29->unk02++ > temp_r29->unk01) {
|
||||
temp_r29->unk02 = 0;
|
||||
temp_r26 = BoardModelMotionTimeGet(diceMdl[temp_r29->unk00_field3]);
|
||||
do {
|
||||
temp_r27 = BoardRandMod(maxRoll);
|
||||
} while (temp_r27 == temp_r26);
|
||||
BoardModelMotionTimeSet(diceMdl[temp_r29->unk00_field3], temp_r27 + 0.5f);
|
||||
}
|
||||
}
|
||||
BoardModelPosSet(diceMdl[temp_r29->unk00_field3], arg0->trans.x, arg0->trans.y, arg0->trans.z);
|
||||
BoardModelRotSet(diceMdl[temp_r29->unk00_field3], arg0->rot.x, arg0->rot.y, arg0->rot.z);
|
||||
BoardModelScaleSet(diceMdl[temp_r29->unk00_field3], arg0->scale.x, arg0->scale.y, arg0->scale.z);
|
||||
}
|
||||
|
||||
static void DicePause(s32 arg0) {
|
||||
omObjData *temp_r31 = diceObj[arg0];
|
||||
|
||||
if (temp_r31) {
|
||||
OM_GET_WORK_PTR(temp_r31, DiceWork)->unk00_field0 = 1;
|
||||
}
|
||||
}
|
||||
|
||||
static void DicePauseAll(void) {
|
||||
DicePause(0);
|
||||
DicePause(1);
|
||||
DicePause(2);
|
||||
}
|
||||
|
||||
s16 BoardDiceEffectCreate(void) {
|
||||
s16 temp_r31;
|
||||
s16 temp_r30;
|
||||
AnimData *temp_r29;
|
||||
void *temp_r28;
|
||||
|
||||
temp_r28 = HuDataSelHeapReadNum(0x7006B, MEMORY_DEFAULT_NUM, HEAP_DATA);
|
||||
temp_r29 = HuSprAnimRead(temp_r28);
|
||||
temp_r31 = Hu3DParManCreate(temp_r29, 0x64, &diceEffParam);
|
||||
Hu3DParManAttrSet(temp_r31, 0x108);
|
||||
Hu3DParManRotSet(temp_r31, 0.0f, 0.0f, 0.0f);
|
||||
Hu3DParManVecSet(temp_r31, 0.0f, 0.4f, 0.2f);
|
||||
Hu3DParManTimeLimitSet(temp_r31, 0x96);
|
||||
temp_r30 = Hu3DParManModelIDGet(temp_r31);
|
||||
Hu3DModelLayerSet(temp_r30, 1);
|
||||
Hu3DParticleBlendModeSet(temp_r30, 0);
|
||||
return temp_r31;
|
||||
}
|
||||
|
||||
static void DiceHideEffect(s32 arg0, s32 arg1) {
|
||||
s16 temp_r31;
|
||||
|
||||
if (diceEff[arg0] == -1) {
|
||||
return;
|
||||
}
|
||||
temp_r31 = Hu3DParManModelIDGet(diceEff[arg0]);
|
||||
if (arg1 != 0) {
|
||||
Hu3DModelAttrReset(temp_r31, 1);
|
||||
} else {
|
||||
Hu3DModelAttrSet(temp_r31, 1);
|
||||
}
|
||||
}
|
||||
|
||||
void BoardDicePauseAll(void) {
|
||||
DiceDigitWork *temp_r30;
|
||||
s32 i;
|
||||
|
||||
for (i = 0; i < numDice; i++) {
|
||||
if (diceDigitObj[i]) {
|
||||
temp_r30 = OM_GET_WORK_PTR(diceDigitObj[i], DiceDigitWork);
|
||||
temp_r30->unk00_field1 = 1;
|
||||
temp_r30->unk00_field2 = 1;
|
||||
temp_r30->unk02 = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
BOOL BoardDiceDoneCheck(void) {
|
||||
DiceDigitWork *temp_r30;
|
||||
s32 i;
|
||||
|
||||
for (i = 0; i < numDice; i++) {
|
||||
if (diceDigitObj[i]) {
|
||||
temp_r30 = OM_GET_WORK_PTR(diceDigitObj[i], DiceDigitWork);
|
||||
if (temp_r30->unk00_field2 != 0) {
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
void BoardDiceStop(s32 arg0) {
|
||||
DiceDigitWork *temp_r31;
|
||||
|
||||
if (!diceDigitObj[arg0]) {
|
||||
return;
|
||||
}
|
||||
temp_r31 = OM_GET_WORK_PTR(diceDigitObj[arg0], DiceDigitWork);
|
||||
temp_r31->unk00_field0 = 1;
|
||||
}
|
||||
|
||||
void BoardDiceVisibleSet(s32 arg0, s32 arg1) {
|
||||
DiceDigitWork *temp_r31;
|
||||
|
||||
if (!diceDigitObj[arg0]) {
|
||||
return;
|
||||
}
|
||||
temp_r31 = OM_GET_WORK_PTR(diceDigitObj[arg0], DiceDigitWork);
|
||||
if ((temp_r31->unk01 / 10) == 0) {
|
||||
BoardModelVisibilitySet(temp_r31->unk04[1], 0);
|
||||
} else {
|
||||
BoardModelVisibilitySet(temp_r31->unk04[1], arg1);
|
||||
}
|
||||
BoardModelVisibilitySet(temp_r31->unk04[0], arg1);
|
||||
}
|
||||
|
||||
void BoardDiceValueSet(s32 arg0, s32 arg1) {
|
||||
omObjData *temp_r27;
|
||||
DiceDigitWork *temp_r31;
|
||||
Vec spC;
|
||||
s16 sp8[2];
|
||||
s16 temp_r30;
|
||||
s16 i;
|
||||
|
||||
if (arg1 > 0x63) {
|
||||
arg1 = 0x63;
|
||||
}
|
||||
sp8[0] = (arg1 % 10);
|
||||
sp8[1] = (arg1 / 10);
|
||||
BoardPlayerPosGet(GWSystem.player_curr, &spC);
|
||||
spC.y += 300.0f;
|
||||
temp_r27 = omAddObjEx(boardObjMan, 0x102, 0, 0, -1, DiceDigitMain);
|
||||
temp_r31 = OM_GET_WORK_PTR(temp_r27, DiceDigitWork);
|
||||
temp_r31->unk00_field0 = 0;
|
||||
temp_r31->unk00_field1 = 0;
|
||||
temp_r31->unk00_field2 = 0;
|
||||
temp_r31->unk00_field3 = arg0;
|
||||
temp_r31->unk08 = 0.3f;
|
||||
temp_r31->unk01 = arg1;
|
||||
temp_r31->unk02 = 360;
|
||||
for (i = 0; i < 2; i++) {
|
||||
temp_r30 = BoardModelCreate(diceDigitMdlTbl[sp8[i]], NULL, 0);
|
||||
BoardModelPosSetV(temp_r30, &spC);
|
||||
BoardModelMotionStart(temp_r30, 0, 0);
|
||||
BoardModelMotionSpeedSet(temp_r30, 0.0f);
|
||||
BoardModelMotionTimeSet(temp_r30, 0.0f);
|
||||
BoardModelScaleSet(temp_r30, 0.143f, 0.143f, 0.143f);
|
||||
temp_r31->unk04[i] = temp_r30;
|
||||
}
|
||||
if (sp8[1] == 0) {
|
||||
BoardModelVisibilitySet(temp_r31->unk04[1], 0);
|
||||
}
|
||||
diceDigitObj[arg0] = temp_r27;
|
||||
}
|
||||
|
||||
static void DiceDigitMain(omObjData *arg0) {
|
||||
DiceDigitWork *temp_r31 = OM_GET_WORK_PTR(arg0, DiceDigitWork);
|
||||
|
||||
if (temp_r31->unk00_field0 != 0 || BoardIsKill()) {
|
||||
DiceDigitKill(temp_r31);
|
||||
diceDigitObj[temp_r31->unk00_field3] = NULL;
|
||||
omDelObjEx(HuPrcCurrentGet(), arg0);
|
||||
return;
|
||||
}
|
||||
DiceDigitMove(temp_r31, temp_r31->unk00_field1);
|
||||
DiceDigitRotate(temp_r31, temp_r31->unk00_field1);
|
||||
}
|
||||
|
||||
static void DiceDigitKill(DiceDigitWork *arg0) {
|
||||
s32 i;
|
||||
|
||||
for (i = 0; i < 2; i++) {
|
||||
if (arg0->unk04[i] != -1) {
|
||||
BoardModelKill(arg0->unk04[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void DiceKill(void) {
|
||||
DiceDigitWork *temp_r29;
|
||||
s32 i;
|
||||
|
||||
for (i = 0; i < 3; i++) {
|
||||
if (diceDigitObj[i]) {
|
||||
temp_r29 = OM_GET_WORK_PTR(diceDigitObj[i], DiceDigitWork);
|
||||
DiceDigitKill(temp_r29);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void DiceDigitMove(DiceDigitWork *arg0, s32 arg1) {
|
||||
s32 sp8 = 0;
|
||||
Vec sp30;
|
||||
Vec sp24;
|
||||
Vec sp54[2];
|
||||
Vec sp18 = { 288.0f, 155.0f, 240.0f };
|
||||
Vec sp3C[2] = {
|
||||
{ 144.0f, 155.0f, 240.0f },
|
||||
{ 432.0f, 155.0f, 240.0f }
|
||||
};
|
||||
Vec sp6C[3] = {
|
||||
{ 144.0f, 155.0f, 240.0f },
|
||||
{ 432.0f, 155.0f, 240.0f },
|
||||
{ 288.0f, 155.0f, 240.0f }
|
||||
};
|
||||
Vec spC = { 288.0f, 176.0f, 240.0f };
|
||||
Vec *var_r29;
|
||||
float var_f31;
|
||||
s16 var_r27;
|
||||
s16 i;
|
||||
|
||||
var_r27 = (arg0->unk01 / 10);
|
||||
if (arg1 != 0) {
|
||||
var_r29 = &spC;
|
||||
var_f31 = -20.0f * arg0->unk00_field3;
|
||||
} else {
|
||||
switch (numDice) {
|
||||
case 1:
|
||||
var_r29 = &sp18;
|
||||
break;
|
||||
case 2:
|
||||
var_r29 = &sp3C[arg0->unk00_field3];
|
||||
break;
|
||||
case 3:
|
||||
var_r29 = &sp6C[arg0->unk00_field3];
|
||||
break;
|
||||
}
|
||||
var_f31 = 0.0f;
|
||||
}
|
||||
for (i = 0; i < 2; i++) {
|
||||
if (var_r27 == 0) {
|
||||
sp54[i].x = var_r29->x;
|
||||
} else if (i != 0) {
|
||||
sp54[i].x = var_r29->x - 30.0f;
|
||||
} else {
|
||||
sp54[i].x = var_r29->x + 30.0f;
|
||||
}
|
||||
sp54[i].y = var_r29->y;
|
||||
sp54[i].z = var_r29->z + var_f31;
|
||||
}
|
||||
for (i = 0; i < 2; i++) {
|
||||
BoardModelPosGet(arg0->unk04[i], &sp30);
|
||||
Hu3D2Dto3D(&sp54[i], 1, &sp54[i]);
|
||||
PSVECSubtract(&sp54[i], &sp30, &sp24);
|
||||
if (PSVECMag(&sp24) < 0.01f) {
|
||||
arg0->unk00_field2 = 0;
|
||||
if (arg1 != 0 && arg0->unk00_field3 != 0) {
|
||||
BoardModelVisibilitySet(arg0->unk04[i], 0);
|
||||
}
|
||||
} else {
|
||||
arg0->unk00_field2 = 1;
|
||||
}
|
||||
PSVECScale(&sp24, &sp24, arg0->unk08);
|
||||
PSVECAdd(&sp30, &sp24, &sp30);
|
||||
BoardModelPosSetV(arg0->unk04[i], &sp30);
|
||||
}
|
||||
}
|
||||
|
||||
static void DiceDigitRotate(DiceDigitWork *arg0, s32 arg1) {
|
||||
float var_f30;
|
||||
s32 i;
|
||||
|
||||
if (arg1 != 0) {
|
||||
arg0->unk02 += 0x12;
|
||||
if (arg0->unk02 >= 360) {
|
||||
arg0->unk02 = 360;
|
||||
}
|
||||
} else {
|
||||
arg0->unk02 -= 0x12;
|
||||
if (arg0->unk02 <= 0) {
|
||||
arg0->unk02 = 0;
|
||||
}
|
||||
}
|
||||
OSs16tof32(&arg0->unk02, &var_f30);
|
||||
for (i = 0; i < 2; i++) {
|
||||
if (arg0->unk04[i] != -1) {
|
||||
BoardModelRotSet(arg0->unk04[i], 0.0f, var_f30, 0.0f);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void SameRollExec(void) {
|
||||
Vec sp8;
|
||||
float var_f31;
|
||||
s32 var_r28;
|
||||
s32 temp_r27;
|
||||
s32 var_r31;
|
||||
s32 i;
|
||||
s32 var_r29;
|
||||
|
||||
temp_r27 = -1;
|
||||
BoardPauseDisableSet(1);
|
||||
var_r28 = 0x50;
|
||||
switch (numDice) {
|
||||
case 2:
|
||||
if (diceValue[0] == 7) {
|
||||
var_r31 = 0x1E;
|
||||
} else {
|
||||
var_r31 = 0xA;
|
||||
}
|
||||
break;
|
||||
case 3:
|
||||
if (diceValue[0] == 7) {
|
||||
var_r31 = 0x32;
|
||||
var_r28 = 0x118;
|
||||
} else if (diceValue[0] & 1) {
|
||||
var_r31 = 0x1E;
|
||||
} else {
|
||||
var_r31 = 0xA;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
return;
|
||||
}
|
||||
sprintf(sameRollCoinStr, "%d", var_r31);
|
||||
BoardPlayerPosGet(rollPlayer, &sp8);
|
||||
if (BoardPlayerSizeGet(rollPlayer) == 2 || GWPlayer[rollPlayer].bowser_suit != 0) {
|
||||
sp8.y += 700.0f;
|
||||
var_f31 = 450.0f;
|
||||
} else {
|
||||
sp8.y += 600.0f;
|
||||
var_f31 = 300.0f;
|
||||
}
|
||||
BoardConfettiCreate(&sp8, var_r28, var_f31);
|
||||
BoardAudSeqPause(0, 1, 0x3E8);
|
||||
HuPrcSleep(0xA);
|
||||
temp_r27 = HuAudSStreamPlay(9);
|
||||
while (HuAudSStreamStatGet(temp_r27) != 0) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
BoardAudSeqPause(0, 0, 0x3E8);
|
||||
BoardWinCreate(0, 0x90000, -1);
|
||||
BoardWinInsertMesSet(sameRollCoinStr, 0);
|
||||
BoardWinWait();
|
||||
BoardWinKill();
|
||||
if (var_r31 >= 0x32) {
|
||||
var_r29 = 1;
|
||||
} else if (var_r31 >= 0x14) {
|
||||
var_r29 = 3;
|
||||
} else {
|
||||
var_r29 = 6;
|
||||
}
|
||||
for (i = 0; i < var_r31; i++) {
|
||||
BoardPlayerCoinsAdd(rollPlayer, 1);
|
||||
HuAudFXPlay(7);
|
||||
HuPrcSleep(var_r29);
|
||||
}
|
||||
HuAudFXPlay(0xF);
|
||||
BoardConfettiStop();
|
||||
BoardPauseDisableSet(0);
|
||||
}
|
||||
|
||||
static s32 GetBtnRoll(s32 arg0) {
|
||||
s32 var_r31 = 0;
|
||||
s32 var_r29;
|
||||
|
||||
if (boardTutorialUseItem >= 0 && boardTutorialUseItem <= 0xD) {
|
||||
var_r31 = 0x200;
|
||||
return var_r31;
|
||||
}
|
||||
if (_CheckFlag(0x1000B)) {
|
||||
var_r31 = 0x100;
|
||||
return var_r31;
|
||||
}
|
||||
if (!GWPlayer[arg0].com) {
|
||||
var_r29 = GWPlayer[arg0].port;
|
||||
var_r31 = HuPadBtnDown[var_r29];
|
||||
return var_r31;
|
||||
}
|
||||
if (_CheckFlag(0x10009) || BoardRollTypeGet() != -1) {
|
||||
return 0x100;
|
||||
}
|
||||
var_r31 = GetComBtnRoll(arg0);
|
||||
return var_r31;
|
||||
}
|
||||
|
||||
static s32 GetComBtnRoll(s32 arg0) {
|
||||
if (BoardRollTypeGet() != -1 || BoardPlayerItemCount(arg0) == 0 || BoardRollResizeCheck() || _CheckFlag(0x10009)) {
|
||||
return 0x100;
|
||||
}
|
||||
if (BoardComUseItemCheck(arg0)) {
|
||||
return 0x200;
|
||||
}
|
||||
return 0x100;
|
||||
}
|
||||
|
||||
void BoardRollTutorialSet(s16 *arg0) {
|
||||
s32 i;
|
||||
|
||||
for (i = 0; i < 3; i++) {
|
||||
tutorialRoll[i] = arg0[i];
|
||||
}
|
||||
tutorialRollF = 1;
|
||||
}
|
||||
|
|
@ -3,18 +3,17 @@
|
|||
#include "game/board/main.h"
|
||||
#include "game/board/player.h"
|
||||
#include "game/board/space.h"
|
||||
#include "game/board/star.h"
|
||||
#include "game/board/tutorial.h"
|
||||
#include "game/hsfman.h"
|
||||
#include "game/data.h"
|
||||
#include "game/sprite.h"
|
||||
#include "game/objsub.h"
|
||||
|
||||
#include "math.h"
|
||||
#include "string.h"
|
||||
|
||||
extern void omVibrate(s16, s16, s16, s16);
|
||||
|
||||
|
||||
extern s16 BoardStarHostMdlGet(void);
|
||||
extern void BoardModelPosSetV(s16 model, Vec *pos);
|
||||
extern s16 BoardModelCreate(s32 file, s32 *data, s32 arg3);
|
||||
extern s16 BoardModelIDGet(s16 model);
|
||||
|
||||
|
|
@ -53,9 +52,6 @@ static s16 starPlatMdl = -1;
|
|||
|
||||
static s32 ExecPipeSpace(s32 player, s32 space);
|
||||
|
||||
extern s8 boardTutorialBlockF;
|
||||
extern s32 boardTutorialBlockPos;
|
||||
|
||||
|
||||
void BoardSpaceWalkEventFuncSet(BoardSpaceEventFunc func)
|
||||
{
|
||||
|
|
@ -992,7 +988,7 @@ void BoardSpaceInit(s32 data_num)
|
|||
AnimData *data;
|
||||
void *data_base;
|
||||
s32 size;
|
||||
data = data_base = HuDataSelHeapReadNum(MAKE_DATA_NUM(DATADIR_BOARD, 29), MEMORY_DEFAULT_NUM, HEAP_DATA);
|
||||
data = data_base = HuDataSelHeapReadNum(DATA_MAKE_NUM(DATADIR_BOARD, 29), MEMORY_DEFAULT_NUM, HEAP_DATA);
|
||||
data->bmp = (void *)((u32)data_base+(u32)data->bmp);
|
||||
data->pat = (void *)((u32)data_base+(u32)data->pat);
|
||||
data->bank = (void *)((u32)data_base+(u32)data->bank);
|
||||
|
|
@ -1024,7 +1020,7 @@ void BoardSpaceInit(s32 data_num)
|
|||
AnimData *data;
|
||||
void *data_base;
|
||||
s32 size;
|
||||
data = data_base = HuDataSelHeapReadNum(MAKE_DATA_NUM(DATADIR_BOARD, 28), MEMORY_DEFAULT_NUM, HEAP_DATA);
|
||||
data = data_base = HuDataSelHeapReadNum(DATA_MAKE_NUM(DATADIR_BOARD, 28), MEMORY_DEFAULT_NUM, HEAP_DATA);
|
||||
data->bmp = (void *)((u32)data_base+(u32)data->bmp);
|
||||
data->pat = (void *)((u32)data_base+(u32)data->pat);
|
||||
data->bank = (void *)((u32)data_base+(u32)data->bank);
|
||||
|
|
@ -1059,7 +1055,7 @@ void BoardSpaceInit(s32 data_num)
|
|||
GWSystem.star_flag = 0;
|
||||
}
|
||||
if(BoardCurrGet() != 7 && BoardCurrGet() != 8) {
|
||||
starPlatMdl = BoardModelCreate(MAKE_DATA_NUM(DATADIR_BOARD, 6), NULL, 0);
|
||||
starPlatMdl = BoardModelCreate(DATA_MAKE_NUM(DATADIR_BOARD, 6), NULL, 0);
|
||||
BoardModelMotionStart(starPlatMdl, 0, 0x40000001);
|
||||
BoardModelVisibilitySet(starPlatMdl, 0);
|
||||
if(_CheckFlag(FLAG_ID_MAKE(1, 1))) {
|
||||
|
|
|
|||
821
src/game/board/star.c
Executable file
821
src/game/board/star.c
Executable file
|
|
@ -0,0 +1,821 @@
|
|||
#include "game/board/star.h"
|
||||
#include "game/audio.h"
|
||||
#include "game/data.h"
|
||||
#include "game/flag.h"
|
||||
#include "game/gamework.h"
|
||||
#include "game/gamework_data.h"
|
||||
#include "game/hsfanim.h"
|
||||
#include "game/hsfman.h"
|
||||
#include "game/msm.h"
|
||||
#include "game/objsub.h"
|
||||
#include "game/wipe.h"
|
||||
#include "game/board/audio.h"
|
||||
#include "game/board/com.h"
|
||||
#include "game/board/main.h"
|
||||
#include "game/board/model.h"
|
||||
#include "game/board/player.h"
|
||||
#include "game/board/tutorial.h"
|
||||
#include "game/board/ui.h"
|
||||
#include "game/board/window.h"
|
||||
|
||||
#include "math.h"
|
||||
|
||||
typedef struct {
|
||||
struct {
|
||||
u8 unk00_field0 : 1;
|
||||
u8 unk00_field1 : 1;
|
||||
u8 unk00_field2 : 1;
|
||||
u8 unk00_field3 : 2;
|
||||
u8 unk00_field4 : 1;
|
||||
};
|
||||
s8 unk01;
|
||||
s8 unk02;
|
||||
char unk03[1];
|
||||
s16 unk04;
|
||||
s16 unk06;
|
||||
s16 unk08;
|
||||
s16 unk0A;
|
||||
s16 unk0C;
|
||||
} GiveStarWork;
|
||||
|
||||
typedef struct {
|
||||
struct {
|
||||
u8 unk00_field0 : 1;
|
||||
};
|
||||
s8 unk01;
|
||||
} ShowNextWork;
|
||||
|
||||
static void ExecStar(void);
|
||||
static void DestroyStar(void);
|
||||
static void GiveStarMain(omObjData *arg0);
|
||||
static void UpdateStarAngle(GiveStarWork *arg0, omObjData *arg1);
|
||||
static void InitGiveStar(GiveStarWork *arg0, omObjData *arg1);
|
||||
static void MoveGiveStar(GiveStarWork *arg0, omObjData *arg1);
|
||||
static void ShrinkGiveStar(GiveStarWork *arg0, omObjData *arg1);
|
||||
static void StopGiveStar(void);
|
||||
static void InitGiveStarEffect(void);
|
||||
static void KillGiveStarEffect(void);
|
||||
static void ShowNextUpdate(omObjData *arg0);
|
||||
static void HideNextHost(s32 arg0);
|
||||
|
||||
static Vec starCharPos;
|
||||
|
||||
static s16 hostMot[2];
|
||||
static omObjData *showNextObj;
|
||||
static s16 starDoneF;
|
||||
static AnimData *starEffAnim;
|
||||
static omObjData *giveStarObj;
|
||||
static Process *starProc;
|
||||
|
||||
static s16 starParman = -1;
|
||||
static s16 hostMdl = -1;
|
||||
|
||||
const s32 lbl_8011E040[9] = {
|
||||
0x000C0000,
|
||||
0x000C0009,
|
||||
0x000C0012,
|
||||
0x000C001B,
|
||||
0x000C0024,
|
||||
0x000C002D,
|
||||
0x000C0000,
|
||||
0x000C0000,
|
||||
0x000C0000
|
||||
};
|
||||
|
||||
const s32 lbl_8011E064[9][2] = {
|
||||
{ 0x00150022, 0x00150028 },
|
||||
{ 0x00150023, 0x00150029 },
|
||||
{ 0x00150024, 0x0015002A },
|
||||
{ 0x00150025, 0x0015002B },
|
||||
{ 0x00150026, 0x0015002C },
|
||||
{ 0x00150027, 0x0015002D },
|
||||
{ 0x00150022, 0x00150028 },
|
||||
{ 0x00150022, 0x00150028 },
|
||||
{ 0x00150022, 0x00150028 }
|
||||
};
|
||||
|
||||
s32 boardStarSndTbl[] = {
|
||||
0x00000120,
|
||||
0x00000160,
|
||||
0x000001A0,
|
||||
0x000001E0,
|
||||
0x00000220,
|
||||
0x00000260,
|
||||
0x000002A0,
|
||||
0x000002E0
|
||||
};
|
||||
|
||||
static s32 hostMotTbl[][2] = {
|
||||
{ 0x00750021, 0x0007009D },
|
||||
{ 0x00760007, 0x0007009E },
|
||||
{ 0x0077001F, 0x0007009F },
|
||||
{ 0x0078000B, 0x000700A0 },
|
||||
{ 0x00790009, 0x000700A1 },
|
||||
{ 0x007A0015, 0x000700A2 },
|
||||
{ 0x00000000, 0x00000000 },
|
||||
{ 0x00000000, 0x00000000 },
|
||||
{ 0x00000000, 0x00000000 }
|
||||
};
|
||||
|
||||
static HsfanimStruct00 starEffParam = {
|
||||
0x001E,
|
||||
{ 0x00, 0x00 }, // padding?
|
||||
3.3f,
|
||||
70.0f,
|
||||
7.0f,
|
||||
{ 0.0f, -0.05f, 0.0f },
|
||||
2.0f,
|
||||
1.0f,
|
||||
20.0f,
|
||||
0.98f,
|
||||
0x0002,
|
||||
{
|
||||
0xFF, 0xFF, 0xFF, 0xFF,
|
||||
0xFF, 0xFF, 0x40, 0xFF,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00
|
||||
},
|
||||
{
|
||||
0xFF, 0x80, 0x80, 0x00,
|
||||
0xFF, 0x40, 0x20, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00
|
||||
}
|
||||
};
|
||||
|
||||
void BoardStarHostSet(s16 arg0) {
|
||||
hostMdl = arg0;
|
||||
if (GWBoardGet() == 7 || GWBoardGet() == 8) {
|
||||
return;
|
||||
}
|
||||
if (_CheckFlag(0x10001)) {
|
||||
BoardSpaceHostSet(boardSpaceStarTbl[GWSystem.star_pos]);
|
||||
}
|
||||
}
|
||||
|
||||
s16 BoardStarHostMdlGet(void) {
|
||||
return hostMdl;
|
||||
}
|
||||
|
||||
void BoardStarExec(s32 arg0, BoardSpace *arg1) {
|
||||
if (GWBoardGet() == 7 || GWBoardGet() == 8) {
|
||||
return;
|
||||
}
|
||||
if (BoardPlayerSizeGet(arg0) != 2) {
|
||||
BoardDiceDigit2DShowSet(0);
|
||||
starProc = HuPrcChildCreate(ExecStar, 0x2003, 0x3800, 0, boardMainProc);
|
||||
HuPrcDestructorSet2(starProc, DestroyStar);
|
||||
while (starProc != NULL) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
BoardDiceDigit2DShowSet(1);
|
||||
}
|
||||
}
|
||||
|
||||
static void ExecStar(void) {
|
||||
Vec sp24;
|
||||
Vec sp18;
|
||||
Vec spC;
|
||||
float temp_f27;
|
||||
float temp_f29;
|
||||
float temp_f30;
|
||||
float var_f28;
|
||||
float var_f31;
|
||||
s16 temp_r30;
|
||||
u32 sp8;
|
||||
s32 temp_r24;
|
||||
s32 temp_r29;
|
||||
s32 var_r26;
|
||||
s32 var_r25;
|
||||
s32 i;
|
||||
s32 temp_r27;
|
||||
s32 temp_r31;
|
||||
s32 var_r22;
|
||||
BoardSpace *var_r23;
|
||||
|
||||
temp_r31 = GWSystem.player_curr;
|
||||
temp_r27 = GWBoardGet();
|
||||
temp_r30 = BoardStarHostMdlGet();
|
||||
HuAudFXPlay(0x33A);
|
||||
for (i = 0; i < 2; i++) {
|
||||
hostMot[i] = BoardModelMotionCreate(temp_r30, hostMotTbl[temp_r27][i]);
|
||||
}
|
||||
BoardPlayerPosGet(temp_r31, &sp24);
|
||||
temp_r24 = GWPlayer[temp_r31].space_curr;
|
||||
var_r23 = BoardSpaceGet(0, temp_r24);
|
||||
sp8 = (var_r23->flag & 0x70000) >> 16;
|
||||
starDoneF = 0;
|
||||
var_r22 = BoardSpaceLinkFlagSearch(0, temp_r24, 0x04000000);
|
||||
BoardSpacePosGet(0, var_r22, &sp18);
|
||||
PSVECSubtract(&sp18, &sp24, &spC);
|
||||
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);
|
||||
if (BoardDAngleCalc(temp_f30 - temp_f29) < 0.0f) {
|
||||
var_f28 = -BoardDAngleCalc(temp_f30 - temp_f29);
|
||||
} else {
|
||||
var_f28 = BoardDAngleCalc(temp_f30 - temp_f29);
|
||||
}
|
||||
if (var_f28 > 90.0f) {
|
||||
var_r25 = 0x1E;
|
||||
} else {
|
||||
var_r25 = 0xF;
|
||||
}
|
||||
BoardPlayerMotBlendSet(temp_r31, temp_f30, var_r25);
|
||||
temp_f27 = BoardModelRotYGet(temp_r30);
|
||||
var_f31 = BoardDAngleCalc(temp_f30 + 180.0f) - temp_f27;
|
||||
if ((var_f31 <= 4.0f && var_f31 >= 0.0f)
|
||||
|| (var_f31 <= 360.0f && var_f31 >= 355.0f)
|
||||
|| (var_f31 <= 0.0f && var_f31 >= -4.0f)) {
|
||||
var_r26 = 0;
|
||||
} else {
|
||||
var_r26 = 1;
|
||||
}
|
||||
if (var_r26 != 0) {
|
||||
var_f31 /= var_r25;
|
||||
BoardModelMotionShiftSet(temp_r30, hostMot[1], 0.0f, 10.0f, 0x40000001);
|
||||
BoardModelMotionSpeedSet(temp_r30, 2.0f);
|
||||
}
|
||||
while (!BoardPlayerMotBlendCheck(temp_r31)) {
|
||||
if (var_r26 != 0) {
|
||||
temp_f30 = var_f31 + BoardModelRotYGet(temp_r30);
|
||||
BoardModelRotYSet(temp_r30, temp_f30);
|
||||
}
|
||||
HuPrcVSleep();
|
||||
}
|
||||
BoardModelMotionShiftSet(temp_r30, 1, 0.0f, 10.0f, 0x40000001);
|
||||
BoardCameraViewSet(3);
|
||||
BoardCameraMotionWait();
|
||||
if (GWStarsGet(temp_r31) >= 999) {
|
||||
temp_r29 = lbl_8011E040[temp_r27] + 5;
|
||||
BoardWinCreate(0, temp_r29, BoardWinPortraitGetStar());
|
||||
BoardWinWait();
|
||||
BoardWinKill();
|
||||
} else if (BoardPlayerCoinsGet(temp_r31) < 20 && GWSystem.last5_effect != 4) {
|
||||
temp_r29 = lbl_8011E040[temp_r27] + 2;
|
||||
BoardWinCreate(2, temp_r29, BoardWinPortraitGetStar());
|
||||
BoardWinWait();
|
||||
BoardWinKill();
|
||||
} else {
|
||||
BoardStatusShowSetAll(0);
|
||||
while (!BoardStatusStopCheck(0) || !BoardStatusStopCheck(1) || !BoardStatusStopCheck(2) || !BoardStatusStopCheck(3)) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
temp_r29 = lbl_8011E040[temp_r27];
|
||||
BoardWinCreate(2, temp_r29, BoardWinPortraitGetStar());
|
||||
BoardWinInsertMesSet(BoardPlayerGetCharMess(temp_r31), 0);
|
||||
BoardWinWait();
|
||||
BoardWinKill();
|
||||
while (1) {
|
||||
BoardStatusShowSetForce(temp_r31);
|
||||
BoardStatusShowSet(temp_r31, 1);
|
||||
while (!BoardStatusStopCheck(temp_r31)) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
if (GWSystem.last5_effect == 4) {
|
||||
temp_r29 = lbl_8011E040[temp_r27] + 8;
|
||||
BoardWinCreate(2, temp_r29, BoardWinPortraitGetStar());
|
||||
BoardWinWait();
|
||||
break;
|
||||
}
|
||||
temp_r29 = lbl_8011E040[temp_r27] + 1;
|
||||
BoardWinCreateChoice(1, temp_r29, BoardWinPortraitGetStar(), 0);
|
||||
BoardWinAttrSet(0x10);
|
||||
if (GWPlayer[temp_r31].com) {
|
||||
if (BoardPlayerCoinsGet(temp_r31) >= 20) {
|
||||
BoardComKeySetUp();
|
||||
} else {
|
||||
BoardComKeySetDown();
|
||||
}
|
||||
}
|
||||
BoardWinWait();
|
||||
switch (BoardWinChoiceGet()) {
|
||||
case 0:
|
||||
if (BoardPlayerCoinsGet(temp_r31) < 20) {
|
||||
temp_r29 = lbl_8011E040[temp_r27] + 2;
|
||||
BoardWinCreate(2, temp_r29, BoardWinPortraitGetStar());
|
||||
BoardWinWait();
|
||||
BoardStatusShowSet(temp_r31, 0);
|
||||
while (!BoardStatusStopCheck(temp_r31)) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
BoardStatusShowSetAll(1);
|
||||
goto block_B;
|
||||
}
|
||||
goto block_A;
|
||||
case 1:
|
||||
temp_r29 = lbl_8011E040[temp_r27] + 4;
|
||||
BoardWinCreate(2, temp_r29, BoardWinPortraitGetStar());
|
||||
BoardWinWait();
|
||||
BoardStatusShowSet(temp_r31, 0);
|
||||
while (!BoardStatusStopCheck(temp_r31)) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
BoardStatusShowSetAll(1);
|
||||
goto block_B;
|
||||
default:
|
||||
BoardStatusShowSet(temp_r31, 0);
|
||||
while (!BoardStatusStopCheck(temp_r31)) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
BoardWinKill();
|
||||
BoardViewMapExec(temp_r31);
|
||||
break;
|
||||
}
|
||||
}
|
||||
block_A:
|
||||
temp_r29 = lbl_8011E040[temp_r27] + 3;
|
||||
BoardWinCreate(2, temp_r29, BoardWinPortraitGetStar());
|
||||
BoardWinWait();
|
||||
BoardWinKill();
|
||||
if (GWSystem.last5_effect != 4) {
|
||||
for (i = 0; i < 20; i++) {
|
||||
BoardPlayerCoinsAdd(temp_r31, -1);
|
||||
HuAudFXPlay(0xE);
|
||||
HuPrcSleep(3);
|
||||
}
|
||||
HuAudFXPlay(0xF);
|
||||
}
|
||||
_SetFlag(0x10017);
|
||||
BoardModelMotionShiftSet(temp_r30, hostMot[0], 0.0f, 10.0f, 0);
|
||||
HuPrcSleep(0x1E);
|
||||
starDoneF = 1;
|
||||
BoardAudSeqFadeOut(0, 0x3E8);
|
||||
BoardModelPosGet(temp_r30, &sp24);
|
||||
sp24.y += 130.0f;
|
||||
BoardStarGive(temp_r31, &sp24);
|
||||
BoardStatusShowSet(temp_r31, 0);
|
||||
while (!BoardStatusStopCheck(temp_r31)) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
BoardModelMotionShiftSet(temp_r30, 1, 0.0f, 10.0f, 0x40000001);
|
||||
BoardStarShowNext(temp_r31);
|
||||
BoardMusStartBoard();
|
||||
BoardModelRotYSet(temp_r30, 0.0f);
|
||||
}
|
||||
block_B:
|
||||
BoardWinKill();
|
||||
var_f31 = -BoardModelRotYGet(temp_r30);
|
||||
if (var_r26 != 0) {
|
||||
var_f31 /= var_r25;
|
||||
BoardModelMotionShiftSet(temp_r30, hostMot[1], 0.0f, 10.0f, 0x40000001);
|
||||
BoardModelMotionSpeedSet(temp_r30, 3.0f);
|
||||
}
|
||||
BoardPlayerMotBlendSet(temp_r31, 0, var_r25);
|
||||
while (!BoardPlayerMotBlendCheck(temp_r31)) {
|
||||
if (var_r26 != 0) {
|
||||
temp_f30 = var_f31 + BoardModelRotYGet(temp_r30);
|
||||
BoardModelRotYSet(temp_r30, temp_f30);
|
||||
}
|
||||
HuPrcVSleep();
|
||||
}
|
||||
BoardModelRotYSet(temp_r30, 0.0f);
|
||||
BoardModelMotionShiftSet(temp_r30, 1, 0.0f, 10.0f, 0x40000001);
|
||||
if (!_CheckFlag(0x10016)) {
|
||||
BoardCameraViewSet(1);
|
||||
BoardCameraTargetPlayerSet(temp_r31);
|
||||
BoardCameraMotionWait();
|
||||
}
|
||||
HuPrcEnd();
|
||||
}
|
||||
|
||||
static void DestroyStar(void) {
|
||||
s32 i;
|
||||
|
||||
_ClearFlag(0x10017);
|
||||
for (i = 0; i < 2; i++) {
|
||||
BoardModelMotionKill(BoardStarHostMdlGet(), hostMot[i]);
|
||||
hostMot[i] = -1;
|
||||
}
|
||||
StopGiveStar();
|
||||
KillGiveStarEffect();
|
||||
starProc = NULL;
|
||||
}
|
||||
|
||||
static void GiveStarMain(omObjData *arg0) {
|
||||
GiveStarWork *temp_r30;
|
||||
|
||||
temp_r30 = OM_GET_WORK_PTR(arg0, GiveStarWork);
|
||||
if (temp_r30->unk00_field0 != 0 || BoardIsKill()) {
|
||||
KillGiveStarEffect();
|
||||
BoardModelKill(temp_r30->unk0C);
|
||||
giveStarObj = NULL;
|
||||
omDelObjEx(HuPrcCurrentGet(), arg0);
|
||||
return;
|
||||
}
|
||||
if (temp_r30->unk04 != 0) {
|
||||
temp_r30->unk04--;
|
||||
} else {
|
||||
switch (temp_r30->unk01) {
|
||||
case 4:
|
||||
break;
|
||||
case 0:
|
||||
InitGiveStar(temp_r30, arg0);
|
||||
break;
|
||||
case 1:
|
||||
MoveGiveStar(temp_r30, arg0);
|
||||
break;
|
||||
case 2:
|
||||
ShrinkGiveStar(temp_r30, arg0);
|
||||
break;
|
||||
}
|
||||
UpdateStarAngle(temp_r30, arg0);
|
||||
}
|
||||
BoardModelPosSet(temp_r30->unk0C, arg0->trans.x, arg0->trans.y, arg0->trans.z);
|
||||
BoardModelRotSet(temp_r30->unk0C, 0.0f, arg0->rot.y, 0.0f);
|
||||
BoardModelScaleSet(temp_r30->unk0C, arg0->scale.x, arg0->scale.y, arg0->scale.z);
|
||||
if (starParman != -1) {
|
||||
Hu3DParManPosSet(starParman, arg0->trans.x, -70.0f + arg0->trans.y, arg0->trans.z);
|
||||
}
|
||||
}
|
||||
|
||||
static void UpdateStarAngle(GiveStarWork *arg0, omObjData *arg1) {
|
||||
float var_f31;
|
||||
|
||||
if (arg0->unk00_field1 != 0) {
|
||||
if (arg0->unk02 < 16.0f) {
|
||||
arg0->unk02 += 2.0f;
|
||||
if (arg0->unk02 > 16.0f) {
|
||||
arg0->unk02 = 0x10;
|
||||
}
|
||||
}
|
||||
OSs8tof32(&arg0->unk02, &var_f31);
|
||||
arg1->rot.y = BoardDAngleCalc(arg1->rot.y + var_f31);
|
||||
}
|
||||
}
|
||||
|
||||
static void InitGiveStar(GiveStarWork *arg0, omObjData *arg1) {
|
||||
Vec sp8;
|
||||
|
||||
BoardPlayerPosGet(arg0->unk00_field3, &sp8);
|
||||
BoardModelVisibilitySet(arg0->unk0C, 1);
|
||||
BoardModelMotionStart(arg0->unk0C, 0, 0x40000001);
|
||||
BoardModelMotionTimeSet(arg0->unk0C, 2.0f);
|
||||
arg0->unk01 = 1;
|
||||
arg0->unk0A = 0;
|
||||
arg1->trans.x = starCharPos.x;
|
||||
arg1->trans.y = starCharPos.y;
|
||||
arg1->trans.z = starCharPos.z;
|
||||
arg1->rot.x = (sp8.x - starCharPos.x) / 10.0f;
|
||||
arg1->rot.z = (sp8.z - starCharPos.z) / 10.0f;
|
||||
arg1->rot.y = 0.0f;
|
||||
arg1->scale.x = arg1->scale.y = arg1->scale.z = 1.0f;
|
||||
InitGiveStarEffect();
|
||||
}
|
||||
|
||||
static void MoveGiveStar(GiveStarWork *arg0, omObjData *arg1) {
|
||||
Vec sp8;
|
||||
float temp_f31;
|
||||
|
||||
BoardPlayerPosGet(arg0->unk00_field3, &sp8);
|
||||
if (arg0->unk00_field2 == 0) {
|
||||
if (BoardModelMotionTimeGet(arg0->unk0C) >= 50.0f) {
|
||||
BoardModelMotionStartEndSet(arg0->unk0C, 0x32, 0x96);
|
||||
arg0->unk00_field2 = 1;
|
||||
}
|
||||
}
|
||||
if (arg0->unk0A < 10) {
|
||||
OSs16tof32(&arg0->unk0A, &temp_f31);
|
||||
arg1->trans.x += arg1->rot.x;
|
||||
arg1->trans.z += arg1->rot.z;
|
||||
arg1->trans.y += -0.08166667f * temp_f31 * temp_f31 * 0.97f + 50.0f;
|
||||
arg0->unk0A++;
|
||||
} else {
|
||||
arg1->trans.y += -4.0f;
|
||||
if (arg1->trans.y <= sp8.y + 300.0f) {
|
||||
arg1->trans.y = sp8.y + 300.0f;
|
||||
arg0->unk01 = 4;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void ShrinkGiveStar(GiveStarWork *arg0, omObjData *arg1) {
|
||||
Vec sp8;
|
||||
float var_f30;
|
||||
|
||||
if (arg0->unk00_field4 == 0) {
|
||||
HuAudFXPlay(0x339);
|
||||
arg0->unk00_field4 = 1;
|
||||
}
|
||||
BoardPlayerPosGet(arg0->unk00_field3, &sp8);
|
||||
arg1->trans.y += -4.0f;
|
||||
if (arg1->trans.y > sp8.y + 80.0f) {
|
||||
if (arg0->unk08 < 90) {
|
||||
if (BoardPlayerSizeGet(arg0->unk00_field3) != 1) {
|
||||
arg0->unk08 += 2;
|
||||
} else {
|
||||
arg0->unk08 += 1.4f;
|
||||
}
|
||||
if (arg0->unk08 > 90) {
|
||||
arg0->unk08 = 90;
|
||||
}
|
||||
}
|
||||
OSs16tof32(&arg0->unk08, &var_f30);
|
||||
arg1->scale.x = sin((var_f30 + 90.0f) * M_PI / 180.0);
|
||||
if (arg1->scale.x <= 0.0f) {
|
||||
arg1->scale.x = 0.001f;
|
||||
}
|
||||
arg1->scale.y = arg1->scale.x;
|
||||
arg1->scale.z = arg1->scale.x;
|
||||
} else {
|
||||
omVibrate(arg0->unk00_field3, 0xC, 0xC, 0);
|
||||
arg0->unk00_field0 = 1;
|
||||
arg0->unk01 = 4;
|
||||
arg1->scale.x = arg1->scale.y = arg1->scale.z = 0.001f;
|
||||
KillGiveStarEffect();
|
||||
BoardModelVisibilitySet(arg0->unk0C, 0);
|
||||
}
|
||||
}
|
||||
|
||||
static void StopGiveStar(void) {
|
||||
GiveStarWork *temp_r31;
|
||||
|
||||
if (giveStarObj) {
|
||||
temp_r31 = OM_GET_WORK_PTR(giveStarObj, GiveStarWork);
|
||||
temp_r31->unk00_field0 = 1;
|
||||
}
|
||||
}
|
||||
|
||||
static void InitGiveStarEffect(void) {
|
||||
s16 temp_r3;
|
||||
void *var_r30;
|
||||
|
||||
var_r30 = HuDataSelHeapReadNum(0x120001, MEMORY_DEFAULT_NUM, HEAP_DATA);
|
||||
starEffAnim = HuSprAnimRead(var_r30);
|
||||
starParman = Hu3DParManCreate(starEffAnim, 0x64, &starEffParam);
|
||||
Hu3DParManAttrSet(starParman, 0x64);
|
||||
Hu3DParManRotSet(starParman, 90.0f, 0.0f, 0.0f);
|
||||
temp_r3 = Hu3DParManModelIDGet(starParman);
|
||||
Hu3DParticleBlendModeSet(temp_r3, 1);
|
||||
Hu3DModelLayerSet(temp_r3, 2);
|
||||
HuDataDirClose(0x120000);
|
||||
}
|
||||
|
||||
static void KillGiveStarEffect(void) {
|
||||
if (starParman != -1) {
|
||||
Hu3DParManKill(starParman);
|
||||
starParman = -1;
|
||||
starEffAnim = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
static inline void StarInlineFunc00(void) {
|
||||
GiveStarWork *temp_r28 = OM_GET_WORK_PTR(giveStarObj, GiveStarWork);
|
||||
|
||||
temp_r28->unk01 = 0;
|
||||
}
|
||||
|
||||
static inline void StarInlineFunc01(void) {
|
||||
GiveStarWork *temp_r27 = OM_GET_WORK_PTR(giveStarObj, GiveStarWork);
|
||||
|
||||
while (temp_r27->unk01 != 4) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
}
|
||||
|
||||
static inline void StarInlineFunc02(void) {
|
||||
GiveStarWork *temp_r29 = OM_GET_WORK_PTR(giveStarObj, GiveStarWork);
|
||||
|
||||
temp_r29->unk00_field1 = 1;
|
||||
temp_r29->unk04 = 0x2D;
|
||||
temp_r29->unk08 = 0;
|
||||
temp_r29->unk01 = 2;
|
||||
}
|
||||
|
||||
void BoardStarGive(s32 arg0, Vec *arg1) {
|
||||
Vec sp8;
|
||||
s32 temp_r25;
|
||||
GiveStarWork *temp_r31;
|
||||
|
||||
if (GWBoardGet() == 7 || GWBoardGet() == 8) {
|
||||
return;
|
||||
}
|
||||
starCharPos = *arg1;
|
||||
giveStarObj = omAddObjEx(boardObjMan, 0x101, 0, 0, -1, GiveStarMain);
|
||||
BoardCameraRotGet(&sp8);
|
||||
temp_r31 = OM_GET_WORK_PTR(giveStarObj, GiveStarWork);
|
||||
temp_r31->unk00_field0 = 0;
|
||||
temp_r31->unk00_field1 = 0;
|
||||
temp_r31->unk00_field2 = 0;
|
||||
temp_r31->unk00_field4 = 0;
|
||||
temp_r31->unk01 = 4;
|
||||
temp_r31->unk00_field3 = arg0;
|
||||
temp_r31->unk06 = 0;
|
||||
temp_r31->unk02 = 0;
|
||||
temp_r31->unk08 = 0;
|
||||
temp_r31->unk0C = BoardModelCreate(0x7000B, NULL, 0);
|
||||
BoardModelVisibilitySet(temp_r31->unk0C, 0);
|
||||
BoardModelPassSet(temp_r31->unk0C, 0);
|
||||
BoardModelMotionSpeedSet(temp_r31->unk0C, 0.0f);
|
||||
BoardModelLayerSet(temp_r31->unk0C, 2);
|
||||
StarInlineFunc00();
|
||||
HuAudFXPlay(0x338);
|
||||
HuAudFXPlay(0x353);
|
||||
StarInlineFunc01();
|
||||
if (_CheckFlag(0x1000B)) {
|
||||
BoardTutorialHookExec(0x15, 0);
|
||||
}
|
||||
BoardPlayerMotBlendSet(arg0, 0, 0xF);
|
||||
while (!BoardPlayerMotBlendCheck(arg0)) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
StarInlineFunc02();
|
||||
StarInlineFunc01();
|
||||
BoardPlayerVoiceEnableSet(arg0, 7, 0);
|
||||
BoardPlayerMotionShiftSet(arg0, 7, 0.0f, 8.0f, 0);
|
||||
HuAudFXPlay(boardStarSndTbl[GWPlayer[arg0].character]);
|
||||
BoardPlayerStarsAdd(arg0, 1);
|
||||
HuAudFXPlay(8);
|
||||
HuPrcSleep(0xA);
|
||||
if (_CheckFlag(0x1000B)) {
|
||||
BoardPlayerMotionEndWait(arg0);
|
||||
} else {
|
||||
temp_r25 = HuAudSStreamPlay(6);
|
||||
BoardPlayerMotionEndWait(arg0);
|
||||
while (msmStreamGetStatus(temp_r25) != 0) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
}
|
||||
BoardPlayerVoiceEnableSet(arg0, 7, 1);
|
||||
}
|
||||
|
||||
void BoardStarShowNext(s32 arg0) {
|
||||
Mtx spBC;
|
||||
Mtx sp8C;
|
||||
Mtx sp5C;
|
||||
Vec sp50;
|
||||
Vec sp44;
|
||||
Vec sp38;
|
||||
Vec sp2C;
|
||||
Vec sp20;
|
||||
float temp_f31;
|
||||
WipeState *var_r26;
|
||||
s32 var_r28;
|
||||
s32 var_r30;
|
||||
s16 var_r27;
|
||||
s16 var_r29;
|
||||
|
||||
var_r28 = 0;
|
||||
if (GWBoardGet() == 7 || GWBoardGet() == 8) {
|
||||
return;
|
||||
}
|
||||
_SetFlag(0x1001C);
|
||||
var_r26 = &wipeData;
|
||||
if (var_r26->mode == 0) {
|
||||
WipeColorSet(0, 0, 0);
|
||||
WipeCreate(2, 0, 0x15);
|
||||
while (WipeStatGet() != 0) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
} else {
|
||||
HuPrcSleep(0x12);
|
||||
}
|
||||
BoardStatusItemSet(0);
|
||||
if (GWBoardGet() == 5 && BoardRollTypeGet() != 9 && boardStarGiveHook) {
|
||||
boardStarGiveHook();
|
||||
}
|
||||
BoardSpaceStarMove();
|
||||
if (arg0 == -1) {
|
||||
var_r28 = 1;
|
||||
arg0 = 0;
|
||||
for (var_r29 = 0; var_r29 < 4; var_r29++) {
|
||||
BoardPlayerCornerPosSet(var_r29);
|
||||
}
|
||||
BoardSpacePosGet(0, GWPlayer[arg0].space_curr, &sp38);
|
||||
BoardPlayerPosSetV(arg0, &sp38);
|
||||
}
|
||||
if (!_CheckFlag(0x10017)) {
|
||||
BoardAudSeqFadeOut(0, 1000);
|
||||
}
|
||||
showNextObj = omAddObjEx(boardObjMan, 0x7E03, 0, 0, -1, ShowNextUpdate);
|
||||
BoardRotateDiceNumbers(arg0);
|
||||
BoardModelMotionStart(BoardStarHostMdlGet(), 1, 0x40000001);
|
||||
BoardModelPosGet(BoardStarHostMdlGet(), &sp50);
|
||||
showNextObj->scale.x = sp50.x;
|
||||
showNextObj->scale.y = sp50.y;
|
||||
showNextObj->scale.z = sp50.z;
|
||||
BoardPlayerPosGet(arg0, &sp38);
|
||||
sp50.y = sp38.y;
|
||||
PSVECSubtract(&sp50, &sp38, &sp20);
|
||||
sp20.y = 0.0f;
|
||||
temp_f31 = PSVECMag(&sp20);
|
||||
if (temp_f31 > 3000.0f) {
|
||||
var_r27 = 0xF0;
|
||||
} else if (temp_f31 > 1500.0f) {
|
||||
var_r27 = 0x78;
|
||||
} else {
|
||||
var_r27 = 0x78;
|
||||
}
|
||||
BoardViewMoveStart(&sp38, &sp50, var_r27);
|
||||
showNextObj->trans.x = 68.0f;
|
||||
showNextObj->trans.y = 430.0f;
|
||||
showNextObj->trans.z = 100.0f;
|
||||
sp44.x = showNextObj->trans.x;
|
||||
sp44.y = showNextObj->trans.y;
|
||||
sp44.z = showNextObj->trans.z;
|
||||
Hu3D2Dto3D(&sp44, 1, &sp44);
|
||||
BoardModelPosSetV(BoardStarHostMdlGet(), &sp44);
|
||||
BoardCameraRotGet(&sp2C);
|
||||
PSMTXRotRad(sp5C, 'y', 0.17453292f);
|
||||
PSMTXRotRad(sp8C, 'x', 0.017453292f * sp2C.x);
|
||||
PSMTXConcat(sp8C, sp5C, spBC);
|
||||
BoardModelMtxSet(BoardStarHostMdlGet(), &spBC);
|
||||
BoardModelRotSet(BoardStarHostMdlGet(), 0.0f, 0.0f, 0.0f);
|
||||
BoardModelScaleSet(BoardStarHostMdlGet(), 0.09f, 0.09f, 0.09f);
|
||||
BoardMusStart(1, 7, 0x7F, 0);
|
||||
BoardCameraMoveSet(0);
|
||||
BoardCameraMotionWait();
|
||||
BoardCameraMoveSet(1);
|
||||
HuPrcSleep(1);
|
||||
WipeCreate(1, 0, 0x15);
|
||||
while (WipeStatGet() != 0) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
if (var_r28 == 0) {
|
||||
var_r30 = lbl_8011E040[GWBoardGet()] + 6;
|
||||
} else {
|
||||
var_r30 = lbl_8011E064[GWBoardGet()][0];
|
||||
}
|
||||
BoardWinCreate(3, var_r30, -1);
|
||||
BoardWinPause();
|
||||
BoardViewMoveEnd();
|
||||
while (!BoardViewMoveCheck()) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
HuPrcSleep(0x1E);
|
||||
BoardWinKill();
|
||||
HuPrcSleep(3);
|
||||
if (var_r28 == 0) {
|
||||
var_r30 = lbl_8011E040[GWBoardGet()] + 7;
|
||||
} else {
|
||||
var_r30 = lbl_8011E064[GWBoardGet()][1];
|
||||
}
|
||||
BoardWinCreate(3, var_r30, -1);
|
||||
BoardWinWait();
|
||||
BoardWinKill();
|
||||
if (GWBoardGet() == 5 && BoardRollTypeGet() != 9 && boardStarShowNextHook) {
|
||||
boardStarShowNextHook();
|
||||
}
|
||||
BoardAudSeqFadeOut(1, 0x3E8);
|
||||
WipeColorSet(0, 0, 0);
|
||||
WipeCreate(2, 0, 0x15);
|
||||
while (WipeStatGet() != 0) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
BoardViewWait();
|
||||
PSMTXIdentity(spBC);
|
||||
BoardModelMtxSet(BoardStarHostMdlGet(), &spBC);
|
||||
HideNextHost(1);
|
||||
while (showNextObj) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
BoardCameraMoveSet(0);
|
||||
BoardCameraTargetPlayerSet(arg0);
|
||||
BoardCameraMotionWait();
|
||||
BoardCameraMoveSet(1);
|
||||
BoardStatusItemSet(1);
|
||||
WipeCreate(1, 0, 0x15);
|
||||
while (WipeStatGet() != 0) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
if (!_CheckFlag(0x10017)) {
|
||||
BoardMusStartBoard();
|
||||
}
|
||||
_ClearFlag(0x1001C);
|
||||
}
|
||||
|
||||
static void ShowNextUpdate(omObjData *arg0) {
|
||||
ShowNextWork *temp_r30 = OM_GET_WORK_PTR(arg0, ShowNextWork);
|
||||
Vec sp8;
|
||||
|
||||
if (temp_r30->unk00_field0 != 0 || BoardIsKill()) {
|
||||
showNextObj = NULL;
|
||||
omDelObjEx(HuPrcCurrentGet(), arg0);
|
||||
return;
|
||||
}
|
||||
switch (temp_r30->unk01) {
|
||||
case 0:
|
||||
sp8.x = arg0->trans.x;
|
||||
sp8.y = arg0->trans.y;
|
||||
sp8.z = arg0->trans.z;
|
||||
Hu3D2Dto3D(&sp8, 1, &sp8);
|
||||
break;
|
||||
case 1:
|
||||
sp8.x = arg0->scale.x;
|
||||
sp8.y = arg0->scale.y;
|
||||
sp8.z = arg0->scale.z;
|
||||
BoardModelLayerSet(BoardStarHostMdlGet(), 0);
|
||||
BoardModelRotSet(BoardStarHostMdlGet(), 0.0f, 0.0f, 0.0f);
|
||||
BoardModelScaleSet(BoardStarHostMdlGet(), 1.0f, 1.0f, 1.0f);
|
||||
temp_r30->unk00_field0 = 1;
|
||||
break;
|
||||
}
|
||||
BoardModelPosSetV(BoardStarHostMdlGet(), &sp8);
|
||||
}
|
||||
|
||||
static void HideNextHost(s32 arg0) {
|
||||
ShowNextWork *temp_r31 = OM_GET_WORK_PTR(showNextObj, ShowNextWork);
|
||||
|
||||
temp_r31->unk01 = arg0;
|
||||
}
|
||||
138
src/game/board/tutorial.c
Executable file
138
src/game/board/tutorial.c
Executable file
|
|
@ -0,0 +1,138 @@
|
|||
#include "game/board/tutorial.h"
|
||||
#include "game/flag.h"
|
||||
#include "game/gamework_data.h"
|
||||
#include "game/process.h"
|
||||
#include "game/board/main.h"
|
||||
#include "game/board/model.h"
|
||||
|
||||
s32 boardTutorialData[4]; // maybe a single s32 + padding?
|
||||
static void (*tutorialHook)(s16, s32);
|
||||
s8 boardTutorialDirInputX;
|
||||
s8 boardTutorialDirInputY;
|
||||
s16 boardTutorialDirInputTime;
|
||||
s32 boardTutorialBlockPos;
|
||||
s8 boardTutorialBlockItem;
|
||||
s8 boardTutorialBlockF;
|
||||
s8 boardTutorialUseItem;
|
||||
static s16 hostMdl;
|
||||
s8 boardTutorialF;
|
||||
static Process *tutorialProcess;
|
||||
static void *playerCfgCopy;
|
||||
static void *playerCopy;
|
||||
static void *systemCopy;
|
||||
static void *gameStatCopy;
|
||||
|
||||
static void TutorialProcFunc(void) {
|
||||
while (1) {
|
||||
if (_CheckFlag(0x10010)) {
|
||||
BoardTutorialHookExec(0x1E, 0);
|
||||
}
|
||||
HuPrcVSleep();
|
||||
}
|
||||
}
|
||||
|
||||
void BoardTutorialInit(void) {
|
||||
boardTutorialDirInputTime = -1;
|
||||
boardTutorialBlockF = 0;
|
||||
boardTutorialUseItem = -1;
|
||||
tutorialHook = NULL;
|
||||
tutorialProcess = NULL;
|
||||
boardTutorialF = 0;
|
||||
if (_CheckFlag(0x1000B)) {
|
||||
tutorialProcess = HuPrcChildCreate(TutorialProcFunc, 0x2002, 0x2000, 0, boardMainProc);
|
||||
}
|
||||
}
|
||||
|
||||
void BoardTutorialKill(void) {
|
||||
if (_CheckFlag(0x1000B)) {
|
||||
if (tutorialProcess) {
|
||||
HuPrcKill(tutorialProcess);
|
||||
}
|
||||
boardTutorialF = 0;
|
||||
}
|
||||
}
|
||||
|
||||
void BoardTutorialHookSet(void *arg0) {
|
||||
tutorialHook = arg0;
|
||||
}
|
||||
|
||||
void BoardTutorialHookExec(s16 arg0, s32 arg1) {
|
||||
if (tutorialHook) {
|
||||
tutorialHook(arg0, arg1);
|
||||
}
|
||||
}
|
||||
|
||||
void BoardTutorialPlayerInit(void) {
|
||||
s32 i;
|
||||
|
||||
for (i = 0; i < 4; i++) {
|
||||
GWPlayer[i].com = 1;
|
||||
GWPlayerCfg[i].iscom = 1;
|
||||
}
|
||||
GWSystem.board = 6;
|
||||
}
|
||||
|
||||
void BoardTutorialWorkSave(void) {
|
||||
OSReport("-O-O-O-O-O-O-O Tutorial Save Work\n");
|
||||
if (gameStatCopy) {
|
||||
HuMemDirectFree(gameStatCopy);
|
||||
}
|
||||
if (systemCopy) {
|
||||
HuMemDirectFree(systemCopy);
|
||||
}
|
||||
if (playerCopy) {
|
||||
HuMemDirectFree(playerCopy);
|
||||
}
|
||||
if (playerCfgCopy) {
|
||||
HuMemDirectFree(playerCfgCopy);
|
||||
}
|
||||
gameStatCopy = HuMemDirectMalloc(HEAP_SYSTEM, sizeof(GWGameStat));
|
||||
systemCopy = HuMemDirectMalloc(HEAP_SYSTEM, sizeof(GWSystem));
|
||||
playerCopy = HuMemDirectMalloc(HEAP_SYSTEM, sizeof(GWPlayer));
|
||||
playerCfgCopy = HuMemDirectMalloc(HEAP_SYSTEM, sizeof(GWPlayerCfg));
|
||||
memcpy(gameStatCopy, &GWGameStat, sizeof(GWGameStat));
|
||||
memcpy(systemCopy, &GWSystem, sizeof(GWSystem));
|
||||
memcpy(playerCopy, GWPlayer, sizeof(GWPlayer));
|
||||
memcpy(playerCfgCopy, GWPlayerCfg, sizeof(GWPlayerCfg));
|
||||
}
|
||||
|
||||
void BoardTutorialWorkRestore(void) {
|
||||
OSReport("-O-O-O-O-O-O-O Tutorial Load Work\n");
|
||||
memcpy(&GWGameStat, gameStatCopy, sizeof(GWGameStat));
|
||||
memcpy(&GWSystem, systemCopy, sizeof(GWSystem));
|
||||
memcpy(GWPlayer, playerCopy, sizeof(GWPlayer));
|
||||
memcpy(GWPlayerCfg, playerCfgCopy, sizeof(GWPlayerCfg));
|
||||
HuMemDirectFree(gameStatCopy);
|
||||
HuMemDirectFree(systemCopy);
|
||||
HuMemDirectFree(playerCopy);
|
||||
HuMemDirectFree(playerCfgCopy);
|
||||
gameStatCopy = NULL;
|
||||
systemCopy = NULL;
|
||||
playerCopy = NULL;
|
||||
playerCfgCopy = NULL;
|
||||
}
|
||||
|
||||
void BoardTutorialDirInputSet(s8 arg0, s8 arg1, s16 arg2) {
|
||||
boardTutorialDirInputX = arg0;
|
||||
boardTutorialDirInputY = arg1;
|
||||
boardTutorialDirInputTime = arg2;
|
||||
}
|
||||
|
||||
void BoardTutorialBlockSetPos(s32 arg0, s8 arg1) {
|
||||
boardTutorialBlockF = 1;
|
||||
boardTutorialBlockPos = arg0;
|
||||
boardTutorialBlockItem = arg1;
|
||||
BoardSpaceBlockPosSet();
|
||||
}
|
||||
|
||||
void BoardTutorialItemSet(s8 arg0) {
|
||||
boardTutorialUseItem = arg0;
|
||||
}
|
||||
|
||||
void BoardTutorialHostSet(s16 arg0) {
|
||||
hostMdl = arg0;
|
||||
}
|
||||
|
||||
void BoardTutorialHostHide(s8 arg0) {
|
||||
BoardModelVisibilitySet(hostMdl, arg0);
|
||||
}
|
||||
|
|
@ -1,5 +1,6 @@
|
|||
#include "game/board/ui.h"
|
||||
#include "game/audio.h"
|
||||
#include "game/chrman.h"
|
||||
#include "game/data.h"
|
||||
#include "game/gamework.h"
|
||||
#include "game/gamework_data.h"
|
||||
|
|
@ -9,13 +10,17 @@
|
|||
#include "game/pad.h"
|
||||
#include "game/process.h"
|
||||
#include "game/window.h"
|
||||
#include "game/board/com.h"
|
||||
#include "game/board/item.h"
|
||||
#include "game/board/main.h"
|
||||
#include "game/board/model.h"
|
||||
#include "game/board/player.h"
|
||||
#include "game/board/tutorial.h"
|
||||
#include "board_unsplit.h"
|
||||
|
||||
#include "math.h"
|
||||
|
||||
#define ABS(x) ((x < 0) ? -x : x)
|
||||
#define ABS(x) (((x) < 0) ? -(x) : (x))
|
||||
|
||||
typedef struct {
|
||||
/* 0x00 */ struct {
|
||||
|
|
@ -91,20 +96,8 @@ typedef struct {
|
|||
} 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);
|
||||
|
|
@ -1201,7 +1194,7 @@ void BoardMakeRandomItem(void) {
|
|||
itemRandTbl[i] = temp_r3;
|
||||
}
|
||||
}
|
||||
BoardItemBagItemSet(&itemRandTbl);
|
||||
BoardItemBagItemSet(itemRandTbl);
|
||||
}
|
||||
|
||||
static inline void TeamItemPosSetInlineFunc01(s32 arg0, s32 arg1, Vec *arg2) {
|
||||
|
|
|
|||
593
src/game/board/view.c
Executable file
593
src/game/board/view.c
Executable file
|
|
@ -0,0 +1,593 @@
|
|||
#include "game/board/view.h"
|
||||
#include "game/audio.h"
|
||||
#include "game/gamework.h"
|
||||
#include "game/gamework_data.h"
|
||||
#include "game/hsfex.h"
|
||||
#include "game/object.h"
|
||||
#include "game/pad.h"
|
||||
#include "game/wipe.h"
|
||||
#include "game/board/main.h"
|
||||
#include "game/board/model.h"
|
||||
#include "game/board/player.h"
|
||||
#include "game/board/space.h"
|
||||
#include "game/board/ui.h"
|
||||
|
||||
typedef struct {
|
||||
struct {
|
||||
u8 unk00_field0 : 1;
|
||||
};
|
||||
u8 unk01;
|
||||
s16 unk02;
|
||||
s16 unk04;
|
||||
} OverheadWork;
|
||||
|
||||
static void ExecMapView(void);
|
||||
static void ExecStarView(void);
|
||||
static void ExecOverheadView(void);
|
||||
static void DestroyView(void);
|
||||
static void SetTargetView(void);
|
||||
static void DestroyFocus(void);
|
||||
static void CreateButtonWin(void);
|
||||
static void DestroyButtonWin(void);
|
||||
static void InitOverheadView(void);
|
||||
static void DestroyOverheadView(void);
|
||||
static void UpdateOverheadView(omObjData *arg0);
|
||||
static void WaitOverheadView(void);
|
||||
|
||||
static Vec focusPos;
|
||||
static Vec focusPosTarget;
|
||||
|
||||
static s8 viewControls;
|
||||
static s8 viewPlayer;
|
||||
static s8 viewMoveF;
|
||||
static s8 focusDestroyF;
|
||||
static u16 focusTimer;
|
||||
static omObjData *overheadObj;
|
||||
static s8 pauseDisableF;
|
||||
static Process *viewProc;
|
||||
|
||||
static s16 buttonWin = -1;
|
||||
static s16 focusMdl = -1;
|
||||
|
||||
static float overhead2DPos[][2] = {
|
||||
{ 48.0f, 72.0f },
|
||||
{ 528.0f, 72.0f },
|
||||
{ 48.0f, 408.0f },
|
||||
{ 528.0f, 408.0f },
|
||||
{ 288.0f, 72.0f }
|
||||
};
|
||||
|
||||
static float mapViewMinZ[] = {
|
||||
-2000.0f, -1500.0f, -2200.0f,
|
||||
-1800.0f, -2100.0f, -3000.0f,
|
||||
-3000.0f, -1800.0f, -1800.0f
|
||||
};
|
||||
|
||||
static float mapViewMaxZ[] = {
|
||||
2300.0f, 2500.0f, 2600.0f,
|
||||
2000.0f, 2300.0f, 2500.0f,
|
||||
2500.0f, 2000.0f, 2000.0f
|
||||
};
|
||||
|
||||
static float mapViewMinX[] = {
|
||||
-3000.0f, -3000.0f, -3000.0f,
|
||||
-3000.0f, -3000.0f, -3000.0f,
|
||||
-3000.0f, -2000.0f, -2000.0f
|
||||
};
|
||||
|
||||
static float mapViewMaxX[] = {
|
||||
3000.0f, 3000.0f, 3000.0f,
|
||||
3000.0f, 3000.0f, 3000.0f,
|
||||
3000.0f, 1600.0f, 2000.0f
|
||||
};
|
||||
|
||||
static float overheadCamZoom[] = {
|
||||
14370.0f, 14500.0f, 15000.0f,
|
||||
15000.0f, 13000.0f, 15000.0f,
|
||||
100.0f, 10000.0f, 10000.0f
|
||||
};
|
||||
|
||||
static float overheadCamPosZ[] = {
|
||||
0.0f, 0.0f, 0.0f,
|
||||
0.0f, 0.0f, 0.0f,
|
||||
0.0f, -160.0f, 0.0f
|
||||
};
|
||||
|
||||
void BoardViewOverheadExec(s32 arg0) {
|
||||
if (BoardPauseDisableGet() == 0) {
|
||||
BoardPauseDisableSet(1);
|
||||
pauseDisableF = 1;
|
||||
} else {
|
||||
pauseDisableF = 0;
|
||||
}
|
||||
_SetFlag(0x1001C);
|
||||
WipeColorSet(0xFF, 0xFF, 0xFF);
|
||||
WipeCreate(2, 1, 1);
|
||||
while (WipeStatGet() != 0) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
viewProc = HuPrcChildCreate(ExecOverheadView, 0x200A, 0x3800, 0, boardMainProc);
|
||||
HuPrcDestructorSet2(viewProc, DestroyView);
|
||||
viewControls = 2;
|
||||
viewPlayer = arg0;
|
||||
focusTimer = 1;
|
||||
viewMoveF = 0;
|
||||
BoardPlayerPosGet(arg0, &focusPos);
|
||||
BoardStatusItemSet(0);
|
||||
while (viewProc != NULL) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
BoardStatusItemSet(1);
|
||||
HuPrcSleep(3);
|
||||
WaitOverheadView();
|
||||
_ClearFlag(0x1001C);
|
||||
}
|
||||
|
||||
void BoardViewFocusGetPos(Vec *arg0) {
|
||||
if (arg0) {
|
||||
BoardModelPosGet(focusMdl, arg0);
|
||||
}
|
||||
}
|
||||
|
||||
static inline void BoardViewInlineFunc00(Vec *arg0, Vec *arg1, u16 arg2) {
|
||||
if (arg2 == 0) {
|
||||
arg2 = 1;
|
||||
}
|
||||
viewControls = 1;
|
||||
viewPlayer = -1;
|
||||
focusTimer = arg2;
|
||||
viewMoveF = 1;
|
||||
if (arg0) {
|
||||
focusPos = *arg0;
|
||||
}
|
||||
if (arg1) {
|
||||
focusPosTarget = *arg1;
|
||||
}
|
||||
}
|
||||
|
||||
void BoardViewFocusSet(Vec *arg0, u16 arg1) {
|
||||
u16 var_r31;
|
||||
|
||||
if (BoardPauseDisableGet() == 0) {
|
||||
BoardPauseDisableSet(1);
|
||||
pauseDisableF = 1;
|
||||
} else {
|
||||
pauseDisableF = 0;
|
||||
}
|
||||
focusDestroyF = 1;
|
||||
BoardViewInlineFunc00(NULL, arg0, arg1);
|
||||
HuPrcSleep(2);
|
||||
}
|
||||
|
||||
void BoardViewMoveStart(Vec *arg0, Vec *arg1, u16 arg2) {
|
||||
u16 var_r31;
|
||||
|
||||
if (BoardPauseDisableGet() == 0) {
|
||||
BoardPauseDisableSet(1);
|
||||
pauseDisableF = 1;
|
||||
} else {
|
||||
pauseDisableF = 0;
|
||||
}
|
||||
viewProc = HuPrcChildCreate(ExecStarView, 0x200A, 0x3800, 0, boardMainProc);
|
||||
HuPrcDestructorSet2(viewProc, DestroyView);
|
||||
focusDestroyF = 0;
|
||||
BoardViewInlineFunc00(arg0, arg1, arg2);
|
||||
HuPrcSleep(2);
|
||||
}
|
||||
|
||||
BOOL BoardViewMoveCheck(void) {
|
||||
return (viewMoveF != 0) ? TRUE : FALSE;
|
||||
}
|
||||
|
||||
void BoardViewMoveEnd(void) {
|
||||
viewMoveF = 0;
|
||||
}
|
||||
|
||||
void BoardViewWait(void) {
|
||||
viewMoveF = 0;
|
||||
while (viewProc != NULL) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
}
|
||||
|
||||
void BoardViewMapExec(s32 arg0) {
|
||||
if (BoardPauseDisableGet() == 0) {
|
||||
BoardPauseDisableSet(1);
|
||||
pauseDisableF = 1;
|
||||
} else {
|
||||
pauseDisableF = 0;
|
||||
}
|
||||
viewProc = HuPrcChildCreate(ExecMapView, 0x200A, 0x3800, 0, boardMainProc);
|
||||
HuPrcDestructorSet2(viewProc, DestroyView);
|
||||
viewControls = 0;
|
||||
viewPlayer = arg0;
|
||||
focusTimer = 1;
|
||||
viewMoveF = 0;
|
||||
BoardPlayerPosGet(arg0, &focusPos);
|
||||
while (viewProc != NULL) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
}
|
||||
|
||||
static void ExecMapView(void) {
|
||||
Vec spC;
|
||||
float var_f29;
|
||||
float temp_f28;
|
||||
float temp_f27;
|
||||
float temp_f26;
|
||||
float temp_f25;
|
||||
float temp_f24;
|
||||
u32 var_r28;
|
||||
s8 sp9;
|
||||
s8 sp8;
|
||||
|
||||
SetTargetView();
|
||||
CreateButtonWin();
|
||||
temp_f25 = mapViewMaxZ[GWBoardGet()];
|
||||
temp_f24 = mapViewMinZ[GWBoardGet()];
|
||||
temp_f27 = mapViewMaxX[GWBoardGet()];
|
||||
temp_f26 = mapViewMinX[GWBoardGet()];
|
||||
while (1) {
|
||||
var_r28 = HuPadBtnDown[GWPlayer[viewPlayer].port];
|
||||
if (var_r28 == 0x200) {
|
||||
HuAudFXPlay(3);
|
||||
break;
|
||||
}
|
||||
if (HuPadBtn[GWPlayer[viewPlayer].port] & 0x100) {
|
||||
var_f29 = 40.0f;
|
||||
} else {
|
||||
var_f29 = 20.0f;
|
||||
}
|
||||
spC.x = spC.y = spC.z = 0.0f;
|
||||
sp9 = HuPadStkX[GWPlayer[viewPlayer].port];
|
||||
sp8 = HuPadStkY[GWPlayer[viewPlayer].port];
|
||||
if (sp9 != 0 || sp8 != 0) {
|
||||
OSs8tof32(&sp9, &spC.x);
|
||||
OSs8tof32(&sp8, &spC.z);
|
||||
temp_f28 = 180.0 * (atan2(spC.x, -spC.z) / M_PI);
|
||||
spC.x = var_f29 * sin(temp_f28 * M_PI / 180.0);
|
||||
spC.z = var_f29 * cos(temp_f28 * M_PI / 180.0);
|
||||
}
|
||||
PSVECAdd(&spC, &focusPos, &focusPos);
|
||||
if (focusPos.x < temp_f26) {
|
||||
focusPos.x = temp_f26;
|
||||
}
|
||||
if (focusPos.x > temp_f27) {
|
||||
focusPos.x = temp_f27;
|
||||
}
|
||||
if (focusPos.z < temp_f24) {
|
||||
focusPos.z = temp_f24;
|
||||
}
|
||||
if (focusPos.z > temp_f25) {
|
||||
focusPos.z = temp_f25;
|
||||
}
|
||||
BoardModelPosSetV(focusMdl, &focusPos);
|
||||
HuPrcVSleep();
|
||||
}
|
||||
DestroyFocus();
|
||||
DestroyButtonWin();
|
||||
HuPrcEnd();
|
||||
}
|
||||
|
||||
static void ExecStarView(void) {
|
||||
Vec sp8;
|
||||
float temp_f30;
|
||||
|
||||
SetTargetView();
|
||||
do {
|
||||
OSu16tof32(&focusTimer, &temp_f30);
|
||||
PSVECSubtract(&focusPosTarget, &focusPos, &sp8);
|
||||
sp8.x /= temp_f30;
|
||||
sp8.y /= temp_f30;
|
||||
sp8.z /= temp_f30;
|
||||
viewMoveF = 1;
|
||||
while (viewMoveF != 0) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
focusDestroyF = 0;
|
||||
while (focusTimer != 0) {
|
||||
PSVECAdd(&sp8, &focusPos, &focusPos);
|
||||
BoardModelPosSetV(focusMdl, &focusPos);
|
||||
HuPrcVSleep();
|
||||
focusTimer--;
|
||||
}
|
||||
BoardModelPosSetV(focusMdl, &focusPosTarget);
|
||||
BoardCameraMotionWait();
|
||||
viewMoveF = 1;
|
||||
while (viewMoveF != 0 && focusDestroyF == 0) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
} while (focusDestroyF != 0);
|
||||
DestroyFocus();
|
||||
HuPrcEnd();
|
||||
}
|
||||
|
||||
static void ExecOverheadView(void) {
|
||||
u32 var_r31;
|
||||
|
||||
if ((GWBoardGet() == 2 || GWBoardGet() == 5) && boardLightResetHook) {
|
||||
boardLightResetHook();
|
||||
}
|
||||
InitOverheadView();
|
||||
CreateButtonWin();
|
||||
HuPrcVSleep();
|
||||
SetTargetView();
|
||||
WipeColorSet(0xFF, 0xFF, 0xFF);
|
||||
WipeCreate(1, 1, 0xA);
|
||||
while (WipeStatGet() != 0) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
while (1) {
|
||||
var_r31 = HuPadBtnDown[GWPlayer[viewPlayer].port];
|
||||
if (var_r31 == 0x200) {
|
||||
HuAudFXPlay(3);
|
||||
break;
|
||||
}
|
||||
HuPrcVSleep();
|
||||
}
|
||||
if ((GWBoardGet() == 2 || GWBoardGet() == 5) && boardLightSetHook) {
|
||||
boardLightSetHook();
|
||||
}
|
||||
DestroyButtonWin();
|
||||
DestroyFocus();
|
||||
HuPrcEnd();
|
||||
}
|
||||
|
||||
static void DestroyView(void) {
|
||||
if (focusMdl != -1) {
|
||||
BoardModelKill(focusMdl);
|
||||
focusMdl = -1;
|
||||
}
|
||||
DestroyOverheadView();
|
||||
DestroyButtonWin();
|
||||
viewMoveF = 0;
|
||||
focusTimer = 0;
|
||||
viewPlayer = -1;
|
||||
if (pauseDisableF != 0) {
|
||||
BoardPauseDisableSet(0);
|
||||
pauseDisableF = 0;
|
||||
}
|
||||
viewProc = NULL;
|
||||
}
|
||||
|
||||
static void SetTargetView(void) {
|
||||
Vec sp14;
|
||||
Vec sp8;
|
||||
|
||||
BoardCameraBackup();
|
||||
focusMdl = BoardModelCreate(0x7000A, 0, 0);
|
||||
BoardModelVisibilitySet(focusMdl, 0);
|
||||
BoardModelPosSetV(focusMdl, &focusPos);
|
||||
BoardCameraNearFarSet(10.0f, 30000.0f);
|
||||
if (viewControls != 2) {
|
||||
sp8.x = -45.0f;
|
||||
sp8.y = 0.0f;
|
||||
sp8.z = 0.0f;
|
||||
BoardCameraMotionStartEx(focusMdl, &sp8, NULL, 3000.0f, -1.0f, 0x15);
|
||||
BoardCameraMotionWait();
|
||||
} else {
|
||||
BoardModelPosSet(focusMdl, 0.0f, 0.0f, 0.0f);
|
||||
sp14.x = 0.0f;
|
||||
sp14.y = 0.0f;
|
||||
sp14.z = 0.0f;
|
||||
sp8.x = -78.0f;
|
||||
sp8.y = 0.0f;
|
||||
sp8.z = 0.0f;
|
||||
sp14.z = overheadCamPosZ[GWBoardGet()];
|
||||
BoardCameraMoveSet(0);
|
||||
BoardCameraMotionStartEx(focusMdl, &sp8, &sp14, overheadCamZoom[GWBoardGet()], -1.0f, 1);
|
||||
BoardCameraMotionWait();
|
||||
BoardCameraMoveSet(1);
|
||||
}
|
||||
}
|
||||
|
||||
static void DestroyFocus(void) {
|
||||
if (focusMdl != -1) {
|
||||
BoardModelKill(focusMdl);
|
||||
focusMdl = -1;
|
||||
}
|
||||
BoardCameraMoveSet(0);
|
||||
BoardCameraRestore();
|
||||
BoardCameraMoveSet(1);
|
||||
}
|
||||
|
||||
static void CreateButtonWin(void) {
|
||||
float sp8[2];
|
||||
float var_f31;
|
||||
float var_f30;
|
||||
s32 var_r31;
|
||||
|
||||
if (viewControls != 2) {
|
||||
var_r31 = 0x90005;
|
||||
var_f31 = 286.0f;
|
||||
} else {
|
||||
var_r31 = 0x10004D;
|
||||
var_f31 = 328.0f;
|
||||
}
|
||||
HuWinMesMaxSizeGet(1, sp8, var_r31);
|
||||
var_f30 = -10000.0f;
|
||||
buttonWin = HuWinCreate(var_f30, var_f31, sp8[0], sp8[1], 0);
|
||||
HuWinBGTPLvlSet(buttonWin, 0.0f);
|
||||
HuWinMesSpeedSet(buttonWin, 0);
|
||||
HuWinMesSet(buttonWin, var_r31);
|
||||
}
|
||||
|
||||
static void DestroyButtonWin(void) {
|
||||
if (buttonWin != -1) {
|
||||
HuWinKill(buttonWin);
|
||||
buttonWin = -1;
|
||||
}
|
||||
}
|
||||
|
||||
static void InitOverheadView(void) {
|
||||
Vec sp10;
|
||||
GXColor spA;
|
||||
s16 sp8;
|
||||
omObjData *temp_r26;
|
||||
OverheadWork *temp_r31;
|
||||
float *temp_r30;
|
||||
s32 i;
|
||||
s32 sp1C[8] = {
|
||||
0x0007002E,
|
||||
0x0007002F,
|
||||
0x00070030,
|
||||
0x00070031,
|
||||
0x00070032,
|
||||
0x00070033,
|
||||
0x00070034,
|
||||
0x00070035
|
||||
};
|
||||
|
||||
temp_r26 = omAddObjEx(boardObjMan, 0x1000, 0, 0, -1, UpdateOverheadView);
|
||||
overheadObj = temp_r26;
|
||||
temp_r31 = OM_GET_WORK_PTR(temp_r26, OverheadWork);
|
||||
temp_r31->unk00_field0 = 0;
|
||||
temp_r31->unk01 = 1;
|
||||
temp_r31->unk02 = HuSprGrpCreate(9);
|
||||
for (i = 0; i < 4; i++) {
|
||||
temp_r30 = overhead2DPos[i];
|
||||
BoardSpriteCreate(sp1C[GWPlayer[i].character], 0x1388, 0, &sp8);
|
||||
HuSprGrpMemberSet(temp_r31->unk02, i, sp8);
|
||||
HuSprAttrSet(temp_r31->unk02, i, 1);
|
||||
HuSprAttrSet(temp_r31->unk02, i, 8);
|
||||
HuSprPosSet(temp_r31->unk02, i, temp_r30[0], temp_r30[1]);
|
||||
if (GWPlayer[i].character == 7) {
|
||||
spA.r = 0x50;
|
||||
spA.g = 0x50;
|
||||
spA.b = 0x50;
|
||||
} else {
|
||||
GWCharColorGet(GWPlayer[i].character, &spA);
|
||||
}
|
||||
BoardSpriteCreate(0x7006C, 0x1770, 0, &sp8);
|
||||
HuSprGrpMemberSet(temp_r31->unk02, i + 4, sp8);
|
||||
HuSprPosSet(temp_r31->unk02, i + 4, temp_r30[0], temp_r30[1]);
|
||||
HuSprColorSet(temp_r31->unk02, i + 4, spA.r, spA.g, spA.b);
|
||||
}
|
||||
temp_r30 = overhead2DPos[4];
|
||||
temp_r31->unk04 = BoardModelCreate(0x70008, NULL, 0);
|
||||
BoardModelMotionSpeedSet(temp_r31->unk04, 0.0f);
|
||||
BoardModelLayerSet(temp_r31->unk04, 6);
|
||||
BoardModelScaleSet(temp_r31->unk04, 0.4f, 0.4f, 0.4f);
|
||||
BoardModelPassSet(temp_r31->unk04, 1);
|
||||
sp10.x = temp_r30[0];
|
||||
sp10.y = temp_r30[1];
|
||||
sp10.z = 1000.0f;
|
||||
spA.r = 0xF8;
|
||||
spA.g = 0xF0;
|
||||
spA.b = 0x80;
|
||||
BoardSpriteCreate(0x7006C, 0x1770, 0, &sp8);
|
||||
HuSprGrpMemberSet(temp_r31->unk02, 8, sp8);
|
||||
HuSprPosSet(temp_r31->unk02, 8, temp_r30[0], temp_r30[1]);
|
||||
HuSprColorSet(temp_r31->unk02, 8, spA.r, spA.g, spA.b);
|
||||
Hu3D2Dto3D(&sp10, 1, &sp10);
|
||||
BoardModelPosSetV(temp_r31->unk04, &sp10);
|
||||
HuSprGrpDrawNoSet(temp_r31->unk02, 0x40);
|
||||
if (GWBoardGet() == 7 || GWBoardGet() == 8) {
|
||||
BoardModelVisibilitySet(temp_r31->unk04, 0);
|
||||
HuSprTPLvlSet(temp_r31->unk02, 8, 0.0f);
|
||||
}
|
||||
}
|
||||
|
||||
static void DestroyOverheadView(void) {
|
||||
if (overheadObj) {
|
||||
OM_GET_WORK_PTR(overheadObj, OverheadWork)->unk00_field0 = 1;
|
||||
}
|
||||
}
|
||||
|
||||
static void UpdateOverheadView(omObjData *arg0) {
|
||||
Vec sp20;
|
||||
Vec sp14;
|
||||
Vec sp8;
|
||||
float temp_f31;
|
||||
float temp_f30;
|
||||
float *var_r29;
|
||||
s32 var_r28;
|
||||
s32 var_r27;
|
||||
s32 i;
|
||||
u32 var_r26;
|
||||
OverheadWork *temp_r31;
|
||||
Mtx sp5C;
|
||||
Mtx sp2C;
|
||||
|
||||
temp_r31 = OM_GET_WORK_PTR(arg0, OverheadWork);
|
||||
if (temp_r31->unk00_field0 != 0 || BoardIsKill()) {
|
||||
if (temp_r31->unk02 != -1) {
|
||||
HuSprGrpKill(temp_r31->unk02);
|
||||
}
|
||||
if (temp_r31->unk04 != -1) {
|
||||
BoardModelKill(temp_r31->unk04);
|
||||
}
|
||||
overheadObj = NULL;
|
||||
omDelObjEx(HuPrcCurrentGet(), arg0);
|
||||
return;
|
||||
}
|
||||
var_r26 = HuPadBtnDown[GWPlayer[viewPlayer].port];
|
||||
if (var_r26 == 0x20) {
|
||||
temp_r31->unk01 ^= 1;
|
||||
HuAudFXPlay(0x1C);
|
||||
}
|
||||
if (GWBoardGet() == 7 || GWBoardGet() == 8) {
|
||||
var_r27 = 1;
|
||||
} else {
|
||||
var_r27 = 0;
|
||||
}
|
||||
for (i = 0; i < 5; i++) {
|
||||
var_r29 = overhead2DPos[i];
|
||||
sp20.x = var_r29[0] - 288.0f;
|
||||
sp20.y = var_r29[1] - 240.0f;
|
||||
sp20.z = 1000.0f;
|
||||
if (i != 4) {
|
||||
BoardSpacePosGet(0, GWPlayer[i].space_curr, &sp14);
|
||||
} else if (var_r27 != 0) {
|
||||
sp14.x = sp14.y = sp14.z = 0.0f;
|
||||
} else {
|
||||
BoardSpacePosGet(0, BoardSpaceStarGetCurr(), &sp14);
|
||||
}
|
||||
Hu3D3Dto2D(&sp14, 1, &sp14);
|
||||
sp14.x -= 288.0f;
|
||||
sp14.y -= 240.0f;
|
||||
PSVECSubtract(&sp20, &sp14, &sp8);
|
||||
sp8.z = 0.0f;
|
||||
temp_f30 = BoardDAngleCalc(180.0 * (atan2(sp8.y, sp8.x) / M_PI) - 90.0);
|
||||
temp_f31 = PSVECMag(&sp8) / 32;
|
||||
if (i != 4) {
|
||||
var_r28 = i + 4;
|
||||
} else {
|
||||
var_r28 = 8;
|
||||
}
|
||||
HuSprZRotSet(temp_r31->unk02, var_r28, temp_f30);
|
||||
HuSprScaleSet(temp_r31->unk02, var_r28, 0.5f, temp_f31);
|
||||
HuSprPosSet(temp_r31->unk02, var_r28, var_r29[0], var_r29[1]);
|
||||
if (i == 4 && (GWBoardGet() == 7 || GWBoardGet() == 8)) {
|
||||
BoardModelVisibilitySet(temp_r31->unk04, 0);
|
||||
} else if (temp_r31->unk01 != 0) {
|
||||
if (i != 4) {
|
||||
HuSprAttrReset(temp_r31->unk02, i, 4);
|
||||
}
|
||||
HuSprAttrReset(temp_r31->unk02, var_r28, 4);
|
||||
BoardModelVisibilitySet(temp_r31->unk04, 1);
|
||||
} else {
|
||||
if (i != 4) {
|
||||
HuSprAttrSet(temp_r31->unk02, i, 4);
|
||||
}
|
||||
HuSprAttrSet(temp_r31->unk02, var_r28, 4);
|
||||
BoardModelVisibilitySet(temp_r31->unk04, 0);
|
||||
}
|
||||
}
|
||||
sp20.x = var_r29[0];
|
||||
sp20.y = var_r29[1];
|
||||
sp20.z = 1000.0f;
|
||||
BoardCameraRotGet(&sp8);
|
||||
PSMTXRotRad(sp5C, 0x78, sp8.x * 0.017453292f);
|
||||
PSMTXRotRad(sp2C, 0x79, sp8.y * 0.017453292f);
|
||||
PSMTXConcat(sp2C, sp5C, sp2C);
|
||||
BoardModelMtxSet(temp_r31->unk04, &sp2C);
|
||||
Hu3D2Dto3D(&sp20, 1, &sp20);
|
||||
BoardModelPosSetV(temp_r31->unk04, &sp20);
|
||||
}
|
||||
|
||||
static void WaitOverheadView(void) {
|
||||
while (overheadObj) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
}
|
||||
|
|
@ -1,9 +1,12 @@
|
|||
#include "game/board/warp.h"
|
||||
#include "game/board/main.h"
|
||||
#include "game/board/player.h"
|
||||
#include "game/board/tutorial.h"
|
||||
#include "game/wipe.h"
|
||||
#include "game/gamework_data.h"
|
||||
#include "game/hsfdraw.h"
|
||||
#include "game/hsfex.h"
|
||||
#include "game/objsub.h"
|
||||
#include "board_unsplit.h"
|
||||
#include "math.h"
|
||||
|
||||
|
|
@ -14,7 +17,6 @@ static void WarpFall(s32);
|
|||
static void WarpImpact(s32);
|
||||
|
||||
|
||||
extern void omVibrate(s16, s16, s16, s16);
|
||||
extern void BoardCharWheelInit(s32, s32);
|
||||
extern void BoardCharWheelSpeedSet(f32);
|
||||
extern void BoardCharWheelWait(void);
|
||||
|
|
@ -22,13 +24,8 @@ extern s32 BoardCharWheelResultGet(void);
|
|||
extern f32 BoardModelMotionTimeGet(s16);
|
||||
extern void BoardModelHookReset(s16);
|
||||
extern s32 BoardModelHookSet(s16, char*, s16);
|
||||
extern void BoardPlayerPosSet(s32, f32, f32, f32);
|
||||
extern void BoardPlayerRotYSet(s32, f32);
|
||||
extern void Hu3DModelObjPosGet(s16, char*, Vec*);
|
||||
extern s32 BoardModelMotionEndCheck(s16);
|
||||
|
||||
extern s32 boardTutorialData[4];
|
||||
|
||||
static Vec warpPos;
|
||||
|
||||
static s8 warpState;
|
||||
|
|
@ -139,7 +136,7 @@ static void WarpInit(s32 player) {
|
|||
Vec pos;
|
||||
s16 player_mdl = BoardPlayerModelGet(player);
|
||||
|
||||
warpSpringMdl = BoardModelCreate(MAKE_DATA_NUM(DATADIR_BOARD, 1), NULL, 0);
|
||||
warpSpringMdl = BoardModelCreate(DATA_MAKE_NUM(DATADIR_BOARD, 1), NULL, 0);
|
||||
BoardSpacePosGet(0, GWPlayer[player].space_curr, &pos);
|
||||
warpYFloor = 1500.0f + pos.y;
|
||||
BoardModelLayerSet(warpSpringMdl, 2);
|
||||
|
|
@ -187,7 +184,7 @@ static void WarpStartImpact(s32 player) {
|
|||
warpImpactCnt++;
|
||||
}
|
||||
}
|
||||
warpImpactMdl = BoardModelCreate(MAKE_DATA_NUM(DATADIR_BOARD, 2), NULL, 0);
|
||||
warpImpactMdl = BoardModelCreate(DATA_MAKE_NUM(DATADIR_BOARD, 2), NULL, 0);
|
||||
BoardModelVisibilitySet(warpImpactMdl, 0);
|
||||
BoardModelMotionSpeedSet(warpImpactMdl, 0.0f);
|
||||
BoardCameraMoveSet(0);
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue