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

Decompile rest of board/model.c

Browse source
This commit is contained in:
gamemasterplc 2024-01-20 09:21:36 -06:00
parent 0c0397ac34
commit 99c38b8325
13 changed files with 732 additions and 79 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -1487,7 +1487,7 @@ s32 BoardVecMaxDistXZCheck(Vec *vec1, Vec *vec2, float max_dist)
}
}
void BoardVecDAngleCalcVec(Vec *vec1)
void BoardDAngleCalcVec(Vec *vec1)
{
int i;
float *data = (float *)(&vec1->x);
@ -1502,7 +1502,7 @@ void BoardVecDAngleCalcVec(Vec *vec1)
}
}
float BoardVecDAngleCalc(float value)
float BoardDAngleCalc(float value)
{
while(value > 180.0f) {
value -= 360.0f;
@ -1513,7 +1513,7 @@ float BoardVecDAngleCalc(float value)
return value;
}
s32 BoardVecDAngleCalcRange(float *value, float min, float range)
s32 BoardDAngleCalcRange(float *value, float min, float range)
{
float diff = min-(*value);
if(diff >= 180.0f) {
@ -1525,17 +1525,17 @@ s32 BoardVecDAngleCalcRange(float *value, float min, float range)
if(min > *value) {
*value += range;
if(*value >= min) {
*value = BoardVecDAngleCalc(min);
*value = BoardDAngleCalc(min);
return 1;
}
} else {
*value -= range;
if(*value <= min) {
*value = BoardVecDAngleCalc(min);
*value = BoardDAngleCalc(min);
return 1;
}
}
*value = BoardVecDAngleCalc(*value);
*value = BoardDAngleCalc(*value);
return 0;
}

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

@ -32,7 +32,7 @@ typedef struct board_model {
s32 data_num;
float mot_start;
float mot_end;
Vec trans;
Vec pos;
Vec rot;
Vec scale;
} BoardModel;
@ -382,7 +382,7 @@ 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);
CharMotionClose(model_ptr->character);
CharMotionDataClose(model_ptr->character);
}
model_ptr->mot_id[i] = model;
model_ptr->mot_count++;
@ -393,7 +393,6 @@ s32 BoardModelMotionCreate(s16 model, s32 data_num)
s32 BoardModelMotionKill(s16 model, s32 motion)
{
BoardModel *model_ptr = SearchBoardModel(model);
s32 i;
if(!model_ptr) {
return -1;
} else {
@ -417,6 +416,638 @@ s32 BoardModelMotionKill(s16 model, s32 motion)
}
}
s32 BoardModelMotionStartEndSet(s16 model, s16 start, s16 end)
{
BoardModel *model_ptr = SearchBoardModel(model);
if(!model_ptr) {
return -1;
} else {
if(start >= 0) {
OSs16tof32(&start, &model_ptr->mot_start);
}
if(end >= 0) {
OSs16tof32(&end, &model_ptr->mot_end);
}
Hu3DMotionStartEndSet(model_ptr->id, model_ptr->mot_start, model_ptr->mot_end);
return 0;
}
}
s32 BoardModelMotionUpdateSet(s16 model, s32 flag)
{
BoardModel *model_ptr = SearchBoardModel(model);
if(!model_ptr) {
return -1;
} else {
if(flag) {
Hu3DModelAttrSet(model_ptr->id, 0x40000001);
} else {
Hu3DModelAttrReset(model_ptr->id, 0x40000001);
}
return 0;
}
}
s32 BoardModelVoiceEnableSet(s16 model, s32 motion, s32 flag)
{
BoardModel *model_ptr = SearchBoardModel(model);
if(!model_ptr) {
return -1;
} else {
if(motion >= BOARD_MOT_MAX || motion < 0) {
return 0;
}
if(model_ptr->character == -1) {
return 0;
}
CharModelVoiceEnableSet(model_ptr->character, model_ptr->mot_id[motion], flag);
return 0;
}
}
s32 BoardModelMotionStart(s16 model, s32 motion, u32 attr)
{
BoardModel *model_ptr = SearchBoardModel(model);
if(!model_ptr) {
return -1;
} else {
if(motion >= BOARD_MOT_MAX || motion < 0) {
return 0;
}
Hu3DMotionSpeedSet(model_ptr->id, 1.0f);
if(model_ptr->character == -1) {
Hu3DMotionSet(model_ptr->id, model_ptr->mot_id[motion]);
} else {
CharModelMotionSet(model_ptr->character, model_ptr->mot_id[motion]);
}
model_ptr->mot_start = 0.0f;
if(model_ptr->character == -1) {
model_ptr->mot_end = Hu3DMotionMaxTimeGet(model_ptr->id);
} else {
model_ptr->mot_end = CharModelMotionMaxTimeGet(model_ptr->character);
}
model_ptr->field00_bit4 = 0;
if(attr & 0x40000024) {
if(model_ptr->character == -1) {
Hu3DMotionTimeSet(model_ptr->id, model_ptr->mot_end);
} else {
CharModelMotionTimeSet(model_ptr->character, model_ptr->mot_end);
}
}
Hu3DModelAttrReset(model_ptr->id, 0x40000003);
Hu3DModelAttrSet(model_ptr->id, attr);
model_ptr->curr_mot = motion;
return 0;
}
}
s32 BoardModelMotionShiftIDGet(s16 model)
{
BoardModel *model_ptr = SearchBoardModel(model);
if(!model_ptr) {
return -1;
} else {
return Hu3DMotionShiftIDGet(model_ptr->id);
}
}
s32 BoardModelMotionShiftSet(s16 model, s32 motion, float time, float shift_time, u32 attr)
{
BoardModel *model_ptr = SearchBoardModel(model);
if(!model_ptr) {
return -1;
} else {
if(motion >= BOARD_MOT_MAX || motion < 0) {
return -1;
}
model_ptr->mot_start = 0.0f;
if(model_ptr->character == -1) {
model_ptr->mot_end = Hu3DMotionMaxTimeGet(model_ptr->id);
} else {
model_ptr->mot_end = CharModelMotionMaxTimeGet(model_ptr->character);
}
model_ptr->field00_bit4 = 0;
if(model_ptr->character == -1) {
Hu3DMotionShiftSet(model_ptr->id, model_ptr->mot_id[motion], time, shift_time, attr);
} else {
CharModelMotionShiftSet(model_ptr->character, model_ptr->mot_id[motion], time, shift_time, attr);
}
model_ptr->curr_mot = motion;
return 0;
}
}
s32 BoardModelAttrSet(s16 model, u32 attr)
{
BoardModel *model_ptr = SearchBoardModel(model);
if(!model_ptr) {
return -1;
} else {
Hu3DModelAttrSet(model_ptr->id, attr);
return 0;
}
}
s32 BoardModelAttrReset(s16 model, u32 attr)
{
BoardModel *model_ptr = SearchBoardModel(model);
if(!model_ptr) {
return -1;
} else {
Hu3DModelAttrReset(model_ptr->id, attr);
return 0;
}
}
s32 BoardModelMotionTimeSet(s16 model, float time)
{
BoardModel *model_ptr = SearchBoardModel(model);
if(!model_ptr) {
return -1;
} else {
if(model_ptr->character == -1) {
Hu3DMotionTimeSet(model_ptr->id, time);
} else {
CharModelMotionTimeSet(model_ptr->character, time);
}
return 0;
}
}
float BoardModelMotionTimeGet(s16 model)
{
BoardModel *model_ptr = SearchBoardModel(model);
if(!model_ptr) {
return -1;
} else {
float time;
if(model_ptr->character == -1) {
time = Hu3DData[model_ptr->id].unk_64;
} else {
time = CharModelMotionTimeGet(model_ptr->character);
}
return time;
}
}
float BoardModelMotionMaxTimeGet(s16 model)
{
BoardModel *model_ptr = SearchBoardModel(model);
if(!model_ptr) {
return -1;
} else {
float time;
if(model_ptr->character == -1) {
time = Hu3DMotionMaxTimeGet(model_ptr->id);
} else {
time = CharModelMotionMaxTimeGet(model_ptr->character);
}
return time;
}
}
float BoardModelMotionSpeedGet(s16 model)
{
BoardModel *model_ptr = SearchBoardModel(model);
if(!model_ptr) {
return -1;
} else {
ModelData *hsf_model = &Hu3DData[model_ptr->id];
return hsf_model->unk_68;
}
}
s32 BoardModelMotionSpeedSet(s16 model, float speed)
{
BoardModel *model_ptr = SearchBoardModel(model);
if(!model_ptr) {
return -1;
} else {
ModelData *hsf_model;
if(model_ptr->character == -1) {
Hu3DMotionSpeedSet(model_ptr->id, speed);
} else {
CharModelMotionSpeedSet(model_ptr->character, speed);
}
hsf_model = &Hu3DData[model_ptr->id];
hsf_model->unk_88 = speed;
return 0;
}
}
s32 BoardModelMotionEndCheck(s16 model)
{
BoardModel *model_ptr = SearchBoardModel(model);
if(!model_ptr) {
return 1;
} else {
s32 result;
if(model_ptr->character == -1) {
result = Hu3DMotionEndCheck(model_ptr->id);
} else {
result = CharModelMotionEndCheck(model_ptr->character);
}
return result;
}
}
s32 BoardModelMotionShapeSet(s16 model, s32 motion, u32 attr)
{
BoardModel *model_ptr = SearchBoardModel(model);
if(!model_ptr) {
return -1;
} else {
ModelData *hsf_model;
if(model_ptr->character != -1) {
return -1;
}
if(motion >= BOARD_MOT_MAX) {
return -1;
}
hsf_model = &Hu3DData[model_ptr->id];
hsf_model->unk_98 = 1.0f;
Hu3DMotionShapeSet(model_ptr->id, model_ptr->mot_id[motion]);
if(attr & 0x40000100) {
float max_time = Hu3DMotionMaxTimeGet(model_ptr->id);
hsf_model->unk_94 = max_time;
}
Hu3DModelAttrSet(model_ptr->id, attr);
return 0;
}
}
float BoardModelMotionShapeTimeGet(s16 model)
{
BoardModel *model_ptr = SearchBoardModel(model);
if(!model_ptr) {
return -1;
} else {
ModelData *hsf_model;
if(model_ptr->character != -1) {
return -1;
}
hsf_model = &Hu3DData[model_ptr->id];
return hsf_model->unk_94;
}
}
float BoardModelMotionShapeMaxTimeGet(s16 model)
{
BoardModel *model_ptr = SearchBoardModel(model);
if(!model_ptr) {
return -1;
} else {
ModelData *hsf_model;
MotionData *motion;
HsfMotion *motion_hsf;
if(model_ptr->character != -1) {
return -1;
}
hsf_model = &Hu3DData[model_ptr->id];
if(hsf_model->unk_0E == -1) {
return 0;
}
motion = &Hu3DMotion[hsf_model->unk_0E];
motion_hsf = motion->unk_04->motion;
return motion_hsf->len;
}
}
s32 BoardModelMotionShapeSpeedSet(s16 model, float speed)
{
BoardModel *model_ptr = SearchBoardModel(model);
if(!model_ptr) {
return -1;
} else {
ModelData *hsf_model;
if(model_ptr->character != -1) {
return -1;
}
hsf_model = &Hu3DData[model_ptr->id];
hsf_model->unk_98 = speed;
return 0;
}
}
float BoardModelMotionShapeSpeedGet(s16 model, float speed)
{
BoardModel *model_ptr = SearchBoardModel(model);
if(!model_ptr) {
return -1;
} else {
ModelData *hsf_model;
hsf_model = &Hu3DData[model_ptr->id];
return hsf_model->unk_98;
}
}
s32 BoardModelMotionShapeEndCheck(s16 model)
{
BoardModel *model_ptr = SearchBoardModel(model);
if(!model_ptr) {
return 1;
} else {
ModelData *hsf_model;
if(model_ptr->character != -1) {
return 1;
}
hsf_model = &Hu3DData[model_ptr->id];
if(hsf_model->attr & 0x40000100) {
return hsf_model->unk_94 <= 0.0f;
}
return BoardModelMotionShapeMaxTimeGet(model) <= hsf_model->unk_94;
}
}
s32 BoardModelMotionShapeStartEndSet(s16 model, s16 start, s16 end)
{
BoardModel *model_ptr = SearchBoardModel(model);
if(!model_ptr) {
return -1;
} else {
if(model_ptr->character != -1) {
return -1;
}
if(start >= 0) {
OSs16tof32(&start, &model_ptr->mot_start);
}
if(end >= 0) {
OSs16tof32(&end, &model_ptr->mot_end);
}
Hu3DMotionShapeStartEndSet(model_ptr->id, model_ptr->mot_start, model_ptr->mot_end);
return 0;
}
}
s32 BoardModelAlphaSet(s16 model, u8 alpha)
{
BoardModel *model_ptr = SearchBoardModel(model);
if(!model_ptr) {
return -1;
} else {
float tp_lvl;
model_ptr->alpha = alpha;
OSu8tof32(&alpha, &tp_lvl);
tp_lvl = tp_lvl*(1.0f/255.0f);
Hu3DModelTPLvlSet(model_ptr->id, tp_lvl);
return 0;
}
}
s32 BoardModelMtxSet(s16 model, Mtx *src)
{
BoardModel *model_ptr = SearchBoardModel(model);
if(!model_ptr) {
return -1;
} else {
ModelData *hsf_model;
if(!src) {
return -1;
}
hsf_model = &Hu3DData[model_ptr->id];
MTXCopy(*src, hsf_model->unk_F0);
return 0;
}
}
s32 BoardModelMtxGet(s16 model, Mtx *dst)
{
BoardModel *model_ptr = SearchBoardModel(model);
if(!model_ptr) {
return -1;
} else {
ModelData *hsf_model;
if(!dst) {
return -1;
}
hsf_model = &Hu3DData[model_ptr->id];
MTXCopy(hsf_model->unk_F0, *dst);
return 0;
}
}
s32 BoardModelRotYSet(s16 model, float rot)
{
Vec rot_orig;
BoardModelRotGet(model, &rot_orig);
return BoardModelRotSet(model, rot_orig.x, BoardDAngleCalc(rot), rot_orig.z);
}
float BoardModelRotYGet(s16 model)
{
Vec rot;
BoardModelRotGet(model, &rot);
return rot.y;
}
s32 BoardModelPosSetV(s16 model, Vec *pos)
{
if(!pos) {
return -1;
} else {
return BoardModelPosSet(model, pos->x, pos->y, pos->z);
}
}
s32 BoardModelPosSet(s16 model, float x, float y, float z)
{
BoardModel *model_ptr = SearchBoardModel(model);
if(!model_ptr) {
return -1;
} else {
model_ptr->pos.x = x;
model_ptr->pos.y = y;
model_ptr->pos.z = z;
Hu3DModelPosSetV(model_ptr->id, &model_ptr->pos);
return 0;
}
}
s32 BoardModelRotSetV(s16 model, Vec *pos)
{
if(!pos) {
return -1;
} else {
return BoardModelRotSet(model, pos->x, pos->y, pos->z);
}
}
s32 BoardModelRotSet(s16 model, float x, float y, float z)
{
BoardModel *model_ptr = SearchBoardModel(model);
if(!model_ptr) {
return -1;
} else {
model_ptr->rot.x = x;
model_ptr->rot.y = y;
model_ptr->rot.z = z;
Hu3DModelRotSetV(model_ptr->id, &model_ptr->rot);
return 0;
}
}
s32 BoardModelScaleSetV(s16 model, Vec *pos)
{
if(!pos) {
return -1;
} else {
return BoardModelScaleSet(model, pos->x, pos->y, pos->z);
}
}
s32 BoardModelScaleSet(s16 model, float x, float y, float z)
{
BoardModel *model_ptr = SearchBoardModel(model);
if(!model_ptr) {
return -1;
} else {
model_ptr->scale.x = x;
model_ptr->scale.y = y;
model_ptr->scale.z = z;
Hu3DModelScaleSetV(model_ptr->id, &model_ptr->scale);
return 0;
}
}
s32 BoardModelPosGet(s16 model, Vec *dst)
{
BoardModel *model_ptr = SearchBoardModel(model);
if(!model_ptr || !dst) {
return -1;
} else {
*dst = model_ptr->pos;
return 0;
}
}
s32 BoardModelRotGet(s16 model, Vec *dst)
{
BoardModel *model_ptr = SearchBoardModel(model);
if(!model_ptr || !dst) {
return -1;
} else {
*dst = model_ptr->rot;
return 0;
}
}
s32 BoardModelScaleGet(s16 model, Vec *dst)
{
BoardModel *model_ptr = SearchBoardModel(model);
if(!model_ptr || !dst) {
return -1;
} else {
*dst = model_ptr->scale;
return 0;
}
}
s32 BoardModelVisibilitySet(s16 model, s32 visible)
{
BoardModel *model_ptr = SearchBoardModel(model);
if(!model_ptr) {
return -1;
} else {
model_ptr->visible = visible;
return 0;
}
}
s32 BoardModelVisibilityGet(s16 model)
{
BoardModel *model_ptr = SearchBoardModel(model);
if(!model_ptr) {
return 0;
} else {
return model_ptr->visible;
}
}
s32 BoardModelCameraSet(s16 model, u16 camera)
{
BoardModel *model_ptr = SearchBoardModel(model);
if(!model_ptr) {
return -1;
} else {
Hu3DModelCameraSet(model_ptr->id, camera);
model_ptr->camera = camera;
return 0;
}
}
s32 BoardModelLayerSet(s16 model, u8 layer)
{
BoardModel *model_ptr = SearchBoardModel(model);
if(!model_ptr) {
return -1;
} else {
model_ptr->layer = layer;
Hu3DModelLayerSet(model_ptr->id, layer);
return 0;
}
}
s32 BoardModelLayerGet(s16 model)
{
BoardModel *model_ptr = SearchBoardModel(model);
if(!model_ptr) {
return -1;
} else {
return model_ptr->layer;
}
}
void BoardModelLayerSetAll(s32 layer)
{
BoardModel *model;
for(model=modelDataList; model < &modelDataList[BOARD_MODEL_MAX]; model++) {
if(model->index == -1 || model->character != -1) {
continue;
}
Hu3DModelLayerSet(model->id, layer);
}
}
s32 BoardModelHookSet(s16 model, char *name, s16 hook)
{
BoardModel *model_ptr = SearchBoardModel(model);
if(!model_ptr) {
return -1;
} else {
BoardModel *hook_ptr = SearchBoardModel(hook);
if(!hook_ptr || !name) {
return -1;
}
Hu3DModelHookSet(model_ptr->id, name, hook_ptr->id);
BoardModelPosSet(hook, 0, 0, 0);
return 0;
}
}
s32 BoardModelHookReset(s16 model)
{
BoardModel *model_ptr = SearchBoardModel(model);
if(!model_ptr) {
return -1;
} else {
Hu3DModelHookReset(model_ptr->id);
return 0;
}
}
s32 BoardModelHookObjReset(s16 model, char *name)
{
BoardModel *model_ptr = SearchBoardModel(model);
if(!model_ptr) {
return -1;
} else {
Hu3DModelHookObjReset(model_ptr->id, name);
return 0;
}
}
static BoardModel *SearchBoardModel(s16 id)
{
BoardModel *model;

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

@ -66,8 +66,8 @@ extern void BoardViewMapExec(s32);
extern s32 fn_80085CC8(s32);
extern void fn_80085EB4(void);
//// #include "game/chrman.h"
extern void CharModelKillIndex(s16);
extern void CharModelSetStepType(s16, s32);
extern void CharModelDataClose(s16);
extern void CharModelStepTypeSet(s16, s32);
////
s32 BoardRollTypeGet(void);
@ -317,7 +317,7 @@ void BoardPlayerModelInit(void) {
GWPlayer[var_r31].diff = GWPlayerCfg[var_r31].diff;
GWPlayerCfg[var_r31].diff = GWPlayerCfg[var_r31].diff;
temp_r27->space_prev = -1;
CharModelKillIndex(GWPlayer[var_r31].character);
CharModelDataClose(GWPlayer[var_r31].character);
}
CharModelLayerSetAll(2);
}
@ -658,11 +658,11 @@ void BoardPlayerSizeSet(s32 arg0, s32 arg1) {
temp_r27 = BoardPlayerGet(arg0);
temp_r27->size = arg1;
if (arg1 == 2) {
CharModelSetStepType(GWPlayer[arg0].character, 4);
CharModelStepTypeSet(GWPlayer[arg0].character, 4);
} else if (arg1 == 1) {
CharModelSetStepType(GWPlayer[arg0].character, 5);
CharModelStepTypeSet(GWPlayer[arg0].character, 5);
} else {
CharModelSetStepType(GWPlayer[arg0].character, 0);
CharModelStepTypeSet(GWPlayer[arg0].character, 0);
}
BoardModelScaleSetV(BoardPlayerModelGet(arg0), &temp_r4[arg1]);
}