Merge branch 'main' into main
This commit is contained in:
CreateSource
GitHub
commit
ee4f87874c
50 changed files with 1195 additions and 534 deletions
|
|
@ -1,4 +1,3 @@
|
|||
#include "common.h"
|
||||
#include "REL/executor.h"
|
||||
#include "dolphin/os.h"
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,3 @@
|
|||
#include "common.h"
|
||||
#include "game/data.h"
|
||||
|
||||
#include "logoNintendoData.inc"
|
||||
|
|
|
|||
|
|
@ -210,7 +210,7 @@ void fn_1_13A4(void) {
|
|||
BoardCameraMotionStartEx(lbl_1_bss_0->unk8, &sp8, NULL, 3200.0f, -1.0f, 30);
|
||||
BoardCameraMotionWait();
|
||||
fn_1_BA0(0x2E0032);
|
||||
BoardCameraTargetModelSet(fn_80083F84());
|
||||
BoardCameraTargetModelSet(BoardStarHostMdlGet());
|
||||
BoardCameraMotionWait();
|
||||
fn_1_BA0(0x2E0033);
|
||||
fn_1_BA0(0x2E0034);
|
||||
|
|
|
|||
|
|
@ -3,7 +3,7 @@
|
|||
#include "game/msm.h"
|
||||
#include "game/object.h"
|
||||
#include "game/wipe.h"
|
||||
|
||||
#include "game/gamework_data.h"
|
||||
|
||||
typedef struct {
|
||||
/* 0x00 */ s16 unk00;
|
||||
|
|
|
|||
|
|
@ -1,7 +1,10 @@
|
|||
#include "game/board/basic_space.h"
|
||||
#include "game/board/main.h"
|
||||
#include "game/data.h"
|
||||
#include "game/flag.h"
|
||||
|
||||
#include "game/object.h"
|
||||
#include "game/gamework_data.h"
|
||||
#include "board_unsplit.h"
|
||||
#include "math.h"
|
||||
|
||||
typedef struct bit_copy {
|
||||
|
|
@ -61,7 +64,7 @@ static s32 coinDigitMdl[10] = {
|
|||
MAKE_DATA_NUM(DATADIR_BOARD, 21),
|
||||
};
|
||||
|
||||
void BoardEventLandBlue(s32 player, s16 space) {
|
||||
void BoardLandBlueExec(s32 player, s16 space) {
|
||||
Vec pos;
|
||||
s32 i;
|
||||
s8 coin_chg;
|
||||
|
|
@ -102,7 +105,7 @@ void BoardEventLandBlue(s32 player, s16 space) {
|
|||
BoardRotateDiceNumbers(player);
|
||||
}
|
||||
|
||||
void BoardEventLandRed(s32 player, s16 space) {
|
||||
void BoardLandRedExec(s32 player, s16 space) {
|
||||
Vec pos;
|
||||
s32 i;
|
||||
s8 coin_chg;
|
||||
|
|
|
|||
|
|
@ -1,4 +1,5 @@
|
|||
#include "common.h"
|
||||
#include "board_unsplit.h"
|
||||
#include "game/gamework_data.h"
|
||||
#include "math.h"
|
||||
#include "game/object.h"
|
||||
#include "game/flag.h"
|
||||
|
|
@ -6,52 +7,8 @@
|
|||
#include "game/wipe.h"
|
||||
#include "string.h"
|
||||
#include "game/hsfman.h"
|
||||
|
||||
|
||||
typedef struct board_focus_data {
|
||||
u16 view_type;
|
||||
s16 time;
|
||||
s16 max_time;
|
||||
float fov_start;
|
||||
float fov_end;
|
||||
float zoom_start;
|
||||
float zoom_end;
|
||||
Vec rot_start;
|
||||
Vec rot_end;
|
||||
Vec target_start;
|
||||
Vec target_end;
|
||||
} BoardFocusData;
|
||||
|
||||
typedef struct board_camera_data {
|
||||
struct {
|
||||
u8 hide_all : 1;
|
||||
u8 moving : 1;
|
||||
u8 quaking : 1;
|
||||
};
|
||||
u16 mask;
|
||||
s16 target_mdl;
|
||||
s16 target_space;
|
||||
s32 quake_timer;
|
||||
float quake_strength;
|
||||
float fov;
|
||||
float near;
|
||||
float far;
|
||||
float aspect;
|
||||
float viewport_x;
|
||||
float viewport_y;
|
||||
float viewport_w;
|
||||
float viewport_h;
|
||||
float viewport_near;
|
||||
float viewport_far;
|
||||
Vec pos;
|
||||
Vec up;
|
||||
Vec target;
|
||||
Vec offset;
|
||||
Vec rot;
|
||||
float zoom;
|
||||
void (*pos_calc)(struct board_camera_data *camera);
|
||||
BoardFocusData focus;
|
||||
} BoardCameraData;
|
||||
#include "game/board/main.h"
|
||||
#include "game/board/player.h"
|
||||
|
||||
typedef struct camera_view {
|
||||
s16 x_rot;
|
||||
|
|
@ -59,7 +16,6 @@ typedef struct camera_view {
|
|||
s16 fov;
|
||||
} CameraView;
|
||||
|
||||
typedef void (*VoidFunc)(void);
|
||||
|
||||
omObjData *boardMainObj;
|
||||
u32 boardRandSeed;
|
||||
|
|
@ -70,11 +26,11 @@ void *boardTurnStartFunc;
|
|||
u32 lbl_801D3F00;
|
||||
u32 lbl_801D3EFC;
|
||||
u32 lbl_801D3EF8;
|
||||
VoidFunc boardTurnFunc;
|
||||
void *boardLightSetHook;
|
||||
void *boardLightResetHook;
|
||||
static VoidFunc destroyFunc;
|
||||
static VoidFunc createFunc;
|
||||
BoardFunc boardTurnFunc;
|
||||
BoardLightHook boardLightSetHook;
|
||||
BoardLightHook boardLightResetHook;
|
||||
static BoardFunc destroyFunc;
|
||||
static BoardFunc createFunc;
|
||||
static BOOL cameraUseBackup;
|
||||
static omObjData *tauntObj;
|
||||
static omObjData *cameraObj;
|
||||
|
|
@ -95,8 +51,7 @@ static CameraView camViewTbl[] = {
|
|||
{ -33, 3200, 25 },
|
||||
};
|
||||
|
||||
extern void BoardPlayerCoinsSet(s32 player, s32 value);
|
||||
extern void BoardPlayerAutoSizeSet(s32 player, s32 value);
|
||||
|
||||
extern void BoardModelPosGet(s16 model, Vec *pos);
|
||||
extern void BoardSpacePosGet(s32 layer, s32 space, Vec *pos);
|
||||
|
||||
|
|
@ -134,49 +89,6 @@ static void DestroyMainFunc(void);
|
|||
static void CreateBoard(void);
|
||||
static void DestroyBoard(void);
|
||||
|
||||
static inline s32 BoardCurrGet()
|
||||
{
|
||||
return GWSystem.board;
|
||||
}
|
||||
|
||||
static inline s32 BoardPartyFlagGet()
|
||||
{
|
||||
s32 value = GWSystem.party;
|
||||
return value;
|
||||
}
|
||||
|
||||
static inline s16 BoardHandicapGet(s32 player)
|
||||
{
|
||||
return GWPlayer[player].handicap;
|
||||
}
|
||||
|
||||
static inline s32 BoardPlayerCurrGetIdx()
|
||||
{
|
||||
return GWSystem.player_curr;
|
||||
}
|
||||
|
||||
static inline PlayerState *BoardPlayerGet(s32 player)
|
||||
{
|
||||
return &GWPlayer[player];
|
||||
}
|
||||
|
||||
static inline PlayerState *BoardPlayerCurrGet()
|
||||
{
|
||||
return &GWPlayer[BoardPlayerCurrGetIdx()];
|
||||
}
|
||||
|
||||
static inline s16 BoardPlayerModelGet(s32 player)
|
||||
{
|
||||
PlayerState *player_ptr = BoardPlayerGet(player);
|
||||
return boardPlayerMdl[player_ptr->player_idx];
|
||||
}
|
||||
|
||||
static inline s16 BoardPlayerCurrModelGet()
|
||||
{
|
||||
PlayerState *player = BoardPlayerCurrGet();
|
||||
return boardPlayerMdl[player->player_idx];
|
||||
}
|
||||
|
||||
static inline int GWMGTypeGet()
|
||||
{
|
||||
return GWSystem.mg_type;
|
||||
|
|
@ -187,10 +99,9 @@ static inline int GWMessSpeedGet()
|
|||
return GWSystem.mess_speed;
|
||||
}
|
||||
|
||||
#define BOARD_FABS(value) ((value < 0) ? -(value) : (value))
|
||||
|
||||
#define BoardFAbs(value) ((value < 0) ? -(value) : (value))
|
||||
|
||||
void BoardCommonInit(VoidFunc create, VoidFunc destroy)
|
||||
void BoardCommonInit(BoardFunc create, BoardFunc destroy)
|
||||
{
|
||||
omSysPauseEnable(FALSE);
|
||||
if(!_CheckFlag(FLAG_ID_MAKE(1, 0))) {
|
||||
|
|
@ -339,7 +250,7 @@ void BoardKill(void)
|
|||
BoardTutorialHookExec(29, 0);
|
||||
}
|
||||
HuAudFXAllStop();
|
||||
if(!BoardIsStarted()) {
|
||||
if(!BoardStartCheck()) {
|
||||
WipeCreate(WIPE_MODE_OUT, WIPE_TYPE_NORMAL, -1);
|
||||
boardTutorialF = 1;
|
||||
while(WipeStatGet()) {
|
||||
|
|
@ -439,7 +350,7 @@ void BoardSaveInit(s32 board)
|
|||
if(!BoardPartyFlagGet() || _CheckFlag(FLAG_ID_MAKE(1, 11))) {
|
||||
GWStarsSet(i, 0);
|
||||
} else {
|
||||
GWStarsSet(i, BoardHandicapGet(i));
|
||||
GWStarsSet(i, BoardPlayerHandicapGet(i));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -599,7 +510,7 @@ static void MainFunc(void)
|
|||
while(WipeStatGet()) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
BoardPlayerCurrMoveAwayStart(GWPlayer[i].space_curr, 1);
|
||||
BoardPlayerMoveAwayStartCurr(GWPlayer[i].space_curr, 1);
|
||||
fade_type = 0;
|
||||
} else {
|
||||
if(BoardCurrGet() == 7 || BoardCurrGet() == 8) {
|
||||
|
|
@ -609,7 +520,7 @@ static void MainFunc(void)
|
|||
while(WipeStatGet()) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
BoardPlayerCurrMoveAwayStart(GWPlayer[i].space_curr, 1);
|
||||
BoardPlayerMoveAwayStartCurr(GWPlayer[i].space_curr, 1);
|
||||
fade_type = 0;
|
||||
}
|
||||
} else {
|
||||
|
|
@ -669,7 +580,7 @@ void BoardNextOvlSet(OverlayID overlay)
|
|||
BoardKill();
|
||||
}
|
||||
|
||||
BOOL BoardIsStarted(void)
|
||||
s32 BoardStartCheck(void)
|
||||
{
|
||||
if(_CheckFlag(FLAG_ID_MAKE(1, 2)) || _CheckFlag(FLAG_ID_MAKE(1, 3)) || _CheckFlag(FLAG_ID_MAKE(1, 4)) || _CheckFlag(FLAG_ID_MAKE(1, 5)) || _CheckFlag(FLAG_ID_MAKE(1, 6))) {
|
||||
return 1;
|
||||
|
|
@ -868,7 +779,7 @@ void BoardCameraViewSet(s32 type)
|
|||
} else {
|
||||
size = 1.0f;
|
||||
}
|
||||
BoardCameraTargetModelSet(BoardPlayerCurrModelGet());
|
||||
BoardCameraTargetModelSet(BoardPlayerModelGetCurr());
|
||||
BoardPlayerPosGet(GWSystem.player_curr, &focus->target_end);
|
||||
BoardCameraOffsetSet(0.0f, 100.0f*size, 0.0f);
|
||||
focus->target_end.y += 100.0f*size;
|
||||
|
|
@ -1022,7 +933,7 @@ void BoardCameraTargetSpaceSet(s32 space)
|
|||
camera->offset.x = camera->offset.y = camera->offset.z = 0;
|
||||
}
|
||||
|
||||
void BoardCameraPosCalcFuncSet(void (*func)(struct board_camera_data *camera))
|
||||
void BoardCameraPosCalcFuncSet(BoardCameraPosCalcFunc func)
|
||||
{
|
||||
BoardCameraData *camera = &boardCamera;
|
||||
if(!camera) {
|
||||
|
|
@ -1042,7 +953,7 @@ void BoardCameraQuakeSet(s32 duration, float strength)
|
|||
camera->quake_timer = duration;
|
||||
}
|
||||
|
||||
void BoardCameraQuakeReset(s32 duration, float strength)
|
||||
void BoardCameraQuakeReset()
|
||||
{
|
||||
BoardCameraData *camera = &boardCamera;
|
||||
camera->quaking = 0;
|
||||
|
|
@ -1093,7 +1004,6 @@ void BoardCameraNearFarSet(float near, float far)
|
|||
camera->far = far;
|
||||
}
|
||||
|
||||
|
||||
void BoardCameraNearFarGet(float *near, float *far)
|
||||
{
|
||||
BoardCameraData *camera = &boardCamera;
|
||||
|
|
@ -1180,7 +1090,7 @@ s32 BoardCameraCullCheck(Vec *point, float radius)
|
|||
}
|
||||
BoardCameraPointDirGet(point, &pos);
|
||||
dot = VECDotProduct(&dir, &pos);
|
||||
if(BoardFAbs(dot) < cos((camera->fov*M_PI)/180)) {
|
||||
if(BOARD_FABS(dot) < cos((camera->fov*M_PI)/180)) {
|
||||
return 0;
|
||||
} else {
|
||||
return 1;
|
||||
|
|
@ -1365,7 +1275,7 @@ float BoardArcSin(float value)
|
|||
s32 sign;
|
||||
if(value < 0) {
|
||||
sign = 1;
|
||||
value = BoardFAbs(value);
|
||||
value = BOARD_FABS(value);
|
||||
} else {
|
||||
sign = 0;
|
||||
}
|
||||
|
|
@ -1378,14 +1288,14 @@ float BoardArcSin(float value)
|
|||
result = 1.0f-atanf((float)sqrtf(1-(value*value))/value);
|
||||
}
|
||||
if(sign) {
|
||||
result = BoardFAbs(result);
|
||||
result = BOARD_FABS(result);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
float BoardArcCos(float value)
|
||||
{
|
||||
if(BoardFAbs(value) > 1) {
|
||||
if(BOARD_FABS(value) > 1) {
|
||||
return 0;
|
||||
}
|
||||
return 1.0f-BoardArcSin(value);
|
||||
|
|
|
|||
|
|
@ -1,20 +1,13 @@
|
|||
#include "common.h"
|
||||
#include "board_unsplit.h"
|
||||
#include "game/gamework_data.h"
|
||||
#include "game/gamework.h"
|
||||
#include "game/window.h"
|
||||
#include "game/object.h"
|
||||
#include "game/process.h"
|
||||
#include "game/hsfman.h"
|
||||
#include "game/board/player.h"
|
||||
#include "game/board/main.h"
|
||||
|
||||
//// #include "game/board/main.h"
|
||||
extern s32 BoardIsStarted(void);
|
||||
extern void BoardCameraMoveSet(s32);
|
||||
extern void BoardCameraViewSet(s32);
|
||||
extern void BoardPauseEnableSet(s32);
|
||||
extern void BoardCameraTargetPlayerSet(s32);
|
||||
extern void BoardCameraOffsetSet(float, float, float);
|
||||
extern void BoardCameraTargetModelSet(s16);
|
||||
extern void BoardCameraTargetPlayerSet(s32);
|
||||
extern Process* boardObjMan;
|
||||
//// #include "game/board/space.h"
|
||||
extern s32 BoardSpaceFlagPosGet(s32, s32, u32);
|
||||
extern void BoardSpaceDirPosGet(s32, s32, Vec*);
|
||||
|
|
@ -242,7 +235,7 @@ void BoardPlayerInit(void) {
|
|||
BoardPlayerSizeSet(var_r31, 0);
|
||||
GWPlayer[var_r31].color = 0;
|
||||
GWPlayer[var_r31].bowser_suit = 0;
|
||||
GWPlayer[var_r31].field01_bit9 = 0;
|
||||
GWPlayer[var_r31].field00_bit9 = 0;
|
||||
GWPlayer[var_r31].field08_bit3 = 0;
|
||||
}
|
||||
return;
|
||||
|
|
@ -258,7 +251,7 @@ void BoardPlayerInit(void) {
|
|||
}
|
||||
|
||||
void BoardPlayerModelInit(void) {
|
||||
s32 sp64[0x10];
|
||||
s32 sp64[14];
|
||||
s32 var_r31;
|
||||
s32 var_r30;
|
||||
s32 temp_r29;
|
||||
|
|
@ -336,7 +329,7 @@ void BoardPlayerModelKill(void) {
|
|||
PlayerState* temp_r29;
|
||||
|
||||
for (var_r31 = 0; var_r31 < 4; var_r31++) {
|
||||
temp_r30 = GetPlayer(var_r31);
|
||||
temp_r30 = BoardPlayerGet(var_r31);
|
||||
if (boardPlayerMdl[temp_r30->player_idx] != -1) {
|
||||
BoardModelKill(boardPlayerMdl[temp_r30->player_idx]);
|
||||
boardPlayerMdl[temp_r30->player_idx] = -1;
|
||||
|
|
@ -350,22 +343,22 @@ void BoardPlayerModelKill(void) {
|
|||
}
|
||||
|
||||
void BoardPlayerLayerSet(s32 arg0, s32 arg1) {
|
||||
BoardModelLayerSet(GetBoardPlayer(arg0), arg1);
|
||||
BoardModelLayerSet(BoardPlayerModelGet(arg0), arg1);
|
||||
}
|
||||
|
||||
void BoardPlayerCameraSet(s32 arg0, u16 arg1) {
|
||||
BoardModelCameraSet(GetBoardPlayer(arg0), arg1);
|
||||
BoardModelCameraSet(BoardPlayerModelGet(arg0), arg1);
|
||||
}
|
||||
|
||||
void fn_80062A40(s32 arg0, f32 arg8) {
|
||||
fn_8006DDE8(GetBoardPlayer(arg0), arg8);
|
||||
fn_8006DDE8(BoardPlayerModelGet(arg0), arg8);
|
||||
}
|
||||
|
||||
void BoardPlayerExistCheck(s32 arg0, s32 arg1) {
|
||||
if (arg1 == 0) {
|
||||
BoardModelExistCheck(GetBoardPlayer(arg0), 0);
|
||||
BoardModelExistCheck(BoardPlayerModelGet(arg0), 0);
|
||||
} else {
|
||||
BoardModelExistCheck(GetBoardPlayer(arg0), 1);
|
||||
BoardModelExistCheck(BoardPlayerModelGet(arg0), 1);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -375,7 +368,7 @@ s32 BoardPlayerItemAdd(s32 arg0, s32 arg1) {
|
|||
s32 var_r31;
|
||||
|
||||
var_r29 = -1;
|
||||
var_r30 = GetPlayer(arg0);
|
||||
var_r30 = BoardPlayerGet(arg0);
|
||||
for (var_r31 = 0; var_r31 < 3; var_r31++) {
|
||||
if (GWPlayer[arg0].items[var_r31] == -1) {
|
||||
HuAudFXPlay(0x360);
|
||||
|
|
@ -392,7 +385,7 @@ s32 BoardPlayerItemRemove(s32 arg0, s32 arg1) {
|
|||
s32 temp_r29;
|
||||
PlayerState* temp_r28;
|
||||
|
||||
temp_r28 = GetPlayer(arg0);
|
||||
temp_r28 = BoardPlayerGet(arg0);
|
||||
temp_r29 = temp_r28->items[arg1];
|
||||
if (temp_r28->items[arg1] == -1) {
|
||||
return temp_r29;
|
||||
|
|
@ -464,15 +457,15 @@ void BoardPlayerCurrSpacePosDirGet(s32 arg0, Point3d* arg1) {
|
|||
}
|
||||
|
||||
void BoardPlayerAmbSet(s32 arg0, f32 arg8, f32 arg9, f32 argA) {
|
||||
BoardModelAmbSet(GetBoardPlayer(arg0), arg8, arg9, argA);
|
||||
BoardModelAmbSet(BoardPlayerModelGet(arg0), arg8, arg9, argA);
|
||||
}
|
||||
|
||||
void BoardPlayerMtxSet(s32 arg0, Mtx arg1) {
|
||||
BoardModelMtxSet(GetBoardPlayer(arg0), arg1);
|
||||
BoardModelMtxSet(BoardPlayerModelGet(arg0), arg1);
|
||||
}
|
||||
|
||||
void BoardPlayerPosSetV(s32 arg0, Vec* arg1) {
|
||||
BoardModelPosSetV(GetBoardPlayer(arg0), arg1);
|
||||
BoardModelPosSetV(BoardPlayerModelGet(arg0), arg1);
|
||||
|
||||
if (GWPlayer[arg0].bowser_suit != 0) {
|
||||
BoardModelPosSetV(suitMdl, arg1);
|
||||
|
|
@ -480,7 +473,7 @@ void BoardPlayerPosSetV(s32 arg0, Vec* arg1) {
|
|||
}
|
||||
|
||||
void BoardPlayerPosSet(s32 arg0, f32 arg8, f32 arg9, f32 argA) {
|
||||
BoardModelPosSet(GetBoardPlayer(arg0), arg8, arg9, argA);
|
||||
BoardModelPosSet(BoardPlayerModelGet(arg0), arg8, arg9, argA);
|
||||
|
||||
if (GWPlayer[arg0].bowser_suit != 0) {
|
||||
BoardModelPosSet(suitMdl, arg8, arg9, argA);
|
||||
|
|
@ -488,11 +481,11 @@ void BoardPlayerPosSet(s32 arg0, f32 arg8, f32 arg9, f32 argA) {
|
|||
}
|
||||
|
||||
void BoardPlayerPosGet(s32 arg0, Vec* arg1) {
|
||||
BoardModelPosGet(GetBoardPlayer(arg0), arg1);
|
||||
BoardModelPosGet(BoardPlayerModelGet(arg0), arg1);
|
||||
}
|
||||
|
||||
void BoardPlayerRotSetV(s32 arg0, Vec* arg1) {
|
||||
BoardModelRotSetV(GetBoardPlayer(arg0), arg1);
|
||||
BoardModelRotSetV(BoardPlayerModelGet(arg0), arg1);
|
||||
|
||||
if (GWPlayer[arg0].bowser_suit != 0) {
|
||||
BoardModelRotSetV(suitMdl, arg1);
|
||||
|
|
@ -500,7 +493,7 @@ void BoardPlayerRotSetV(s32 arg0, Vec* arg1) {
|
|||
}
|
||||
|
||||
void BoardPlayerRotSet(s32 arg0, f32 arg8, f32 arg9, f32 argA) {
|
||||
BoardModelRotSet(GetBoardPlayer(arg0), arg8, arg9, argA);
|
||||
BoardModelRotSet(BoardPlayerModelGet(arg0), arg8, arg9, argA);
|
||||
|
||||
if (GWPlayer[arg0].bowser_suit != 0) {
|
||||
BoardModelRotSet(suitMdl, arg8, arg9, argA);
|
||||
|
|
@ -508,7 +501,7 @@ void BoardPlayerRotSet(s32 arg0, f32 arg8, f32 arg9, f32 argA) {
|
|||
}
|
||||
|
||||
void BoardPlayerRotGet(s32 arg0, Vec* arg1) {
|
||||
BoardModelRotGet(GetBoardPlayer(arg0), arg1);
|
||||
BoardModelRotGet(BoardPlayerModelGet(arg0), arg1);
|
||||
}
|
||||
|
||||
void BoardPlayerRotYSet(s32 arg0, f32 arg8) {
|
||||
|
|
@ -518,7 +511,7 @@ void BoardPlayerRotYSet(s32 arg0, f32 arg8) {
|
|||
if (arg8 > 360.0f) {
|
||||
arg8 -= 360.0f;
|
||||
}
|
||||
BoardModelRotYSet(GetBoardPlayer(arg0), arg8);
|
||||
BoardModelRotYSet(BoardPlayerModelGet(arg0), arg8);
|
||||
if (GWPlayer[arg0].bowser_suit != 0) {
|
||||
BoardModelRotYSet(suitMdl, arg8);
|
||||
}
|
||||
|
|
@ -530,47 +523,47 @@ f32 BoardPlayerRotYGet(s32 arg0) {
|
|||
if (GWPlayer[arg0].bowser_suit != 0) {
|
||||
var_f31 = BoardModelRotYGet(suitMdl);
|
||||
} else {
|
||||
var_f31 = BoardModelRotYGet(GetBoardPlayer(arg0));
|
||||
var_f31 = BoardModelRotYGet(BoardPlayerModelGet(arg0));
|
||||
}
|
||||
return var_f31;
|
||||
}
|
||||
|
||||
void BoardPlayerScaleSetV(s32 arg0, Vec* arg1) {
|
||||
BoardModelScaleSetV(GetBoardPlayer(arg0), arg1);
|
||||
BoardModelScaleSetV(BoardPlayerModelGet(arg0), arg1);
|
||||
}
|
||||
|
||||
void BoardPlayerScaleSet(s32 arg0, f32 arg8, f32 arg9, f32 argA) {
|
||||
BoardModelScaleSet(GetBoardPlayer(arg0), arg8, arg9, argA);
|
||||
BoardModelScaleSet(BoardPlayerModelGet(arg0), arg8, arg9, argA);
|
||||
}
|
||||
|
||||
void BoardPlayerScaleGet(s32 arg0, s32 *arg1) {
|
||||
BoardModelScaleGet(GetBoardPlayer(arg0), arg1);
|
||||
BoardModelScaleGet(BoardPlayerModelGet(arg0), arg1);
|
||||
}
|
||||
|
||||
s16 BoardPlayerCurrMotionGet(s32 arg0) {
|
||||
PlayerState* player = GetPlayer(arg0);
|
||||
PlayerState* player = BoardPlayerGet(arg0);
|
||||
|
||||
return playerMot[player->player_idx];
|
||||
}
|
||||
|
||||
void BoardPlayerVoiceEnableSet(s32 arg0, s32 arg1, s32 arg2) {
|
||||
BoardModelVoiceEnableSet(GetBoardPlayer(arg0), arg1, arg2);
|
||||
BoardModelVoiceEnableSet(BoardPlayerModelGet(arg0), arg1, arg2);
|
||||
}
|
||||
|
||||
void BoardPlayerMotionCreate(s32 arg0, s32 arg1) {
|
||||
BoardModelMotionCreate(GetBoardPlayer(arg0), arg1);
|
||||
BoardModelMotionCreate(BoardPlayerModelGet(arg0), arg1);
|
||||
}
|
||||
|
||||
void BoardPlayerMotionKill(s32 arg0, s32 arg1) {
|
||||
BoardModelMotionKill(GetBoardPlayer(arg0), arg1);
|
||||
BoardModelMotionKill(BoardPlayerModelGet(arg0), arg1);
|
||||
}
|
||||
|
||||
void BoardPlayerMotionEndCheck(s32 arg0) {
|
||||
BoardModelMotionEndCheck(GetBoardPlayer(arg0));
|
||||
BoardModelMotionEndCheck(BoardPlayerModelGet(arg0));
|
||||
}
|
||||
|
||||
void BoardPlayerMotionEndWait(s32 arg0) {
|
||||
while (BoardModelMotionEndCheck(GetBoardPlayer(arg0)) == 0) {
|
||||
while (BoardModelMotionEndCheck(BoardPlayerModelGet(arg0)) == 0) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
}
|
||||
|
|
@ -579,11 +572,11 @@ void BoardPlayerMotionStart(s32 arg0, s32 arg1, s32 arg2) {
|
|||
PlayerState* player;
|
||||
s32 temp_r29;
|
||||
|
||||
player = GetPlayer(arg0);
|
||||
player = BoardPlayerGet(arg0);
|
||||
if (arg1 == 0) {
|
||||
}
|
||||
if (arg1 != playerMot[player->player_idx]) {
|
||||
temp_r29 = BoardModelMotionStart(GetBoardPlayer(arg0), arg1, arg2);
|
||||
temp_r29 = BoardModelMotionStart(BoardPlayerModelGet(arg0), arg1, arg2);
|
||||
if (temp_r29 == 0) {
|
||||
playerMot[player->player_idx] = arg1;
|
||||
}
|
||||
|
|
@ -594,11 +587,11 @@ void BoardPlayerMotionShiftSet(s32 arg0, s32 arg1, f32 arg8, f32 arg9, s32 arg2)
|
|||
PlayerState* player;
|
||||
s32 temp_r29;
|
||||
|
||||
player = GetPlayer(arg0);
|
||||
player = BoardPlayerGet(arg0);
|
||||
if (arg1 == 0) {
|
||||
}
|
||||
if (arg1 != playerMot[player->player_idx]) {
|
||||
temp_r29 = BoardModelMotionShiftSet(GetBoardPlayer(arg0), arg1, arg8, arg9, arg2);
|
||||
temp_r29 = BoardModelMotionShiftSet(BoardPlayerModelGet(arg0), arg1, arg8, arg9, arg2);
|
||||
if (temp_r29 == 0) {
|
||||
playerMot[player->player_idx] = arg1;
|
||||
}
|
||||
|
|
@ -606,31 +599,31 @@ void BoardPlayerMotionShiftSet(s32 arg0, s32 arg1, f32 arg8, f32 arg9, s32 arg2)
|
|||
}
|
||||
|
||||
void BoardPlayerMotionSpeedSet(s32 arg0, f32 arg8) {
|
||||
BoardModelMotionSpeedSet(GetBoardPlayer(arg0), arg8);
|
||||
BoardModelMotionSpeedSet(BoardPlayerModelGet(arg0), arg8);
|
||||
}
|
||||
|
||||
void BoardPlayerMotionTimeSet(s32 arg0, f32 arg8) {
|
||||
BoardModelMotionTimeSet(GetBoardPlayer(arg0), arg8);
|
||||
BoardModelMotionTimeSet(BoardPlayerModelGet(arg0), arg8);
|
||||
}
|
||||
|
||||
f32 BoardPlayerMotionTimeGet(s32 arg0) {
|
||||
BoardModelMotionTimeGet(GetBoardPlayer(arg0));
|
||||
BoardModelMotionTimeGet(BoardPlayerModelGet(arg0));
|
||||
}
|
||||
|
||||
f32 BoardPlayerMotionMaxTimeGet(s32 arg0) {
|
||||
BoardModelMotionMaxTimeGet(GetBoardPlayer(arg0));
|
||||
BoardModelMotionMaxTimeGet(BoardPlayerModelGet(arg0));
|
||||
}
|
||||
|
||||
void BoardPlayerMotionTimeRangeSet(s32 arg0, f32 arg8, f32 arg9) {
|
||||
BoardModelMotionTimeRangeSet(GetBoardPlayer(arg0), arg8, arg9);
|
||||
BoardModelMotionTimeRangeSet(BoardPlayerModelGet(arg0), arg8, arg9);
|
||||
}
|
||||
|
||||
void BoardPlayerModelAttrSet(s32 arg0, s32 arg1) {
|
||||
BoardModelAttrSet(GetBoardPlayer(arg0), arg1);
|
||||
BoardModelAttrSet(BoardPlayerModelGet(arg0), arg1);
|
||||
}
|
||||
|
||||
void BoardPlayerModelAttrReset(s32 arg0, s32 arg1) {
|
||||
BoardModelAttrReset(GetBoardPlayer(arg0), arg1);
|
||||
BoardModelAttrReset(BoardPlayerModelGet(arg0), arg1);
|
||||
}
|
||||
|
||||
void BoardPlayerCoinsSet(s32 arg0, s32 arg1) {
|
||||
|
|
@ -645,7 +638,7 @@ void BoardPlayerCoinsAdd(s32 arg0, s32 arg1) {
|
|||
PlayerState* player;
|
||||
s16 coins;
|
||||
|
||||
player = GetPlayer(arg0);
|
||||
player = BoardPlayerGet(arg0);
|
||||
if ((arg1 > 0) && (player->coins_total < 0x3E7)) {
|
||||
player->coins_total += arg1;
|
||||
if (player->coins_total > 0x3E7) {
|
||||
|
|
@ -663,7 +656,7 @@ void BoardPlayerSizeSet(s32 arg0, s32 arg1) {
|
|||
PlayerState* temp_r27;
|
||||
Vec temp_r4[3] = { { 1, 1, 1 }, { 0.3, 0.3, 0.3 }, { 2.5, 2.5, 2.5 } };
|
||||
|
||||
temp_r27 = GetPlayer(arg0);
|
||||
temp_r27 = BoardPlayerGet(arg0);
|
||||
temp_r27->size = arg1;
|
||||
if (arg1 == 2) {
|
||||
CharModelSetStepType(GWPlayer[arg0].character, 4);
|
||||
|
|
@ -672,13 +665,13 @@ void BoardPlayerSizeSet(s32 arg0, s32 arg1) {
|
|||
} else {
|
||||
CharModelSetStepType(GWPlayer[arg0].character, 0);
|
||||
}
|
||||
BoardModelScaleSetV(GetBoardPlayer(arg0), &temp_r4[arg1]);
|
||||
BoardModelScaleSetV(BoardPlayerModelGet(arg0), &temp_r4[arg1]);
|
||||
}
|
||||
|
||||
s32 BoardPlayerSizeGet(s32 arg0) {
|
||||
PlayerState* temp_r30;
|
||||
|
||||
temp_r30 = GetPlayer(arg0);
|
||||
temp_r30 = BoardPlayerGet(arg0);
|
||||
if (temp_r30 != 0) {
|
||||
arg0 = temp_r30->size;
|
||||
}
|
||||
|
|
@ -713,22 +706,22 @@ s32 BoardPlayerTeamFind(s32 arg0) {
|
|||
return var_r31;
|
||||
}
|
||||
|
||||
s32 BoardPlayerRankCalc(s32 arg0) {
|
||||
s32 temp_r29;
|
||||
s32 var_r30;
|
||||
s32 var_r31;
|
||||
s32 sp8[4];
|
||||
s32 BoardPlayerRankCalc(s32 player) {
|
||||
s32 coins;
|
||||
s32 rank;
|
||||
s32 i;
|
||||
s32 score[4];
|
||||
|
||||
for (var_r31 = 0; var_r31 < 4; var_r31++) {
|
||||
temp_r29 = GWCoinsGet(var_r31);
|
||||
sp8[var_r31] = temp_r29 | (GWStarsGet(var_r31) << 0xA);
|
||||
for (i = 0; i < 4; i++) {
|
||||
coins = GWCoinsGet(i);
|
||||
score[i] = coins | (GWStarsGet(i) << 0xA);
|
||||
}
|
||||
for (var_r30 = 0, var_r31 = 0; var_r31 < 4; var_r31++) {
|
||||
if ((var_r31 != arg0) && (sp8[arg0] < sp8[var_r31])) {
|
||||
var_r30++;
|
||||
for (rank = 0, i = 0; i < 4; i++) {
|
||||
if ((i != player) && (score[player] < score[i])) {
|
||||
rank++;
|
||||
}
|
||||
}
|
||||
return var_r30;
|
||||
return rank;
|
||||
}
|
||||
|
||||
void BoardPlayerPreTurnHookSet(s32 arg0, s32 (*arg1)()) {
|
||||
|
|
@ -930,12 +923,12 @@ void BoardPlayerSizeRestore(s32 arg0) {
|
|||
s32 var_r28;
|
||||
s32 var_r27;
|
||||
|
||||
temp_r24 = GetPlayer(arg0);
|
||||
temp_r24 = BoardPlayerGet(arg0);
|
||||
if (temp_r24 != 0) {
|
||||
var_r28 = temp_r24->size;
|
||||
}
|
||||
if (var_r28 != 0) {
|
||||
temp_r23 = GetPlayer(arg0);
|
||||
temp_r23 = BoardPlayerGet(arg0);
|
||||
if (temp_r23 != 0) {
|
||||
var_r27 = temp_r23->size;
|
||||
}
|
||||
|
|
@ -962,8 +955,8 @@ void BoardPlayerZoomRestore(s32 arg0) {
|
|||
Vec sp18;
|
||||
Vec spC;
|
||||
|
||||
sp8 = GetPlayer(arg0);
|
||||
BoardModelPosGet(GetBoardPlayer(arg0), &spC);
|
||||
sp8 = BoardPlayerGet(arg0);
|
||||
BoardModelPosGet(BoardPlayerModelGet(arg0), &spC);
|
||||
temp_r27 = GWPlayer[arg0].space_curr;
|
||||
var_r31 = GWSystem.player_curr;
|
||||
if (var_r31 == -1) {
|
||||
|
|
|
|||
589
src/game/board/space.c
Normal file
589
src/game/board/space.c
Normal file
|
|
@ -0,0 +1,589 @@
|
|||
#include "game/gamework_data.h"
|
||||
#include "game/flag.h"
|
||||
#include "game/board/main.h"
|
||||
#include "game/board/space.h"
|
||||
|
||||
#include "math.h"
|
||||
|
||||
extern s16 BoardStarHostMdlGet(void);
|
||||
extern void BoardModelPosSetV(s16 model, Vec *pos);
|
||||
|
||||
|
||||
static GXTexObj spaceHiliteTex;
|
||||
static GXTexObj spaceTex;
|
||||
s16 boardSpaceStarTbl[8];
|
||||
static BoardSpace spaceData[2][256];
|
||||
|
||||
static s16 spaceCnt[2];
|
||||
static u32 spaceAttr[2];
|
||||
static void *spaceTexData;
|
||||
static void *spaceHiliteTexData;
|
||||
static GXTexFmt spaceTexFmt;
|
||||
static GXTexFmt spaceHiliteTexFmt;
|
||||
s16 lbl_801D3FC4[4];
|
||||
static BoardSpaceEventFunc landEventFunc;
|
||||
static BoardSpaceEventFunc walkMiniEventFunc;
|
||||
static BoardSpaceEventFunc walkEventFunc;
|
||||
static s32 spaceDrawCnt;
|
||||
static s16 spaceDrawF;
|
||||
|
||||
static s16 spaceDrawMdl = -1;
|
||||
static s16 starMdl = -1;
|
||||
|
||||
s32 BoardSpaceRotGet(s32 layer, s32 index, Vec *rot);
|
||||
s32 BoardSpaceStarGet(s32 index);
|
||||
s32 BoardSpaceStarGetCurr(void);
|
||||
|
||||
void BoardSpaceWalkEventFuncSet(BoardSpaceEventFunc func)
|
||||
{
|
||||
walkEventFunc = func;
|
||||
}
|
||||
|
||||
void BoardSpaceWalkMiniEventFuncSet(BoardSpaceEventFunc func)
|
||||
{
|
||||
walkMiniEventFunc = func;
|
||||
}
|
||||
|
||||
void BoardSpaceLandEventFuncSet(BoardSpaceEventFunc func)
|
||||
{
|
||||
landEventFunc = func;
|
||||
}
|
||||
|
||||
s32 BoardSpaceWalkEventExec(void)
|
||||
{
|
||||
s32 ret = -1;
|
||||
if(walkEventFunc) {
|
||||
ret = walkEventFunc();
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
s32 BoardSpaceWalkMiniEventExec(void)
|
||||
{
|
||||
s32 ret = -1;
|
||||
if(walkMiniEventFunc) {
|
||||
_SetFlag(FLAG_ID_MAKE(1, 8));
|
||||
ret = walkMiniEventFunc();
|
||||
_ClearFlag(FLAG_ID_MAKE(1, 8));
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
s16 BoardSpaceCountGet(s32 layer)
|
||||
{
|
||||
return spaceCnt[layer];
|
||||
}
|
||||
|
||||
BoardSpace *BoardSpaceGet(s32 layer, s32 index)
|
||||
{
|
||||
if(index <= 0 || index > spaceCnt[layer]) {
|
||||
return NULL;
|
||||
} else {
|
||||
return &spaceData[layer][index-1];
|
||||
}
|
||||
}
|
||||
|
||||
void BoardSpaceAttrSet(s32 layer, u32 attr)
|
||||
{
|
||||
spaceAttr[layer] |= attr;
|
||||
}
|
||||
|
||||
void BoardSpaceAttrReset(s32 layer, u32 attr)
|
||||
{
|
||||
spaceAttr[layer] &= ~attr;
|
||||
}
|
||||
|
||||
u32 BoardSpaceFlagGet(s32 layer, s32 index)
|
||||
{
|
||||
if(index <= 0 || index > spaceCnt[layer]) {
|
||||
return 0;
|
||||
} else {
|
||||
return spaceData[layer][index-1].flag;
|
||||
}
|
||||
}
|
||||
|
||||
s32 BoardSpaceTypeGet(s32 layer, s32 index)
|
||||
{
|
||||
if(index <= 0 || index > spaceCnt[layer]) {
|
||||
return 0;
|
||||
} else {
|
||||
return spaceData[layer][index-1].type;
|
||||
}
|
||||
}
|
||||
|
||||
void BoardSpaceTypeSet(s32 layer, s32 index, s32 type)
|
||||
{
|
||||
if(index <= 0 || index > spaceCnt[layer]) {
|
||||
return;
|
||||
} else {
|
||||
spaceData[layer][index-1].type = type;
|
||||
}
|
||||
}
|
||||
|
||||
s32 BoardSpacePosGet(s32 layer, s32 index, Vec *pos)
|
||||
{
|
||||
BoardSpace *space = BoardSpaceGet(layer, index);
|
||||
if(!space) {
|
||||
return -1;
|
||||
} else {
|
||||
*pos = space->pos;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
void BoardSpaceCornerPosGet(s32 index, s32 corner, Vec *pos)
|
||||
{
|
||||
Vec corner_ofs;
|
||||
Vec rot;
|
||||
s8 corner_pos[4][2] = {{-1, -1}, {1, -1}, {-1, 1}, {1, 1}};
|
||||
BoardSpaceRotGet(0, index, &rot);
|
||||
BoardSpacePosGet(0, index, pos);
|
||||
corner_ofs.x = corner_pos[corner][0]*80.0f;
|
||||
corner_ofs.y = 0;
|
||||
corner_ofs.z = corner_pos[corner][1]*80.0f;
|
||||
corner_ofs.x = (cos((M_PI*rot.z)/180)*corner_ofs.x)+(sin((M_PI*rot.z)/180)*corner_ofs.y);
|
||||
corner_ofs.y = (cos((M_PI*rot.x)/180)*cos((M_PI*rot.z)/180)*corner_ofs.y)
|
||||
+(sin((M_PI*rot.z)/180)*corner_ofs.x)
|
||||
+(sin((M_PI*-rot.x)/180)*corner_ofs.z);
|
||||
corner_ofs.z = (sin((M_PI*rot.x)/180)*corner_ofs.y)+(cos((M_PI*rot.x)/180)*corner_ofs.z);
|
||||
pos->x += corner_ofs.x;
|
||||
pos->y += corner_ofs.y;
|
||||
pos->z += corner_ofs.z;
|
||||
}
|
||||
|
||||
s32 BoardSpaceRotGet(s32 layer, s32 index, Vec *rot)
|
||||
{
|
||||
BoardSpace *space = BoardSpaceGet(layer, index);
|
||||
if(!space) {
|
||||
return -1;
|
||||
} else {
|
||||
*rot = space->rot;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
s32 BoardSpaceFlagSearch(s32 layer, u32 flag)
|
||||
{
|
||||
s32 i;
|
||||
for(i=0; i<spaceCnt[layer]; i++) {
|
||||
BoardSpace *space = &spaceData[layer][i];
|
||||
if((space->flag & flag) == flag) {
|
||||
return space-(&spaceData[layer][0])+1;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
s32 BoardSpaceFlagPosGet(s32 layer, u32 flag, Vec *pos)
|
||||
{
|
||||
s32 space = BoardSpaceFlagSearch(layer, flag);
|
||||
if(space == -1) {
|
||||
return -1;
|
||||
}
|
||||
if(pos) {
|
||||
BoardSpacePosGet(layer, space, pos);
|
||||
}
|
||||
return space;
|
||||
}
|
||||
|
||||
s32 BoardSpaceLinkFlagSearch(s32 layer, s32 index, u32 flag)
|
||||
{
|
||||
BoardSpace *link_space;
|
||||
BoardSpace *space = BoardSpaceGet(layer, index);
|
||||
s32 i;
|
||||
if(!space) {
|
||||
return -1;
|
||||
}
|
||||
for(i=0; i<space->link_cnt; i++) {
|
||||
link_space = BoardSpaceGet(layer, space->link[i]);
|
||||
if(link_space->flag & flag) {
|
||||
return link_space-&spaceData[layer][0]+1;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
s32 BoardSpaceLinkTypeListGet(s32 layer, s32 index, s32 type, s16 *list)
|
||||
{
|
||||
s32 count;
|
||||
BoardSpace *space = BoardSpaceGet(layer, index);
|
||||
s32 i;
|
||||
if(!space) {
|
||||
return -1;
|
||||
}
|
||||
for(count=i=0; i<space->link_cnt; i++) {
|
||||
BoardSpace *link_space = BoardSpaceGet(layer, space->link[i]);
|
||||
if(link_space->type == type && count < BOARD_SPACE_LINKMAX) {
|
||||
list[count] = link_space-&spaceData[layer][0]+1;
|
||||
count++;
|
||||
}
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
s32 BoardSpaceLinkTargetListGet(s32 layer, s32 target, s16 *list)
|
||||
{
|
||||
s32 i, j;
|
||||
s32 count;
|
||||
BoardSpace *space;
|
||||
memset(list, 0, BOARD_SPACE_LINKMAX*sizeof(s16));
|
||||
space = &spaceData[layer][0];
|
||||
for(count=i=0; i<spaceCnt[layer]; i++, space++) {
|
||||
for(j=0; j<space->link_cnt; j++) {
|
||||
if(space->link[j] == target && count < BOARD_SPACE_LINKMAX) {
|
||||
list[count++] = space-&spaceData[layer][0]+1;
|
||||
}
|
||||
}
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
s32 BoardSpaceLinkTypeSearch(s32 layer, s32 target, u16 type)
|
||||
{
|
||||
s32 i;
|
||||
BoardSpace *space = BoardSpaceGet(layer, target);
|
||||
if(!space) {
|
||||
return -1;
|
||||
}
|
||||
for(i=0; i<space->link_cnt; i++) {
|
||||
BoardSpace *link_space = BoardSpaceGet(layer, space->link[i]);
|
||||
if(link_space->type == type) {
|
||||
return space->link[i];
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
s32 BoardSpaceLinkTransformGet(s32 flag, Vec *pos, Vec *rot, Vec *scale)
|
||||
{
|
||||
s32 i;
|
||||
s32 space_flag = BoardSpaceFlagSearch(0, flag);
|
||||
BoardSpace *space = BoardSpaceGet(0, space_flag);
|
||||
|
||||
for(i=0; i<space->link_cnt; i++) {
|
||||
BoardSpace *link_space = BoardSpaceGet(0, space->link[i]);
|
||||
BoardSpace *src_space;
|
||||
if(!(link_space->flag & 0x2000000)) {
|
||||
continue;
|
||||
}
|
||||
src_space = BoardSpaceGet(0, link_space->link[0]);
|
||||
if(pos) {
|
||||
*pos = src_space->pos;
|
||||
}
|
||||
if(rot) {
|
||||
*rot = src_space->rot;
|
||||
}
|
||||
if(scale) {
|
||||
*scale = src_space->scale;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
void BoardSpaceStarSet(s32 space)
|
||||
{
|
||||
s16 host_space;
|
||||
Vec pos;
|
||||
BoardSpace *space_plat;
|
||||
BoardSpaceTypeSet(0, space, 8);
|
||||
host_space = BoardSpaceLinkFlagSearch(0, space, 0x04000000);
|
||||
BoardSpacePosGet(0, host_space, &pos);
|
||||
BoardModelPosSetV(BoardStarHostMdlGet(), &pos);
|
||||
}
|
||||
|
||||
static inline s16 BoardStarMdlGet(void)
|
||||
{
|
||||
return starMdl;
|
||||
}
|
||||
|
||||
static inline s32 BoardStarSpaceTypeGet(s16 index)
|
||||
{
|
||||
return BoardSpaceTypeGet(0, BoardSpaceStarGet(index));
|
||||
}
|
||||
|
||||
void BoardSpaceStarSetIndex(s32 index)
|
||||
{
|
||||
Vec pos;
|
||||
Vec rot;
|
||||
s16 space;
|
||||
if(_CheckFlag(FLAG_ID_MAKE(1, 1))) {
|
||||
BoardSpaceTypeSet(0, boardSpaceStarTbl[GWSystem.star_pos], 1);
|
||||
}
|
||||
GWSystem.star_pos = index & 0x7;
|
||||
BoardSpaceStarSet(BoardSpaceStarGetCurr());
|
||||
space = BoardSpaceLinkFlagSearch(0, BoardSpaceStarGetCurr(), 0x04000000);
|
||||
BoardSpacePosGet(0, space, &pos);
|
||||
BoardModelPosSetV(BoardStarMdlGet(), &pos);
|
||||
BoardSpaceRotGet(0, space, &rot);
|
||||
BoardModelRotYSet(BoardStarMdlGet(), rot.y);
|
||||
BoardModelVisibilitySet(BoardStarMdlGet(), 1);
|
||||
}
|
||||
|
||||
s32 BoardSpaceStarGetNext(void)
|
||||
{
|
||||
s16 random_pos;
|
||||
s16 star_total;
|
||||
s16 star_pos;
|
||||
star_total = GWSystem.star_total;
|
||||
star_pos = GWSystem.star_pos;
|
||||
if(BoardCurrGet() == 5) {
|
||||
s16 i;
|
||||
s32 count;
|
||||
s32 last_free;
|
||||
last_free = -1;
|
||||
for(count=i=0; i<8; i++) {
|
||||
if((1 << i) & GWSystem.star_flag) {
|
||||
count++;
|
||||
} else {
|
||||
last_free = i;
|
||||
}
|
||||
}
|
||||
if(count == 7) {
|
||||
if(BoardSpaceTypeGet(0, BoardSpaceStarGet(last_free)) == 10) {
|
||||
GWSystem.star_flag = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
begin:
|
||||
random_pos = BoardRandMod(8);
|
||||
if(star_pos == random_pos || BoardStarSpaceTypeGet(random_pos) == 10) {
|
||||
goto begin;
|
||||
}
|
||||
switch(GWSystem.board) {
|
||||
case 0:
|
||||
if(star_total >= 2) {
|
||||
break;
|
||||
}
|
||||
if(random_pos != 6 && random_pos != 7) {
|
||||
break;
|
||||
}
|
||||
goto begin;
|
||||
|
||||
case 1:
|
||||
if(star_total >= 2) {
|
||||
break;
|
||||
}
|
||||
if(random_pos != 6 && random_pos != 7) {
|
||||
break;
|
||||
}
|
||||
goto begin;
|
||||
|
||||
case 2:
|
||||
if(star_total == 1) {
|
||||
if(random_pos < 3 || random_pos > 5) {
|
||||
break;
|
||||
}
|
||||
goto begin;
|
||||
} else {
|
||||
if(star_total != 2) {
|
||||
break;
|
||||
}
|
||||
if(random_pos != 3 && random_pos != 4) {
|
||||
break;
|
||||
}
|
||||
goto begin;
|
||||
}
|
||||
|
||||
case 3:
|
||||
if(star_total == 1) {
|
||||
if(random_pos < 5 || random_pos > 7) {
|
||||
break;
|
||||
}
|
||||
goto begin;
|
||||
} else {
|
||||
if(star_total != 2) {
|
||||
break;
|
||||
}
|
||||
if(random_pos == 5) {
|
||||
goto begin;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
case 4:
|
||||
if(star_total == 1) {
|
||||
if(random_pos <= 1 || random_pos >= 4) {
|
||||
goto begin;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case 5:
|
||||
if(star_total == 1) {
|
||||
if(random_pos == 1 || random_pos == 4 || random_pos == 5) {
|
||||
goto begin;
|
||||
}
|
||||
}
|
||||
if(star_total != 2) {
|
||||
break;
|
||||
}
|
||||
if(random_pos == 5) {
|
||||
goto begin;
|
||||
}
|
||||
}
|
||||
if((1 << random_pos) & GWSystem.star_flag) {
|
||||
goto begin;
|
||||
}
|
||||
return random_pos;
|
||||
}
|
||||
|
||||
s32 BoardSpaceStarGetRandom(s32 excl_pos)
|
||||
{
|
||||
s8 new_pos;
|
||||
int i;
|
||||
for(i=0; i<1024; i++) {
|
||||
new_pos = BoardRandMod(8);
|
||||
if(new_pos == GWSystem.star_pos) {
|
||||
continue;
|
||||
}
|
||||
if(GWSystem.turn == 1 && new_pos <= 2) {
|
||||
continue;
|
||||
}
|
||||
if(new_pos != excl_pos) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
return new_pos;
|
||||
}
|
||||
|
||||
void BoardSpaceStarMove(void)
|
||||
{
|
||||
u8 star_total;
|
||||
s16 star_pos;
|
||||
s16 star_next;
|
||||
if(_CheckFlag(FLAG_ID_MAKE(1, 1))) {
|
||||
star_pos = GWSystem.star_pos;
|
||||
GWSystem.star_flag |= (u8)(1 << star_pos);
|
||||
if(GWSystem.star_flag == 0xFF) {
|
||||
GWSystem.star_flag = 0;
|
||||
}
|
||||
if(GWSystem.star_total >= 99) {
|
||||
star_total = 99;
|
||||
GWSystem.star_total = star_total;
|
||||
} else {
|
||||
star_total = GWSystem.star_total++;
|
||||
}
|
||||
}
|
||||
star_next = BoardSpaceStarGetNext();
|
||||
BoardSpaceStarSetIndex(star_next);
|
||||
}
|
||||
|
||||
s32 BoardSpaceStarGet(s32 index)
|
||||
{
|
||||
return boardSpaceStarTbl[index & 0x7];
|
||||
}
|
||||
|
||||
s32 BoardSpaceStarGetCurr(void)
|
||||
{
|
||||
return BoardSpaceStarGet(GWSystem.star_pos);
|
||||
}
|
||||
|
||||
s32 BoardSpaceStarCheck(s32 index)
|
||||
{
|
||||
s32 ret;
|
||||
BoardSpace *space = BoardSpaceGet(0, index);
|
||||
BoardSpace *star_space;
|
||||
if(BoardCurrGet() == 7 || BoardCurrGet() == 8) {
|
||||
ret = 0;
|
||||
goto end;
|
||||
}
|
||||
star_space = BoardSpaceGet(0, boardSpaceStarTbl[GWSystem.star_pos]);
|
||||
if(space == star_space) {
|
||||
ret = 1;
|
||||
} else {
|
||||
ret = 0;
|
||||
}
|
||||
end:
|
||||
return ret;
|
||||
}
|
||||
|
||||
void BoardSpaceLandExec(s32 player, s32 space)
|
||||
{
|
||||
BoardSpace *space_ptr = BoardSpaceGet(0, space);
|
||||
switch(space_ptr->type) {
|
||||
case 1:
|
||||
GWPlayer[player].blue_count++;
|
||||
if(GWPlayer[player].blue_count > 99) {
|
||||
GWPlayer[player].blue_count = 99;
|
||||
}
|
||||
BoardLandBlueExec(player, space);
|
||||
break;
|
||||
|
||||
case 2:
|
||||
GWPlayer[player].red_count++;
|
||||
if(GWPlayer[player].red_count > 99) {
|
||||
GWPlayer[player].red_count = 99;
|
||||
}
|
||||
BoardLandRedExec(player, space);
|
||||
break;
|
||||
|
||||
case 3:
|
||||
GWPlayer[player].bowser_count++;
|
||||
if(GWPlayer[player].bowser_count > 99) {
|
||||
GWPlayer[player].bowser_count = 99;
|
||||
}
|
||||
BoardBowserExec(player, space);
|
||||
break;
|
||||
|
||||
case 4:
|
||||
GWPlayer[player].mushroom_count++;
|
||||
if(GWPlayer[player].mushroom_count > 99) {
|
||||
GWPlayer[player].mushroom_count = 99;
|
||||
}
|
||||
BoardMushroomExec(player, space);
|
||||
break;
|
||||
|
||||
case 5:
|
||||
GWPlayer[player].battle_count++;
|
||||
if(GWPlayer[player].battle_count > 99) {
|
||||
GWPlayer[player].battle_count = 99;
|
||||
}
|
||||
BoardBattleExec(player, space);
|
||||
break;
|
||||
|
||||
case 6:
|
||||
GWPlayer[player].question_count++;
|
||||
if(GWPlayer[player].question_count > 99) {
|
||||
GWPlayer[player].question_count = 99;
|
||||
}
|
||||
if(_CheckFlag(FLAG_ID_MAKE(1, 11))) {
|
||||
HuAudFXPlay(842);
|
||||
BoardCameraViewSet(2);
|
||||
BoardPlayerAnimBlendSet(player, 0, 15);
|
||||
while(!BoardPlayerAnimBlendCheck(player)) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
BoardCameraMotionWait();
|
||||
BoardTutorialHookExec(16, 0);
|
||||
} else {
|
||||
if(landEventFunc) {
|
||||
HuAudFXPlay(842);
|
||||
omVibrate(player, 12, 4, 2);
|
||||
landEventFunc();
|
||||
}
|
||||
}
|
||||
GWPlayer[player].color = 3;
|
||||
break;
|
||||
|
||||
case 7:
|
||||
GWPlayer[player].fortune_count++;
|
||||
if(GWPlayer[player].fortune_count > 99) {
|
||||
GWPlayer[player].fortune_count = 99;
|
||||
}
|
||||
BoardFortuneExec(player, space);
|
||||
break;
|
||||
|
||||
case 9:
|
||||
GWPlayer[player].warp_count++;
|
||||
if(GWPlayer[player].warp_count > 99) {
|
||||
GWPlayer[player].warp_count = 99;
|
||||
}
|
||||
BoardWarpExec(player, space);
|
||||
break;
|
||||
|
||||
case 8:
|
||||
BoardStarExec(player, space);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
@ -1,4 +1,18 @@
|
|||
#include "game/board/warp.h"
|
||||
#include "game/board/main.h"
|
||||
#include "game/board/player.h"
|
||||
#include "game/wipe.h"
|
||||
#include "game/gamework_data.h"
|
||||
#include "board_unsplit.h"
|
||||
#include "unsplit.h"
|
||||
#include "math.h"
|
||||
|
||||
static void WarpInit(s32);
|
||||
static void WarpLaunch(s32);
|
||||
static void WarpStartImpact(s32);
|
||||
static void WarpFall(s32);
|
||||
static void WarpImpact(s32);
|
||||
|
||||
|
||||
extern void omVibrate(s16, s16, s16, s16);
|
||||
extern void fn_800816CC(s32, s32);
|
||||
|
|
@ -12,102 +26,94 @@ extern void BoardPlayerPosSet(s32, f32, f32, f32);
|
|||
extern void BoardPlayerRotYSet(s32, f32);
|
||||
extern void Hu3DModelObjPosGet(s16, char*, Vec*);
|
||||
extern s32 BoardModelMotionEndCheck(s16);
|
||||
extern void BoardPlayerPosSetV(s32, Point3d*);
|
||||
void BoardPlayerRotSet(s32, f32, f32, f32);
|
||||
void BoardCameraMoveSet(s32);
|
||||
void BoardCameraTargetSpaceSet(s16);
|
||||
extern void BoardRotateDiceNumbers(s32);
|
||||
extern void BoardPlayerPosGet(s32, Vec*);
|
||||
void BoardPlayerMotionStart(s16, s32, s32);
|
||||
|
||||
extern Process* boardMainProc;
|
||||
extern s32 boardTutorialData[4];
|
||||
extern s16 boardPlayerMdl[4];
|
||||
|
||||
Vec lbl_801A4AC0;
|
||||
static Vec warpPos;
|
||||
|
||||
s8 lbl_801D4038;
|
||||
s8 lbl_801D4037;
|
||||
s8 lbl_801D4036;
|
||||
s16 lbl_801D4034;
|
||||
f32 lbl_801D4030;
|
||||
f32 lbl_801D402C;
|
||||
Process* lbl_801D4028;
|
||||
static s8 warpState;
|
||||
static s8 warpTarget;
|
||||
static s8 warpImpactCnt;
|
||||
static s16 warpSpace;
|
||||
static f32 warpYFloor;
|
||||
static f32 warpYVel;
|
||||
static Process* warpProcess;
|
||||
|
||||
s16 lbl_801D3748 = 0xFFFF;
|
||||
s16 lbl_801D374A = 0xFFFF;
|
||||
s8 lbl_801D374C[4] = {-1, -1, -1, -1};
|
||||
char lbl_801D3750[] = "warp01";
|
||||
static s16 warpSpringMdl = -1;
|
||||
static s16 warpImpactMdl = -1;
|
||||
static s8 warpImpactPlayer[4] = {-1, -1, -1, -1};
|
||||
|
||||
void fn_80080D54(s32 arg0) {
|
||||
omVibrate(arg0, 0xC, 4, 2);
|
||||
lbl_801D4028 = HuPrcChildCreate(fn_80080DF8, 0x2003U, 0x3800U, 0, boardMainProc);
|
||||
HuPrcDestructorSet2(lbl_801D4028, fn_80081048);
|
||||
static void WarpProcess(void);
|
||||
static void WarpKill(void);
|
||||
|
||||
while (lbl_801D4028 != NULL) {
|
||||
void BoardWarpExec(s32 player, s16 space) {
|
||||
omVibrate(player, 12, 4, 2);
|
||||
warpProcess = HuPrcChildCreate(WarpProcess, 8195, 14336, 0, boardMainProc);
|
||||
HuPrcDestructorSet2(warpProcess, WarpKill);
|
||||
|
||||
while (warpProcess != NULL) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
GWPlayer[arg0].color = 3;
|
||||
GWPlayer[player].color = 3;
|
||||
}
|
||||
|
||||
void fn_80080DF8(void) {
|
||||
s32 currPlayer;
|
||||
f32 var_f1;
|
||||
s32 temp_r3[8] = {291, 355, 419, 483, 547, 611, 675, 739};
|
||||
void WarpProcess(void) {
|
||||
s32 curr_player;
|
||||
s32 warp_sound[8] = {291, 355, 419, 483, 547, 611, 675, 739};
|
||||
|
||||
lbl_801D4038 = 0;
|
||||
currPlayer = GWSystem.player_curr;
|
||||
HuAudFXPlay(0x34A);
|
||||
warpState = 0;
|
||||
curr_player = GWSystem.player_curr;
|
||||
HuAudFXPlay(842);
|
||||
BoardCameraViewSet(3);
|
||||
BoardCameraMotionWait();
|
||||
BoardPlayerAnimBlendSet(currPlayer, 0, 15);
|
||||
BoardPlayerAnimBlendSet(curr_player, 0, 15);
|
||||
|
||||
while (BoardPlayerAnimBlendCheck(currPlayer) == 0) {
|
||||
while (BoardPlayerAnimBlendCheck(curr_player) == 0) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
|
||||
BoardRotateDiceNumbers(currPlayer);
|
||||
BoardRotateDiceNumbers(curr_player);
|
||||
if (_CheckFlag(0x1000B) != 0) {
|
||||
BoardTutorialHookExec(0x12, 0);
|
||||
BoardTutorialHookExec(18, 0);
|
||||
boardTutorialData[0] = 0;
|
||||
}
|
||||
fn_800816CC(currPlayer, 3);
|
||||
fn_800816CC(curr_player, 3);
|
||||
fn_80081884(18.0f);
|
||||
fn_8008181C();
|
||||
lbl_801D4037 = fn_8008186C();
|
||||
warpTarget = fn_8008186C();
|
||||
BoardCameraViewSet(1);
|
||||
BoardCameraMotionWait();
|
||||
fn_800810A4(currPlayer);
|
||||
WarpInit(curr_player);
|
||||
|
||||
while (1) {
|
||||
switch (lbl_801D4038) {
|
||||
switch (warpState) {
|
||||
case 0:
|
||||
if (BoardModelMotionTimeGet(lbl_801D3748) < 15.0f) {
|
||||
if (BoardModelMotionTimeGet(warpSpringMdl) < 15.0f) {
|
||||
break;
|
||||
}
|
||||
BoardModelHookReset(lbl_801D3748);
|
||||
Hu3DModelObjPosGet(BoardModelIDGet(lbl_801D3748), lbl_801D3750, &lbl_801A4AC0);
|
||||
BoardSpacePosGet(0, GWPlayer[currPlayer].space_curr, &lbl_801A4AC0);
|
||||
lbl_801A4AC0.y += 700.0f;
|
||||
BoardPlayerPosSetV(currPlayer, &lbl_801A4AC0);
|
||||
lbl_801D4038 = 1;
|
||||
HuAudFXPlay(temp_r3[GWPlayer[currPlayer].character]);
|
||||
BoardModelHookReset(warpSpringMdl);
|
||||
Hu3DModelObjPosGet(BoardModelIDGet(warpSpringMdl), "warp01", &warpPos);
|
||||
BoardSpacePosGet(0, GWPlayer[curr_player].space_curr, &warpPos);
|
||||
warpPos.y += 700.0f;
|
||||
BoardPlayerPosSetV(curr_player, &warpPos);
|
||||
warpState = 1;
|
||||
HuAudFXPlay(warp_sound[GWPlayer[curr_player].character]);
|
||||
break;
|
||||
case 1:
|
||||
fn_800811BC(currPlayer);
|
||||
WarpLaunch(curr_player);
|
||||
break;
|
||||
case 2:
|
||||
if (BoardModelMotionEndCheck(lbl_801D3748) == 0) break;
|
||||
lbl_801D4038 = 6;
|
||||
if (BoardModelMotionEndCheck(warpSpringMdl) == 0) break;
|
||||
warpState = 6;
|
||||
break;
|
||||
case 3:
|
||||
fn_80081278(currPlayer);
|
||||
WarpStartImpact(curr_player);
|
||||
break;
|
||||
case 4:
|
||||
fn_80081428(currPlayer);
|
||||
WarpFall(curr_player);
|
||||
break;
|
||||
case 5:
|
||||
fn_800814CC(currPlayer);
|
||||
WarpImpact(curr_player);
|
||||
break;
|
||||
case 6:
|
||||
HuPrcEnd();
|
||||
|
|
@ -117,147 +123,135 @@ void fn_80080DF8(void) {
|
|||
}
|
||||
}
|
||||
|
||||
void fn_80081048(void) {
|
||||
if (lbl_801D3748 != -1) {
|
||||
BoardModelKill(lbl_801D3748);
|
||||
lbl_801D3748 = -1;
|
||||
void WarpKill(void) {
|
||||
if (warpSpringMdl != -1) {
|
||||
BoardModelKill(warpSpringMdl);
|
||||
warpSpringMdl = -1;
|
||||
}
|
||||
if (lbl_801D374A != -1) {
|
||||
BoardModelKill(lbl_801D374A);
|
||||
lbl_801D374A = -1;
|
||||
if (warpImpactMdl != -1) {
|
||||
BoardModelKill(warpImpactMdl);
|
||||
warpImpactMdl = -1;
|
||||
}
|
||||
lbl_801D4028 = NULL;
|
||||
warpProcess = NULL;
|
||||
}
|
||||
|
||||
static inline PlayerState* GetPlayer(s32 index) {
|
||||
return &GWPlayer[index];
|
||||
static void WarpInit(s32 player) {
|
||||
Vec pos;
|
||||
s16 player_mdl = BoardPlayerModelGet(player);
|
||||
|
||||
warpSpringMdl = BoardModelCreate(MAKE_DATA_NUM(DATADIR_BOARD, 1), NULL, 0);
|
||||
BoardSpacePosGet(0, GWPlayer[player].space_curr, &pos);
|
||||
warpYFloor = 1500.0f + pos.y;
|
||||
BoardModelLayerSet(warpSpringMdl, 2);
|
||||
BoardCameraTargetModelSet(warpSpringMdl);
|
||||
BoardModelMotionStart(warpSpringMdl, 0, 0);
|
||||
BoardModelHookSet(warpSpringMdl, "warp01", player_mdl);
|
||||
BoardModelPosSetV(warpSpringMdl, &pos);
|
||||
HuAudFXPlay(835);
|
||||
BoardPlayerRotYSet(player, 0.0f);
|
||||
BoardPlayerPosSet(player, 0.0f, 0.0f, 0.0f);
|
||||
BoardRotateDiceNumbers(player);
|
||||
}
|
||||
|
||||
static inline s16 GetBoardPlayer(s32 index) {
|
||||
PlayerState *player = GetPlayer(index);
|
||||
return boardPlayerMdl[player->player_idx];
|
||||
}
|
||||
static void WarpLaunch(s32 player) {
|
||||
|
||||
void fn_800810A4(s32 arg0) {
|
||||
Point3d sp8;
|
||||
s16 temp_r30 = GetBoardPlayer(arg0);
|
||||
|
||||
lbl_801D3748 = BoardModelCreate(0x70001, NULL, 0);
|
||||
BoardSpacePosGet(0, GWPlayer[arg0].space_curr, &sp8);
|
||||
lbl_801D4030 = 1500.0f + sp8.y;
|
||||
BoardModelLayerSet(lbl_801D3748, 2);
|
||||
BoardCameraTargetModelSet(lbl_801D3748);
|
||||
BoardModelMotionStart(lbl_801D3748, 0, 0);
|
||||
BoardModelHookSet(lbl_801D3748, lbl_801D3750, temp_r30);
|
||||
BoardModelPosSetV(lbl_801D3748, &sp8);
|
||||
HuAudFXPlay(0x343);
|
||||
BoardPlayerRotYSet(arg0, 0.0f);
|
||||
BoardPlayerPosSet(arg0, 0.0f, 0.0f, 0.0f);
|
||||
BoardRotateDiceNumbers(arg0);
|
||||
}
|
||||
|
||||
void fn_800811BC(s32 arg0) {
|
||||
f32 temp_f1;
|
||||
|
||||
lbl_801A4AC0.y += 20.0f;
|
||||
BoardPlayerPosSetV(arg0, &lbl_801A4AC0);
|
||||
if (!(lbl_801A4AC0.y < lbl_801D4030)) {
|
||||
warpPos.y += 20.0f;
|
||||
BoardPlayerPosSetV(player, &warpPos);
|
||||
if (!(warpPos.y < warpYFloor)) {
|
||||
WipeColorSet(0U, 0U, 0U);
|
||||
WipeCreate(2, 0, 0x15);
|
||||
WipeCreate(2, 0, 21);
|
||||
|
||||
while (WipeStatGet() != 0) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
lbl_801A4AC0.y = lbl_801D4030;
|
||||
BoardModelVisibilitySet(lbl_801D3748, 0);
|
||||
lbl_801D4038 = 3;
|
||||
warpPos.y = warpYFloor;
|
||||
BoardModelVisibilitySet(warpSpringMdl, 0);
|
||||
warpState = 3;
|
||||
}
|
||||
}
|
||||
|
||||
void fn_80081278(s32 arg0) {
|
||||
f32 temp_f1;
|
||||
s32 var_r31;
|
||||
static void WarpStartImpact(s32 player) {
|
||||
s32 i;
|
||||
|
||||
lbl_801D4034 = GWPlayer[lbl_801D4037].space_curr;
|
||||
GWPlayer[arg0].space_curr = lbl_801D4034;
|
||||
BoardSpacePosGet(0, lbl_801D4034, &lbl_801A4AC0);
|
||||
lbl_801D4030 = lbl_801A4AC0.y;
|
||||
lbl_801A4AC0.y += 1500.0f;
|
||||
BoardPlayerPosSetV(arg0, &lbl_801A4AC0);
|
||||
BoardPlayerRotSet(arg0, 180.0f, 180.0f, 0.0f);
|
||||
warpSpace = GWPlayer[warpTarget].space_curr;
|
||||
GWPlayer[player].space_curr = warpSpace;
|
||||
BoardSpacePosGet(0, warpSpace, &warpPos);
|
||||
warpYFloor = warpPos.y;
|
||||
warpPos.y += 1500.0f;
|
||||
BoardPlayerPosSetV(player, &warpPos);
|
||||
BoardPlayerRotSet(player, 180.0f, 180.0f, 0.0f);
|
||||
|
||||
for (var_r31 = 0, lbl_801D4036 = var_r31; var_r31 < 4; var_r31++) {
|
||||
if (lbl_801D4034 == GWPlayer[var_r31].space_curr) {
|
||||
lbl_801D374C[lbl_801D4036] = var_r31;
|
||||
lbl_801D4036++;
|
||||
for (i = 0, warpImpactCnt = i; i < 4; i++) {
|
||||
if (warpSpace == GWPlayer[i].space_curr) {
|
||||
warpImpactPlayer[warpImpactCnt] = i;
|
||||
warpImpactCnt++;
|
||||
}
|
||||
}
|
||||
lbl_801D374A = BoardModelCreate(0x70002, NULL, 0);
|
||||
BoardModelVisibilitySet(lbl_801D374A, 0);
|
||||
BoardModelMotionSpeedSet(lbl_801D374A, 0.0f);
|
||||
warpImpactMdl = BoardModelCreate(MAKE_DATA_NUM(DATADIR_BOARD, 2), NULL, 0);
|
||||
BoardModelVisibilitySet(warpImpactMdl, 0);
|
||||
BoardModelMotionSpeedSet(warpImpactMdl, 0.0f);
|
||||
BoardCameraMoveSet(0);
|
||||
BoardCameraTargetSpaceSet(lbl_801D4034);
|
||||
BoardCameraTargetSpaceSet(warpSpace);
|
||||
HuPrcSleep(1);
|
||||
WipeCreate(1, 0, 0x15);
|
||||
while (WipeStatGet() != 0) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
BoardCameraMoveSet(1);
|
||||
lbl_801D402C = -10.0f;
|
||||
lbl_801D4038 = 4;
|
||||
warpYVel = -10.0f;
|
||||
warpState = 4;
|
||||
}
|
||||
|
||||
void fn_80081428(s32 arg0) {
|
||||
lbl_801D402C += -2.0f;
|
||||
lbl_801A4AC0.y += lbl_801D402C;
|
||||
if (lbl_801A4AC0.y <= (150.0f + lbl_801D4030)) {
|
||||
lbl_801A4AC0.y = lbl_801D4030;
|
||||
lbl_801D4038 = 5;
|
||||
HuAudFXPlay(0x345);
|
||||
HuAudFXPlay(0x33D);
|
||||
static void WarpFall(s32 player) {
|
||||
warpYVel += -2.0f;
|
||||
warpPos.y += warpYVel;
|
||||
if (warpPos.y <= (150.0f + warpYFloor)) {
|
||||
warpPos.y = warpYFloor;
|
||||
warpState = 5;
|
||||
HuAudFXPlay(837);
|
||||
HuAudFXPlay(829);
|
||||
}
|
||||
BoardPlayerPosSetV(arg0, &lbl_801A4AC0);
|
||||
BoardPlayerPosSetV(player, &warpPos);
|
||||
}
|
||||
|
||||
void fn_800814CC(s32 arg0) {
|
||||
Vec sp18;
|
||||
Point3d spC;
|
||||
s16 sp8;
|
||||
f32 temp_f29;
|
||||
static void WarpImpact(s32 player) {
|
||||
Vec pos;
|
||||
Vec pos_player;
|
||||
s16 temp;
|
||||
f32 speed;
|
||||
f32 temp_f30;
|
||||
f32 var_f31;
|
||||
s16 var_r31;
|
||||
s32 temp_r30;
|
||||
f32 angle;
|
||||
s16 i;
|
||||
|
||||
sp18.x = 288.0f;
|
||||
sp18.y = 240.0f;
|
||||
sp18.z = 700.0f;
|
||||
Hu3D2Dto3D(&sp18, 1, &sp18);
|
||||
BoardModelPosSetV(lbl_801D374A, &sp18);
|
||||
BoardModelVisibilitySet(lbl_801D374A, 1);
|
||||
BoardModelMotionStart(lbl_801D374A, 0, 0x40000001);
|
||||
pos.x = 288.0f;
|
||||
pos.y = 240.0f;
|
||||
pos.z = 700.0f;
|
||||
Hu3D2Dto3D(&pos, 1, &pos);
|
||||
BoardModelPosSetV(warpImpactMdl, &pos);
|
||||
BoardModelVisibilitySet(warpImpactMdl, 1);
|
||||
BoardModelMotionStart(warpImpactMdl, 0, 0x40000001);
|
||||
|
||||
for (var_r31 = 0; var_r31 < lbl_801D4036; var_r31++) {
|
||||
temp_r30 = lbl_801D374C[var_r31];
|
||||
omVibrate(temp_r30, 0xC, 4, 2);
|
||||
BoardPlayerMotionStart(temp_r30, 6, 0x40000001);
|
||||
for (i = 0; i < warpImpactCnt; i++) {
|
||||
s32 player = warpImpactPlayer[i];
|
||||
omVibrate(player, 0xC, 4, 2);
|
||||
BoardPlayerMotionStart(player, 6, 0x40000001);
|
||||
}
|
||||
BoardPlayerRotSet(arg0, 0.0f, 0.0f, 0.0f);
|
||||
BoardPlayerPosGet(arg0, &spC);
|
||||
spC.y = lbl_801D4030;
|
||||
BoardPlayerPosSetV(arg0, &spC);
|
||||
temp_f29 = 4.0f;
|
||||
BoardPlayerRotSet(player, 0.0f, 0.0f, 0.0f);
|
||||
BoardPlayerPosGet(player, &pos_player);
|
||||
pos_player.y = warpYFloor;
|
||||
BoardPlayerPosSetV(player, &pos_player);
|
||||
speed = 4.0f;
|
||||
|
||||
for (var_f31 = 0.0f, sp8 = var_f31; var_f31 < 180.0f; var_f31 += temp_f29) {
|
||||
temp_f30 = sin((M_PI * var_f31) / 180.0);
|
||||
BoardModelScaleSet(lbl_801D374A, 0.5f + temp_f30, 0.5f + temp_f30, 0.5f + temp_f30);
|
||||
for (angle = 0.0f, temp = angle; angle < 180.0f; angle += speed) {
|
||||
temp_f30 = sin((M_PI * angle) / 180.0);
|
||||
BoardModelScaleSet(warpImpactMdl, 0.5f + temp_f30, 0.5f + temp_f30, 0.5f + temp_f30);
|
||||
HuPrcVSleep();
|
||||
}
|
||||
BoardModelVisibilitySet(lbl_801D374A, 0);
|
||||
HuPrcSleep(0x3C);
|
||||
BoardModelVisibilitySet(warpImpactMdl, 0);
|
||||
HuPrcSleep(60);
|
||||
|
||||
for (var_r31 = 0; var_r31 < lbl_801D4036; var_r31++) {
|
||||
BoardRotateDiceNumbers(lbl_801D374C[var_r31]);
|
||||
for (i = 0; i < warpImpactCnt; i++) {
|
||||
BoardRotateDiceNumbers(warpImpactPlayer[i]);
|
||||
}
|
||||
lbl_801D4038 = 6;
|
||||
warpState = 6;
|
||||
}
|
||||
|
|
@ -1,7 +1,7 @@
|
|||
#include "game/board/window.h"
|
||||
|
||||
extern s32 BoardPlayerIsAllCom(void);
|
||||
extern Process* boardMainProc;
|
||||
#include "game/board/main.h"
|
||||
#include "game/board/player.h"
|
||||
#include "game/gamework_data.h"
|
||||
|
||||
static s8 winChoice;
|
||||
static s8 autoPickF;
|
||||
|
|
|
|||
|
|
@ -1,4 +1,3 @@
|
|||
#include "common.h"
|
||||
#include "game/data.h"
|
||||
#include "game/armem.h"
|
||||
#include "dolphin/dvd.h"
|
||||
|
|
|
|||
|
|
@ -1,4 +1,3 @@
|
|||
#include "common.h"
|
||||
#include "game/data.h"
|
||||
#include "dolphin/os.h"
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,3 @@
|
|||
#include "common.h"
|
||||
#include "game/dvd.h"
|
||||
#include "game/data.h"
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,5 @@
|
|||
#include "common.h"
|
||||
#include "dolphin.h"
|
||||
#include "game/gamework_data.h"
|
||||
|
||||
static u8 _Sys_Flag[16];
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
#include "common.h"
|
||||
#include "dolphin.h"
|
||||
|
||||
static u32 frand_seed;
|
||||
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
#include "common.h"
|
||||
#include "string.h"
|
||||
#include "game/gamework.h"
|
||||
#include "game/gamework_data.h"
|
||||
#include "game/flag.h"
|
||||
|
||||
GameStat GWGameStatDefault;
|
||||
|
|
|
|||
|
|
@ -1,4 +1,3 @@
|
|||
#include "common.h"
|
||||
#include "game/init.h"
|
||||
#include "dolphin/os.h"
|
||||
#include "dolphin/gx.h"
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
#include "common.h"
|
||||
#include "game/gamework_data.h"
|
||||
#include "game/dvd.h"
|
||||
#include "game/printfunc.h"
|
||||
#include "game/object.h"
|
||||
|
|
|
|||
|
|
@ -1,4 +1,3 @@
|
|||
#include "common.h"
|
||||
#include "game/memory.h"
|
||||
#include "game/init.h"
|
||||
#include "dolphin/os.h"
|
||||
|
|
|
|||
|
|
@ -1,4 +1,3 @@
|
|||
#include "common.h"
|
||||
#include "game/memory.h"
|
||||
#include "dolphin/os.h"
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
#include "common.h"
|
||||
#include "dolphin.h"
|
||||
|
||||
static void *MessData_MesDataGet(void *messdata, u32 id)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -1,4 +1,5 @@
|
|||
#include "common.h"
|
||||
#include "game/audio.h"
|
||||
#include "game/hsfman.h"
|
||||
#include "game/printfunc.h"
|
||||
#include "game/object.h"
|
||||
#include "game/pad.h"
|
||||
|
|
|
|||
|
|
@ -1,4 +1,3 @@
|
|||
#include "common.h"
|
||||
#include "game/dvd.h"
|
||||
#include "game/object.h"
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,3 @@
|
|||
#include "common.h"
|
||||
#include "dolphin.h"
|
||||
#include "game/msm.h"
|
||||
#include "game/pad.h"
|
||||
|
|
|
|||
|
|
@ -1,4 +1,3 @@
|
|||
#include "common.h"
|
||||
#include "dolphin.h"
|
||||
#include "game/printfunc.h"
|
||||
#include "game/init.h"
|
||||
|
|
|
|||
|
|
@ -1,4 +1,3 @@
|
|||
#include "common.h"
|
||||
#include "game/process.h"
|
||||
#include "game/memory.h"
|
||||
#include "dolphin/os.h"
|
||||
|
|
|
|||
|
|
@ -4,6 +4,7 @@
|
|||
#include "game/window.h"
|
||||
#include "game/flag.h"
|
||||
#include "game/card.h"
|
||||
#include "game/gamework_data.h"
|
||||
|
||||
#include "string.h"
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,3 @@
|
|||
#include "common.h"
|
||||
#include "game/sprite.h"
|
||||
#include "game/memory.h"
|
||||
#include "game/init.h"
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
#include "common.h"
|
||||
#include "game/sprite.h"
|
||||
#include "game/hsfman.h"
|
||||
#include "game/init.h"
|
||||
#include "dolphin/mtx.h"
|
||||
#include "dolphin/gx.h"
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
#include "common.h"
|
||||
#include "game/gamework_data.h"
|
||||
|
||||
#include "game/window.h"
|
||||
#include "game/sprite.h"
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue