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

14
config/GMPE01_00/symbols.txt
View file

@ -863,7 +863,7 @@ PlayEffectSound = .text:0x8004C9D4; // type:function size:0x344 scope:local
CharMotionCreate = .text:0x8004CD18; // type:function size:0x1D0
CharMotionSet = .text:0x8004CEE8; // type:function size:0x88
CharMotionKill = .text:0x8004CF70; // type:function size:0x9C
CharMotionClose = .text:0x8004D00C; // type:function size:0x2B8
CharMotionDataClose = .text:0x8004D00C; // type:function size:0x2B8
CharModelDataClose = .text:0x8004D2C4; // type:function size:0x430
CharModelKill = .text:0x8004D6F4; // type:function size:0x244
CharModelMotionSet = .text:0x8004D938; // type:function size:0x7C
@ -895,7 +895,7 @@ fn_8004F578 = .text:0x8004F578; // type:function size:0xB0
fn_8004F628 = .text:0x8004F628; // type:function size:0x2CC
fn_8004F8F4 = .text:0x8004F8F4; // type:function size:0x2CC
fn_8004FBC0 = .text:0x8004FBC0; // type:function size:0xF80
CharModelSetStepType = .text:0x80050B40; // type:function size:0x30
CharModelStepTypeSet = .text:0x80050B40; // type:function size:0x30
PlayStepFX = .text:0x80050B70; // type:function size:0xEC scope:local
MapWall = .text:0x80050C5C; // type:function size:0x1B8
MapWallCheck = .text:0x80050E14; // type:function size:0x110
@ -1075,9 +1075,9 @@ BoardRandMod = .text:0x8005FB40; // type:function size:0x50
BoardRandFloat = .text:0x8005FB90; // type:function size:0x58
BoardVecDistXZCalc = .text:0x8005FBE8; // type:function size:0x134
BoardVecMaxDistXZCheck = .text:0x8005FD1C; // type:function size:0x15C
BoardVecDAngleCalcVec = .text:0x8005FE78; // type:function size:0x7C
BoardVecDAngleCalc = .text:0x8005FEF4; // type:function size:0x34
BoardVecDAngleCalcRange = .text:0x8005FF28; // type:function size:0x1C0
BoardDAngleCalcVec = .text:0x8005FE78; // type:function size:0x7C
BoardDAngleCalc = .text:0x8005FEF4; // type:function size:0x34
BoardDAngleCalcRange = .text:0x8005FF28; // type:function size:0x1C0
BoardVecMinDistCheck = .text:0x800600E8; // type:function size:0x6C
BoardFilterFadeOut = .text:0x80060154; // type:function size:0xD4
BoardFilterFadeInit = .text:0x80060228; // type:function size:0x174
@ -1241,7 +1241,7 @@ BoardModelExistDupe = .text:0x8006DDA0; // type:function size:0x48
fn_8006DDE8 = .text:0x8006DDE8; // type:function size:0x70
BoardModelMotionCreate = .text:0x8006DE58; // type:function size:0x140
BoardModelMotionKill = .text:0x8006DF98; // type:function size:0x118
BoardModelMotionTimeRangeSet = .text:0x8006E0B0; // type:function size:0xE8
BoardModelMotionStartEndSet = .text:0x8006E0B0; // type:function size:0xE8
BoardModelMotionUpdateSet = .text:0x8006E198; // type:function size:0x7C
BoardModelVoiceEnableSet = .text:0x8006E214; // type:function size:0xA4
BoardModelMotionStart = .text:0x8006E2B8; // type:function size:0x174
@ -1256,7 +1256,7 @@ BoardModelMotionSpeedGet = .text:0x8006E814; // type:function size:0x64
BoardModelMotionSpeedSet = .text:0x8006E878; // type:function size:0xA4
BoardModelMotionEndCheck = .text:0x8006E91C; // type:function size:0x80
BoardModelMotionShapeSet = .text:0x8006E99C; // type:function size:0x100
BoardModelMotionShapeTimeSet = .text:0x8006EA9C; // type:function size:0x7C
BoardModelMotionShapeTimeGet = .text:0x8006EA9C; // type:function size:0x7C
BoardModelMotionShapeMaxTimeGet = .text:0x8006EB18; // type:function size:0xBC
BoardModelMotionShapeSpeedSet = .text:0x8006EBD4; // type:function size:0x88
BoardModelMotionShapeSpeedGet = .text:0x8006EC5C; // type:function size:0x64

2
configure.py
View file

@ -361,7 +361,7 @@ config.libs = [
Object(NonMatching, "game/sreset.c"),
Object(Matching, "game/board/main.c"),
Object(NonMatching, "game/board/player.c"),
Object(NonMatching, "game/board/model.c"),
Object(Matching, "game/board/model.c"),
Object(Matching, "game/board/window.c"),
Object(NonMatching, "game/board/audio.c"),
Object(NonMatching, "game/board/com.c"),

6
include/game/board/main.h
View file

@ -142,9 +142,9 @@ u32 BoardRandMod(u32 value);
float BoardRandFloat(void);
float BoardVecDistXZCalc(Vec *vec1, Vec *vec2);
s32 BoardVecMaxDistXZCheck(Vec *vec1, Vec *vec2, float max_dist);
void BoardVecDAngleCalcVec(Vec *vec1);
float BoardVecDAngleCalc(float value);
s32 BoardVecDAngleCalcRange(float *value, float min, float range);
void BoardDAngleCalcVec(Vec *vec1);
float BoardDAngleCalc(float value);
s32 BoardDAngleCalcRange(float *value, float min, float range);
s32 BoardVecMinDistCheck(Vec *vec1, Vec *vec2, float min_dist);
void BoardFilterFadeOut(s16 len);
void BoardFilterFadeInit(s16 len, u8 max_alpha);

26
include/game/board/model.h
View file

@ -36,13 +36,23 @@ s32 BoardModelExistDupe(s16 model, s32 arg1);
s32 fn_8006DDE8(s16 model, float arg1);
s32 BoardModelMotionStart(s16 model, s32 slot, u32 attr);
s32 BoardModelMotionSpeedSet(s16 model, float speed);
void BoardModelPosSet(s16 model, float x, float y, float z);
void BoardModelPosSetV(s16 model, Vec *pos);
void BoardModelRotSet(s16 model, float x, float y, float z);
void BoardModelRotSetV(s16 model, Vec *rot);
void BoardModelScaleSet(s16 model, float x, float y, float z);
void BoardModelScaleSetV(s16 model, Vec *scale);
void BoardModelVisibilitySet(s16 model, s32 flag);
s32 BoardModelPosSet(s16 model, float x, float y, float z);
s32 BoardModelPosSetV(s16 model, Vec *pos);
s32 BoardModelRotSet(s16 model, float x, float y, float z);
s32 BoardModelRotSetV(s16 model, Vec *rot);
s32 BoardModelScaleSet(s16 model, float x, float y, float z);
s32 BoardModelScaleSetV(s16 model, Vec *scale);
s32 BoardModelPosGet(s16 model, Vec *dst);
s32 BoardModelRotGet(s16 model, Vec *dst);
s32 BoardModelScaleGet(s16 model, Vec *dst);
s32 BoardModelVisibilitySet(s16 model, s32 flag);
s32 BoardModelVisibilityGet(s16 model);
s32 BoardModelCameraSet(s16 model, u16 camera);
s32 BoardModelLayerSet(s16 model, u8 layer);
s32 BoardModelLayerGet(s16 model);
void BoardModelLayerSetAll(s32 layer);
s32 BoardModelHookSet(s16 model, char *name, s16 hook);
s32 BoardModelHookReset(s16 model);
s32 BoardModelHookObjReset(s16 model, char *name);
#endif

10
include/game/hsfman.h
View file

@ -38,7 +38,9 @@ typedef struct model_data {
u32 motion_attr;
Point3d unk_58;
f32 unk_64;
Point3d unk_68;
f32 unk_68;
f32 unk_6C;
f32 unk_70;
f32 unk_74;
f32 unk_78;
f32 unk_7C;
@ -135,11 +137,11 @@ s16 Hu3DModelLink(s16);
s16 Hu3DHookFuncCreate(ModelHookFunc);
void Hu3DModelAllKill(void);
void Hu3DModelPosSet(s16, f32, f32, f32);
void Hu3DModelPosSetV(s16, Vec);
void Hu3DModelPosSetV(s16, Vec *);
void Hu3DModelRotSet(s16, f32, f32, f32);
void Hu3DModelRotSetV(s16, Vec);
void Hu3DModelRotSetV(s16, Vec *);
void Hu3DModelScaleSet(s16, f32, f32, f32);
void Hu3DModelScaleSetV(s16, Vec);
void Hu3DModelScaleSetV(s16, Vec *);
void Hu3DModelAttrSet(s16, u32);
void Hu3DModelAttrReset(s16, u32);
u32 Hu3DModelAttrGet(s16);

12
include/unsplit.h
View file

@ -6,10 +6,20 @@
void MGSeqKillAll(void);
void MGSeqPracticeStart(void);
void CharMotionClose(s16 character);
void CharModelClose(s16 character);
void CharModelKill(s16 character);
s16 CharModelCreate(s16 character, s16 lod);
s16 CharMotionCreate(s16 character, s32 data_num);
void CharMotionKill(s16 character, u32 motion);
void CharModelMotionSet(s16 character, s16 motion);
float CharModelMotionMaxTimeGet(s16 character);
float CharModelMotionTimeGet(s16 character);
void CharModelMotionShiftSet(s16 model, s16 motion, float time, float shift_time, u32 attr);
void CharModelMotionTimeSet(s16 character, float time);
void CharModelMotionSpeedSet(s16 character, float speed);
void CharMotionKill(s16 character, s32 motion);
void CharModelVoiceEnableSet(s16 character, s16 motion, s32 flag);
s32 CharModelMotionEndCheck(s16 character);
#endif

8
src/REL/w03Dll/main.c
View file

@ -37,7 +37,7 @@ extern const VoidFunc _dtors[];
f32 BoardModelMotionTimeGet(s16);
s16 BoardModelCreate(s32, void*, s32);
void BoardModelKill(s16);
void BoardModelMotionTimeRangeSet(s16, s32, s32);
void BoardModelMotionStartEndSet(s16, s32, s32);
void Hu3DFogSet(f32, f32, u8, u8, u8);
void HuAudFXListnerSetEX(Vec* arg0, Vec* arg1, float sndDist, float sndSpeed, float arg4, float arg5, float arg6);
u8 WipeStatGet(void);
@ -194,9 +194,9 @@ void BoardCreate(void) {
var_f31 = lbl_1_data_1EC.unk_04;
fn_1_63F4(1);
}
BoardModelMotionTimeRangeSet(lbl_1_bss_C[0], var_f30, var_f31);
BoardModelMotionStartEndSet(lbl_1_bss_C[0], var_f30, var_f31);
BoardModelMotionStart(lbl_1_bss_C[2], 0, 0x40000001);
BoardModelMotionTimeRangeSet(lbl_1_bss_C[2], 1, 0x64);
BoardModelMotionStartEndSet(lbl_1_bss_C[2], 1, 0x64);
fn_1_785C();
if (lbl_1_bss_0->unk2 != 0) {
for (i = 0; i < 4; i++) {
@ -327,7 +327,7 @@ void fn_1_B5C(s32 arg0) {
}
BoardModelAttrSet(lbl_1_bss_C[0], 0x40000001);
BoardModelMotionTimeSet(lbl_1_bss_C[0], var_f31);
BoardModelMotionTimeRangeSet(lbl_1_bss_C[0], (s32) var_f31, (s32) var_f28);
BoardModelMotionStartEndSet(lbl_1_bss_C[0], (s32) var_f31, (s32) var_f28);
}
void fn_1_CF4(void) {

8
src/REL/w03Dll/statue.c
View file

@ -24,7 +24,7 @@ void fn_1_2AC0(void);
void fn_1_2818(void);
void fn_1_2A40(void);
void fn_1_2B44(void);
s32 BoardVecDAngleCalcRange(f32*, f32, f32);
s32 BoardDAngleCalcRange(f32*, f32, f32);
s32 BoardPlayerMotBlendCheck(s32);
void BoardPlayerMotBlendSet(s32, s32, s32);
f32 BoardPlayerRotYGet(s32);
@ -232,7 +232,7 @@ s32 fn_1_1650(s32 arg0) {
HuAudFXPlay(0x435);
sp8.y = BoardModelRotYGet(lbl_1_bss_6C);
while (BoardVecDAngleCalcRange(&sp8.y, 180.0f, 2.0f) == 0) {
while (BoardDAngleCalcRange(&sp8.y, 180.0f, 2.0f) == 0) {
BoardModelRotYSet(lbl_1_bss_6C, sp8.y);
HuPrcVSleep();
}
@ -367,7 +367,7 @@ void fn_1_1ED4(s32 arg0) {
BoardConfettiCreate(&spC, 0x64, 300.0f);
sp8 = BoardModelRotYGet(lbl_1_bss_6C);
while (BoardVecDAngleCalcRange(&sp8, 0.0f, 30.0f) == 0) {
while (BoardDAngleCalcRange(&sp8, 0.0f, 30.0f) == 0) {
BoardModelRotYSet(lbl_1_data_284, sp8);
HuPrcVSleep();
}
@ -408,7 +408,7 @@ void fn_1_20E0(s32 arg0) {
BoardModelPosSetV(lbl_1_data_284, &spC);
BoardFilterFadeOut(0x1E);
sp8 = BoardModelRotYGet(lbl_1_bss_6C);
while (BoardVecDAngleCalcRange(&sp8, 0.0f, 30.0f) == 0) {
while (BoardDAngleCalcRange(&sp8, 0.0f, 30.0f) == 0) {
BoardModelRotYSet(lbl_1_data_284, sp8);
HuPrcVSleep();
}

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]);
}

26
src/game/hsfman.c
View file

@ -348,7 +348,7 @@ s16 Hu3DModelCreate(void *arg0) {
var_r31->motion_attr = 0;
var_r31->unk_02 = 0;
MakeDisplayList(var_r30, (HsfData* ) var_r31->unk_48);
var_r31->unk_68.x = 1.0f;
var_r31->unk_68 = 1.0f;
for (i = 0; i < 4; i++) {
var_r31->unk_10[i] = -1;
}
@ -369,8 +369,8 @@ s16 Hu3DModelCreate(void *arg0) {
if (var_r31->hsfData->shapeCnt != 0) {
Hu3DMotionShapeSet(var_r30, var_r31->unk_08);
}
var_r31->unk_68.y = 0.0f;
var_r31->unk_68.z = Hu3DMotionMaxTimeGet(var_r30);
var_r31->unk_6C = 0.0f;
var_r31->unk_70 = Hu3DMotionMaxTimeGet(var_r30);
} else {
var_r31->unk_20 = var_r31->unk_08 = -1;
}
@ -439,8 +439,8 @@ s16 Hu3DModelLink(s16 arg0) {
var_r31->scale.x = var_r31->scale.y = var_r31->scale.z = 1.0f;
var_r31->unk_08 = temp_r30->unk_08;
if (var_r31->unk_08 != -1) {
var_r31->unk_68.y = 0.0f;
var_r31->unk_68.z = Hu3DMotionMaxTimeGet(var_r28);
var_r31->unk_6C = 0.0f;
var_r31->unk_70 = Hu3DMotionMaxTimeGet(var_r28);
}
var_r31->unk_0C = var_r31->unk_0A = var_r31->unk_0E = -1;
for (i = 0; i < 4; i++) {
@ -451,7 +451,7 @@ s16 Hu3DModelLink(s16 arg0) {
}
}
var_r31->unk_64 = temp_r30->unk_64;
var_r31->unk_68.x = temp_r30->unk_68.x;
var_r31->unk_68 = temp_r30->unk_68;
var_r31->unk_20 = temp_r30->unk_20;
var_r31->camera = -1;
var_r31->layer = 0;
@ -499,7 +499,7 @@ s16 Hu3DHookFuncCreate(ModelHookFunc hook) {
var_r31->unk_10[i] = -1;
}
var_r31->unk_64 = 0.0f;
var_r31->unk_68.x = 1.0f;
var_r31->unk_68 = 1.0f;
var_r31->unk_20 = -1;
var_r31->camera = -1;
var_r31->layer = 0;
@ -641,11 +641,11 @@ void Hu3DModelPosSet(s16 index, f32 x, f32 y, f32 z) {
temp_r31->pos.z = z;
}
void Hu3DModelPosSetV(s16 arg0, Vec arg1) {
void Hu3DModelPosSetV(s16 arg0, Vec *arg1) {
ModelData* temp_r31;
temp_r31 = &Hu3DData[arg0];
temp_r31->pos = arg1;
temp_r31->pos = *arg1;
}
void Hu3DModelRotSet(s16 index, f32 x, f32 y, f32 z) {
@ -657,11 +657,11 @@ void Hu3DModelRotSet(s16 index, f32 x, f32 y, f32 z) {
temp_r31->rot.z = z;
}
void Hu3DModelRotSetV(s16 arg0, Vec arg1) {
void Hu3DModelRotSetV(s16 arg0, Vec *arg1) {
ModelData* temp_r31;
temp_r31 = &Hu3DData[arg0];
temp_r31->rot = arg1;
temp_r31->rot = *arg1;
}
void Hu3DModelScaleSet(s16 index, f32 x, f32 y, f32 z) {
@ -673,11 +673,11 @@ void Hu3DModelScaleSet(s16 index, f32 x, f32 y, f32 z) {
temp_r31->scale.z = z;
}
void Hu3DModelScaleSetV(s16 arg0, Vec arg1) {
void Hu3DModelScaleSetV(s16 arg0, Vec *arg1) {
ModelData* temp_r31;
temp_r31 = &Hu3DData[arg0];
temp_r31->scale = arg1;
temp_r31->scale = *arg1;
}
void Hu3DModelAttrSet(s16 arg0, u32 arg1) {

38
src/game/hsfmotion.c
View file

@ -112,8 +112,8 @@ void Hu3DMotionSet(s16 arg0, s16 arg1) {
Hu3DData[arg0].unk_0C = -1;
Hu3DData[arg0].unk_08 = arg1;
Hu3DData[arg0].unk_64 = 0.0f;
Hu3DData[arg0].unk_68.y = 0.0f;
Hu3DData[arg0].unk_68.z = Hu3DMotionMaxTimeGet(arg0);
Hu3DData[arg0].unk_6C = 0.0f;
Hu3DData[arg0].unk_70 = Hu3DMotionMaxTimeGet(arg0);
}
void Hu3DMotionOverlaySet(s16 arg0, s16 arg1) {
@ -148,9 +148,9 @@ void Hu3DMotionShiftSet(s16 arg0, s16 arg1, float arg2, float arg3, u32 arg4) {
if (temp_r31->unk_0C != -1) {
temp_r31->unk_08 = temp_r31->unk_0C;
temp_r31->unk_64 = temp_r31->unk_84;
temp_r31->unk_68.x = temp_r31->unk_88;
temp_r31->unk_68.y = temp_r31->unk_8C;
temp_r31->unk_68.z = temp_r31->unk_90;
temp_r31->unk_68 = temp_r31->unk_88;
temp_r31->unk_6C = temp_r31->unk_8C;
temp_r31->unk_70 = temp_r31->unk_90;
if (arg4 & 0x40000008) {
var_r30 |= 0x40000000 | 1;
}
@ -373,8 +373,8 @@ float Hu3DMotionMotionMaxTimeGet(s16 arg0) {
void Hu3DMotionStartEndSet(s16 arg0, float arg1, float arg2) {
ModelData *temp_r31 = &Hu3DData[arg0];
temp_r31->unk_68.y = arg1;
temp_r31->unk_68.z = arg2;
temp_r31->unk_6C = arg1;
temp_r31->unk_70 = arg2;
}
s32 Hu3DMotionEndCheck(s16 arg0) {
@ -388,7 +388,7 @@ s32 Hu3DMotionEndCheck(s16 arg0) {
void Hu3DMotionSpeedSet(s16 arg0, float arg1) {
ModelData *temp_r31 = &Hu3DData[arg0];
temp_r31->unk_68.x = arg1;
temp_r31->unk_68 = arg1;
}
void Hu3DMotionShiftSpeedSet(s16 arg0, float arg1) {
@ -482,20 +482,20 @@ void Hu3DMotionNext(s16 arg0) {
temp_r27 = &Hu3DMotion[temp_r31->unk_08];
if (!(temp_r28 & 0x40000002)) {
if (!(temp_r28 & 0x40000004)) {
temp_r31->unk_64 += temp_r31->unk_68.x * minimumVcountf;
temp_r31->unk_64 += temp_r31->unk_68 * minimumVcountf;
} else {
temp_r31->unk_64 -= temp_r31->unk_68.x * minimumVcountf;
temp_r31->unk_64 -= temp_r31->unk_68 * minimumVcountf;
}
if (temp_r28 & 0x40000001) {
if (temp_r31->unk_64 < temp_r31->unk_68.y) {
temp_r31->unk_64 = temp_r31->unk_68.z - (temp_r31->unk_68.y - temp_r31->unk_64);
} else if (temp_r31->unk_64 >= temp_r31->unk_68.z) {
temp_r31->unk_64 = temp_r31->unk_68.y + (temp_r31->unk_64 - temp_r31->unk_68.z);
if (temp_r31->unk_64 < temp_r31->unk_6C) {
temp_r31->unk_64 = temp_r31->unk_70 - (temp_r31->unk_6C - temp_r31->unk_64);
} else if (temp_r31->unk_64 >= temp_r31->unk_70) {
temp_r31->unk_64 = temp_r31->unk_6C + (temp_r31->unk_64 - temp_r31->unk_70);
}
} else if (temp_r31->unk_64 < 0.0f) {
temp_r31->unk_64 = 0.0f;
} else if (temp_r31->unk_64 >= temp_r31->unk_68.z) {
temp_r31->unk_64 = temp_r31->unk_68.z;
} else if (temp_r31->unk_64 >= temp_r31->unk_70) {
temp_r31->unk_64 = temp_r31->unk_70;
}
}
}
@ -526,9 +526,9 @@ void Hu3DMotionNext(s16 arg0) {
if (temp_r31->unk_7C >= temp_r31->unk_80) {
temp_r31->unk_08 = temp_r31->unk_0C;
temp_r31->unk_64 = temp_r31->unk_84;
temp_r31->unk_68.x = temp_r31->unk_88;
temp_r31->unk_68.y = temp_r31->unk_8C;
temp_r31->unk_68.z = temp_r31->unk_90;
temp_r31->unk_68 = temp_r31->unk_88;
temp_r31->unk_6C = temp_r31->unk_8C;
temp_r31->unk_70 = temp_r31->unk_90;
temp_r31->unk_0C = -1;
temp_r28 = 0;
if (temp_r31->motion_attr & 0x40000008) {