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

Merge branch 'Rainchus:main' into main

Browse source
This commit is contained in:
CreateSource 2024-02-24 20:09:42 -05:00 • committed by GitHub
commit ecf2b20a15
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
116 changed files with 21323 additions and 1302 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/game/ClusterExec.c
View file

@ -119,7 +119,7 @@ void ClusterProc(ModelData *arg0) {
temp_r31 = temp_r23->object;
temp_r31 += var_r29->target;
Vertextop = temp_r31->data.vertex->data;
if (temp_r31->data.hook) {
if (temp_r31->data.cenvCnt) {
for (k = 0; k < temp_r31->data.vertex->count; k++) {
Vertextop[k].x = ((Vec*) temp_r31->data.file[0])[k].x;
Vertextop[k].y = ((Vec*) temp_r31->data.file[0])[k].y;

2
src/game/EnvelopeExec.c
View file

@ -179,7 +179,7 @@ static void SetEnvelopMain(HsfData *arg0) {
normtop = var_r31->data.file[1];
normenv = temp_r28->data;
var_r25 = var_r31->data.cenv;
for (j = 0; j < var_r31->data.hook; j++, var_r25++) {
for (j = 0; j < var_r31->data.cenvCnt; j++, var_r25++) {
SetEnvelop(var_r25);
}
sp10 = temp_r30->data;

2
src/game/audio.c
View file

@ -261,7 +261,7 @@ s32 HuAudSeqPlay(s16 arg0) {
if (musicOffF != 0 || omSysExitReq != 0) {
return 0;
}
temp_r31 = msmMusPlay(arg0, 0);
temp_r31 = msmMusPlay(arg0, NULL);
return temp_r31;
}

158
src/game/board/audio.c Executable file
View 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;
}
}

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

@ -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
View 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
View file

File diff suppressed because it is too large Load diff

677
src/game/board/com.c Executable file
View 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
View 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
View file

File diff suppressed because it is too large Load diff

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

@ -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) {

9
src/game/board/model.c
View file

@ -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
View file

File diff suppressed because it is too large Load diff

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

@ -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
View 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;
}

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

@ -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
View 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
View 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);
}

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

@ -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
View 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();
}
}

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

@ -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);

2080
src/game/chrman.c Executable file
View file

File diff suppressed because it is too large Load diff

155
src/game/data.c
View file

@ -1,5 +1,6 @@
#include "game/data.h"
#include "game/armem.h"
#include "game/process.h"
#include "dolphin/dvd.h"
#define PTR_OFFSET(ptr, offset) (void *)(((u8 *)(ptr)+(u32)(offset)))
@ -11,7 +12,7 @@ static void **HuDataReadMultiSub(s32 *data_ids, BOOL use_num, s32 num);
#define DATADIR_DEFINE(name, path) { path, -1 },
static FileListEntry DataDirStat[DATADIR_COUNT+1] = {
static FileListEntry DataDirStat[] = {
#include "datadir_table.h"
{ NULL, -1 }
};
@ -21,7 +22,7 @@ static FileListEntry DataDirStat[DATADIR_COUNT+1] = {
u32 DirDataSize;
static u32 DataDirMax;
static s32 shortAccessSleep;
static DataReadStat ReadDataStat[DATA_MAX_READSTAT];
static DataReadStat ATTRIBUTE_ALIGN(32) ReadDataStat[DATA_MAX_READSTAT];
void HuDataInit(void)
{
@ -131,7 +132,7 @@ DataReadStat *HuDataDirRead(s32 data_num)
return read_stat;
}
DataReadStat *HuDataDirReadNum(s32 data_num, s32 num)
static DataReadStat *HuDataDirReadNum(s32 data_num, s32 num)
{
DataReadStat *read_stat;
int status;
@ -544,8 +545,152 @@ void HuDataDirCloseNum(s32 num)
}
}
static s32 HuDataDVDdirDirectOpen(s32 data_id, DVDFileInfo *fileInfo)
{
s32 dir = data_id >> 16;
if(dir >= (s32)DataDirMax) {
OSReport("data.c: Data Number Error(0x%08x)\n", data_id);
return 0;
}
if(!DVDFastOpen(DataDirStat[dir].file_id, fileInfo)) {
char panic_str[48];
sprintf(panic_str, "HuDataDVDdirDirectOpen: File Open Error(%08x)", data_id);
OSPanic("data.c", 895, panic_str);
}
return 1;
}
static s32 HuDataDVDdirDirectRead(DVDFileInfo *fileInfo, void *dest, s32 len, s32 offset)
{
s32 result = DVDReadAsync(fileInfo, dest, len, offset, NULL);
if(result != 1) {
OSPanic("data.c", 904, "HuDataDVDdirDirectRead: File Read Error");
}
while(DVDGetCommandBlockStatus(&fileInfo->cb)) {
if(shortAccessSleep) {
HuPrcVSleep();
}
}
return result;
}
static void *HuDataDecodeIt(void *buf_start, s32 buf_ofs, s32 num, HeapID heap)
{
void *data_start;
s32 *buf;
s32 raw_len, comp_type;
void *dest;
buf = (s32 *)((u8 *)buf_start+buf_ofs);
if((u32)buf & 0x3) {
u8 *data = (u8 *)buf;
raw_len = *data++ << 24;
raw_len += *data++ << 16;
raw_len += *data++ << 8;
raw_len += *data++;
comp_type = *data++ << 24;
comp_type += *data++ << 16;
comp_type += *data++ << 8;
comp_type += *data++;
data_start = data;
} else {
s32 *data = buf;
raw_len = *data++;
comp_type = *data++;
data_start = data;
}
switch(heap) {
case HEAP_MUSIC:
dest = HuMemDirectMalloc(HEAP_MUSIC, DATA_EFF_SIZE(raw_len));
break;
case HEAP_DATA:
dest = HuMemDirectMallocNum(HEAP_DATA, DATA_EFF_SIZE(raw_len), num);
break;
case HEAP_DVD:
dest = HuMemDirectMallocNum(HEAP_DVD, DATA_EFF_SIZE(raw_len), num);
break;
default:
dest = HuMemDirectMallocNum(HEAP_SYSTEM, DATA_EFF_SIZE(raw_len), num);
break;
}
if(dest) {
HuDecodeData(data_start, dest, raw_len, comp_type);
}
return dest;
}
//Still to be decompiled
void *HuDataReadNumHeapShortForce(s32 data_id, s32 num, HeapID heap)
{
return NULL;
}
DVDFileInfo fileInfo;
s32 *data_hdr;
s32 *file_data;
void *file_raw_buf;
s32 read_len;
s32 file_id;
s32 file_ofs;
s32 read_ofs;
s32 data_ofs;
void *ret;
s32 dir;
s32 data_len;
s32 file_max;
if(!HuDataDVDdirDirectOpen(data_id, &fileInfo)) {
return NULL;
}
dir = (data_id >> 16) & 0xFFFF0000;
file_id = data_id & 0xFFFF;
file_ofs = (file_id*4)+4;
data_len = OSRoundUp32B(file_ofs+8);
file_data = HuMemDirectMalloc(HEAP_SYSTEM, data_len);
if(!HuDataDVDdirDirectRead(&fileInfo, file_data, data_len, 0)) {
HuMemDirectFree(file_data);
DVDClose(&fileInfo);
return NULL;
}
file_max = *file_data;
if(file_max <= file_id) {
HuMemDirectFree(file_data);
OSReport("data.c%d: Data Number Error(0x%08x)\n", 1005, data_id);
DVDClose(&fileInfo);
return NULL;
}
data_hdr = file_data;
data_hdr += file_id+1;
file_ofs = *data_hdr;
read_ofs = OSRoundDown32B(file_ofs);
if(file_max <= file_id+1) {
read_len = fileInfo.length;
data_ofs = read_len-read_ofs;
} else {
data_hdr++;
data_ofs = (*data_hdr)-read_ofs;
read_len = fileInfo.length;
}
read_len = OSRoundUp32B(data_ofs);
HuMemDirectFree(file_data);
file_raw_buf = HuMemDirectMalloc(HEAP_SYSTEM, (read_len+4) & ~0x3);
if(file_raw_buf == NULL) {
OSReport("data.c: couldn't allocate read buffer(0x%08x)\n", data_id);
DVDClose(&fileInfo);
return NULL;
}
if(!HuDataDVDdirDirectRead(&fileInfo, file_raw_buf, read_len, read_ofs)) {
HuMemDirectFree(file_raw_buf);
DVDClose(&fileInfo);
return NULL;
}
DVDClose(&fileInfo);
data_ofs = file_ofs-read_ofs;
ret = HuDataDecodeIt(file_raw_buf, data_ofs, num, heap);
HuMemDirectFree(file_raw_buf);
return ret;
}
char lbl_8011FDA6[] = "** dcnt %d tmp %08x sp1 %08x\n";
char lbl_8011FDC4[] = "** dcnt %d lastNum %08x\n";

358
src/game/fault.c
View file

@ -1,13 +1,20 @@
#include "game/gamework_data.h"
#include "game/fault.h"
#include "stdarg.h"
#include "stdio.h"
typedef struct rgb_color {
s8 r;
s8 g;
s8 b;
u8 r;
u8 g;
u8 b;
} RGBColor;
typedef struct xfb_geometry {
void* frame_buffers[4];
u16 width;
u16 height;
u16 mode;
} XFBGeometry;
static RGBColor XFB_Colors[5] = {
{ 0x00, 0x80, 0x80 },
{ 0xFF, 0x80, 0x80 },
@ -16,15 +23,27 @@ static RGBColor XFB_Colors[5] = {
{ 0x40, 0x80, 0x80 }
};
s16 XFB_Geometry[6][2];
#include "Ascii8x8_1bpp.inc"
static XFBGeometry XFB_Geometry;
static s32 (*XFB_putc)(u8 c, s32 x, s32 y);
static RGBColor Draw_Color;
static s32 y_start;
static s32 x_start;
const char* lbl_801D34A0 = "OSPanic encounterd:";
static s32 x_start;
static s32 y_start;
static s32 XFB_putcProgressive(u8 arg0, s32 arg1, s32 arg2);
static s32 XFB_putcInterlace(u8 arg0, s32 arg1, s32 arg2);
static s32 XFB_puts(s8* arg0, s32 arg1, s32 arg2);
static s32 XFB_putcS(u8 arg0, s32 arg1, s32 arg2);
static void XFB_WriteBackCache(void);
static void XFB_CR(s32 arg0, s32* arg1, s32* arg2);
void OSPanic(const char* file, int line, const char* msg, ...) {
static char* titleMes = "OSPanic encounterd:";
va_list sp78;
s32 sp74;
s32 sp70;
@ -33,16 +52,329 @@ void OSPanic(const char* file, int line, const char* msg, ...) {
sp74 = x_start = 0x10;
sp70 = y_start = 0x20;
puts = XFB_puts(lbl_801D34A0, sp74, sp70);
puts = XFB_puts((s8*)titleMes, sp74, sp70);
XFB_CR(puts + 1, &sp74, &sp70);
sprintf(sp84, "%s:%d", file, line);
puts = XFB_puts(sp84, sp74, sp70);
puts = XFB_puts((s8*)sp84, sp74, sp70);
XFB_CR(puts, &sp74, &sp70);
va_start(sp78, msg);
vsnprintf(sp84, 0x400U, msg, &sp78[0]);
puts = XFB_puts(sp84, sp74, sp70);
puts = XFB_puts((s8*)sp84, sp74, sp70);
XFB_CR(puts, &sp74, &sp70);
XFB_WriteBackCache();
PPCHalt();
va_end();
}
va_end(sp78);
}
void HuFaultInitXfbDirectDraw(GXRenderModeObj *mode) {
s32 i;
for (i = 0; i < 4; i++) {
XFB_Geometry.frame_buffers[i] = 0;
}
XFB_Geometry.width = 0;
XFB_Geometry.height = 0;
XFB_Geometry.mode = 0;
XFB_putc = XFB_putcProgressive;
Draw_Color = XFB_Colors[1];
if (mode) {
XFB_Geometry.width = ((u16)mode->fbWidth + 0xF) & 0xFFFFFFF0;
XFB_Geometry.height = mode->xfbHeight;
XFB_Geometry.mode = mode->xFBmode;
if (XFB_Geometry.mode == 0) {
XFB_putc = XFB_putcInterlace;
} else {
XFB_putc = XFB_putcProgressive;
}
}
}
void HuFaultSetXfbAddress(s16 index, void* value) {
if (index >= 0 && index < 4) {
XFB_Geometry.frame_buffers[index] = value;
}
}
static void XFB_WriteBackCache(void) {
s32 i;
void* frame_buffer;
u32 temp_r29;
temp_r29 = XFB_Geometry.width * 2 * XFB_Geometry.height;
if (temp_r29 != 0) {
for (i = 0; i < 4; i += 1) {
frame_buffer = XFB_Geometry.frame_buffers[i];
if (frame_buffer) {
DCStoreRange(frame_buffer, temp_r29);
}
}
}
}
static void XFB_CR(s32 arg0, s32* x_ptr, s32* y_ptr) {
s32 temp_r30;
s32 y;
s32 x;
x = *x_ptr;
y = *y_ptr;
x = x_start;
y += 0x12;
temp_r30 = arg0 & 7;
if (temp_r30 != 0) {
y += temp_r30 * 0x12;
}
*x_ptr = x;
*y_ptr = y;
}
static s32 XFB_puts(s8* message, s32 x, s32 y) {
s32 i;
s32 temp_r31;
s8 current_char;
i = 0;
do {
current_char = *message++;
if (current_char == '\n') {
XFB_CR(0, &x, &y);
i += 1;
} else {
temp_r31 = XFB_putcS(current_char, x, y);
if (temp_r31 >= 0) {
if (temp_r31 != 0) {
temp_r31 -= 1;
XFB_CR(temp_r31, &x, &y);
i += temp_r31 + 1;
}
x += 0x10;
} else {
break;
}
}
} while(current_char != 0);
return i;
}
static s32 XFB_putcS(u8 c, s32 x, s32 y) {
RGBColor sp8;
s32 var_r26;
s32 var_r25;
s32 var_r27;
s32 var_r29;
RGBColor* temp_r3;
var_r27 = 0;
sp8 = Draw_Color;
if (x + 0x11 >= XFB_Geometry.width) {
XFB_CR(0, &x, &y);
var_r27++;
}
Draw_Color = XFB_Colors[0];
XFB_putc(c, x, y - 2);
XFB_putc(c, x, y + 2);
XFB_putc(c, x - 1, y);
XFB_putc(c, x + 1, y);
Draw_Color = sp8;
XFB_putc(c, x, y);
return var_r27;
}
static s32 XFB_putcProgressive(u8 c, s32 x, s32 y) {
s32 result;
s32 temp_r20;
u8 red;
u8 blue;
u8 green;
s32 i;
s32 j;
s32 var_r23;
u8* var_r29;
s32 k;
s32 var_r27;
s32 var_r26;
u32 temp_r31;
u32 var_r30;
u32 var_r22;
u8* frame_buffer;
result = 0;
if (c == 0) {
return -1;
}
if (x + 0x10 >= XFB_Geometry.width) {
y += 0x12;
x = x_start;
result = 1;
}
if (y + 0x10 >= XFB_Geometry.height) {
return -1;
}
red = Draw_Color.r;
green = Draw_Color.g;
blue = Draw_Color.b;
temp_r20 = XFB_Geometry.width * 2;
var_r23 = (x & 0xFFFE) * 2 + y * temp_r20;
var_r29 = Ascii8x8_1bpp + (c * 8);
i = 8;
while (i != 0) {
j = 2;
while (j != 0) {
for (k = 0; k < 4; k ++) {
frame_buffer = XFB_Geometry.frame_buffers[k];
if (frame_buffer != 0) {
frame_buffer += var_r23;
var_r22 = *var_r29;
var_r30 = 0;
var_r26 = 0;
while (var_r26 < 0x10) {
if (var_r22 & 0xF != 0) {
var_r30 |= 3 << var_r26;
}
var_r26 += 2;
var_r22 >>= 1;
}
var_r27 = 8;
if ((s32) (x & 1) != 0) {
var_r30 *= 2;
var_r27 = 0xA;
}
while (var_r27 != 0) {
if ((u32) (var_r30 & 3) != 0) {
frame_buffer[1] = blue;
frame_buffer[3] = green;
if ((u32) (var_r30 & 1) != 0) {
frame_buffer[0] = red;
}
if ((u32) (var_r30 & 2) != 0) {
frame_buffer[2] = red;
}
}
var_r27 -= 1;
frame_buffer += 4;
var_r30 = var_r30 >> 2;
}
}
}
j -= 1;
var_r23 += temp_r20;
}
i -= 1;
var_r29 += 1;
}
return result;
}
static s32 XFB_putcInterlace(u8 c, s32 x, s32 y) {
u8 red;
u8 blue;
u8 green;
s32 temp_r23;
s32 i;
s32 var_r25;
u8* var_r28;
s32 j;
s16 var_r29;
s32 var_r30;
u8* var_r31;
if (c == 0) {
return -1;
}
if (x + 8 >= XFB_Geometry.width || y + 8 >= XFB_Geometry.height) {
return -1;
}
red = Draw_Color.r;
green = Draw_Color.g;
blue = Draw_Color.b;
temp_r23 = XFB_Geometry.width * 2;
var_r25 = ((x & 0xFFFE) * 2) + ((y >> 1) * temp_r23);
var_r28 = Ascii8x8_1bpp + c * 8;
i = 8;
while (i != 0) {
for (j = 0; j < 4; j += 2) {
var_r30 = j;
if ((s32) (y & 1) != 0) {
var_r30 += 1;
}
var_r31 = XFB_Geometry.frame_buffers[var_r30];
if (var_r31) {
var_r31 = var_r31 + var_r25;
var_r29 = *var_r28;
var_r30 = 4;
if (x & 1) {
var_r29 = (s16)var_r29 * 2;
var_r30 = 5;
}
while (var_r30) {
if (var_r29 & 3) {
var_r31[1] = blue;
var_r31[3] = green;
if (var_r29 & 1) {
var_r31[0] = red;
}
if (var_r29 & 2) {
var_r31[2] = red;
}
}
var_r30 -= 1;
var_r31 += 4;
var_r29 >>= 2;
}
}
}
i -= 1;
y += 1;
var_r28 += 1;
var_r25 += temp_r23;
}
return 0;
}

177
src/game/hsfdraw.c
View file

@ -6,7 +6,7 @@
#include "math.h"
#include "string.h"
#define ABS(x) ((x < 0) ? -x : x)
#define ABS(x) (((x) < 0) ? -(x) : (x))
typedef struct {
/* 0x00 */ ModelData *unk00;
@ -24,18 +24,9 @@ typedef struct {
u32 unk0C;
} DrawDataStruct; // Size 0x10
typedef struct {
/* 0x00 */ s16 unk00;
/* 0x02 */ s16 unk02;
/* 0x04 */ s16 unk04[3][4]; // goes up to index [3][3] (union?)
/* 0x1C */ u32 unk1C;
/* 0x20 */ void *unk20;
/* 0x24 */ char unk24[0xC];
} HsfdrawStruct02; // Size 0x30
static void objCall(ModelData *arg0, HsfObject *arg1);
static void objMesh(ModelData *arg0, HsfObject *arg1);
static void FaceDraw(HsfdrawStruct00 *arg0, HsfdrawStruct02 *arg1);
static void FaceDraw(HsfdrawStruct00 *arg0, HsfFace *arg1);
static void SetTevStageNoTex(HsfdrawStruct00 *arg0, HsfMaterial *arg1);
static void SetTevStageTex(HsfdrawStruct00 *arg0, HsfMaterial *arg1);
static GXTevKColorSel SetKColor(GXTevStageID arg0, u8 arg1);
@ -45,7 +36,7 @@ static void SetReflect(HsfdrawStruct00 *arg0, s16 arg1, s16 arg2, u8 arg3);
static void SetProjection(HsfdrawStruct00 *arg0, s16 arg1, s16 arg2, s16 arg3, GXTexMapID arg4, u32 arg5);
static void SetShadowTex(void);
static void SetShadow(HsfdrawStruct00 *arg0, s16 arg1, s16 arg2);
static void FaceDrawShadow(HsfdrawStruct00 *arg0, HsfdrawStruct02 *arg1);
static void FaceDrawShadow(HsfdrawStruct00 *arg0, HsfFace *arg1);
static void LoadTexture(ModelData *arg0, HsfBitmap *arg1, HsfAttribute *arg2, s16 arg3);
static void objNull(ModelData *arg0, HsfObject *arg1);
static void objRoot(ModelData *arg0, HsfObject *arg1);
@ -55,10 +46,10 @@ static void objReplica(ModelData *arg0, HsfObject *arg1);
static void ObjDraw(HsfdrawStruct00 *arg0);
static void MDObjCall(HsfData *arg0, HsfObject *arg1);
static void MDObjMesh(HsfData *arg0, HsfObject *arg1);
static void MDFaceDraw(HsfObject *arg0, HsfdrawStruct02 *arg1);
static s32 MakeCalcNBT(HsfObject *arg0, HsfdrawStruct02 *arg1, s16 arg2, s16 arg3);
static s32 MakeNBT(HsfObject *arg0, HsfdrawStruct02 *arg1, s16 arg2, s16 arg3);
static void MDFaceCnt(HsfObject *arg0, HsfdrawStruct02 *arg1);
static void MDFaceDraw(HsfObject *arg0, HsfFace *arg1);
static s32 MakeCalcNBT(HsfObject *arg0, HsfFace *arg1, s16 arg2, s16 arg3);
static s32 MakeNBT(HsfObject *arg0, HsfFace *arg1, s16 arg2, s16 arg3);
static void MDFaceCnt(HsfObject *arg0, HsfFace *arg1);
void GXResetWriteGatherPipe(void);
@ -249,7 +240,7 @@ static void objMesh(ModelData *arg0, HsfObject *arg1) {
temp_r25 = arg1->constData;
if (!(temp_r25->flags & 0x1000)) {
if (CancelTRXF == 0) {
if (arg1->data.hook != 0 && hookIdx == -1) {
if (arg1->data.cenvCnt != 0 && hookIdx == -1) {
temp_r21 = arg1 - temp_r20->object;
PSMTXConcat(MTXBuf[0], temp_r20->matrix->data[temp_r21 + temp_r20->matrix->base_idx], MTXBuf[MTXIdx]);
} else {
@ -429,7 +420,7 @@ s32 ObjCullCheck(HsfData *arg0, HsfObject *arg1, Mtx arg2) {
}
// TODO: not matching (https://decomp.me/scratch/54Pjw)
static void FaceDraw(HsfdrawStruct00 *arg0, HsfdrawStruct02 *arg1) {
static void FaceDraw(HsfdrawStruct00 *arg0, HsfFace *arg1) {
GXColor sp2C;
void *sp28;
Hu3DTexAnimDataStruct *sp24;
@ -453,7 +444,7 @@ static void FaceDraw(HsfdrawStruct00 *arg0, HsfdrawStruct02 *arg1) {
temp_r29 = arg0->unk00;
temp_r20 = temp_r28->constData;
kColorIdx = 0;
temp_r30 = &temp_r28->data.material[arg1->unk02 & 0xFFF];
temp_r30 = &temp_r28->data.material[arg1->mat & 0xFFF];
temp_r19 = temp_r28->flags | temp_r30->flags;
if (temp_r19 & 0x30) {
if (temp_r19 & 0x10) {
@ -1651,7 +1642,7 @@ static void SetShadow(HsfdrawStruct00 *arg0, s16 arg1, s16 arg2) {
GXSetTevAlphaOp(arg1, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_FALSE, GX_TEVPREV);
}
static void FaceDrawShadow(HsfdrawStruct00 *arg0, HsfdrawStruct02 *arg1) {
static void FaceDrawShadow(HsfdrawStruct00 *arg0, HsfFace *arg1) {
HsfObject *temp_r31;
ModelData *temp_r28;
HsfConstData *temp_r27;
@ -1663,7 +1654,7 @@ static void FaceDrawShadow(HsfdrawStruct00 *arg0, HsfdrawStruct02 *arg1) {
temp_r31 = arg0->unk04;
temp_r28 = arg0->unk00;
temp_r27 = temp_r31->constData;
temp_r29 = &temp_r31->data.material[arg1->unk02 & 0xFFF];
temp_r29 = &temp_r31->data.material[arg1->mat & 0xFFF];
if (temp_r29 != materialBak) {
if (!(temp_r27->flags & 0x400)) {
drawCnt++;
@ -2079,7 +2070,7 @@ void Hu3DDrawPost(void) {
float temp_f26;
float temp_f25;
LightData *temp_r22;
HsfdrawStruct02 *var_r27;
HsfFace *var_r27;
Mtx sp150;
Mtx sp120;
Mtx spF0;
@ -2218,12 +2209,12 @@ void Hu3DDrawPost(void) {
if (shadowModelDrawF == 0) {
for (i = 0; i < temp_r24->count;) {
FaceDraw(temp_r28, var_r27);
if (var_r27->unk00 == 4) {
if (var_r27->type == 4) {
totalPolyCnt += DrawData[drawCnt - 1].unk08;
i++;
var_r27++;
} else {
totalPolyCnt += DrawData[drawCnt - 1].unk08 * ((var_r27->unk00 & 7) == 3 ? 2 : 1);
totalPolyCnt += DrawData[drawCnt - 1].unk08 * ((var_r27->type & 7) == 3 ? 2 : 1);
i += DrawData[drawCnt - 1].unk08;
var_r27 += DrawData[drawCnt - 1].unk08;
}
@ -2237,7 +2228,7 @@ void Hu3DDrawPost(void) {
GXSetNumChans(1);
for (i = 0; i < temp_r24->count;) {
FaceDrawShadow(temp_r28, var_r27);
if (var_r27->unk00 == 4) {
if (var_r27->type == 4) {
i++;
var_r27++;
} else {
@ -2277,7 +2268,7 @@ static void ObjDraw(HsfdrawStruct00 *arg0) {
float temp_f26;
LightData *temp_r24;
DrawDataStruct *temp_r25;
HsfdrawStruct02 *var_r27;
HsfFace *var_r27;
Mtx sp140;
Mtx sp110;
Mtx spE0;
@ -2360,13 +2351,13 @@ static void ObjDraw(HsfdrawStruct00 *arg0) {
if (shadowModelDrawF == 0) {
for (i = 0; i < temp_r26->count;) {
FaceDraw(arg0, var_r27);
if (var_r27->unk00 == 4) {
if (var_r27->type == 4) {
totalPolyCnt += DrawData[drawCnt - 1].unk08;
i++;
var_r27++;
} else {
temp_r25 = &DrawData[drawCnt - 1];
if ((var_r27->unk00 & 7) == 3) {
if ((var_r27->type & 7) == 3) {
var_r20 = 2;
} else {
var_r20 = 1;
@ -2385,7 +2376,7 @@ static void ObjDraw(HsfdrawStruct00 *arg0) {
GXSetNumChans(1);
for (i = 0; i < temp_r26->count;) {
FaceDrawShadow(arg0, var_r27);
if (var_r27->unk00 == 4) {
if (var_r27->type == 4) {
i++;
var_r27++;
} else {
@ -2441,7 +2432,7 @@ static void MDObjCall(HsfData *arg0, HsfObject *arg1) {
static void MDObjMesh(HsfData *arg0, HsfObject *arg1) {
HsfBuffer *temp_r29;
HsfdrawStruct02 *var_r28;
HsfFace *var_r28;
s16 i;
temp_r29 = arg1->data.face;
@ -2503,7 +2494,7 @@ HsfConstData *ObjConstantMake(HsfObject *arg0, u32 arg1) {
return temp_r3;
}
static void MDFaceDraw(HsfObject *arg0, HsfdrawStruct02 *arg1) {
static void MDFaceDraw(HsfObject *arg0, HsfFace *arg1) {
HsfMaterial *temp_r30;
s16 *var_r24;
s16 var_r26;
@ -2514,9 +2505,9 @@ static void MDFaceDraw(HsfObject *arg0, HsfdrawStruct02 *arg1) {
s32 var_r25;
var_r26 = -1;
temp_r30 = &arg0->data.material[arg1->unk02 & 0xFFF];
if (temp_r30 != materialBak || polyTypeBak != (arg1->unk00 & 7) || (arg1->unk00 & 7) == 4) {
polyTypeBak = arg1->unk00 & 7;
temp_r30 = &arg0->data.material[arg1->mat & 0xFFF];
if (temp_r30 != materialBak || polyTypeBak != (arg1->type & 7) || (arg1->type & 7) == 4) {
polyTypeBak = arg1->type & 7;
materialBak = temp_r30;
DrawData[drawCnt].unk00 = (u32) DLBufP - (u32) DLBufStartP;
GXBeginDisplayList(DLBufP, 0x20000);
@ -2558,60 +2549,60 @@ static void MDFaceDraw(HsfObject *arg0, HsfdrawStruct02 *arg1) {
Hu3DObjInfoP->flags |= 0x10000;
}
faceCnt = 0;
switch (arg1->unk00 & 7) {
switch (arg1->type & 7) {
case 0:
case 1:
break;
case 2:
GXBegin(GX_TRIANGLES, GX_VTXFMT0, faceNumBuf[drawCnt]);
for (var_r27 = 0; var_r27 < faceNumBuf[drawCnt] / 3; var_r27++, arg1++) {
GXUnknownu16(arg1->unk04[0][0]);
GXUnknownu16(arg1->indices[0][0]);
if (var_r26 == -1) {
GXUnknownu16(arg1->unk04[0][1]);
GXUnknownu16(arg1->indices[0][1]);
} else {
MakeCalcNBT(arg0, arg1, 0, 1);
}
if (temp_r30->vtxMode == 5) {
temp_r28 = arg1->unk04[0][2];
temp_r28 = arg1->indices[0][2];
GXUnknownu16(temp_r28);
if (((GXColor*) arg0->data.color->data)[temp_r28].a != 0xFF) {
Hu3DObjInfoP->flags |= 0x4001;
}
}
if (var_r25 != 0) {
GXUnknownu16(arg1->unk04[0][3]);
GXUnknownu16(arg1->indices[0][3]);
}
GXUnknownu16(arg1->unk04[2][0]);
GXUnknownu16(arg1->indices[2][0]);
if (var_r26 == -1) {
GXUnknownu16(arg1->unk04[2][1]);
GXUnknownu16(arg1->indices[2][1]);
} else {
MakeNBT(arg0, arg1, 2, 0);
}
if (temp_r30->vtxMode == 5) {
temp_r28 = arg1->unk04[2][2];
temp_r28 = arg1->indices[2][2];
GXUnknownu16(temp_r28);
if (((GXColor*) arg0->data.color->data)[temp_r28].a != 0xFF) {
Hu3DObjInfoP->flags |= 0x4001;
}
}
if (var_r25 != 0) {
GXUnknownu16(arg1->unk04[2][3]);
GXUnknownu16(arg1->indices[2][3]);
}
GXUnknownu16(arg1->unk04[1][0]);
GXUnknownu16(arg1->indices[1][0]);
if (var_r26 == -1) {
GXUnknownu16(arg1->unk04[1][1]);
GXUnknownu16(arg1->indices[1][1]);
} else {
MakeNBT(arg0, arg1, 1, 2);
}
if (temp_r30->vtxMode == 5) {
temp_r28 = arg1->unk04[1][2];
temp_r28 = arg1->indices[1][2];
GXUnknownu16(temp_r28);
if (((GXColor*) arg0->data.color->data)[temp_r28].a != 0xFF) {
Hu3DObjInfoP->flags |= 0x4001;
}
}
if (var_r25 != 0) {
GXUnknownu16(arg1->unk04[1][3]);
GXUnknownu16(arg1->indices[1][3]);
}
}
faceCnt = faceNumBuf[drawCnt] / 3;
@ -2619,125 +2610,125 @@ static void MDFaceDraw(HsfObject *arg0, HsfdrawStruct02 *arg1) {
case 3:
GXBegin(GX_QUADS, GX_VTXFMT0, faceNumBuf[drawCnt]);
for (var_r27 = 0; var_r27 < faceNumBuf[drawCnt] / 4; var_r27++, arg1++) {
GXUnknownu16(arg1->unk04[0][0]);
GXUnknownu16(arg1->indices[0][0]);
if (var_r26 == -1) {
GXUnknownu16(arg1->unk04[0][1]);
GXUnknownu16(arg1->indices[0][1]);
} else {
MakeCalcNBT(arg0, arg1, 0, 1);
}
if (temp_r30->vtxMode == 5) {
temp_r28 = arg1->unk04[0][2];
temp_r28 = arg1->indices[0][2];
GXUnknownu16(temp_r28);
if (((GXColor*) arg0->data.color->data)[temp_r28].a != 0xFF) {
Hu3DObjInfoP->flags |= 0x4001;
}
}
if (var_r25 != 0) {
GXUnknownu16(arg1->unk04[0][3]);
GXUnknownu16(arg1->indices[0][3]);
}
GXUnknownu16(arg1->unk04[2][0]);
GXUnknownu16(arg1->indices[2][0]);
if (var_r26 == -1) {
GXUnknownu16(arg1->unk04[2][1]);
GXUnknownu16(arg1->indices[2][1]);
} else {
MakeNBT(arg0, arg1, 2, 0);
}
if (temp_r30->vtxMode == 5) {
temp_r28 = arg1->unk04[2][2];
temp_r28 = arg1->indices[2][2];
GXUnknownu16(temp_r28);
if (((GXColor*) arg0->data.color->data)[temp_r28].a != 0xFF) {
Hu3DObjInfoP->flags |= 0x4001;
}
}
if (var_r25 != 0) {
GXUnknownu16(arg1->unk04[2][3]);
GXUnknownu16(arg1->indices[2][3]);
}
GXUnknownu16(arg1->unk04[3][0]);
GXUnknownu16(arg1->indices[3][0]);
if (var_r26 == -1) {
GXUnknownu16(arg1->unk04[3][1]);
GXUnknownu16(arg1->indices[3][1]);
} else {
MakeNBT(arg0, arg1, 3, 2);
}
if (temp_r30->vtxMode == 5) {
temp_r28 = arg1->unk04[3][2];
temp_r28 = arg1->indices[3][2];
GXUnknownu16(temp_r28);
if (((GXColor*) arg0->data.color->data)[temp_r28].a != 0xFF) {
Hu3DObjInfoP->flags |= 0x4001;
}
}
if (var_r25 != 0) {
GXUnknownu16(arg1->unk04[3][3]);
GXUnknownu16(arg1->indices[3][3]);
}
GXUnknownu16(arg1->unk04[1][0]);
GXUnknownu16(arg1->indices[1][0]);
if (var_r26 == -1) {
GXUnknownu16(arg1->unk04[1][1]);
GXUnknownu16(arg1->indices[1][1]);
} else {
MakeNBT(arg0, arg1, 1, 3);
}
if (temp_r30->vtxMode == 5) {
temp_r28 = arg1->unk04[1][2];
temp_r28 = arg1->indices[1][2];
GXUnknownu16(temp_r28);
if (((GXColor*) arg0->data.color->data)[temp_r28].a != 0xFF) {
Hu3DObjInfoP->flags |= 0x4001;
}
}
if (var_r25 != 0) {
GXUnknownu16(arg1->unk04[1][3]);
GXUnknownu16(arg1->indices[1][3]);
}
}
faceCnt = faceNumBuf[drawCnt] / 4;
break;
case 4:
GXBegin(GX_TRIANGLESTRIP, GX_VTXFMT0, faceNumBuf[drawCnt]);
GXUnknownu16(arg1->unk04[0][0]);
GXUnknownu16(arg1->indices[0][0]);
if (var_r26 == -1) {
GXUnknownu16(arg1->unk04[0][1]);
GXUnknownu16(arg1->indices[0][1]);
} else {
MakeCalcNBT(arg0, arg1, 0, 1);
}
if (temp_r30->vtxMode == 5) {
temp_r28 = arg1->unk04[0][2];
temp_r28 = arg1->indices[0][2];
GXUnknownu16(temp_r28);
if (((GXColor*) arg0->data.color->data)[temp_r28].a != 0xFF) {
Hu3DObjInfoP->flags |= 0x4001;
}
}
if (var_r25 != 0) {
GXUnknownu16(arg1->unk04[0][3]);
GXUnknownu16(arg1->indices[0][3]);
}
GXUnknownu16(arg1->unk04[2][0]);
GXUnknownu16(arg1->indices[2][0]);
if (var_r26 == -1) {
GXUnknownu16(arg1->unk04[2][1]);
GXUnknownu16(arg1->indices[2][1]);
} else {
MakeNBT(arg0, arg1, 2, 0);
}
if (temp_r30->vtxMode == 5) {
temp_r28 = arg1->unk04[2][2];
temp_r28 = arg1->indices[2][2];
GXUnknownu16(temp_r28);
if (((GXColor*) arg0->data.color->data)[temp_r28].a != 0xFF) {
Hu3DObjInfoP->flags |= 0x4001;
}
}
if (var_r25 != 0) {
GXUnknownu16(arg1->unk04[2][3]);
GXUnknownu16(arg1->indices[2][3]);
}
GXUnknownu16(arg1->unk04[1][0]);
GXUnknownu16(arg1->indices[1][0]);
if (var_r26 == -1) {
GXUnknownu16(arg1->unk04[1][1]);
GXUnknownu16(arg1->indices[1][1]);
} else {
MakeNBT(arg0, arg1, 1, 2);
}
if (temp_r30->vtxMode == 5) {
temp_r28 = arg1->unk04[1][2];
temp_r28 = arg1->indices[1][2];
GXUnknownu16(temp_r28);
if (((GXColor*) arg0->data.color->data)[temp_r28].a != 0xFF) {
Hu3DObjInfoP->flags |= 0x4001;
}
}
if (var_r25 != 0) {
GXUnknownu16(arg1->unk04[1][3]);
GXUnknownu16(arg1->indices[1][3]);
}
var_r24 = arg1->unk20;
for (var_r27 = 0; var_r27 < arg1->unk1C; var_r27++, var_r24 += 4) {
var_r24 = arg1->strip.data;
for (var_r27 = 0; var_r27 < arg1->strip.count; var_r27++, var_r24 += 4) {
GXUnknownu16(var_r24[0]);
if (var_r26 == -1) {
GXUnknownu16(var_r24[1]);
@ -2755,7 +2746,7 @@ static void MDFaceDraw(HsfObject *arg0, HsfdrawStruct02 *arg1) {
GXUnknownu16(var_r24[3]);
}
}
faceCnt = arg1->unk1C + 1;
faceCnt = arg1->strip.count + 1;
break;
}
temp_r3 = GXEndDisplayList();
@ -2767,7 +2758,7 @@ static void MDFaceDraw(HsfObject *arg0, HsfdrawStruct02 *arg1) {
}
}
static s32 MakeCalcNBT(HsfObject *arg0, HsfdrawStruct02 *arg1, s16 arg2, s16 arg3) {
static s32 MakeCalcNBT(HsfObject *arg0, HsfFace *arg1, s16 arg2, s16 arg3) {
Vec sp10;
Vec *temp_r29;
Vec *temp_r31;
@ -2777,10 +2768,10 @@ static s32 MakeCalcNBT(HsfObject *arg0, HsfdrawStruct02 *arg1, s16 arg2, s16 arg
s16 temp_r27;
temp_r31 = arg0->data.vertex->data;
temp_r27 = arg1->unk04[arg2][1];
temp_r25 = arg1->unk04[arg2][0];
temp_r24 = arg1->unk04[arg3][0];
if (arg0->data.hook != 0) {
temp_r27 = arg1->indices[arg2][1];
temp_r25 = arg1->indices[arg2][0];
temp_r24 = arg1->indices[arg3][0];
if (arg0->data.cenvCnt != 0) {
temp_r29 = arg0->data.normal->data;
sp10.x = temp_r29[temp_r27].x;
sp10.y = temp_r29[temp_r27].y;
@ -2802,7 +2793,7 @@ static s32 MakeCalcNBT(HsfObject *arg0, HsfdrawStruct02 *arg1, s16 arg2, s16 arg
GXPosition3s16(NBTT.x * 256.0f, NBTT.y * 256.0f, NBTT.z * 256.0f);
}
static s32 MakeNBT(HsfObject *arg0, HsfdrawStruct02 *arg1, s16 arg2, s16 arg3) {
static s32 MakeNBT(HsfObject *arg0, HsfFace *arg1, s16 arg2, s16 arg3) {
Vec sp10;
Vec *temp_r30;
Vec *spC;
@ -2810,8 +2801,8 @@ static s32 MakeNBT(HsfObject *arg0, HsfdrawStruct02 *arg1, s16 arg2, s16 arg3) {
s16 temp_r28;
spC = arg0->data.vertex->data;
temp_r28 = arg1->unk04[arg2][1];
if (arg0->data.hook != 0) {
temp_r28 = arg1->indices[arg2][1];
if (arg0->data.cenvCnt != 0) {
temp_r30 = arg0->data.normal->data;
sp10.x = temp_r30[temp_r28].x;
sp10.y = temp_r30[temp_r28].y;
@ -2828,15 +2819,15 @@ static s32 MakeNBT(HsfObject *arg0, HsfdrawStruct02 *arg1, s16 arg2, s16 arg3) {
GXPosition3s16(NBTT.x * 256.0f, NBTT.y * 256.0f, NBTT.z * 256.0f);
}
static void MDFaceCnt(HsfObject *arg0, HsfdrawStruct02 *arg1) {
static void MDFaceCnt(HsfObject *arg0, HsfFace *arg1) {
HsfMaterial *temp_r30;
s16 i;
temp_r30 = &arg0->data.material[arg1->unk02 & 0xFFF];
temp_r30 = &arg0->data.material[arg1->mat & 0xFFF];
// Bug? Likely to be polyTypeBak != (arg1->unk00 & 7)
if (temp_r30 != materialBak || ((polyTypeBak != arg1->unk00) & 7) || (arg1->unk00 & 7) == 4) {
if (temp_r30 != materialBak || ((polyTypeBak != arg1->type) & 7) || (arg1->type & 7) == 4) {
polySize = 4;
polyTypeBak = arg1->unk00 & 7;
polyTypeBak = arg1->type & 7;
materialBak = temp_r30;
matChgCnt++;
if (DLFirstF != 0) {
@ -2858,7 +2849,7 @@ static void MDFaceCnt(HsfObject *arg0, HsfdrawStruct02 *arg1) {
polySize += 2;
}
}
switch (arg1->unk00 & 7) {
switch (arg1->type & 7) {
case 0:
OSReport("Error\n");
break;
@ -2877,9 +2868,9 @@ static void MDFaceCnt(HsfObject *arg0, HsfdrawStruct02 *arg1) {
break;
case 4:
triCnt++;
faceNumBuf[drawCnt] += arg1->unk1C + 3;
faceNumBuf[drawCnt] += arg1->strip.count + 3;
DLTotalNum += polySize * 3;
DLTotalNum += polySize * arg1->unk1C;
DLTotalNum += polySize * arg1->strip.count;
break;
default:
OSReport("Error\n");

14
src/game/hsfload.c
View file

@ -3,6 +3,8 @@
#include "ctype.h"
#define AS_S16(field) (*((s16 *)&(field)))
#define AS_U16(field) (*((u16 *)&(field)))
GXColor rgba[100];
HsfHeader head;
HsfData Model;
@ -401,7 +403,7 @@ static void FaceLoad(void)
HsfFace *data;
HsfFace *file_face_strip;
HsfFace *new_face_strip;
HsfTristrip *strip;
u8 *strip;
s32 i;
s32 j;
@ -418,14 +420,14 @@ static void FaceLoad(void)
new_face->name = SetName((u32 *)&file_face->name);
new_face->count = file_face->count;
new_face->data = (void *)((u32)data+(u32)temp_data);
strip = (HsfTristrip *)(&((HsfFace *)new_face->data)[new_face->count]);
strip = (u8 *)(&((HsfFace *)new_face->data)[new_face->count]);
}
new_face = temp_face;
for(i=0; i<head.face.count; i++, new_face++) {
file_face_strip = new_face_strip = new_face->data;
for(j=0; j<new_face->count; j++, new_face_strip++, file_face_strip++) {
if(file_face_strip->type == 4) {
new_face_strip->strip.data = &strip[(u32)file_face_strip->strip.data];
if(AS_U16(file_face_strip->type) == 4) {
new_face_strip->strip.data = (s16 *)(strip+(u32)file_face_strip->strip.data*(sizeof(s16)*4));
}
}
}
@ -892,14 +894,14 @@ static void MapAttrLoad(void)
HsfMapAttr *mapattr_base;
HsfMapAttr *mapattr_file;
HsfMapAttr *mapattr_new;
s16 *data;
u16 *data;
if(head.mapAttr.count) {
mapattr_file = mapattr_base = (HsfMapAttr *)((u32)fileptr+head.mapAttr.ofs);
mapattr_new = mapattr_base;
Model.mapAttrCnt = head.mapAttr.count;
Model.mapAttr = mapattr_base;
data = (s16 *)&mapattr_base[head.mapAttr.count];
data = (u16 *)&mapattr_base[head.mapAttr.count];
for(i=0; i<head.mapAttr.count; i++, mapattr_file++, mapattr_new++) {
mapattr_new->data = &data[(u32)mapattr_file->data];
}

8
src/game/hsfman.c
View file

@ -2063,10 +2063,10 @@ void Hu3DProjectionKill(s16 arg0) {
Hu3DProjection[arg0].unk_04 = NULL;
}
void Hu3DProjectionPosSet(s16 arg0, Vec arg1, Vec arg2, Vec arg3) {
Hu3DProjection[arg0].unk_14 = arg1;
Hu3DProjection[arg0].unk_20 = arg3;
Hu3DProjection[arg0].unk_2C = arg2;
void Hu3DProjectionPosSet(s16 arg0, Vec* arg1, Vec* arg2, Vec* arg3) {
Hu3DProjection[arg0].unk_14 = *arg1;
Hu3DProjection[arg0].unk_20 = *arg3;
Hu3DProjection[arg0].unk_2C = *arg2;
}
void Hu3DProjectionTPLvlSet(s16 arg0, f32 arg8) {

3
src/game/init.c
View file

@ -1,4 +1,5 @@
#include "game/init.h"
#include "game/fault.h"
#include "dolphin/os.h"
#include "dolphin/gx.h"
#include "dolphin/dvd.h"
@ -14,8 +15,6 @@ extern void HuAudInit();
extern void HuCardInit();
extern void HuARInit();
extern u32 frand();
extern void HuFaultInitXfbDirectDraw(GXRenderModeObj *mode);
extern void HuFaultSetXfbAddress(int fb, void *addr);
static GXRenderModeObj rmodeobj;

86
src/game/main.c
View file

@ -15,35 +15,34 @@
extern FileListEntry _ovltbl[];
u32 GlobalCounter;
u32 lbl_801D3A50;
u32 lbl_801D3A4C;
u32 lbl_801D3A48;
u32 lbl_801D3A44;
u32 lbl_801D3A40;
u32 lbl_801D3A3C;
u32 lbl_801D3A38;
u32 lbl_801D3A34;
u32 lbl_801D3A30;
u32 lbl_801D3A2C;
u32 lbl_801D3A28;
u32 lbl_801D3A24;
u32 lbl_801D3A20;
u32 lbl_801D3A1C;
u32 lbl_801D3A18;
u32 lbl_801D3A14;
u32 lbl_801D3A10;
u32 lbl_801D3A0C;
u32 lbl_801D3A08;
static u32 vcheck;
static u32 vmiss;
static u32 vstall;
static u32 top_pixels_in;
static u32 top_pixels_out;
static u32 bot_pixels_in;
static u32 bot_pixels_out;
static u32 clr_pixels_in;
static u32 total_copy_clks;
static u32 cp_req;
static u32 tc_req;
static u32 cpu_rd_req;
static u32 cpu_wr_req;
static u32 dsp_req;
static u32 io_req;
static u32 vi_req;
static u32 pe_req;
static u32 rf_req;
static u32 fi_req;
s32 HuDvdErrWait;
s32 SystemInitF;
void main(void) {
u32 sp14;
u32 sp10;
s32 spC;
s32 sp8;
s16 var_r31;
s32 temp_r30;
void main(void)
{
u32 met0;
u32 met1;
s16 i;
s32 retrace;
HuDvdErrWait = 0;
SystemInitF = 0;
@ -58,14 +57,14 @@ void main(void) {
HuDataInit();
HuPerfInit();
HuPerfCreate("USR0", 0xFF, 0xFF, 0xFF, 0xFF);
HuPerfCreate("USR1", 0, 0xFF, 0xFF, 0xFF);
HuPerfCreate("USR1", 0, 0xFF, 0xFF, 0xFF);
WipeInit(RenderMode);
for (var_r31 = 0; var_r31 < 4; var_r31++) {
GWPlayerCfg[var_r31].character = -1;
for (i = 0; i < 4; i++) {
GWPlayerCfg[i].character = -1;
}
omMasterInit(0, _ovltbl, 0x63, 1);
omMasterInit(0, _ovltbl, OVL_COUNT, OVL_BOOT);
VIWaitForRetrace();
if (VIGetNextField() == 0) {
@ -73,7 +72,7 @@ void main(void) {
VIWaitForRetrace();
}
while (1) {
temp_r30 = VIGetRetraceCount();
retrace = VIGetRetraceCount();
if (HuSoftResetButtonCheck() != 0 || HuDvdErrWait != 0) {
continue;
}
@ -100,28 +99,31 @@ void main(void) {
pfDrawFonts();
HuPerfEnd(1);
msmMusFdoutEnd();
HuSysDoneRender(temp_r30);
GXReadGPMetric(&sp14, &sp10);
GXReadVCacheMetric(&lbl_801D3A50, &lbl_801D3A4C, &lbl_801D3A48);
GXReadPixMetric(&lbl_801D3A44, &lbl_801D3A40, &lbl_801D3A3C, &lbl_801D3A38, &lbl_801D3A34, &lbl_801D3A30);
GXReadMemMetric(&lbl_801D3A2C, &lbl_801D3A28, &lbl_801D3A24, &lbl_801D3A20, &lbl_801D3A1C, &lbl_801D3A18, &lbl_801D3A14, &lbl_801D3A10, &lbl_801D3A0C, &lbl_801D3A08);
HuSysDoneRender(retrace);
GXReadGPMetric(&met0, &met1);
GXReadVCacheMetric(&vcheck, &vmiss, &vstall);
GXReadPixMetric(&top_pixels_in, &top_pixels_out, &bot_pixels_in, &bot_pixels_out, &clr_pixels_in, &total_copy_clks);
GXReadMemMetric(&cp_req, &tc_req, &cpu_rd_req, &cpu_wr_req, &dsp_req, &io_req, &vi_req, &pe_req, &rf_req, &fi_req);
HuPerfEnd(2);
GlobalCounter++;
}
}
void HuSysVWaitSet(s16 arg0) {
minimumVcount = arg0;
minimumVcountf = arg0;
void HuSysVWaitSet(s16 vcount)
{
minimumVcount = vcount;
minimumVcountf = vcount;
}
s16 HuSysVWaitGet(void) {
s16 HuSysVWaitGet(s16 param)
{
return (s16) minimumVcount;
}
s32 rnd_seed = 0x0000D9ED;
s32 rand8(void) {
s32 rand8(void)
{
rnd_seed = (rnd_seed * 0x41C64E6D) + 0x3039;
return (u8)(((rnd_seed + 1) >> 0x10) & 0xFF);
return (u8)(((rnd_seed + 1) >> 16) & 0xFF);
}

911
src/game/mapspace.c Executable file
View file

@ -0,0 +1,911 @@
#include "game/mapspace.h"
#include "game/hsfman.h"
#include "math.h"
extern void HuSetVecF(Vec*, double, double, double);
static BOOL PolygonRangeCheck(HsfMapAttr *arg0, float arg1, float arg2, float *arg3, float arg4);
static s32 DefIfnnerMapCircle(Vec *arg0, s16 *arg1, Vec *arg2, Vec *arg3);
static s32 CalcPPLength(float *arg0, s16 *arg1, Vec *arg2);
static float MapIflnnerCalc(float arg0, float arg1, float arg2, Vec *arg3, Vec *arg4, Vec *arg5);
static float MapCalcPoint(float arg0, float arg1, float arg2, Vec *arg3, u16 *arg4);
static BOOL AreaCheck(float arg0, float arg1, u16 *arg2, Vec *arg3);
static s32 MapIflnnerTriangle(float arg0, float arg1, u16 *arg2, Vec *arg3);
static s32 MapIflnnerQuadrangle(float arg0, float arg1, u16 *arg2, Vec *arg3);
static BOOL GetPolygonCircleMtx(s16 *arg0, Vec *arg1, float *arg2, float *arg3);
static s32 PrecalcPntToTriangle(Vec *arg0, Vec *arg1, Vec *arg2, Vec* arg3, Vec *arg4, Vec *arg5);
static void DefSetHitFace(float arg0, float arg1, float arg2);
omObjData *MapObject[16];
Mtx MapMT;
Mtx MapMTR;
static Vec MTRAdd;
static Vec FieldVec;
s32 ColisionIdx[10][3];
Vec HitFaceVec[32];
static Vec OldXYZ;
Vec HitFace[32];
u8 CharObject[0x30];
float AddX;
float AddZ;
s32 nMap;
s32 nChar;
s32 HitFaceCount;
static HsfData *AttrHsf;
static Vec *topvtx;
s32 ColisionCount;
void MapWall(float arg0, float arg1, float arg2, float arg3) {
float sp28[4];
float sp18[4];
float var_f31;
float var_f30;
float var_f29;
omObjData *var_r25;
ModelData *var_r26;
HsfData *temp_r29;
HsfMapAttr *sp14;
HsfMapAttr *var_r31;
s32 temp_r24;
s32 i;
s32 j;
for (i = 0; i < nMap; i++) {
var_r25 = MapObject[i];
temp_r24 = MapObject[i]->model[0];
sp18[0] = sp28[0] = arg1;
sp18[1] = sp28[1] = arg2;
sp18[2] = sp28[2] = arg3;
sp18[3] = sp28[3] = arg0;
var_f31 = sp28[3];
CharRotInv(MapMT, MapMTR, (Vec*) sp18, var_r25);
ColisionCount = 0;
HitFaceCount = 0;
var_r26 = &Hu3DData[temp_r24];
temp_r29 = var_r26->hsfData;
AttrHsf = temp_r29;
sp14 = AttrHsf->mapAttr;
var_r31 = temp_r29->mapAttr;
for (j = 0; j < temp_r29->mapAttrCnt; j++, var_r31++) {
var_f30 = sp18[0];
var_f29 = sp18[2];
sp18[3] = arg0;
if (var_r31->minX <= var_f30 + var_f31 && var_r31->maxX > var_f30 - var_f31
&& var_r31->minZ <= var_f29 + var_f31 && var_r31->maxZ > var_f29 - var_f31) {
MapWallCheck(sp28, sp18, var_r31);
}
}
}
}
void MapWallCheck(float *arg0, float *arg1, HsfMapAttr *arg2) {
u32 var_r30;
u16 temp_r29;
u16 *var_r31;
s32 var_r28;
Mtx sp10;
var_r28 = 0;
var_r28 = 0;
topvtx = AttrHsf->vertex->data;
var_r31 = arg2->data;
MTRAdd.x = AddX;
MTRAdd.z = AddZ;
MTRAdd.y = 0.0f;
PSMTXInvXpose(MapMT, sp10);
PSMTXMultVec(sp10, &MTRAdd, &MTRAdd);
for (var_r30 = 0; var_r30 < arg2->dataLen;) {
temp_r29 = *var_r31;
if (temp_r29 & 0x8000) {
GetPolygonCircleMtx((s16*) var_r31, topvtx, arg0, arg1);
var_r28++;
}
var_r30 += (temp_r29 & 0xFF) + 1;
var_r31 += (temp_r29 & 0xFF) + 1;
}
}
float MapPos(float arg0, float arg1, float arg2, float arg3, Vec *arg4) {
Vec sp14;
float var_f31;
float var_f29;
float sp10;
float var_f28;
HsfMapAttr *var_r29;
ModelData *var_r24;
omObjData *temp_r27;
s32 i;
s32 j;
HsfData *temp_r25;
Mtx sp20;
var_f31 = -100000.0f;
ColisionCount = 0;
for (i = 0; i < nMap; i++) {
temp_r27 = MapObject[i];
var_r24 = &Hu3DData[*temp_r27->model];
temp_r25 = var_r24->hsfData;
sp14.x = arg0;
sp14.y = arg1;
sp14.z = arg2;
CharRotInv(MapMT, MapMTR, &sp14, temp_r27);
var_f29 = sp14.x;
var_f28 = sp14.z;
AttrHsf = temp_r25;
var_r29 = AttrHsf->mapAttr;
for (j = 0; j < temp_r25->mapAttrCnt; j++, var_r29++) {
if (var_r29->minX <= var_f29 && var_r29->maxX >= var_f29
&& var_r29->minZ <= var_f28 && var_r29->maxZ >= var_f28
&& PolygonRangeCheck(var_r29, var_f29, var_f28, &sp10, arg1 + arg3) == TRUE) {
sp14.x = var_f29;
sp14.y = sp10;
sp14.z = var_f28;
PSMTXMultVec(MapMT, &sp14, &sp14);
sp10 = sp14.y;
if (sp10 > arg1 + arg3 || fabs(arg1 - sp10) > fabs(arg1 - var_f31)) {
continue;
}
var_f31 = sp10;
arg4->x = FieldVec.x;
arg4->y = FieldVec.y;
arg4->z = FieldVec.z;
PSMTXInvXpose(MapMT, sp20);
PSMTXMultVec(sp20, arg4, arg4);
var_f31 = sp14.y;
}
}
}
if (var_f31 == -100000.0f) {
arg4->x = 0.0f;
arg4->y = 1.0f;
arg4->x = 0.0f;
return arg1;
} else {
return var_f31;
}
}
BOOL PolygonRangeCheck(HsfMapAttr *arg0, float arg1, float arg2, float *arg3, float arg4) {
Vec sp20;
float temp_f29;
float var_f27;
u16 *var_r31;
u16 temp_r29;
s32 var_r28;
s32 var_r27;
s32 i;
var_r28 = 0;
var_r27 = 0;
var_f27 = 100000.0f;
topvtx = AttrHsf->vertex->data;
var_r31 = arg0->data;
for (i = 0; i < arg0->dataLen;) {
temp_r29 = *var_r31;
if (temp_r29 & 0x8000) {
i += (temp_r29 & 0xFF) + 1;
var_r31 += (temp_r29 & 0xFF) + 1;
} else {
switch (temp_r29 & 0xFF) {
case 1:
i += 2;
var_r31 += 2;
break;
case 2:
i += 3;
var_r31 += 3;
break;
case 3:
if (AreaCheck(arg1, arg2, var_r31, topvtx) == TRUE) {
var_r28++;
if (MapIflnnerTriangle(arg1, arg2, var_r31, topvtx) == 1) {
temp_f29 = MapCalcPoint(arg1, 0.0f, arg2, topvtx, var_r31);
sp20.x = arg1;
sp20.y = temp_f29;
sp20.z = arg2;
PSMTXMultVec(MapMT, &sp20, &sp20);
if (arg4 > sp20.y && var_f27 > fabs(arg4 - sp20.y)) {
var_f27 = fabs(arg4 - sp20.y);
*arg3 = temp_f29;
var_r27 = 1;
}
}
}
i += 4;
var_r31 += 4;
break;
case 4:
if (AreaCheck(arg1, arg2, var_r31, topvtx) == TRUE) {
var_r28++;
if (MapIflnnerQuadrangle(arg1, arg2, var_r31, topvtx) == 1) {
temp_f29 = MapCalcPoint(arg1, 0.0f, arg2, topvtx, var_r31);
sp20.x = arg1;
sp20.y = temp_f29;
sp20.z = arg2;
PSMTXMultVec(MapMT, &sp20, &sp20);
if (arg4 > sp20.y) {
if (var_f27 > fabs(arg4 - sp20.y)) {
var_f27 = fabs(arg4 - sp20.y);
*arg3 = temp_f29;
var_r27 = 1;
}
}
}
}
i += 5;
var_r31 += 5;
break;
default:
i++;
var_r31++;
break;
}
}
}
if (var_r27 != 0) {
return TRUE;
} else {
return FALSE;
}
}
static s32 DefIfnnerMapCircle(Vec *arg0, s16 *arg1, Vec *arg2, Vec *arg3) {
float temp_f30;
float temp_f29;
float temp_f28;
float var_f31;
s32 var_r28;
s32 var_r27;
s32 var_r25;
temp_f30 = arg0->x;
temp_f29 = arg0->y;
temp_f28 = arg0->z;
var_r27 = *arg1 & 0xFF;
arg1++;
if (var_r27 == 3) {
var_f31 = MapIflnnerCalc(temp_f30, temp_f29, temp_f28, &arg2[arg1[0]], &arg2[arg1[1]], arg3);
if (var_f31 > 0.0f) {
for (var_r28 = 1; var_r28 < var_r27; var_r28++) {
var_r25 = (var_r28 + 1) % var_r27;
var_f31 = MapIflnnerCalc(temp_f30, temp_f29, temp_f28, &arg2[arg1[var_r28]], &arg2[arg1[var_r25]], arg3);
if (var_f31 < 0.0f) {
return 0;
}
}
return 1;
} else {
for (var_r28 = 1; var_r28 < var_r27; var_r28++) {
var_r25 = (var_r28 + 1) % var_r27;
var_f31 = MapIflnnerCalc(temp_f30, temp_f29, temp_f28, &arg2[arg1[var_r28]], &arg2[arg1[var_r25]], arg3);
if (var_f31 > 0.0f) {
return 0;
}
}
return 1;
}
} else if (var_r27 == 4) {
var_f31 = MapIflnnerCalc(temp_f30, temp_f29, temp_f28, &arg2[arg1[0]], &arg2[arg1[2]], arg3);
if (var_f31 > 0.0f) {
var_f31 = MapIflnnerCalc(temp_f30, temp_f29, temp_f28, &arg2[arg1[2]], &arg2[arg1[3]], arg3);
if (var_f31 < 0.0f) {
var_r27 = 1;
} else {
var_f31 = MapIflnnerCalc(temp_f30, temp_f29, temp_f28, &arg2[arg1[3]], &arg2[arg1[0]], arg3);
if (var_f31 < 0.0f) {
var_r27 = 1;
}
}
} else {
var_f31 = MapIflnnerCalc(temp_f30, temp_f29, temp_f28, &arg2[arg1[2]], &arg2[arg1[3]], arg3);
if (var_f31 > 0.0f) {
var_r27 = 1;
} else {
var_f31 = MapIflnnerCalc(temp_f30, temp_f29, temp_f28, &arg2[arg1[3]], &arg2[arg1[0]], arg3);
if (var_f31 > 0.0f) {
var_r27 = 1;
}
}
}
if (var_r27 != 0) {
var_f31 = MapIflnnerCalc(temp_f30, temp_f29, temp_f28, &arg2[arg1[0]], &arg2[arg1[3]], arg3);
if (var_f31 > 0.0f) {
var_f31 = MapIflnnerCalc(temp_f30, temp_f29, temp_f28, &arg2[arg1[3]], &arg2[arg1[1]], arg3);
if (var_f31 < 0.0f) {
return 0;
}
var_f31 = MapIflnnerCalc(temp_f30, temp_f29, temp_f28, &arg2[arg1[1]], &arg2[arg1[0]], arg3);
if (var_f31 < 0.0f) {
return 0;
}
} else {
var_f31 = MapIflnnerCalc(temp_f30, temp_f29, temp_f28, &arg2[arg1[3]], &arg2[arg1[1]], arg3);
if (var_f31 > 0.0f) {
return 0;
}
var_f31 = MapIflnnerCalc(temp_f30, temp_f29, temp_f28, &arg2[arg1[1]], &arg2[arg1[0]], arg3);
if (var_f31 > 0.0f) {
return 0;
}
}
}
}
return 0;
}
static inline void MapspaceInlineFunc00(Vec *arg0) {
float sp24;
float sp28;
float sp2C;
float sp14;
sp24 = arg0->x;
sp28 = arg0->y;
sp2C = arg0->z;
sp14 = sqrtf(sp24 * sp24 + sp28 * sp28 + sp2C * sp2C);
if (sp14 != 0.0f) {
arg0->x /= sp14;
arg0->y /= sp14;
arg0->z /= sp14;
}
}
static inline void MapspaceInlineFunc01(Vec *arg0, Vec *arg1, Vec *arg2, Vec *arg3) {
float sp48;
float sp4C;
float sp50;
float temp_f18;
float temp_f19;
float temp_f20;
sp48 = arg2->x - arg1->x;
sp4C = arg2->y - arg1->y;
sp50 = arg2->z - arg1->z;
temp_f18 = arg3->x - arg1->x;
temp_f19 = arg3->y - arg1->y;
temp_f20 = arg3->z - arg1->z;
arg0->x = sp4C * temp_f20 - sp50 * temp_f19;
arg0->y = sp50 * temp_f18 - sp48 * temp_f20;
arg0->z = sp48 * temp_f19 - sp4C * temp_f18;
MapspaceInlineFunc00(arg0);
}
static s32 CalcPPLength(float *arg0, s16 *arg1, Vec *arg2) {
Vec *temp_r29;
Vec sp68;
float temp_f25;
float temp_f24;
float temp_f23;
float temp_f22;
float temp_f21;
float sp5C;
float sp58;
float sp54;
s16 temp_r24;
s16 temp_r22;
s32 var_r23;
var_r23 = -1;
temp_r24 = arg1[0];
if (!(temp_r24 & 0x8000)) {
return 0;
}
if ((temp_r24 & 0xFF) == 4) {
MapspaceInlineFunc01(&sp68, &arg2[arg1[1]], &arg2[arg1[4]], &arg2[arg1[3]]);
} else {
MapspaceInlineFunc01(&sp68, &arg2[arg1[1]], &arg2[arg1[2]], &arg2[arg1[3]]);
}
temp_r22 = arg1[1];
temp_r29 = &arg2[temp_r22];
sp5C = temp_r29->x;
sp58 = temp_r29->y;
sp54 = temp_r29->z;
temp_f24 = sp5C - arg0[0];
temp_f23 = sp58 - arg0[1];
temp_f22 = sp54 - arg0[2];
temp_f21 = sp68.x * temp_f24 + sp68.y * temp_f23 + sp68.z * temp_f22;
if (temp_f21 >= 0.0f) {
var_r23 = 1;
}
if (fabs(temp_f21) > arg0[3]) {
return 0;
}
temp_f25 = sp68.x * temp_f24 + sp68.y * temp_f23 + sp68.z * temp_f22;
arg0[0] += sp68.x * temp_f25;
arg0[1] += sp68.y * temp_f25;
arg0[2] += sp68.z * temp_f25;
return var_r23;
}
static float MapIflnnerCalc(float arg0, float arg1, float arg2, Vec *arg3, Vec *arg4, Vec *arg5) {
float temp_f31;
float temp_f30;
float temp_f29;
float temp_f28;
float temp_f27;
float temp_f26;
float temp_f25;
temp_f31 = arg3->x - arg0;
temp_f30 = arg3->y - arg1;
temp_f29 = arg3->z - arg2;
temp_f28 = arg4->x - arg0;
temp_f27 = arg4->y - arg1;
temp_f26 = arg4->z - arg2;
temp_f25 = arg5->x * (temp_f30 * temp_f26 - temp_f29 * temp_f27)
+ arg5->y * (temp_f29 * temp_f28 - temp_f31 * temp_f26)
+ arg5->z * (temp_f31 * temp_f27 - temp_f30 * temp_f28);
return temp_f25;
}
static float MapCalcPoint(float arg0, float arg1, float arg2, Vec *arg3, u16 *arg4) {
Vec sp40;
float sp3C;
float sp38;
float sp34;
float sp30;
float sp2C;
float sp28;
float var_f28;
float var_f26;
float var_f25;
float var_f27;
float var_f24;
s32 temp_r27;
Vec *temp_r30;
temp_r27 = ColisionCount - 1;
temp_r30 = &arg3[ColisionIdx[temp_r27][0]];
sp34 = temp_r30->x;
sp38 = temp_r30->y;
sp3C = temp_r30->z;
sp30 = arg0;
var_f26 = arg1;
sp2C = arg2;
sp28 = 1.0f;
MapspaceInlineFunc01(&sp40, &arg3[ColisionIdx[temp_r27][0]], &arg3[ColisionIdx[temp_r27][1]], &arg3[ColisionIdx[temp_r27][2]]);
var_f25 = sp40.x;
var_f27 = sp40.y;
var_f24 = sp40.z;
FieldVec.x = var_f25;
FieldVec.y = var_f27;
FieldVec.z = var_f24;
var_f28 = var_f25 * (sp34 - sp30) + var_f27 * (sp38 - var_f26) + var_f24 * (sp3C - sp2C);
var_f28 /= var_f27;
return var_f26 + sp28 * var_f28;
}
static BOOL AreaCheck(float arg0, float arg1, u16 *arg2, Vec *arg3) {
float var_f31;
float var_f30;
float var_f29;
float var_f28;
s32 var_r29;
s32 temp_r31;
s32 i;
var_f31 = var_f30 = -100000.0f;
var_f29 = var_f28 = 100000.0f;
var_r29 = *arg2 & 0xFF;
arg2++;
for (i = 0; i < var_r29; i++, arg2++) {
temp_r31 = *arg2;
if (var_f29 > arg3[temp_r31].x) {
var_f29 = arg3[temp_r31].x;
}
if (var_f31 < arg3[temp_r31].x) {
var_f31 = arg3[temp_r31].x;
}
if (var_f28 > arg3[temp_r31].z) {
var_f28 = arg3[temp_r31].z;
}
if (var_f30 < arg3[temp_r31].z) {
var_f30 = arg3[temp_r31].z;
}
}
if (var_f29 <= arg0 && var_f31 >= arg0
&& var_f28 <= arg1 && var_f30 >= arg1) {
return TRUE;
} else {
return FALSE;
}
}
static inline float MapspaceInlineFunc02(float arg0, float arg1, Vec *arg2, Vec *arg3) {
float sp54;
float sp58;
float sp5C;
float sp60;
float sp64;
sp54 = arg2->x - arg0;
sp58 = arg2->z - arg1;
sp5C = arg3->x - arg0;
sp60 = arg3->z - arg1;
sp64 = -(sp58 * sp5C - sp54 * sp60);
return sp64;
}
static s32 MapIflnnerTriangle(float arg0, float arg1, u16 *arg2, Vec *arg3) {
Vec sp68;
float var_f29;
s32 var_r21;
s32 i;
MapspaceInlineFunc01(&sp68, &arg3[arg2[1]], &arg3[arg2[2]], &arg3[arg2[3]]);
if (sp68.y == 0.0f) {
return 0;
}
arg2++;
var_f29 = MapspaceInlineFunc02(arg0, arg1, &arg3[arg2[0]], &arg3[arg2[1]]);
if (var_f29 > 0.0f) {
for (i = 1; i < 3; i++) {
var_r21 = (i + 1) % 3;
var_f29 = MapspaceInlineFunc02(arg0, arg1, &arg3[arg2[i]], &arg3[arg2[var_r21]]);
if (var_f29 < 0.0f) {
return 0;
}
}
} else {
for (i = 1; i < 3; i++) {
var_r21 = (i + 1) % 3;
var_f29 = MapspaceInlineFunc02(arg0, arg1, &arg3[arg2[i]], &arg3[arg2[var_r21]]);
if (var_f29 > 0.0f) {
return 0;
}
}
}
ColisionIdx[ColisionCount][0] = arg2[0];
ColisionIdx[ColisionCount][1] = arg2[1];
ColisionIdx[ColisionCount][2] = arg2[2];
ColisionCount++;
return 1;
}
static s32 MapIflnnerQuadrangle(float arg0, float arg1, u16 *arg2, Vec *arg3) {
Vec sp158;
float var_f31;
s32 var_r28;
MapspaceInlineFunc01(&sp158, &arg3[arg2[1]], &arg3[arg2[2]], &arg3[arg2[3]]);
if (sp158.y == 0.0f) {
return 0;
}
var_r28 = 0;
arg2++;
var_f31 = MapspaceInlineFunc02(arg0, arg1, &arg3[arg2[0]], &arg3[arg2[3]]);
if (var_f31 > 0.0f) {
var_f31 = MapspaceInlineFunc02(arg0, arg1, &arg3[arg2[3]], &arg3[arg2[2]]);
if (var_f31 < 0.0f) {
var_r28 = 1;
} else {
var_f31 = MapspaceInlineFunc02(arg0, arg1, &arg3[arg2[2]], &arg3[arg2[0]]);
if (var_f31 < 0.0f) {
var_r28 = 1;
}
}
} else {
var_f31 = MapspaceInlineFunc02(arg0, arg1, &arg3[arg2[3]], &arg3[arg2[2]]);
if (var_f31 > 0.0f) {
var_r28 = 1;
} else {
var_f31 = MapspaceInlineFunc02(arg0, arg1, &arg3[arg2[2]], &arg3[arg2[0]]);
if (var_f31 > 0.0f) {
var_r28 = 1;
}
}
}
if (var_r28 == 0) {
ColisionIdx[ColisionCount][0] = arg2[0];
ColisionIdx[ColisionCount][1] = arg2[3];
ColisionIdx[ColisionCount][2] = arg2[2];
ColisionCount++;
return 1;
}
var_f31 = MapspaceInlineFunc02(arg0, arg1, &arg3[arg2[0]], &arg3[arg2[1]]);
if (var_f31 > 0.0f) {
var_f31 = MapspaceInlineFunc02(arg0, arg1, &arg3[arg2[1]], &arg3[arg2[3]]);
if (var_f31 < 0.0f) {
return 0;
}
var_f31 = MapspaceInlineFunc02(arg0, arg1, &arg3[arg2[3]], &arg3[arg2[0]]);
if (var_f31 < 0.0f) {
return 0;
}
} else {
var_f31 = MapspaceInlineFunc02(arg0, arg1, &arg3[arg2[1]], &arg3[arg2[3]]);
if (var_f31 > 0.0f) {
return 0;
}
var_f31 = MapspaceInlineFunc02(arg0, arg1, &arg3[arg2[3]], &arg3[arg2[0]]);
if (var_f31 > 0.0f) {
return 0;
}
}
ColisionIdx[ColisionCount][0] = arg2[0];
ColisionIdx[ColisionCount][1] = arg2[1];
ColisionIdx[ColisionCount][2] = arg2[3];
ColisionCount++;
return 1;
}
static inline s32 MapspaceInlineFunc03(float *spE0, s16 *temp_r31, Vec *arg1) {
Vec spAC;
Vec *temp_r21;
float sp70;
float sp74;
float sp78;
float sp7C;
s16 sp8;
MapspaceInlineFunc01(&spAC, &arg1[temp_r31[0]], &arg1[temp_r31[1]], &arg1[temp_r31[2]]);
sp8 = temp_r31[1];
temp_r21 = &arg1[sp8];
sp70 = temp_r21->x;
sp74 = temp_r21->y;
sp78 = temp_r21->z;
sp70 -= spE0[0];
sp74 -= spE0[1];
sp78 -= spE0[2];
sp7C = spAC.x * sp70 + spAC.y * sp74 + spAC.z * sp78;
return (sp7C < 0.0f) ? -1 : 1;
}
static BOOL GetPolygonCircleMtx(s16 *arg0, Vec *arg1, float *arg2, float *arg3) {
Vec sp144[4];
Vec sp120[3];
float spE0[4];
float spD0[4];
float temp_f31;
float temp_f30;
float var_f21;
Vec spC4;
Vec spB8;
s32 spA8;
float spA4;
s32 spA0;
BOOL var_r17;
s16 *temp_r31;
Vec *temp_r29;
Mtx spF0;
spA8 = 0;
spD0[0] = spE0[0] = arg3[0] + MTRAdd.x;
spD0[1] = spE0[1] = arg3[1];
spD0[2] = spE0[2] = arg3[2] + MTRAdd.z;
spD0[3] = spE0[3] = arg3[3];
temp_r31 = arg0 + 1;
if ((spA0 = CalcPPLength(spE0, arg0, arg1)) == 0) {
return 0;
}
spC4.x = spC4.y = spC4.z = 0.0f;
if ((arg0[0] & 0xFF) == 4) {
sp144[0].x = arg1[temp_r31[0]].x;
sp144[0].y = arg1[temp_r31[0]].y;
sp144[0].z = arg1[temp_r31[0]].z;
sp144[1].x = arg1[temp_r31[1]].x;
sp144[1].y = arg1[temp_r31[1]].y;
sp144[1].z = arg1[temp_r31[1]].z;
sp144[2].x = arg1[temp_r31[2]].x;
sp144[2].y = arg1[temp_r31[2]].y;
sp144[2].z = arg1[temp_r31[2]].z;
sp144[3].x = arg1[temp_r31[3]].x;
sp144[3].y = arg1[temp_r31[3]].y;
sp144[3].z = arg1[temp_r31[3]].z;
var_r17 = Hitcheck_Quadrangle_with_Sphere(sp144, (Vec*) spD0, spE0[3], &spC4);
} else {
sp120[0].x = arg1[temp_r31[0]].x;
sp120[0].y = arg1[temp_r31[0]].y;
sp120[0].z = arg1[temp_r31[0]].z;
sp120[1].x = arg1[temp_r31[1]].x;
sp120[1].y = arg1[temp_r31[1]].y;
sp120[1].z = arg1[temp_r31[1]].z;
sp120[2].x = arg1[temp_r31[2]].x;
sp120[2].y = arg1[temp_r31[2]].y;
sp120[2].z = arg1[temp_r31[2]].z;
var_r17 = Hitcheck_Triangle_with_Sphere(sp120, (Vec*) spD0, spE0[3], &spC4);
}
if (var_r17 == TRUE) {
spD0[0] = arg2[0] + AddX;
spD0[1] = arg2[1];
spD0[2] = arg2[2] + AddZ;
PSMTXMultVec(MapMT, &spC4, &spC4);
DefSetHitFace(spC4.x, spC4.y, spC4.z);
temp_r29 = &HitFaceVec[HitFaceCount];
MapspaceInlineFunc01(temp_r29, &arg1[arg0[0]], &arg1[arg0[1]], &arg1[arg0[2]]);
temp_f31 = spC4.x - spD0[0];
spA4 = spC4.y - spD0[1];
temp_f30 = spC4.z - spD0[2];
var_f21 = spE0[3] - sqrtf(temp_f31 * temp_f31 + temp_f30 * temp_f30);
HitFaceCount++;
if (spA0 > 0) {
spE0[0] = OldXYZ.x;
spE0[1] = OldXYZ.y;
spE0[2] = OldXYZ.z;
PSMTXMultVec(MapMTR, (Vec*) &spE0, (Vec*) &spE0);
if (MapspaceInlineFunc03(spE0, temp_r31, arg1) < 0) {
spB8.x = spE0[0] - spD0[0];
spB8.y = spE0[1] - spD0[1];
spB8.z = spE0[2] - spD0[2];
MapspaceInlineFunc00(&spB8);
if (DefIfnnerMapCircle((Vec*) spD0, arg0 - 1, arg1, &spB8) == 1) {
var_f21 = spE0[3] + sqrtf(temp_f31 * temp_f31 + temp_f30 * temp_f30);
}
} else {
var_f21 = 0.0f;
}
}
if (var_f21 > 0.0f) {
AppendAddXZ(-temp_f31, -temp_f30, var_f21);
MTRAdd.x = AddX;
MTRAdd.z = AddZ;
MTRAdd.y = 0.0f;
PSMTXInvXpose(MapMT, spF0);
PSMTXMultVec(spF0, &MTRAdd, &MTRAdd);
}
}
return var_r17;
}
static s32 PrecalcPntToTriangle(Vec *arg0, Vec *arg1, Vec *arg2, Vec* arg3, Vec *arg4, Vec *arg5) {
Vec sp14;
Vec sp8;
float temp_f28;
float temp_f30;
float temp_f29;
float temp_f31;
HuSetVecF(&sp14, -arg4->x, -arg4->y, -arg4->z);
temp_f28 = 1.0f / (-(arg1->z * arg2->y * arg3->x) + arg1->y * arg2->z * arg3->x + arg1->z * arg2->x * arg3->y - arg1->x * arg2->z * arg3->y - arg1->y * arg2->x * arg3->z + arg1->x * arg2->y * arg3->z);
temp_f30 = temp_f28 * (arg2->z * (arg3->y * sp14.x - arg3->x * sp14.y) + arg2->y * (arg3->x * sp14.z - arg3->z * sp14.x) + arg2->x * (arg3->z * sp14.y - arg3->y * sp14.z));
temp_f29 = temp_f28 * (arg1->z * (arg3->x * sp14.y - arg3->y * sp14.x) + arg1->y * (arg3->z * sp14.x - arg3->x * sp14.z) + arg1->x * (arg3->y * sp14.z - arg3->z * sp14.y));
if (temp_f30 > 0.0f && temp_f29 > 0.0f && temp_f30 + temp_f29 > 1.0f) {
PSVECSubtract(arg2, arg1, &sp14);
PSVECSubtract(arg4, arg1, &sp8);
temp_f31 = PSVECDotProduct(&sp14, &sp8) / PSVECDotProduct(&sp14, &sp14);
if (temp_f31 <= 0.0f) {
arg5 = arg1;
} else {
if (temp_f31 >= 1.0f) {
arg5 = arg2;
} else {
PSVECScale(&sp14, &sp8, temp_f31);
PSVECAdd(arg1, &sp8, arg5);
}
}
} else if (temp_f29 < 0.0f) {
temp_f31 = PSVECDotProduct(arg1, arg4) / PSVECDotProduct(arg1, arg1);
if (temp_f31 <= 0.0f) {
HuSetVecF(arg5, 0.0, 0.0, 0.0);
} else {
if (temp_f31 >= 1.0f) {
arg5 = arg1;
} else {
PSVECScale(arg1, arg5, temp_f31);
}
}
} else if (temp_f30 < 0.0f) {
temp_f31 = PSVECDotProduct(arg2, arg4) / PSVECDotProduct(arg2, arg2);
if (temp_f31 <= 0.0f) {
HuSetVecF(arg5, 0.0, 0.0, 0.0);
} else {
if (temp_f31 >= 1.0f) {
arg5 = arg2;
} else {
PSVECScale(arg2, arg5, temp_f31);
}
}
} else {
HuSetVecF(arg5, temp_f30 * arg1->x + temp_f29 * arg2->x, temp_f30 * arg1->y + temp_f29 * arg2->y, temp_f30 * arg1->z + temp_f29 * arg2->z);
}
return 1;
}
BOOL Hitcheck_Triangle_with_Sphere(Vec *arg0, Vec *arg1, float arg2, Vec *arg3) {
Vec sp48;
Vec sp3C;
Vec sp30;
Vec sp24;
Vec sp18;
Vec spC;
float var_f31;
sp48.x = arg0[0].x;
sp48.y = arg0[0].y;
sp48.z = arg0[0].z;
PSVECSubtract(&arg0[1], &arg0[0], &sp3C);
PSVECSubtract(&arg0[2], &arg0[0], &sp30);
PSVECCrossProduct(&sp3C, &sp30, &sp24);
PSVECSubtract(arg1, &arg0[0], &sp18);
PrecalcPntToTriangle(&sp48, &sp3C, &sp30, &sp24, &sp18, &spC);
PSVECAdd(&spC, &sp48, arg3);
var_f31 = PSVECDistance(arg3, arg1);
if (var_f31 > arg2) {
return FALSE;
} else {
return TRUE;
}
}
BOOL Hitcheck_Quadrangle_with_Sphere(Vec *arg0, Vec *arg1, float arg2, Vec *arg3) {
Vec sp6C;
Vec sp60;
Vec sp54;
Vec sp48;
Vec sp3C;
Vec sp30;
Vec sp24;
Vec sp18;
Vec spC;
float temp_f30;
float var_f31;
sp6C.x = arg0->x;
sp6C.y = arg0->y;
sp6C.z = arg0->z;
PSVECSubtract(&arg0[2], &arg0[0], &sp60);
PSVECSubtract(&arg0[3], &arg0[0], &sp54);
PSVECSubtract(&arg0[1], &arg0[0], &sp48);
PSVECCrossProduct(&sp60, &sp54, &sp3C);
PSVECSubtract(arg1, &arg0[0], &sp30);
PrecalcPntToTriangle(&sp6C, &sp60, &sp54, &sp3C, &sp30, &sp24);
PSVECAdd(&sp24, &sp6C, &sp18);
PrecalcPntToTriangle(&sp6C, &sp54, &sp48, &sp3C, &sp30, &sp24);
PSVECAdd(&sp24, &sp6C, &spC);
var_f31 = PSVECDistance(&sp18, arg1);
temp_f30 = PSVECDistance(&spC, arg1);
if (temp_f30 > var_f31) {
arg3->x = sp18.x;
arg3->y = sp18.y;
arg3->z = sp18.z;
} else {
var_f31 = temp_f30;
arg3->x = spC.x;
arg3->y = spC.y;
arg3->z = spC.z;
}
if (var_f31 > arg2) {
return FALSE;
} else {
return TRUE;
}
}
static void DefSetHitFace(float arg0, float arg1, float arg2) {
HitFace[HitFaceCount].x = arg0;
HitFace[HitFaceCount].y = arg1;
HitFace[HitFaceCount].z = arg2;
}
void AppendAddXZ(float arg0, float arg1, float arg2) {
Vec spC;
spC.x = arg0;
spC.y = 0.0f;
spC.z = arg1;
MapspaceInlineFunc00(&spC);
AddX += spC.x * arg2;
AddZ += spC.z * arg2;
}
void CharRotInv(Mtx arg0, Mtx arg1, Vec *arg2, omObjData *arg3) {
Mtx sp8;
PSMTXTrans(arg0, arg3->trans.x, arg3->trans.y, arg3->trans.z);
if (arg3->rot.z) {
PSMTXRotRad(sp8, 'z', MTXDegToRad(arg3->rot.z));
PSMTXConcat(arg0, sp8, arg0);
}
if (arg3->rot.y) {
PSMTXRotRad(sp8, 'y', MTXDegToRad(arg3->rot.y));
PSMTXConcat(arg0, sp8, arg0);
}
if (arg3->rot.x) {
PSMTXRotRad(sp8, 'x', MTXDegToRad(arg3->rot.x));
PSMTXConcat(arg0, sp8, arg0);
}
PSMTXInverse(arg0, arg1);
PSMTXMultVec(arg1, arg2, arg2);
}

3576
src/game/minigame_seq.c Normal file
View file

File diff suppressed because it is too large Load diff

172
src/game/objdll.c Normal file
View file

@ -0,0 +1,172 @@
#include "game/object.h"
#include "game/dvd.h"
#include "game/memory.h"
typedef s32 (*DLLProlog)(void);
typedef void (*DLLEpilog)(void);
omDllData *omDLLinfoTbl[OM_DLL_MAX];
static FileListEntry *omDLLFileList;
void omDLLDBGOut(void)
{
OSReport("DLL DBG OUT\n");
}
void omDLLInit(FileListEntry *ovl_list)
{
int i;
OSReport("DLL DBG OUT\n");
for(i=0; i<OM_DLL_MAX; i++) {
omDLLinfoTbl[i] = NULL;
}
omDLLFileList = ovl_list;
}
int omDLLStart(s16 overlay, s16 flag)
{
int dllno;
OSReport("DLLStart %d %d\n", overlay, flag);
dllno = omDLLSearch(overlay);
if(dllno >= 0 && !flag) {
omDllData *dll = omDLLinfoTbl[dllno];
OSReport("objdll>Already Loaded %s(%08x %08x)\n", dll->name, dll->module, dll->bss);
omDLLInfoDump(&dll->module->info);
omDLLHeaderDump(dll->module);
memset(dll->bss, 0, dll->module->bssSize);
HuMemDCFlushAll();
dll->ret = ((DLLProlog)dll->module->prolog)();
OSReport("objdll> %s prolog end\n", dll->name);
return dllno;
} else {
for(dllno=0; dllno<OM_DLL_MAX; dllno++) {
if(omDLLinfoTbl[dllno] == NULL) {
break;
}
}
if(dllno == OM_DLL_MAX) {
return -1;
}
omDLLLink(&omDLLinfoTbl[dllno], overlay, TRUE);
return dllno;
}
}
void omDLLNumEnd(s16 overlay, s16 flag)
{
s16 dllno;
if(overlay < 0) {
OSReport("objdll>omDLLNumEnd Invalid dllno %d\n", overlay);
return;
}
OSReport("objdll>omDLLNumEnd %d %d\n", overlay, flag);
dllno = omDLLSearch(overlay);
if(dllno < 0) {
OSReport("objdll>omDLLNumEnd not found DLL No%d\n", overlay);
return;
}
omDLLEnd(dllno, flag);
}
void omDLLEnd(s16 dllno, s16 flag)
{
OSReport("objdll>omDLLEnd %d %d\n", dllno, flag);
if(flag == 1) {
OSReport("objdll>End DLL:%s\n", omDLLinfoTbl[dllno]->name);
omDLLUnlink(omDLLinfoTbl[dllno], 1);
omDLLinfoTbl[dllno] = NULL;
} else {
omDllData *dll;
dll = omDLLinfoTbl[dllno];
OSReport("objdll>Call Epilog\n");
((DLLEpilog)dll->module->epilog)();
OSReport("objdll>End DLL stayed:%s\n", omDLLinfoTbl[dllno]->name);
}
OSReport("objdll>End DLL finish\n");
}
omDllData *omDLLLink(omDllData **dll_ptr, s16 overlay, s16 flag)
{
omDllData *dll;
FileListEntry *dllFile = &omDLLFileList[overlay];
OSReport("objdll>Link DLL:%s\n", dllFile->name);
dll = HuMemDirectMalloc(HEAP_SYSTEM, sizeof(omDllData));
*dll_ptr = dll;
dll->name = dllFile->name;
dll->module = HuDvdDataReadDirect(dllFile->name, HEAP_SYSTEM);
dll->bss = HuMemDirectMalloc(HEAP_SYSTEM, dll->module->bssSize);
if(OSLink(&dll->module->info, dll->bss) != TRUE) {
OSReport("objdll>++++++++++++++++ DLL Link Failed\n");
}
omDLLInfoDump(&dll->module->info);
omDLLHeaderDump(dll->module);
OSReport("objdll>LinkOK %08x %08x\n", dll->module, dll->bss);
if(flag == 1) {
OSReport("objdll> %s prolog start\n", dllFile->name);
dll->ret = ((DLLProlog)dll->module->prolog)();
OSReport("objdll> %s prolog end\n", dllFile->name);
}
return dll;
}
void omDLLUnlink(omDllData *dll_ptr, s16 flag)
{
OSReport("odjdll>Unlink DLL:%s\n", dll_ptr->name);
if(flag == 1) {
OSReport("objdll>Unlink DLL epilog\n");
((DLLEpilog)dll_ptr->module->epilog)();
OSReport("objdll>Unlink DLL epilog finish\n");
}
if(OSUnlink(&dll_ptr->module->info) != TRUE) {
OSReport("objdll>+++++++++++++++++ DLL Unlink Failed\n");
}
HuMemDirectFree(dll_ptr->bss);
HuMemDirectFree(dll_ptr->module);
HuMemDirectFree(dll_ptr);
}
s32 omDLLSearch(s16 overlay)
{
s32 i;
FileListEntry *dllFile = &omDLLFileList[overlay];
OSReport("Search:%s\n", dllFile->name);
for(i=0; i<OM_DLL_MAX; i++) {
omDllData *dll = omDLLinfoTbl[i];
if(dll != NULL && strcmp(dll->name, dllFile->name) == 0) {
OSReport("+++++++++++ Find%d: %s\n", i, dll->name);
return i;
}
}
return -1;
}
void omDLLInfoDump(OSModuleInfo *module)
{
OSReport("===== DLL Module Info dump ====\n");
OSReport(" ID:0x%08x\n", module->id);
OSReport(" LinkPrev:0x%08x\n", module->link.prev);
OSReport(" LinkNext:0x%08x\n", module->link.next);
OSReport(" Section num:%d\n", module->numSections);
OSReport("Section info tbl ofst:0x%08x\n", module->sectionInfoOffset);
OSReport(" nameOffset:0x%08x\n", module->nameOffset);
OSReport(" nameSize:%d\n", module->nameSize);
OSReport(" version:0x%08x\n", module->version);
OSReport("===============================\n");
}
void omDLLHeaderDump(OSModuleHeader *module)
{
OSReport("==== DLL Module Header dump ====\n");
OSReport(" bss Size:0x%08x\n", module->bssSize);
OSReport(" rel Offset:0x%08x\n", module->relOffset);
OSReport(" imp Offset:0x%08x\n", module->impOffset);
OSReport(" prolog Section:%d\n", module->prologSection);
OSReport(" epilog Section:%d\n", module->epilogSection);
OSReport("unresolved Section:%d\n", module->unresolvedSection);
OSReport(" prolog func:0x%08x\n", module->prolog);
OSReport(" epilog func:0x%08x\n", module->epilog);
OSReport(" unresolved func:0x%08x\n", module->unresolved);
OSReport("================================\n");
}

3
src/game/objmain.c
View file

@ -1,4 +1,5 @@
#include "game/audio.h"
#include "game/chrman.h"
#include "game/esprite.h"
#include "game/hsfdraw.h"
#include "game/hsfman.h"
@ -45,7 +46,7 @@ s16 omdispinfo;
static omOvlHisData omovlhis[OM_OVL_HIS_MAX];
char omSysPauseEnableFlag = TRUE;
u8 omSysPauseEnableFlag = TRUE;
OverlayID omprevovl = OVL_INVALID;
static void omWatchOverlayProc(void);

1221
src/game/objsub.c Normal file
View file

File diff suppressed because it is too large Load diff

149
src/game/objsysobj.c Normal file
View file

@ -0,0 +1,149 @@
#include "game/object.h"
#include "game/hsfman.h"
#include "game/pad.h"
#include "game/objsub.h"
#include "game/minigame_seq.h"
#include "game/sprite.h"
#include "game/hsfman.h"
#include "game/audio.h"
#include "math.h"
Vec CRot;
Vec Center;
float CZoom;
Vec CRotM[16];
Vec CenterM[16];
float CZoomM[16];
omObjData *omDBGMenuButton;
void omOutView(omObjData *object)
{
Vec pos, target, up;
float rot_x = CRot.x;
float rot_y = CRot.y;
float rot_z = CRot.z;
pos.x = (sin(M_PI*rot_y/180.0)*cos(M_PI*rot_x/180.0)*CZoom)+Center.x;
pos.y = (-sin(M_PI*rot_x/180.0)*CZoom)+Center.y;
pos.z = (cos(M_PI*rot_y/180.0)*cos(M_PI*rot_x/180.0)*CZoom)+Center.z;
target.x = Center.x;
target.y = Center.y;
target.z = Center.z;
up.x = sin(M_PI*rot_y/180.0)*sin(M_PI*rot_x/180.0);
up.y = cos(M_PI*rot_x/180.0);
up.z = cos(M_PI*rot_y/180.0)*sin(M_PI*rot_x/180.0);
Hu3DCameraPosSet(1, pos.x, pos.y, pos.z, up.x, up.y, up.z, target.x, target.y, target.z);
}
void omOutViewMulti(omObjData *object)
{
u8 i;
for(i=0; i<object->work[0]; i++) {
Vec pos, target, up;
float rot_x = CRotM[i].x;
float rot_y = CRotM[i].y;
float rot_z = CRotM[i].z;
pos.x = (sin(M_PI*rot_y/180.0)*cos(M_PI*rot_x/180.0)*CZoomM[i])+CenterM[i].x;
pos.y = (-sin(M_PI*rot_x/180.0)*CZoomM[i])+CenterM[i].y;
pos.z = (cos(M_PI*rot_y/180.0)*cos(M_PI*rot_x/180.0)*CZoomM[i])+CenterM[i].z;
target.x = CenterM[i].x;
target.y = CenterM[i].y;
target.z = CenterM[i].z;
up.x = sin(M_PI*rot_y/180.0)*sin(M_PI*rot_x/180.0);
up.y = cos(M_PI*rot_x/180.0);
up.z = cos(M_PI*rot_y/180.0)*sin(M_PI*rot_x/180.0);
Hu3DCameraPosSetV((1 << i), &pos, &up, &target);
}
}
void omSystemKeyCheck(omObjData *object);
void omSystemKeyCheckSetup(Process *objman)
{
omObjData *object;
object = omAddObjEx(objman, 32731, 0, 0, -1, omSystemKeyCheck);
omDBGSysKeyObj = object;
omSetStatBit(object, 0xA0);
object->work[0] = 0;
object->work[1] = 0;
object->work[2] = 0;
}
void omSystemKeyCheck(omObjData *object)
{
if(!omSysPauseEnableFlag) {
return;
}
if(object->work[0] & 0x1) {
u32 pad = object->work[1];
if(pad != (u16)-1 && HuPadStatGet(pad) == 0 && (HuPadBtnDown[pad] & PAD_BUTTON_START)) {
object->work[0] |= 0x200;
}
if(object->work[0] & 0x200) {
if(omMgIndexGet(omcurovl) != -1) {
MGSeqPauseKill();
} else {
object->work[0] |= 0x100;
}
}
if(object->work[0] & 0x100) {
object->work[0] &= ~0x301;
omAllPause(0);
HuPrcAllPause(0);
Hu3DPauseSet(0);
HuSprPauseSet(0);
HuAudFXPauseAll(0);
HuAudSeqPauseAll(0);
}
} else {
int i;
s16 pause = 0;
if(WipeStatGet() || omCurrentOvlGet() == OVL_INVALID || omSysExitReq) {
return;
}
for(i=0; i<4; i++) {
if(HuPadStatGet(i) == 0 && (HuPadBtnDown[i] & PAD_BUTTON_START)) {
pause = 1;
break;
}
}
if(object->work[0] & 0x80) {
object->work[0] &= ~0x80;
pause = 1;
i = (u16)-1;
}
if(pause) {
object->work[0] |= 0x1;
object->work[1] = i;
omAllPause(1);
HuPrcAllPause(1);
Hu3DPauseSet(1);
HuSprPauseSet(1);
HuAudFXPauseAll(1);
HuAudSeqPauseAll(1);
if(omMgIndexGet(omcurovl) != -1) {
MGSeqPauseInit();
}
HuPadRumbleAllStop();
}
}
}
void omSysPauseEnable(u8 flag)
{
omSysPauseEnableFlag = flag;
}
void omSysPauseCtrl(s16 flag)
{
if(!omDBGSysKeyObj) {
return;
}
omDBGSysKeyObj->work[0] &= ~0x180;
if(flag) {
omDBGSysKeyObj->work[0] |= 0x80;
} else {
omDBGSysKeyObj->work[0] |= 0x100;
}
}

2
src/game/pad.c
View file

@ -43,7 +43,7 @@ static u8 _PadDStkRepCnt[4];
static u8 _PadDStkRepOld[4];
static s8 _PadErr[4];
static u32 RumbleBit;
u32 VCounter;
s32 VCounter;
static u32 chanTbl[4] = { PAD_CHAN0_BIT, PAD_CHAN1_BIT, PAD_CHAN2_BIT, PAD_CHAN3_BIT };

718
src/game/saveload.c
View file

File diff suppressed because it is too large Load diff

2
src/game/sprman.c
View file

@ -675,7 +675,7 @@ void HuSprSprBGSet(short sprite, AnimData *bg, short bg_bank)
sprite_ptr->bg = bg;
sprite_ptr->bg_bank = bg_bank;
sprite_ptr->wrap_t = sprite_ptr->wrap_s = GX_REPEAT;
sprite_ptr->attr &= ~SPIRTE_ATTR_BILINEAR;
sprite_ptr->attr &= ~SPRITE_ATTR_BILINEAR;
}
void AnimDebug(AnimData *anim)

2
src/game/sprput.c
View file

@ -123,7 +123,7 @@ void HuSprDisp(SpriteData *sprite)
continue;
}
GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR0A0);
HuSprTexLoad(anim, layer->bmpNo, 0, sprite->wrap_s, sprite->wrap_t, (sprite->attr & SPIRTE_ATTR_BILINEAR) ? GX_LINEAR : GX_NEAR);
HuSprTexLoad(anim, layer->bmpNo, 0, sprite->wrap_s, sprite->wrap_t, (sprite->attr & SPRITE_ATTR_BILINEAR) ? GX_LINEAR : GX_NEAR);
if(layer->alpha != 255 || color_sum != 255*4) {
color.a = (u16)(sprite->a*layer->alpha) >> 8;
GXSetTevColor(GX_TEVSTAGE1, color);

422
src/game/sreset.c Normal file
View file

@ -0,0 +1,422 @@
#include "dolphin.h"
#include "game/flag.h"
#include "game/dvd.h"
#include "game/pad.h"
#include "game/audio.h"
#include "game/thpmain.h"
#define SR_DVD_LOADING 0
#define SR_DVD_COVER_OPEN 1
#define SR_DVD_NO_DISK 2
#define SR_DVD_WRONG_DISK 3
#define SR_DVD_RETRY_ERROR 4
#define SR_DVD_FATAL_ERROR 5
#define PAD_BTN_SRESET (PAD_BUTTON_START|PAD_BUTTON_X|PAD_BUTTON_B)
#define PAD_BTN_SRESET_SHORT (PAD_BUTTON_X|PAD_BUTTON_B)
extern s32 HuDvdErrWait;
static s32 SR_PreRstChk[4] = {};
#include "coveropen_en.inc"
#include "fatalerror_en.inc"
#include "loading_en.inc"
#include "nodisc_en.inc"
#include "retryerror_en.inc"
#include "wrongdisc_en.inc"
static s16 SR_PushTime[4] = {};
static s8 SR_ResetPad = -1;
static s16 XfbW;
static s16 XfbH;
static s32 XfbProg;
static void *Xfb[2] = {};
static BOOL trychkBusyWait;
s32 SR_ExecReset;
static s32 SR_RestartChk;
static BOOL H_ResetReady;
void HuRestartSystem(void);
s32 HuSoftResetCheck(void);
s32 HuSoftResetCountCheck(void);
static void HuSoftResetPostProc(void);
s32 HuSoftResetButtonCheck(void)
{
if(SR_ExecReset) {
HuRestartSystem();
}
return (SR_ExecReset) ? 1 : 0;
}
static OSMessageQueue ToeMessageQueue;
void HuDvdErrDispIntFunc(u32 retraceCount)
{
OSWakeupThread(&ToeMessageQueue.queueSend);
}
static void HuPreRstChk(void)
{
static PADStatus padStat[4];
int i;
PADRead(padStat);
for(i=0; i<4; i++) {
PADStatus *status = &padStat[i];
if(status->err != 0) {
continue;
}
if((status->button & PAD_BTN_SRESET) == PAD_BTN_SRESET) {
SR_PreRstChk[i] = 1;
} else {
SR_PreRstChk[i] = 0;
}
}
}
static OSMessage ToeMessageArray[16];
static OSThread ToeThread;
static u8 ToeThreadStack[4096];
static void *ToeThreadFunc(void *param);
static void ToeDispCheck(void);
void HuDvdErrDispInit(GXRenderModeObj *rmode, void *xfb1, void *xfb2)
{
BOOL intrOld;
_ClearFlag(0x30000);
SR_ResetPad = -1;
SR_ExecReset = H_ResetReady = 0;
SR_RestartChk = 0;
SR_PushTime[0] = SR_PushTime[1] = SR_PushTime[2] = SR_PushTime[3] = 0;
VIWaitForRetrace();
VIWaitForRetrace();
VIWaitForRetrace();
HuPreRstChk();
HuDvdErrWait = 0;
Xfb[0] = xfb1;
Xfb[1] = xfb2;
if(rmode) {
XfbW = (u16)(((u16)rmode->fbWidth+15) & ~0xF);
XfbH = rmode->xfbHeight;
} else {
XfbW = 640;
XfbH = 480;
}
if((u16)rmode->xFBmode == VI_XFBMODE_SF) {
XfbProg = 0;
} else {
XfbProg = 1;
}
trychkBusyWait = FALSE;
OSInitMessageQueue(&ToeMessageQueue, ToeMessageArray, 16);
OSCreateThread(&ToeThread, ToeThreadFunc, NULL, &ToeThreadStack[4096], 4096, 8, OS_THREAD_ATTR_DETACH);
OSResumeThread(&ToeThread);
intrOld = OSDisableInterrupts();
VISetPreRetraceCallback(HuDvdErrDispIntFunc);
OSRestoreInterrupts(intrOld);
}
static void *ToeThreadFunc(void *param)
{
while(1) {
BOOL hide_disp;
OSSleepThread(&ToeMessageQueue.queueSend);
if(!_CheckFlag(0x30000)) {
BOOL reset;
if(!HuSoftResetCheck()) {
if(SR_ExecReset) {
reset = TRUE;
} else {
if(H_ResetReady == TRUE && OSGetResetButtonState() != TRUE) {
reset = TRUE;
} else {
if(H_ResetReady != TRUE && OSGetResetButtonState() == TRUE) {
H_ResetReady = TRUE;
}
reset = FALSE;
}
}
if(reset) {
proc_reset:
HuSoftResetPostProc();
}
} else {
goto proc_reset;
}
}
if(SR_ExecReset) {
HuRestartSystem();
}
if(SR_ExecReset) {
hide_disp = TRUE;
} else {
hide_disp = FALSE;
}
if(!hide_disp) {
ToeDispCheck();
}
}
}
static void _HuDvdErrDispXFB(s32 error);
static void ToeDispCheck(void)
{
s32 status;
if(SR_ResetPad != -1 || SR_ExecReset != FALSE || SR_RestartChk != 0) {
return;
}
status = DVDGetDriveStatus();
switch(status) {
case DVD_STATE_FATAL_ERROR:
status = SR_DVD_FATAL_ERROR;
trychkBusyWait = TRUE;
break;
case DVD_STATE_END:
HuDvdErrWait = 0;
trychkBusyWait = FALSE;
return;
case DVD_STATE_COVER_OPEN:
status = SR_DVD_COVER_OPEN;
trychkBusyWait = TRUE;
break;
case DVD_STATE_BUSY:
case DVD_STATE_COVER_CLOSED:
if(!trychkBusyWait) {
return;
}
status = SR_DVD_LOADING;
break;
case DVD_STATE_NO_DISK:
status = SR_DVD_NO_DISK;
trychkBusyWait = TRUE;
break;
case DVD_STATE_WRONG_DISK:
status = SR_DVD_WRONG_DISK;
trychkBusyWait = TRUE;
break;
case DVD_STATE_RETRY:
status = SR_DVD_RETRY_ERROR;
trychkBusyWait = TRUE;
break;
default:
return;
}
HuDvdErrWait = 1;
HuPadRumbleAllStop();
VISetBlack(FALSE);
VIFlush();
if(msmSysCheckInit()) {
HuAudSStreamAllStop();
}
_HuDvdErrDispXFB(status);
}
static void _HuDvdErrDispXFB(s32 error)
{
static void *bmpMes[][6] = {
loading_en, coveropen_en, nodisc_en, wrongdisc_en, retryerror_en, fatalerror_en
};
volatile s32 status;
u8 color[2];
s8 language;
s16 *bmpData;
u8 *xfb1_ptr;
u8 *xfb2_ptr;
u32 i;
u32 data;
u32 row;
u32 *xfb1;
u32 *xfb2;
u32 j;
u8 y1;
u8 y2;
s32 reset;
u32 *data_ptr;
u32 row_offset;
u32 row_pitch;
language = 0;
xfb1 = Xfb[0];
xfb2 = Xfb[1];
for(i=0; i<0x25800; i++, xfb1++, xfb2++) {
*xfb1 = *xfb2 = 0x800080;
}
DCStoreRangeNoSync(Xfb[0], 0x96000);
DCStoreRangeNoSync(Xfb[1], 0x96000);
bmpData = bmpMes[language][error];
data_ptr = (u32 *)(bmpData+2);
row_offset = ((XfbW/2)-(bmpData[0]/2))*2;
row_pitch = XfbW*2;
color[1] = color[0] = 128;
for(row=0; row<bmpData[1]; row++) {
void *sp14[2];
xfb1_ptr = ((u8 *)(Xfb[0])+((row+200)*row_pitch)+row_offset);
sp14[1] = xfb1_ptr;
xfb2_ptr = ((u8 *)(Xfb[1])+((row+200)*row_pitch)+row_offset);
sp14[0] = xfb2_ptr;
for(i=0; i<bmpData[0]; i += 32) {
data = *data_ptr++;
for(j=0; j<32; j += 2, data >>= 2, xfb1_ptr += 4, xfb2_ptr += 4) {
if(data & 0x3){
if(data & 0x1) {
y1 = 0xEB;
} else {
y1 = 0x10;
}
if(data & 0x2) {
y2 = 0xEB;
} else {
y2 = 0x10;
}
xfb1_ptr[0] = y1;
xfb1_ptr[1] = color[1];
xfb1_ptr[2] = y2;
xfb1_ptr[3] = color[0];
xfb2_ptr[0] = y1;
xfb2_ptr[1] = color[1];
xfb2_ptr[2] = y2;
xfb2_ptr[3] = color[0];
}
}
}
DCStoreRangeNoSync(sp14[1], bmpData[0]*2);
DCStoreRangeNoSync(sp14[0], bmpData[0]*2);
}
status = DVDGetDriveStatus();
while(status) {
if(status != DVDGetDriveStatus()) {
break;
}
if(SR_ExecReset) {
reset = TRUE;
} else {
if(H_ResetReady == TRUE && OSGetResetButtonState() != TRUE) {
reset = TRUE;
} else {
if(H_ResetReady != TRUE && OSGetResetButtonState() == TRUE) {
H_ResetReady = TRUE;
}
reset = FALSE;
}
}
if(reset) {
if(msmSysCheckInit()) {
msmStreamSetMasterVolume(0);
msmSeSetMasterVolume(0);
msmMusSetMasterVolume(0);
}
HuRestartSystem();
}
OSYieldThread();
}
}
void HuRestartSystem(void)
{
u32 retrace[2];
BOOL prevInt;
if(SR_RestartChk) {
return;
}
SR_RestartChk = TRUE;
PADRecalibrate(PAD_CHAN0_BIT|PAD_CHAN1_BIT|PAD_CHAN2_BIT|PAD_CHAN3_BIT);
msmSysCheckInit();
VISetBlack(TRUE);
VIFlush();
prevInt = OSDisableInterrupts();
if(!prevInt) {
OSReport("PrevInt=DISABLE!!\n");
}
OSEnableInterrupts();
retrace[1] = VIGetRetraceCount();
retrace[0] = 0;
while(retrace[1] == VIGetRetraceCount()) {
if(retrace[0]++ >= 1349800) {
break;
}
}
OSReport("Timeout Count=%d\n", retrace[0]);
__GXAbortWaitPECopyDone();
OSResetSystem(0, 0, 0);
}
s32 HuSoftResetCheck(void)
{
int i;
if(VCounter == 0) {
return 0;
}
if(SR_ExecReset) {
return 1;
}
if(SR_ResetPad != -1) {
if(!(_PadBtn[SR_ResetPad] & PAD_BTN_SRESET)) {
return 1;
}
} else {
for(i=0; i<4; i++) {
if(SR_PreRstChk[i] && (_PadBtn[i] & PAD_BTN_SRESET) != PAD_BTN_SRESET) {
SR_PreRstChk[i] = 0;
}
}
}
if(HuSoftResetCountCheck()) {
return 1;
} else {
return 0;
}
}
s32 HuSoftResetCountCheck(void)
{
int i;
for(i=0; i<4; i++) {
if((_PadBtn[i] & PAD_BTN_SRESET_SHORT) != PAD_BTN_SRESET_SHORT) {
SR_PushTime[i] = 0;
} else {
if(!SR_PreRstChk[i]) {
if(_PadBtn[i] & PAD_BUTTON_START) {
if(SR_PushTime[i]++ >= 30) {
SR_ResetPad = i;
return 1;
}
} else {
SR_PushTime[i] = 0;
}
}
}
}
return 0;
}
static void HuSoftResetPostProc(void)
{
if(!SR_ExecReset) {
VISetBlack(TRUE);
VIFlush();
if(THPProc) {
HuTHPStop();
HuTHPClose();
}
if(msmSysCheckInit()) {
msmStreamSetMasterVolume(0);
msmSeSetMasterVolume(0);
msmMusSetMasterVolume(0);
}
HuPadRumbleAllStop();
SR_ExecReset = TRUE;
}
}

68
src/game/window.c
View file

@ -14,6 +14,8 @@
#include "stdarg.h"
#include "string.h"
#include "data_num/win.h"
typedef struct {
/* 0x00 */ AnimData **anim;
/* 0x04 */ s16 bank;
@ -163,10 +165,10 @@ static u8 ATTRIBUTE_ALIGN(32) charColPal[2*3*10] = {
};
static s32 frameFileTbl[] = {
MAKE_DATA_NUM(DATADIR_WIN, 6),
MAKE_DATA_NUM(DATADIR_WIN, 7),
MAKE_DATA_NUM(DATADIR_WIN, 8),
MAKE_DATA_NUM(DATADIR_WIN, 6)
WIN_FRAME1_ANM,
WIN_FRAME2_ANM,
WIN_FRAME3_ANM,
WIN_FRAME1_ANM
};
static char *mesDataTbl[] = {
@ -190,7 +192,7 @@ static s16 winPrio = 1000;
void HuWindowInit(void) {
s16 i;
winAMemP = HuAR_DVDtoARAM(MAKE_DIR_NUM(DATADIR_WIN));
winAMemP = HuAR_DVDtoARAM(DATADIR_WIN);
for (i = 0; i < 32; i++) {
winData[i].group = -1;
}
@ -215,33 +217,33 @@ void HuWinInit(s32 mess_data_no) {
}
if (!fontAnim) {
if (LanguageNo == 0) {
anim_data = HuDataReadNum(MAKE_DATA_NUM(DATADIR_WIN, 0), MEMORY_DEFAULT_NUM);
anim_data = HuDataReadNum(WIN_FONTJ_ANM, MEMORY_DEFAULT_NUM);
} else {
anim_data = HuDataReadNum(MAKE_DATA_NUM(DATADIR_WIN, 1), MEMORY_DEFAULT_NUM);
anim_data = HuDataReadNum(WIN_FONTE_ANM, MEMORY_DEFAULT_NUM);
}
fontAnim = HuSprAnimRead(anim_data);
}
if (!iconAnim) {
anim_data = HuDataReadNum(MAKE_DATA_NUM(DATADIR_WIN, 3), MEMORY_DEFAULT_NUM);
anim_data = HuDataReadNum(WIN_ICON_ANM, MEMORY_DEFAULT_NUM);
iconAnim = HuSprAnimRead(anim_data);
HuSprAnimLock(iconAnim);
}
if (!cursorAnim) {
anim_data = HuDataReadNum(MAKE_DATA_NUM(DATADIR_WIN, 2), MEMORY_DEFAULT_NUM);
anim_data = HuDataReadNum(WIN_CURSOR_ANM, MEMORY_DEFAULT_NUM);
cursorAnim = HuSprAnimRead(anim_data);
HuSprAnimLock(cursorAnim);
}
if (!cardAnimA) {
anim_data = HuDataReadNum(MAKE_DATA_NUM(DATADIR_WIN, 4), MEMORY_DEFAULT_NUM);
anim_data = HuDataReadNum(WIN_CARDA_ANM, MEMORY_DEFAULT_NUM);
cardAnimA = HuSprAnimRead(anim_data);
HuSprAnimLock(cardAnimA);
}
if (!cardAnimB) {
anim_data = HuDataReadNum(MAKE_DATA_NUM(DATADIR_WIN, 5), MEMORY_DEFAULT_NUM);
anim_data = HuDataReadNum(WIN_CARDB_ANM, MEMORY_DEFAULT_NUM);
cardAnimB = HuSprAnimRead(anim_data);
HuSprAnimLock(cardAnimB);
}
HuDataDirClose(MAKE_DIR_NUM(DATADIR_WIN));
HuDataDirClose(DATADIR_WIN);
HuWinComKeyReset();
winPrio = 1000;
}
@ -402,7 +404,7 @@ void HuWinAllKill(void) {
HuMemDirectFree(messDataPtr);
messDataPtr = 0;
}
HuDataDirClose(MAKE_DIR_NUM(DATADIR_WIN));
HuDataDirClose(DATADIR_WIN);
}
static void MesDispFunc(SpriteData *sprite) {
@ -1200,7 +1202,7 @@ void HuWinAttrReset(s16 window, u32 attr) {
window_ptr->attr &= ~attr;
}
u8 HuWinStatGet(s16 window) {
s16 HuWinStatGet(s16 window) {
WindowData *window_ptr = &winData[window];
return window_ptr->stat;
@ -1775,25 +1777,25 @@ void HuWinDisablePlayerReset(s16 window, u8 player) {
}
static s32 winPortraitTbl[] = {
MAKE_DATA_NUM(DATADIR_WIN, 15),
MAKE_DATA_NUM(DATADIR_WIN, 16),
MAKE_DATA_NUM(DATADIR_WIN, 17),
MAKE_DATA_NUM(DATADIR_WIN, 18),
MAKE_DATA_NUM(DATADIR_WIN, 19),
MAKE_DATA_NUM(DATADIR_WIN, 20),
MAKE_DATA_NUM(DATADIR_WIN, 21),
MAKE_DATA_NUM(DATADIR_WIN, 22),
MAKE_DATA_NUM(DATADIR_WIN, 23),
MAKE_DATA_NUM(DATADIR_WIN, 24),
MAKE_DATA_NUM(DATADIR_WIN, 25),
MAKE_DATA_NUM(DATADIR_WIN, 26),
MAKE_DATA_NUM(DATADIR_WIN, 27),
MAKE_DATA_NUM(DATADIR_WIN, 9),
MAKE_DATA_NUM(DATADIR_WIN, 10),
MAKE_DATA_NUM(DATADIR_WIN, 11),
MAKE_DATA_NUM(DATADIR_WIN, 12),
MAKE_DATA_NUM(DATADIR_WIN, 13),
MAKE_DATA_NUM(DATADIR_WIN, 14)
WIN_TOAD_TALK_ANM,
WIN_BOBOMB_TALK_ANM,
WIN_SHYGUY_TALK_ANM,
WIN_BOO_TALK_ANM,
WIN_GOOMBA_TALK_ANM,
WIN_BOWSER_TALK_ANM,
WIN_KKID_TALK_ANM,
WIN_KOOPA_TALK_ANM,
WIN_CONDOR_TALK_ANM,
WIN_BOO_BLUE_TALK_ANM,
WIN_DOLPHIN_TALK_ANM,
WIN_BOO_RED_TALK_ANM,
WIN_THWOMP_TALK_ANM,
WIN_W01_HOST_TALK_ANM,
WIN_W02_HOST_TALK_ANM,
WIN_W03_HOST_TALK_ANM,
WIN_W04_HOST_TALK_ANM,
WIN_W05_HOST_TALK_ANM,
WIN_W06_HOST_TALK_ANM
};
s16 HuWinExCreate(float x, float y, s16 w, s16 h, s16 portrait) {

3
src/game/wipe.c
View file

@ -2,8 +2,7 @@
#include "game/wipe.h"
#include "game/memory.h"
#include "game/flag.h"
extern s8 boardTutorialF;
#include "game/board/tutorial.h"
s16 HuSysVWaitGet(s16 old);