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

Merge branch 'main' into main

Browse source
This commit is contained in:
CreateSource 2024-01-21 13:25:40 -05:00 • committed by GitHub
commit 83df5dfe18
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
110 changed files with 11426 additions and 1767 deletions
Download patch file Download diff file Expand all files Collapse all files

29
include/REL/w03Dll.h Normal file
View file

@ -0,0 +1,29 @@
#include "game/gamework_data.h"
#include "dolphin.h"
#include "REL/executor.h"
#include "game/process.h"
#include "game/window.h"
#include "game/object.h"
#define ARRAY_COUNT(arr) (s32)(sizeof(arr) / sizeof(arr[0]))
typedef struct w03StructUnk0 {
/* 0x00 */ Vec unk_00;
/* 0x0C */ Vec unk_0C;
/* 0x18 */ Vec unk_18;
/* 0x24 */ s32 datanum;
} w03StructUnk0;
typedef struct w03UnkStruct2{
u8 unk0 : 1;
} w03UnkStruct2;
typedef struct w03State {
s8 unk0;
u8 unk1;
u8 unk2;
s8 unk3;
u16 unk4;
u16 unk6;
s16 unk8;
} w03State;

40
include/board_unsplit.h
View file

@ -3,18 +3,28 @@
#include "dolphin.h"
#ifndef _BOARD_SPACE_EVENT_FUNC
#define _BOARD_SPACE_EVENT_FUNC
typedef s32 (*BoardSpaceEventFunc)(void);
#endif
#ifndef _BOARD_MAIN_H
typedef void (*BoardLightHook)(void);
#endif
void BoardCameraTargetModelSet(s16 model);
void BoardCameraMotionStartEx(s16, Vec *, Vec *, f32, f32, s16);
void BoardCameraMotionWait(void);
void fn_8007A360(s32);
void fn_8007F894(void);
s32 BoardSpacePosGet(s32, s32, Vec*);
void BoardShopTutorialExec(s32);
void BoardLotteryTutorialExec(void);
s16 BoardStarHostMdlGet(void);
void BoardStatusShowSetAll(s32);
void fn_800A4C88(void);
void fn_800A6B10(void);
void BoardMGSetupTutorialExec(void);
void BoardBooHouseTutorialExec(void);
void BoardStatusItemSet(s32);
void BoardTutorialItemSet(s32);
void fn_80082AAC(s32);
void BoardCharWheelSetTarget(s32);
void BoardTutorialDirInputSet(s32, s32, s32);
void BoardSpaceStarSetIndex(s32);
void BoardModelRotYSet(s16, f32);
@ -23,7 +33,7 @@ void BoardModelLayerSet(s16, u8);
void BoardTutorialHostSet(s16);
s16 BoardModelIDGet(s16);
void BoardModelScaleSetV(s16, Vec*);
void BoardLightHookSet(void*, void*);
void BoardLightHookSet(BoardLightHook set, BoardLightHook reset);
s16 BoardModelCreate(s32, void*, s32);
void BoardModelKill(s16);
void fn_8006DDE8(s16, f32);
@ -33,18 +43,26 @@ void BoardModelPosSetV(s16, Vec*);
void BoardModelPosSet(s16, f32, f32, f32);
void BoardModelRotSetV(s16 arg0, Vec* arg1);
void BoardModelVisibilitySet(s16, s32);
void BoardSpaceWalkEventFuncSet(BoardSpaceEventFunc func);
void BoardSpaceWalkMiniEventFuncSet(BoardSpaceEventFunc func);
void BoardSpaceLandEventFuncSet(BoardSpaceEventFunc func);
s32 BoardSpaceFlagSearch(s32, u32);
void BoardSpaceInit(s32);
void BoardSpaceDestroy(void);
void fn_80077AAC(s16);
void fn_8007A83C(s16);
void fn_80083EDC(s16);
void fn_800A4F6C(s16);
void BoardShopHostSet(s16);
void BoardLotteryHostSet(s16);
void BoardStarHostSet(s16);
void BoardBooHouseHostSet(s16);
void BoardTutorialHookSet(void*);
void BoardTutorialBlockSetPos(s32, s32);
s32 BoardCameraRotGet(Vec*);
void BoardModelScaleSet(s16, f32, f32, f32);
s32 BoardIsKill(void);
void BoardModelMtxSet(s16, Mtx);
void BoardModelMtxSet(s16, Mtx*);
void BoardModelRotSet(s16, f32, f32, f32);
void BoardBowserExec(s32 player, s32 space);
void BoardBattleExec(s32 player, s32 space);
void BoardFortuneExec(s32 player, s32 space);
#endif

12
include/dolphin/gx/GXVert.h
View file

@ -149,6 +149,18 @@ static inline void GXColor1x8(u8 index) {
GXWGFifo.u8 = index;
}
static inline void GXPosition1x16(u16 index) {
GXWGFifo.u16 = index;
}
static inline void GXColor1x16(u16 index) {
GXWGFifo.u16 = index;
}
static inline void GXTexCoord1x16(u16 index) {
GXWGFifo.u16 = index;
}
static inline void GXEnd(void) {}
#endif

18
include/dolphin/os/OSFastCast.h
View file

@ -76,6 +76,24 @@ static inline u8 __OSf32tou8(register f32 inF)
static inline void OSf32tou8(f32 *f, u8 *out) { *out = __OSf32tou8(*f); }
static inline s8 __OSf32tos8(register f32 inF)
{
u32 tmp;
register u32 *tmpPtr = &tmp;
register s8 out;
// clang-format off
asm {
psq_st inF, 0(tmpPtr), 0x1, OS_FASTCAST_S8
lbz out, 0(tmpPtr)
extsb out, out //HACK to match fast cast inlines
}
// clang-format on
return out;
}
static inline void OSf32tos8(f32 *f, s8 *out) { *out = __OSf32tos8(*f); }
static inline u16 __OSf32tou16(register f32 inF)
{
u32 tmp;

13
include/game/ClusterExec.h Normal file
View file

@ -0,0 +1,13 @@
#ifndef _GAME_CLUSTER_EXEC_H
#define _GAME_CLUSTER_EXEC_H
#include "game/hsfformat.h"
#include "game/hsfman.h"
float GetClusterCurve(HsfTrack *arg0, float arg1);
float GetClusterWeightCurve(HsfTrack *arg0, float arg1);
void SetClusterMain(HsfCluster *arg0);
void ClusterProc(ModelData *arg0);
void ClusterMotionExec(ModelData *arg0);
#endif

12
include/game/EnvelopeExec.h Normal file
View file

@ -0,0 +1,12 @@
#ifndef _GAME_ENVELOPE_EXEC_H
#define _GAME_ENVELOPE_EXEC_H
#include "game/hsfformat.h"
void InitEnvelope(HsfData *arg0);
void EnvelopeProc(HsfData *arg0);
void InitVtxParm(HsfData *arg0);
extern Vec *Vertextop;
#endif

8
include/game/ShapeExec.h Executable file
View file

@ -0,0 +1,8 @@
#ifndef _GAME_SHAPE_EXEC_H
#define _GAME_SHAPE_EXEC_H
#include "game/hsfformat.h"
void ShapeProc(HsfData *arg0);
#endif

10
include/game/THPDraw.h Executable file
View file

@ -0,0 +1,10 @@
#ifndef _GAME_THPDRAW_H
#define _GAME_THPDRAW_H
#include "dolphin.h"
void THPGXRestore(void);
void THPGXYuv2RgbSetup(GXRenderModeObj *obj, GXColor *arg1, Mtx arg2);
void THPGXYuv2RgbDraw(u32 *yImage, u32 *uImage, u32 *vImage, s16 x, s16 y, s16 texWidth, s16 texHeight, s16 polyWidth, s16 polyHeight);
#endif

84
include/game/THPSimple.h Executable file
View file

@ -0,0 +1,84 @@
#ifndef _GAME_THPSIMPLE_H
#define _GAME_THPSIMPLE_H
#include "dolphin.h"
#include "dolphin/thp/THPFile.h"
#include "dolphin/thp/THPInfo.h"
// THPReadBuffer?
typedef struct {
/* 0x00 */ s32 *unk00;
/* 0x04 */ s32 unk04;
/* 0x08 */ s32 unk08;
} UnkThpStruct01; // Size 0xC
typedef struct {
/* 0x00 */ void *unk00;
/* 0x04 */ void *unk04;
/* 0x08 */ void *unk08;
/* 0x0C */ s32 unk0C;
} UnkThpStruct02; // Size 0x10
typedef struct {
/* 0x00 */ void *unk00;
/* 0x04 */ void *unk04;
/* 0x08 */ u32 unk08;
} UnkThpStruct03; // Size 0xC
typedef struct {
/* 0x00 */ u32 unk00;
/* 0x04 */ u32 unk04;
} UnkThpStruct04; // Size 8
typedef struct {
/* 0x000 */ DVDFileInfo unk00;
/* 0x03C */ THPHeader unk3C;
/* 0x06C */ THPFrameCompInfo unk6C;
/* 0x080 */ UnkThpStruct04 unk80;
/* 0x088 */ u8 unk88[0xC];
/* 0x094 */ void *unk94;
/* 0x098 */ s32 unk98;
/* 0x09C */ u8 unk9C;
/* 0x09D */ u8 unk9D;
/* 0x09E */ u8 unk9E;
/* 0x09F */ u8 unk9F;
/* 0x0A0 */ s32 unkA0;
/* 0x0A4 */ s32 unkA4;
/* 0x0A8 */ u32 unkA8;
/* 0x0AC */ s32 unkAC;
/* 0x0B0 */ s32 unkB0;
/* 0x0B4 */ s32 unkB4;
/* 0x0B8 */ s32 unkB8;
/* 0x0BC */ float unkBC;
/* 0x0C0 */ float unkC0;
/* 0x0C4 */ float unkC4;
/* 0x0C8 */ s32 unkC8;
/* 0x0CC */ UnkThpStruct01 unkCC[10];
/* 0x144 */ UnkThpStruct02 unk144[2];
/* 0x164 */ UnkThpStruct03 unk164[4];
/* 0x194 */ s32 unk194;
/* 0x198 */ s32 unk198;
/* 0x19C */ u8 unk19C;
/* 0x19D */ char unk19D[1];
/* 0x19E */ s16 unk19E;
} UnkThpStruct10; // Size 0x1A0
s32 THPSimpleInit(s32 arg0);
void THPSimpleQuit(void);
s32 THPSimpleOpen(char *arg0);
s32 THPSimpleClose(void);
s32 THPSimpleCalcNeedMemory(void);
s32 THPSimpleSetBuffer(void *arg0);
s32 THPSimplePreLoad(s32 arg0);
void THPSimpleAudioStart(void);
void THPSimpleAudioStop(void);
s32 THPSimpleLoadStop(void);
s32 THPSimpleDecode(void);
s32 THPSimpleDrawCurrentFrame(GXRenderModeObj *arg0, GXColor *arg1, Mtx arg2, s32 arg3, s32 arg4, s32 arg5, s32 arg6);
s32 THPSimpleGetVideoInfo(UnkThpStruct04 *arg0);
s32 THPSimpleGetTotalFrame(void);
s32 THPSimpleSetVolume(s32 left, s32 right);
extern UnkThpStruct10 SimpleControl;
#endif

4
include/game/audio.h
View file

@ -18,8 +18,8 @@ void HuAudFXStop(s32 arg0);
void HuAudFXAllStop(void);
void HuAudFXFadeOut(s32 arg0, s32 arg1);
void HuAudFXPanning(s32 arg0, s16 arg1);
void HuAudFXListnerSet(s32 arg0, s32 arg1, float arg2, float arg3);
void HuAudFXListnerSetEX(s32 arg0, s32 arg1, float sndDist, float sndSpeed, float arg4, float arg5, float arg6);
void HuAudFXListnerSet(Vec* arg0, Vec* arg1, float arg2, float arg3);
void HuAudFXListnerSetEX(Vec* arg0, Vec* arg1, float sndDist, float sndSpeed, float arg4, float arg5, float arg6);
void HuAudFXListnerUpdate(s32 arg0, s32 arg1);
s32 HuAudFXEmiterPlay(s32 arg0, Vec *arg1);
void HuAudFXEmiterUpDate(s32 arg0, Vec *arg1);

4
include/game/board/basic_space.h
View file

@ -3,8 +3,8 @@
#include "dolphin.h"
void BoardEventLandBlue(s32, s16);
void BoardEventLandRed(s32, s16);
void BoardEventLandBlue(s32, s32);
void BoardEventLandRed(s32, s32);
s8 BoardCoinChgCreate(Vec*, s8);
s32 BoardCoinChgExist(s32);
void BoardCoinChgHide(s32);

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

@ -58,8 +58,7 @@ static inline s32 BoardCurrGet()
static inline s32 BoardPartyFlagGet()
{
s32 value = GWSystem.party;
return value;
return GWSystem.party;
}
extern BoardCameraData boardCamera;
@ -73,17 +72,27 @@ typedef void (*BoardFunc)(void);
typedef void (*BoardLightHook)(void);
typedef void (*BoardCameraPosCalcFunc)(BoardCameraData *camera);
typedef void (*BoardTurnStartHook)(s32 player, s32 space);
extern BoardTurnStartHook boardTurnStartFunc;
extern BoardFunc boardTurnFunc;
extern BoardLightHook boardLightResetHook;
extern BoardLightHook boardLightSetHook;
void BoardCommonInit(BoardFunc create, BoardFunc destroy);
void BoardKill(void);
s32 BoardIsKill(void);
void BoardPauseEnableSet(s32 value);
s32 BoardPauseEnableGet();
void BoardPauseDisableSet(s32 value);
s32 BoardPauseDisableGet();
void BoardSaveInit(s32 board);
void BoardStoryConfigSet(s32 mg_type, s32 diff_story);
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);
BOOL BoardTurnNext(void);
s32 BoardTurnNext(void);
void BoardNextOvlSet(OverlayID overlay);
s32 BoardStartCheck(void);
void BoardLightHookSet(BoardLightHook set, BoardLightHook reset);
void BoardLightSetExec(void);
void BoardLightResetExec(void);
void BoardCameraBackup(void);
void BoardCameraRestore(void);
void BoardCameraScissorSet(s32 x, s32 y, s32 w, s32 h);
@ -117,6 +126,14 @@ s32 BoardCameraCullCheck(Vec *point, float radius);
s32 BoardCameraMotionIsDone(void);
void BoardCameraMotionWait(void);
void BoardCameraInit(void);
void BoardMGDoneFlagSet(s32 flag);
s32 BoardMGDoneFlagGet();
void BoardMGExit(void);
void BoardMGCreate(s32 arg0);
void BoardEventFlagSet(void);
void BoardEventFlagReset(void);
s32 BoardEventFlagGet(void);
void BoardMTXCalcLookAt(Mtx dest, Vec *eye, Vec *up, Vec *target);
float BoardArcSin(float value);
float BoardArcCos(float value);
void BoardRandInit(void);
@ -125,7 +142,21 @@ u32 BoardRandMod(u32 value);
float BoardRandFloat(void);
float BoardVecDistXZCalc(Vec *vec1, Vec *vec2);
s32 BoardVecMaxDistXZCheck(Vec *vec1, Vec *vec2, float max_dist);
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);
s32 BoardFilterFadePauseCheck(void);
s32 BoardFilterFadeCheck(void);
void BoardConfettiCreate(Vec *pos, s16 count, float range);
void BoardConfettiKill(void);
void BoardConfettiStop(void);
void BoardLast5GfxInit(void);
void BoardLast5GfxShowSet(s32 show);
void BoardTauntInit(void);
void BoardTauntKill(void);
s32 BoardDataDirReadAsync(s32 data_num);
void BoardDataAsyncWait(s32 status);

58
include/game/board/model.h Normal file
View file

@ -0,0 +1,58 @@
#ifndef _BOARD_WARP_H
#define _BOARD_WARP_H
#include "game/hsfman.h"
#include "game/data.h"
typedef struct board_model_param {
s32 data_num;
struct {
u8 field04_bit0 : 2;
u8 visible : 1;
u8 link : 1;
u8 start_mot : 1;
u8 pause : 1;
};
s16 unk6;
} BoardModelParam;
void BoardModelInit(void);
void BoardModelKillAll(void);
void BoardModelDummyUpdate(void);
void BoardModelVisibilityUpdate(void);
void BoardModelHideSetAll(s32 flag);
void BoardModelAmbSetAll(float r, float g, float b);
void BoardModelCameraSetAll(u16 camera);
s16 BoardModelCreate(s32 data_num, s32 *mot_list, s32 link);
s16 BoardModelCreateCharacter(s32 character, s32 data_num, s32 *mot_list, s32 link);
s16 BoardModelCreateParam(BoardModelParam *param, Vec *pos, Vec *rot);
void BoardModelKill(s16 model);
s16 BoardModelIDGet(s16 model);
s32 fn_8006DC1C(s16 model, s32 arg1);
s32 BoardModelPassSet(s16 model, s32 pass);
s32 BoardModelAmbSet(s16 model, float r, float g, float b);
s32 BoardModelExistCheck(s16 model, s32 arg1);
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);
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

9
include/game/board/player.h
View file

@ -113,10 +113,15 @@ void BoardDiceDigit2DUpdateEnable(s32);
void BoardPlayerMoveTo(s32, s16);
void BoardPlayerZoomRestore(s32);
void BoardRotateDiceNumbers(s32);
s32 DoDebugMove(s32, s16*);
s32 DoSparkSpace(s32, s16*);
s32 ExecJunction(s32, s16*);
s32 MegaPlayerPassFunc(s32, s16);
s32 BoardPlayerAnimBlendCheck(s32);
void BoardPlayerCoinsSet(s32 player, s32 value);
s32 BoardPlayerSizeGet(s32 player);
void BoardPlayerAutoSizeSet(s32 player, s32 value);
void BoardPlayerMotionStart(s32, s32, s32);
void BoardPlayerMotionShiftSet(s32 player, s32 arg1, float start, float end, u32 attr);
void BoardPlayerRotYSet(s32 player, float rot_y);
void BoardPlayerZoomRestore(s32 player);
#endif

10
include/game/board/space.h
View file

@ -5,7 +5,10 @@
#define BOARD_SPACE_LINKMAX 4
#ifndef _BOARD_SPACE_EVENT_FUNC
#define _BOARD_SPACE_EVENT_FUNC
typedef s32 (*BoardSpaceEventFunc)(void);
#endif
typedef struct board_space {
Vec pos;
@ -22,8 +25,7 @@ void BoardSpaceWalkMiniEventFuncSet(BoardSpaceEventFunc func);
void BoardSpaceLandEventFuncSet(BoardSpaceEventFunc func);
s32 BoardSpaceWalkEventExec(void);
s32 BoardSpaceWalkMiniEventExec(void);
s16 BoardSpaceCountGet(s32 layer);
s16 BoardSpaceCountGet(s32 layer);
s32 BoardSpaceCountGet(s32 layer);
BoardSpace *BoardSpaceGet(s32 layer, s32 index);
void BoardSpaceAttrSet(s32 layer, u32 attr);
void BoardSpaceAttrReset(s32 layer, u32 attr);
@ -32,6 +34,7 @@ s32 BoardSpaceTypeGet(s32 layer, s32 index);
void BoardSpaceTypeSet(s32 layer, s32 index, s32 type);
s32 BoardSpacePosGet(s32 layer, s32 index, Vec *pos);
void BoardSpaceCornerPosGet(s32 index, s32 corner, Vec *pos);
s32 BoardSpaceRotGet(s32 layer, s32 index, Vec *rot);
s32 BoardSpaceFlagSearch(s32 layer, u32 flag);
s32 BoardSpaceFlagPosGet(s32 layer, u32 flag, Vec *pos);
s32 BoardSpaceLinkFlagSearch(s32 layer, s32 index, u32 flag);
@ -39,7 +42,7 @@ s32 BoardSpaceLinkTypeListGet(s32 layer, s32 index, s32 type, s16 *list);
s32 BoardSpaceLinkTargetListGet(s32 layer, s32 target, s16 *list);
s32 BoardSpaceLinkTypeSearch(s32 layer, s32 target, u16 type);
s32 BoardSpaceLinkTransformGet(s32 flag, Vec *pos, Vec *rot, Vec *scale);
void BoardSpaceStarSet(s32 space);
void BoardSpaceHostSet(s32 space);
void BoardSpaceStarSetIndex(s32 index);
s32 BoardSpaceStarGetNext(void);
s32 BoardSpaceStarGetRandom(s32 excl_pos);
@ -48,5 +51,6 @@ s32 BoardSpaceStarGet(s32 index);
s32 BoardSpaceStarGetCurr(void);
s32 BoardSpaceStarCheck(s32 index);
void BoardSpaceLandExec(s32 player, s32 space);
void BoardSpaceBlockPosSet(void);
#endif

2
include/game/board/warp.h
View file

@ -4,6 +4,6 @@
#include "game/process.h"
#include "game/wipe.h"
void BoardWarpExec(s32 player, s16 space);
void BoardWarpExec(s32 player, s32 space);
#endif

4
include/game/board/window.h
View file

@ -17,8 +17,8 @@ void BoardWinCreate(s32 pos, u32 mess, s32 portrait);
void BoardWinInsertMesSet(u32 value, s32 index);
void BoardWinWait(void);
void BoardWinKill(void);
void BoardWinSetAttr(s32 attr);
void BoardWinResetAttr(s32 attr);
void BoardWinAttrSet(s32 attr);
void BoardWinAttrReset(s32 attr);
void BoardWinChoiceDisable(s32 choice);
void BoardWinKeyWait(void);
int BoardWinSpeedGet(void);

24
include/game/esprite.h Executable file
View file

@ -0,0 +1,24 @@
#ifndef _GAME_ESPRITE_H
#define _GAME_ESPRITE_H
#include "dolphin.h"
void espInit(void);
s16 espEntry(s32 arg0, s16 arg1, s16 arg2);
void espKill(s16 arg0);
s16 espGrpIDGet(void);
void espDispOn(s16 arg0);
void espDispOff(s16 arg0);
void espAttrSet(s16 arg0, u16 arg1);
void espAttrReset(s16 arg0, u16 arg1);
void espPosSet(s16 arg0, float arg1, float arg2);
void espScaleSet(s16 arg0, float arg1, float arg2);
void espZRotSet(s16 arg0, float arg1);
void espTPLvlSet(s16 arg0, float arg1);
void espColorSet(s16 arg0, u8 arg1, u8 arg2, u8 arg3);
void espSpeedSet(s16 arg0, float arg1);
void espBankSet(s16 arg0, s16 arg1);
void espDrawNoSet(s16 arg0, s16 arg1);
void espPriSet(s16 arg0, s16 arg1);
#endif

19
include/game/gamework_data.h
View file

@ -46,7 +46,7 @@ typedef struct system_state {
/* 0x32 */ s8 unk_32;
/* 0x34 */ u16 mg_next;
/* 0x36 */ s16 mg_next_extra;
/* 0x38 */ s16 unk_38;
/* 0x38 */ u16 unk_38;
/* 0x3A */ u8 flag[3][16];
/* 0x6A */ u8 unk_6A[0x72];
} SystemState; //8018fcf8, sizeof 0xDC
@ -105,7 +105,7 @@ typedef struct player_state {
typedef struct game_stat {
/* 0x0 */ s16 unk_00;
/* 0x2 */ s8 language;
/* 0x2 */ u8 language;
/* 0x3 */ u8 sound_mode;
/* 0x4 */ s8 rumble;
/* 0x6 */ u16 total_stars;
@ -147,4 +147,19 @@ extern PlayerState GWPlayer[4];
extern SystemState GWSystem;
extern GameStat GWGameStat;
static inline s32 GWLanguageGet(void)
{
return GWGameStat.language;
}
static inline s32 GWMGTypeGet()
{
return GWSystem.mg_type;
}
static inline s32 GWMessSpeedGet()
{
return GWSystem.mess_speed;
}
#endif

33
include/game/hsfdraw.h
View file

@ -4,6 +4,30 @@
#include "game/hsfman.h"
#include "dolphin.h"
typedef struct model_data ModelData;
typedef struct {
/* 0x00 */ u16 unk00;
/* 0x02 */ s16 unk02;
/* 0x04 */ s16 unk04;
/* 0x06 */ char unk06[2];
/* 0x08 */ float unk08;
/* 0x0C */ float unk0C;
/* 0x10 */ float unk10;
/* 0x14 */ float unk14;
/* 0x18 */ float unk18;
/* 0x1C */ float unk1C;
/* 0x20 */ float unk20;
/* 0x24 */ float unk24;
/* 0x28 */ float unk28;
/* 0x2C */ float unk2C;
/* 0x30 */ float unk30;
/* 0x34 */ float unk34;
/* 0x38 */ float unk38;
/* 0x3C */ HsfBitmap *unk3C;
/* 0x40 */ char unk40[4];
} HsfdrawStruct01; // Size 0x44
void Hu3DDrawPreInit(void);
void Hu3DDraw(ModelData *arg0, Mtx arg1, Vec *arg2);
s32 ObjCullCheck(HsfData *arg0, HsfObject *arg1, Mtx arg2);
@ -25,4 +49,13 @@ HsfObject *Hu3DObjDuplicate(HsfData *arg0, u32 arg1);
void Hu3DModelObjDrawInit(void);
void Hu3DModelObjDraw(s16 arg0, char *arg1, Mtx arg2);
extern u32 totalPolyCnt;
extern u32 totalPolyCnted;
extern u32 totalMatCnt;
extern u32 totalMatCnted;
extern u32 totalTexCnt;
extern u32 totalTexCnted;
extern u32 totalTexCacheCnt;
extern u32 totalTexCacheCnted;
#endif

15
include/game/hsfex.h Normal file
View file

@ -0,0 +1,15 @@
#ifndef _GAME_HSFEX_H
#define _GAME_HSFEX_H
#include "dolphin.h"
void CamMotionEx2(s16 arg0, s16 arg1, float arg2, s16 arg3);
void CamMotionEx(s16 arg0, s16 arg1, Vec *arg2, Vec *arg3, Vec *arg4, float arg5, s16 arg6);
float InterpolateBMLine(float *arg0, float *arg1, float arg2);
void Hu3D2Dto3D(Vec *arg0, s16 arg1, Vec *arg2);
void Hu3D3Dto2D(Vec *arg0, s16 arg1, Vec *arg2);
void Hu3DMtxTransGet(Mtx arg0, Vec *arg1);
void Hu3DMtxRotGet(Mtx arg0, Vec *arg1);
void Hu3DMtxScaleGet(Mtx arg0, Vec *arg1);
#endif

30
include/game/hsfformat.h
View file

@ -238,10 +238,12 @@ typedef struct hsf_cluster {
char *name[2];
union {
char *targetName;
u32 target;
s32 target;
};
HsfPart *part;
u8 unk10[132];
float unk10;
float unk14[1]; // unknown array size
u8 unk18[124];
u8 adjusted;
u8 unk95;
u16 type;
@ -269,7 +271,7 @@ typedef struct hsf_object_data {
HsfVector3f min;
HsfVector3f max;
float baseMorph;
float *morphWeight[33];
float morphWeight[33];
} mesh;
struct hsf_object *replica;
};
@ -339,9 +341,23 @@ typedef struct hsf_bitmap_keyframe {
typedef struct hsf_track {
u8 type;
u8 start;
u16 target;
u16 param;
u16 channel;
union {
u16 target;
s16 target_s16;
};
union {
s32 unk04;
struct {
union {
s16 param;
u16 param_u16;
};
union {
u16 channel;
s16 channel_s16;
};
};
};
u16 curveType;
u16 numKeyframes;
union {
@ -352,7 +368,7 @@ typedef struct hsf_track {
typedef struct hsf_motion {
char *name;
u32 numTracks;
s32 numTracks;
HsfTrack *track;
float len;
} HsfMotion;

96
include/game/hsfman.h
View file

@ -1,20 +1,17 @@
#ifndef _GAME_HSFMAN_H
#define _GAME_HSFMAN_H
#include "math.h"
#include "game/memory.h"
#include "game/hsfanim.h"
#include "game/hsfformat.h"
#include "game/sprite.h"
#include "game/init.h"
#include "game/data.h"
#include "game/memory.h"
#include "dolphin/gx/GXVert.h"
#include "game/data.h"
#define Hu3DModelCreateFile(data_id) (Hu3DModelCreate(HuDataSelHeapReadNum((data_id), MEMORY_DEFAULT_NUM, HEAP_DATA)))
typedef struct particle_data ParticleData;
typedef void (*ModelHookFunc)(struct model_data *, Mtx);
typedef struct model_data {
u8 unk_00;
u8 unk_01;
@ -41,12 +38,27 @@ 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;
char unk_78[0x1C];
f32 unk_78;
f32 unk_7C;
f32 unk_80;
f32 unk_84;
f32 unk_88;
f32 unk_8C;
f32 unk_90;
f32 unk_94;
char unk_98[0x2C];
HsfData *hsfData;
f32 unk_98;
f32 unk_9C;
f32 unk_A0;
f32 unk_A4[4];
f32 unk_B4[4];
union {
HsfData *hsfData;
ModelHookFunc hook;
};
HsfData *unk_C8;
Vec pos;
Vec rot;
@ -97,11 +109,6 @@ typedef struct shadow_data {
Mtx unk_38;
Mtx unk_68;
} ShadowData; // sizeof 0x98
typedef struct motion_data {
s16 unk_00;
s16 unk_02;
HsfData *unk_04;
} MotionData;
typedef struct light_data {
s16 unk_00;
s16 unk_02;
@ -114,49 +121,7 @@ typedef struct light_data {
GXColor color;
} LightData;
extern void ClusterMotionExec(ModelData*); /* extern */
extern void ClusterProc(ModelData*); /* extern */
extern void EnvelopeProc(HsfData*); /* extern */
extern void GXWaitDrawDone(); /* extern */
extern void Hu3DAnimExec(); /* extern */
extern void Hu3DCameraMotionExec(s16); /* extern */
extern void Hu3DDraw(ModelData*, Mtx, Vec*); /* extern */
extern void Hu3DDrawPost(); /* extern */
extern void Hu3DDrawPreInit(); /* extern */
extern void Hu3DMotionNext(s16); /* extern */
extern void Hu3DShadowExec(); /* extern */
extern void Hu3DSubMotionExec(s16); /* extern */
extern void HuPerfBegin(s32); /* extern */
extern void HuPerfEnd(s32); /* extern */
extern void HuSprBegin(void); /* extern */
extern void HuSprDispInit(void); /* extern */
extern void HuSprExec(s16); /* extern */
extern void HuSprFinish(void); /* extern */
extern void InitVtxParm(HsfData*); /* extern */
extern void ShapeProc(HsfData*); /* extern */
extern void mtxRot(Mtx, f32, f32, f32); /* extern */
extern void mtxScaleCat(Mtx, f32, f32, f32); /* extern */
extern void mtxTransCat(Mtx, f32, f32, f32);
extern void Hu3DAnimInit(void);
extern void Hu3DMotionInit(void);
extern void Hu3DParManInit(void);
extern void Hu3DMotionClusterSet(s16, s16); /* extern */
extern void Hu3DMotionExec(s16, s16, f32, s32);
extern f32 Hu3DMotionMaxTimeGet(s16); /* extern */
extern s16 Hu3DMotionModelCreate(s16); /* extern */
extern void Hu3DMotionShapeSet(s16, s16); /* extern */
extern void MakeDisplayList(s16, HsfData*); /* extern */
extern void ClusterAdjustObject(HsfData*, HsfData*); /* extern */
extern HsfObject* Hu3DObjDuplicate(HsfData*, u32); /* extern */
extern void Hu3DAnimModelKill(s16); /* extern */
extern void Hu3DGLightKill(s16); /* extern */
extern void Hu3DLLightKill(s16, s16); /* extern */
extern s32 Hu3DMotionKill(s16);
extern void Hu3DModelKill(s16);
extern void Hu3DParManAllKill(void);
extern f32 Hu3DMotionMotionMaxTimeGet(s16);
extern void Hu3DMotionStartEndSet(s16, f32, f32);
extern void Hu3DMotionTimeSet(s16, f32);
extern void GXInitSpecularDir(GXLightObj*, f32, f32, f32);
void Hu3DInit(void);
@ -169,14 +134,14 @@ void Hu3DPauseSet(s32);
void Hu3DNoSyncSet(s32);
s16 Hu3DModelCreate(void *);
s16 Hu3DModelLink(s16);
s16 Hu3DHookFuncCreate(HsfData*);
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);
@ -278,13 +243,4 @@ extern s16 Hu3DCameraNo;
extern s16 Hu3DCameraBit;
extern s16 Hu3DPauseF;
extern MotionData Hu3DMotion[0x100];
extern u32 totalMatCnt;
extern u32 totalMatCnted;
extern u32 totalPolyCnt;
extern u32 totalPolyCnted;
extern u32 totalTexCacheCnt;
extern u32 totalTexCacheCnted;
extern u32 totalTexCnt;
extern u32 totalTexCnted;
#endif

76
include/game/hsfmotion.h Normal file
View file

@ -0,0 +1,76 @@
#ifndef _GAME_HSFMOTION_H
#define _GAME_HSFMOTION_H
#include "dolphin.h"
#include "game/hsfformat.h"
typedef struct motion_data {
s16 unk_00;
s16 unk_02;
HsfData *unk_04;
} MotionData;
typedef struct {
/* 0x00 */ float unk00;
/* 0x04 */ HsfBitmap *unk04;
} UnknownHsfMotionStruct01; // Size 8
void Hu3DMotionInit(void);
s16 Hu3DMotionCreate(void *arg0);
s16 Hu3DMotionModelCreate(s16 arg0);
s32 Hu3DMotionKill(s16 arg0);
void Hu3DMotionAllKill(void);
void Hu3DMotionSet(s16 arg0, s16 arg1);
void Hu3DMotionOverlaySet(s16 arg0, s16 arg1);
void Hu3DMotionOverlayReset(s16 arg0);
float Hu3DMotionOverlayTimeGet(s16 arg0);
void Hu3DMotionOverlayTimeSet(s16 arg0, float arg1);
void Hu3DMotionOverlaySpeedSet(s16 arg0, float arg1);
void Hu3DMotionShiftSet(s16 arg0, s16 arg1, float arg2, float arg3, u32 arg4);
void Hu3DMotionShapeSet(s16 arg0, s16 arg1);
s16 Hu3DMotionShapeIDGet(s16 arg0);
void Hu3DMotionShapeSpeedSet(s16 arg0, float arg1);
void Hu3DMotionShapeTimeSet(s16 arg0, float arg1);
float Hu3DMotionShapeMaxTimeGet(s16 arg0);
void Hu3DMotionShapeStartEndSet(s16 arg0, float arg1, float arg2);
s16 Hu3DMotionClusterSet(s16 arg0, s16 arg1);
s16 Hu3DMotionClusterNoSet(s16 arg0, s16 arg1, s16 arg2);
void Hu3DMotionShapeReset(s16 arg0);
void Hu3DMotionClusterReset(s16 arg0, s16 arg1);
s16 Hu3DMotionIDGet(s16 arg0);
s16 Hu3DMotionShiftIDGet(s16 arg0);
void Hu3DMotionTimeSet(s16 arg0, float arg1);
float Hu3DMotionTimeGet(s16 arg0);
float Hu3DMotionShiftTimeGet(s16 arg0);
float Hu3DMotionMaxTimeGet(s16 arg0);
float Hu3DMotionShiftMaxTimeGet(s16 arg0);
void Hu3DMotionShiftStartEndSet(s16 arg0, float arg1, float arg2);
float Hu3DMotionMotionMaxTimeGet(s16 arg0);
void Hu3DMotionStartEndSet(s16 arg0, float arg1, float arg2);
s32 Hu3DMotionEndCheck(s16 arg0);
void Hu3DMotionSpeedSet(s16 arg0, float arg1);
void Hu3DMotionShiftSpeedSet(s16 arg0, float arg1);
void Hu3DMotionNoMotSet(s16 arg0, char *arg1, u32 arg2);
void Hu3DMotionNoMotReset(s16 arg0, char *arg1, u32 arg2);
void Hu3DMotionForceSet(s16 arg0, char *arg1, u32 arg2, float arg3);
void Hu3DMotionNext(s16 arg0);
void Hu3DMotionExec(s16 arg0, s16 arg1, float arg2, s32 arg3);
void Hu3DCameraMotionExec(s16 arg0);
void Hu3DSubMotionExec(s16 arg0);
float *GetObjTRXPtr(HsfObject *arg0, u16 arg1);
void SetObjMatMotion(s16 arg0, HsfTrack *arg1, float arg2);
void SetObjAttrMotion(s16 arg0, HsfTrack *arg1, float arg2);
void SetObjCameraMotion(s16 arg0, HsfTrack *arg1, float arg2);
void SetObjLightMotion(s16 arg0, HsfTrack *arg1, float arg2);
float GetCurve(HsfTrack *arg0, float arg1);
float GetConstant(s32 arg0, float *arg1, float arg2);
float GetLinear(s32 arg0, float arg1[][2], float arg2);
float GetBezier(s32 arg0, HsfTrack *arg1, float arg2);
HsfBitmap *GetBitMap(s32 arg0, UnknownHsfMotionStruct01 *arg1, float arg2);
s16 Hu3DJointMotion(s16 arg0, void *arg1);
void JointModel_Motion(s16 arg0, s16 arg1);
void Hu3DMotionCalc(s16 arg0);
extern MotionData Hu3DMotion[256];
#endif

19
include/game/jmp.h Executable file
View file

@ -0,0 +1,19 @@
#ifndef _GAME_JMP_H
#define _GAME_JMP_H
#include "dolphin.h"
typedef struct jump_buf {
u32 lr;
u32 cr;
u32 sp;
u32 r2;
u32 pad;
u32 regs[19];
double flt_regs[19];
} jmp_buf;
int gcsetjmp(jmp_buf *jump);
int gclongjmp(jmp_buf *jump, int status);
#endif

2
include/game/msm.h
View file

@ -54,7 +54,7 @@ void msmMusStop(s32 arg0, s32 arg1);
s32 msmMusPlay(s32 arg0, s32 arg1);
void msmSeDelListener(void);
void msmSeUpdataListener(s32 arg0, s32 arg1);
void msmSeSetListener(s32 arg0, s32 arg1, float arg2, float arg3, UnkMsmStruct_02 *arg4);
void msmSeSetListener(Vec* arg0, Vec* arg1, float arg2, float arg3, UnkMsmStruct_02 *arg4);
s32 msmSeGetEntryID(s32 arg0, void *arg1);
s32 msmSeGetNumPlay(s32 arg0);
s32 msmSeGetStatus(s32 arg0);

3
include/game/object.h
View file

@ -22,6 +22,9 @@ typedef enum {
#define OM_STAT_NOPAUSE 0x20
#define OM_STAT_MODEL_PAUSED 0x100
#define OM_GET_WORK_PTR(object, type) ((type *)(&((object)->work[0])))
typedef void (*omObjFunc)(struct om_obj_data *);
typedef struct om_ovl_his_data {

11
include/game/process.h
View file

@ -1,6 +1,7 @@
#ifndef _GAME_PROCESS_H
#define _GAME_PROCESS_H
#include "game/jmp.h"
#include "dolphin/types.h"
#define PROCESS_STAT_PAUSE 0x1
@ -8,16 +9,6 @@
#define PROCESS_STAT_PAUSE_EN 0x4
#define PROCESS_STAT_UPAUSE_EN 0x8
typedef struct jump_buf {
u32 lr;
u32 cr;
u32 sp;
u32 r2;
u32 pad;
u32 regs[19];
double flt_regs[19];
} jmp_buf;
typedef struct process {
struct process *next;
struct process *prev;

8
include/game/thpmain.h
View file

@ -10,9 +10,9 @@ s16 HuTHP3DCreate(char *path, s16 loop);
void HuTHPStop(void);
void HuTHPClose(void);
void HuTHPRestart(void);
int HuTHPEndCheck(void);
int HuTHPFrameGet(void);
int HuTHPTotalFrameGet(void);
void HuTHPSetVolume(int left, int right);
BOOL HuTHPEndCheck(void);
s32 HuTHPFrameGet(void);
s32 HuTHPTotalFrameGet(void);
void HuTHPSetVolume(s32 left, s32 right);
#endif

1
include/math.h
View file

@ -73,6 +73,7 @@ _MATH_INLINE float sinf(float x) { return (float)sin((double)x); }
_MATH_INLINE float cosf(float x) { return (float)cos((double)x); }
_MATH_INLINE float atan2f(float y, float x) { return (float)atan2((double)y, (double)x); }
_MATH_INLINE float atanf(float x) { return (float)atan((double)x); }
_MATH_INLINE float asinf(float x) { return (float)asin((double)x); }
_MATH_INLINE float fmodf(float x, float m) { return (float)fmod((double)x, (double)m); }

35
include/unsplit.h
View file

@ -3,28 +3,23 @@
#include "dolphin.h"
void Hu3D2Dto3D(Vec*, s32, Vec*);
void HuAudFadeOut(s32 arg0);
void Hu3DModelPosSet(s16 index, float x, float y, float z);
void Hu3DModelRotSet(s16 index, float x, float y, float z);
void Hu3DModelScaleSet(s16 index, float x, float y, float z);
void espInit(void);
void espScaleSet(s16, f32, f32);
s16 espEntry(s32, s32, s32);
void espDispOff(s16);
void espKill(s16);
void espDispOn(s16);
void espPosSet(s16, f32, f32);
void HuAudFXListnerKill(void);
void HuAudDllSndGrpSet(u16 ovl);
void HuAudVoiceInit(s16 ovl);
void MGSeqKillAll(void);
void MGSeqPracticeStart(void);
void fn_8004D6F4(s16 arg);
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 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