Merge branch 'main' into main

config/GMPE01_00/symbols.txt

@@ -1015,7 +1015,7 @@ MainFunc = .text:0x8005BF9C; // type:function size:0x7D0 scope:local
 BoardTurnNext = .text:0x8005C76C; // type:function size:0x8C
 ExecTurnStart = .text:0x8005C7F8; // type:function size:0x28C scope:local
 BoardNextOvlSet = .text:0x8005CA84; // type:function size:0xC4
-BoardIsStarted = .text:0x8005CB48; // type:function size:0x8C
+BoardStartCheck = .text:0x8005CB48; // type:function size:0x8C
 CreateBoard = .text:0x8005CBD4; // type:function size:0x410 scope:local
 DestroyBoard = .text:0x8005CFE4; // type:function size:0x128 scope:local
 BoardLightHookSet = .text:0x8005D10C; // type:function size:0xC
@@ -1195,7 +1195,7 @@ BoardPlayerAutoSizeSet = .text:0x80068E6C; // type:function size:0x9C
 BoardPlayerAutoSizeGet = .text:0x80068F08; // type:function size:0x40
 BoardPlayerMoveAwayIsDone = .text:0x80068F48; // type:function size:0x1C
 BoardPlayerMoveAwayStart = .text:0x80068F64; // type:function size:0x224
-BoardPlayerCurrMoveAwayStart = .text:0x80069188; // type:function size:0x40
+BoardPlayerMoveAwayStartCurr = .text:0x80069188; // type:function size:0x40
 MoveAwayObjFunc = .text:0x800691C8; // type:function size:0x100 scope:local
 BoardBowserSuitInit = .text:0x800692C8; // type:function size:0x1A4
 BoardBowserSuitKill = .text:0x8006946C; // type:function size:0x128
@@ -1385,27 +1385,27 @@ BoardSpaceFlagGet = .text:0x80074138; // type:function size:0x48
 BoardSpaceTypeGet = .text:0x80074180; // type:function size:0x48
 BoardSpaceTypeSet = .text:0x800741C8; // type:function size:0x48
 BoardSpacePosGet = .text:0x80074210; // type:function size:0x8C
-BoardSpaceDirPosGet = .text:0x8007429C; // type:function size:0x2C8
+BoardSpaceCornerPosGet = .text:0x8007429C; // type:function size:0x2C8
 BoardSpaceRotGet = .text:0x80074564; // type:function size:0x8C
 BoardSpaceFlagSearch = .text:0x800745F0; // type:function size:0xA0
 BoardSpaceFlagPosGet = .text:0x80074690; // type:function size:0x134
 BoardSpaceLinkFlagSearch = .text:0x800747C4; // type:function size:0x134
-BoardSpaceLinkGet = .text:0x800748F8; // type:function size:0x148
+BoardSpaceLinkTypeListGet = .text:0x800748F8; // type:function size:0x148
-BoardSpaceLinkTargetGet = .text:0x80074A40; // type:function size:0x104
+BoardSpaceLinkTargetListGet = .text:0x80074A40; // type:function size:0x104
-BoardSpaceLinkSearch = .text:0x80074B44; // type:function size:0x110
+BoardSpaceLinkTypeSearch = .text:0x80074B44; // type:function size:0x110
-BoardSpaceTransformGet = .text:0x80074C54; // type:function size:0x1FC
+BoardSpaceLinkTransformGet = .text:0x80074C54; // type:function size:0x1FC
 BoardSpaceStarSet = .text:0x80074E50; // type:function size:0x1BC
 BoardSpaceStarSetIndex = .text:0x8007500C; // type:function size:0x4AC
-BoardSpaceStarNextGet = .text:0x800754B8; // type:function size:0x344
+BoardSpaceStarGetNext = .text:0x800754B8; // type:function size:0x344
-BoardSpaceStarRandomGet = .text:0x800757FC; // type:function size:0x9C
+BoardSpaceStarGetRandom = .text:0x800757FC; // type:function size:0x9C
 BoardSpaceStarMove = .text:0x80075898; // type:function size:0xF0
 BoardSpaceStarGet = .text:0x80075988; // type:function size:0x1C
-BoardSpaceStarCurrGet = .text:0x800759A4; // type:function size:0x3C
+BoardSpaceStarGetCurr = .text:0x800759A4; // type:function size:0x3C
 BoardSpaceStarCheck = .text:0x800759E0; // type:function size:0x110
 BoardSpaceLandExec = .text:0x80075AF0; // type:function size:0x474
 BoardSpaceWalkExec = .text:0x80075F64; // type:function size:0x2A4
-BoardSpaceHiddenBlockExec = .text:0x80076208; // type:function size:0x180
+BoardSpaceBlockExec = .text:0x80076208; // type:function size:0x180
-BoardSpacePipeJumpExec = .text:0x80076388; // type:function size:0x268
+BoardSpacePipeExec = .text:0x80076388; // type:function size:0x268
 BoardSpaceTypeForce = .text:0x800765F0; // type:function size:0x5C
 BoardSpaceHide = .text:0x8007664C; // type:function size:0x48
 DrawSpaces = .text:0x80076694; // type:function size:0x9E8 scope:local
@@ -1418,7 +1418,7 @@ fn_80077AAC = .text:0x80077AAC; // type:function size:0x8
 fn_80077AB4 = .text:0x80077AB4; // type:function size:0x8
 fn_80077ABC = .text:0x80077ABC; // type:function size:0xD4
 fn_80077B90 = .text:0x80077B90; // type:function size:0xA0
-fn_80077C30 = .text:0x80077C30; // type:function size:0x9C
+BoardShopExec = .text:0x80077C30; // type:function size:0x9C
 fn_80077CCC = .text:0x80077CCC; // type:function size:0x800
 fn_800784CC = .text:0x800784CC; // type:function size:0xD4
 fn_800785A0 = .text:0x800785A0; // type:function size:0x1B4
@@ -1448,7 +1448,7 @@ fn_8007A330 = .text:0x8007A330; // type:function size:0x30
 fn_8007A360 = .text:0x8007A360; // type:function size:0x4DC
 fn_8007A83C = .text:0x8007A83C; // type:function size:0x8
 fn_8007A844 = .text:0x8007A844; // type:function size:0x8
-fn_8007A84C = .text:0x8007A84C; // type:function size:0x8C
+BoardLotteryExec = .text:0x8007A84C; // type:function size:0x8C
 fn_8007A8D8 = .text:0x8007A8D8; // type:function size:0x16C
 fn_8007AA44 = .text:0x8007AA44; // type:function size:0x3B4
 fn_8007ADF8 = .text:0x8007ADF8; // type:function size:0x1FC
@@ -1484,8 +1484,8 @@ fn_8007F6BC = .text:0x8007F6BC; // type:function size:0xA4
 fn_8007F760 = .text:0x8007F760; // type:function size:0xFC
 fn_8007F85C = .text:0x8007F85C; // type:function size:0x38
 fn_8007F894 = .text:0x8007F894; // type:function size:0x2BC
-BoardEventLandBlue = .text:0x8007FB50; // type:function size:0x184
+BoardLandBlueExec = .text:0x8007FB50; // type:function size:0x184
-BoardEventLandRed = .text:0x8007FCD4; // type:function size:0x19C
+BoardLandRedExec = .text:0x8007FCD4; // type:function size:0x19C
 BoardCoinChgCreate = .text:0x8007FE70; // type:function size:0x1E8
 BoardCoinChgExist = .text:0x80080058; // type:function size:0x6C
 BoardCoinChgHide = .text:0x800800C4; // type:function size:0x60
@@ -1495,14 +1495,14 @@ CoinChgAppear = .text:0x800804F8; // type:function size:0x1B8 scope:local
 CoinChgSeparate = .text:0x800806B0; // type:function size:0x29C scope:local
 CoinChgShow = .text:0x8008094C; // type:function size:0x1A8 scope:local
 CoinChgDisappear = .text:0x80080AF4; // type:function size:0x260 scope:local
-fn_80080D54 = .text:0x80080D54; // type:function size:0xA4
+BoardWarpExec = .text:0x80080D54; // type:function size:0xA4
-fn_80080DF8 = .text:0x80080DF8; // type:function size:0x250
+WarpProcess = .text:0x80080DF8; // type:function size:0x250 scope:local
-fn_80081048 = .text:0x80081048; // type:function size:0x5C
+WarpKill = .text:0x80081048; // type:function size:0x5C scope:local
-fn_800810A4 = .text:0x800810A4; // type:function size:0x118
+WarpInit = .text:0x800810A4; // type:function size:0x118 scope:local
-fn_800811BC = .text:0x800811BC; // type:function size:0xBC
+WarpLaunch = .text:0x800811BC; // type:function size:0xBC scope:local
-fn_80081278 = .text:0x80081278; // type:function size:0x1B0
+WarpStartImpact = .text:0x80081278; // type:function size:0x1B0 scope:local
-fn_80081428 = .text:0x80081428; // type:function size:0xA4
+WarpFall = .text:0x80081428; // type:function size:0xA4 scope:local
-fn_800814CC = .text:0x800814CC; // type:function size:0x200
+WarpImpact = .text:0x800814CC; // type:function size:0x200 scope:local
 fn_800816CC = .text:0x800816CC; // type:function size:0x11C
 fn_800817E8 = .text:0x800817E8; // type:function size:0x34
 fn_8008181C = .text:0x8008181C; // type:function size:0x50
@@ -1520,7 +1520,7 @@ fn_80082888 = .text:0x80082888; // type:function size:0x224
 fn_80082AAC = .text:0x80082AAC; // type:function size:0x10
 fn_80082ABC = .text:0x80082ABC; // type:function size:0x148
 fn_80082C04 = .text:0x80082C04; // type:function size:0x8C
-fn_80082C90 = .text:0x80082C90; // type:function size:0xA4
+BoardMushroomExec = .text:0x80082C90; // type:function size:0xA4
 fn_80082D34 = .text:0x80082D34; // type:function size:0x38C
 fn_800830C0 = .text:0x800830C0; // type:function size:0x58
 fn_80083118 = .text:0x80083118; // type:function size:0x118
@@ -1542,8 +1542,8 @@ fn_80083E14 = .text:0x80083E14; // type:function size:0x38
 fn_80083E4C = .text:0x80083E4C; // type:function size:0x48
 fn_80083E94 = .text:0x80083E94; // type:function size:0x48
 fn_80083EDC = .text:0x80083EDC; // type:function size:0xA8
-fn_80083F84 = .text:0x80083F84; // type:function size:0x8
+BoardStarHostMdlGet = .text:0x80083F84; // type:function size:0x8
-fn_80083F8C = .text:0x80083F8C; // type:function size:0xCC
+BoardStarExec = .text:0x80083F8C; // type:function size:0xCC
 fn_80084058 = .text:0x80084058; // type:function size:0x8F4
 fn_8008494C = .text:0x8008494C; // type:function size:0x84
 fn_800849D0 = .text:0x800849D0; // type:function size:0x160
@@ -1653,7 +1653,7 @@ SetItemWindowCurr = .text:0x8008D9E8; // type:function size:0xA4 scope:local
 UpdateItemWindow = .text:0x8008DA8C; // type:function size:0x350 scope:local
 CreatePickerWindow = .text:0x8008DDDC; // type:function size:0x148 scope:local
 KillPickerWindow = .text:0x8008DF24; // type:function size:0x44 scope:local
-fn_8008DF68 = .text:0x8008DF68; // type:function size:0x84
+BoardBlockExec = .text:0x8008DF68; // type:function size:0x84
 fn_8008DFEC = .text:0x8008DFEC; // type:function size:0x358
 fn_8008E344 = .text:0x8008E344; // type:function size:0x54
 fn_8008E398 = .text:0x8008E398; // type:function size:0x1F4
@@ -1709,7 +1709,7 @@ fn_800972A4 = .text:0x800972A4; // type:function size:0x2C
 fn_800972D0 = .text:0x800972D0; // type:function size:0x2C
 fn_800972FC = .text:0x800972FC; // type:function size:0x2C
 fn_80097328 = .text:0x80097328; // type:function size:0x284
-fn_800975AC = .text:0x800975AC; // type:function size:0x144
+BoardBowserExec = .text:0x800975AC; // type:function size:0x144
 fn_800976F0 = .text:0x800976F0; // type:function size:0x28C
 fn_8009797C = .text:0x8009797C; // type:function size:0x208
 fn_80097B84 = .text:0x80097B84; // type:function size:0x1DC
@@ -1764,7 +1764,7 @@ fn_8009B2B0 = .text:0x8009B2B0; // type:function size:0x80
 fn_8009B330 = .text:0x8009B330; // type:function size:0xD8
 fn_8009B408 = .text:0x8009B408; // type:function size:0x6C
 fn_8009B474 = .text:0x8009B474; // type:function size:0x60
-fn_8009B4D4 = .text:0x8009B4D4; // type:function size:0x124
+BoardBattleExec = .text:0x8009B4D4; // type:function size:0x124
 fn_8009B5F8 = .text:0x8009B5F8; // type:function size:0x2C
 fn_8009B624 = .text:0x8009B624; // type:function size:0x708
 fn_8009BD2C = .text:0x8009BD2C; // type:function size:0x1D4
@@ -1786,7 +1786,7 @@ fn_8009CF84 = .text:0x8009CF84; // type:function size:0x24
 fn_8009CFA8 = .text:0x8009CFA8; // type:function size:0x10
 fn_8009CFB8 = .text:0x8009CFB8; // type:function size:0x34
 fn_8009CFEC = .text:0x8009CFEC; // type:function size:0x15C
-fn_8009D148 = .text:0x8009D148; // type:function size:0x124
+BoardFortuneExec = .text:0x8009D148; // type:function size:0x124
 fn_8009D26C = .text:0x8009D26C; // type:function size:0x74
 fn_8009D2E0 = .text:0x8009D2E0; // type:function size:0xC
 fn_8009D2EC = .text:0x8009D2EC; // type:function size:0x340
@@ -1873,7 +1873,7 @@ fn_800A4F6C = .text:0x800A4F6C; // type:function size:0x8
 fn_800A4F74 = .text:0x800A4F74; // type:function size:0x8
 fn_800A4F7C = .text:0x800A4F7C; // type:function size:0xB4
 fn_800A5030 = .text:0x800A5030; // type:function size:0x50
-fn_800A5080 = .text:0x800A5080; // type:function size:0x94
+BoardBooHouseExec = .text:0x800A5080; // type:function size:0x94
 fn_800A5114 = .text:0x800A5114; // type:function size:0x538
 fn_800A564C = .text:0x800A564C; // type:function size:0xF0
 fn_800A573C = .text:0x800A573C; // type:function size:0xFC
@@ -5533,7 +5533,7 @@ winInsertMesTbl = .bss:0x8019D998; // type:object size:0x20 scope:local
 choiceDisableTbl = .bss:0x8019D9B8; // type:object size:0x40 scope:local
 lbl_8019D9F8 = .bss:0x8019D9F8; // type:object size:0xC data:float
 lbl_8019DA04 = .bss:0x8019DA04; // type:object size:0xC data:4byte
-SpaceData = .bss:0x8019DA10; // type:object size:0x7000 scope:local data:float
+spaceData = .bss:0x8019DA10; // type:object size:0x7000 scope:local data:float
 boardSpaceStarTbl = .bss:0x801A4A10; // type:object size:0x10
 spaceTex = .bss:0x801A4A20; // type:object size:0x20 scope:local
 spaceHiliteTex = .bss:0x801A4A40; // type:object size:0x20 scope:local
@@ -5542,7 +5542,7 @@ lbl_801A4A74 = .bss:0x801A4A74; // type:object size:0x1C
 lbl_801A4A90 = .bss:0x801A4A90; // type:object size:0xC data:2byte
 lbl_801A4A9C = .bss:0x801A4A9C; // type:object size:0xC
 lbl_801A4AA8 = .bss:0x801A4AA8; // type:object size:0x18 data:2byte
-lbl_801A4AC0 = .bss:0x801A4AC0; // type:object size:0x10
+warpPos = .bss:0x801A4AC0; // type:object size:0x10 scope:local
 lbl_801A4AD0 = .bss:0x801A4AD0; // type:object size:0x10 data:4byte
 lbl_801A4AE0 = .bss:0x801A4AE0; // type:object size:0x10
 itemMdlId = .bss:0x801A4AF0; // type:object size:0x18 scope:local
@@ -5849,9 +5849,9 @@ lbl_801D373A = .sdata:0x801D373A; // type:object size:0x2 data:2byte
 lbl_801D373C = .sdata:0x801D373C; // type:object size:0x8
 lbl_801D3744 = .sdata:0x801D3744; // type:object size:0x2 data:2byte
 lbl_801D3746 = .sdata:0x801D3746; // type:object size:0x2 data:2byte
-lbl_801D3748 = .sdata:0x801D3748; // type:object size:0x2 data:2byte
+warpSpringMdl = .sdata:0x801D3748; // type:object size:0x2 scope:local data:2byte
-lbl_801D374A = .sdata:0x801D374A; // type:object size:0x2 data:2byte
+warpImpactMdl = .sdata:0x801D374A; // type:object size:0x2 scope:local data:2byte
-lbl_801D374C = .sdata:0x801D374C; // type:object size:0x4
+warpImpactPlayer = .sdata:0x801D374C; // type:object size:0x4 scope:local
 lbl_801D3750 = .sdata:0x801D3750; // type:object size:0x8
 lbl_801D3758 = .sdata:0x801D3758; // type:object size:0x1 data:byte
 lbl_801D375A = .sdata:0x801D375A; // type:object size:0x2 data:2byte
@@ -6370,13 +6370,13 @@ lbl_801D401B = .sbss:0x801D401B; // type:object size:0x1 data:byte
 lbl_801D401C = .sbss:0x801D401C; // type:object size:0x1 data:byte
 lbl_801D401E = .sbss:0x801D401E; // type:object size:0x2 data:2byte
 lbl_801D4020 = .sbss:0x801D4020; // type:object size:0x8 data:4byte
-lbl_801D4028 = .sbss:0x801D4028; // type:object size:0x4 data:4byte
+warpProcess = .sbss:0x801D4028; // type:object size:0x4 scope:local data:4byte
-lbl_801D402C = .sbss:0x801D402C; // type:object size:0x4 data:float
+warpYVel = .sbss:0x801D402C; // type:object size:0x4 scope:local data:float
-lbl_801D4030 = .sbss:0x801D4030; // type:object size:0x4 data:float
+warpYFloor = .sbss:0x801D4030; // type:object size:0x4 scope:local data:float
-lbl_801D4034 = .sbss:0x801D4034; // type:object size:0x2 data:2byte
+warpSpace = .sbss:0x801D4034; // type:object size:0x2 scope:local data:2byte
-lbl_801D4036 = .sbss:0x801D4036; // type:object size:0x1 data:byte
+warpImpactCnt = .sbss:0x801D4036; // type:object size:0x1 scope:local data:byte
-lbl_801D4037 = .sbss:0x801D4037; // type:object size:0x1 data:byte
+warpTarget = .sbss:0x801D4037; // type:object size:0x1 scope:local data:byte
-lbl_801D4038 = .sbss:0x801D4038; // type:object size:0x8 data:byte
+warpState = .sbss:0x801D4038; // type:object size:0x1 scope:local data:byte
 lbl_801D4040 = .sbss:0x801D4040; // type:object size:0x4 data:4byte
 lbl_801D4044 = .sbss:0x801D4044; // type:object size:0x2 data:2byte
 lbl_801D4048 = .sbss:0x801D4048; // type:object size:0x4 data:float

include/REL/w10Dll.h

@@ -1,7 +1,10 @@
-#include "common.h"
+#include "game/gamework_data.h"
 #include "dolphin.h"
 #include "REL/executor.h"
 #include "game/process.h"
+#include "game/window.h"
+#include "board_unsplit.h"
+#include "unsplit.h"
 
 #define ARRAY_COUNT(arr) (s32)(sizeof(arr) / sizeof(arr[0]))
 
@@ -27,11 +30,6 @@ typedef struct w10DllUnk01 {
     f32 unk10;
 } w10DllUnk01; //sizeof ?
 
-typedef struct m456DllUnk02 {
-    char unk00[0x5C];
-    w10DllUnk01* unk5C;
-} m456DllUnk02; //sizeof ?
-
 typedef struct w10DllUnk03 {
     s16 unk0;
     s16 unk2;

include/board_unsplit.h

@@ -1,49 +1,7 @@
-#ifndef _FUNCTIONS_H_
+#ifndef _UNSPLIT_BOARD_H
-#define _FUNCTIONS_H_
+#define _UNSPLIT_BOARD_H
 
 #include "dolphin.h"
-#include "common_structs.h"
-
-void Hu3DLayerHookSet(short layer, void (*func)(short layer));
-void Hu3D2Dto3D(Vec*, s32, Vec*);
-void Hu3DBGColorSet(u8, u8, u8);
-void Hu3DCameraCreate(s32);
-void Hu3DCameraPerspectiveSet(s32, f32, f32, f32, f32);
-void Hu3DCameraViewportSet(s32, f32, f32, f32, f32, f32, f32);
-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 HuWinAllKill(void);
-void HuWinKill(s16);
-void HuWinPriSet(s16, s16);
-void HuWinHomeClear(s16);
-void HuWinMesPalSet(s16, u8, u8, u8, u8);
-void HuWinMesSet(s16, u32);
-void HuWinMesSpeedSet(s16, s16);
-void HuWinMesMaxSizeGet(s16, f32*, ...);
-s16 HuWinCreate(float x, float y, s16 w, s16 h, s16 frame);
-
-void HuAudFXListnerKill(void);
-void HuAudDllSndGrpSet(u16 ovl);
-void HuAudVoiceInit(s16 ovl);
-
-void MGSeqKillAll(void);
-
-void MGSeqPracticeStart(void);
-void fn_8004D6F4(s16 arg);
-
-s32 rand8(void);
 
 void BoardCameraTargetModelSet(s16 model); 
 void BoardCameraMotionStartEx(s16, Vec *, Vec *, f32, f32, s16); 
@@ -51,7 +9,7 @@ void BoardCameraMotionWait(void);
 void BoardSpacePosGet(s32, s32, Vec*);
 void fn_8007A360(s32);
 void fn_8007F894(void);
-s16 fn_80083F84(void);
+s16 BoardStarHostMdlGet(void);
 void BoardStatusShowSetAll(s32);
 void fn_800A4C88(void);
 void fn_800A6B10(void);

include/common.h

@@ -1,9 +0,0 @@
-#ifndef _COMMON_H_
-#define _COMMON_H_
-
-#include "types.h"
-#include "common_structs.h"
-#include "functions.h"
-#include "variables.h"
-
-#endif

include/game/armem.h

@@ -1,7 +1,7 @@
 #ifndef _GAME_ARMEM_H
 #define _GAME_ARMEM_H
 
-#include "common.h"
+#include "dolphin.h"
 #include "game/memory.h"
 #include "game/data.h"
 

include/game/audio.h

@@ -1,7 +1,7 @@
 #ifndef _GAME_AUDIO_H
 #define _GAME_AUDIO_H
 
-#include "common.h"
+#include "dolphin.h"
 
 void HuAudInit(void);
 s32 HuAudStreamPlay(void);
@@ -56,4 +56,6 @@ s32 HuAudCharVoicePlay(s16 arg0, s16 arg1);
 s32 HuAudCharVoicePlayPos(s16 arg0, s16 arg1, Vec *arg2);
 void HuAudCharVoicePlayEntry(s16 arg0, s16 arg1);
 
+extern u8 fadeStat;
+
 #endif

include/game/board/basic_space.h

@@ -1,13 +1,7 @@
 #ifndef _BOARD_BASIC_SPACE_H
 #define _BOARD_BASIC_SPACE_H
 
-#include "common.h"
+#include "dolphin.h"
-#include "math.h"
-#include "game/process.h"
-#include "game/audio.h"
-#include "game/object.h"
-
-extern Process *boardObjMan;
 
 void BoardEventLandBlue(s32, s16);
 void BoardEventLandRed(s32, s16);

include/game/board/main.h

@@ -0,0 +1,132 @@
+#ifndef _BOARD_MAIN_H
+#define _BOARD_MAIN_H
+
+#include "game/gamework_data.h"
+#include "game/object.h"
+#include "game/data.h"
+#include "dolphin.h"
+
+typedef struct board_focus_data {
+	u16 view_type;
+	s16 time;
+	s16 max_time;
+	float fov_start;
+	float fov_end;
+	float zoom_start;
+	float zoom_end;
+	Vec rot_start;
+	Vec rot_end;
+	Vec target_start;
+	Vec target_end;
+} BoardFocusData;
+
+typedef struct board_camera_data {
+	struct {
+		u8 hide_all : 1;
+		u8 moving : 1;
+		u8 quaking : 1;
+	};
+	u16 mask;
+	s16 target_mdl;
+	s16 target_space;
+	s32 quake_timer;
+	float quake_strength;
+	float fov;
+	float near;
+	float far;
+	float aspect;
+	float viewport_x;
+	float viewport_y;
+	float viewport_w;
+	float viewport_h;
+	float viewport_near;
+	float viewport_far;
+	Vec pos;
+	Vec up;
+	Vec target;
+	Vec offset;
+	Vec rot;
+	float zoom;
+	void (*pos_calc)(struct board_camera_data *);
+	BoardFocusData focus;
+} BoardCameraData;
+
+static inline s32 BoardCurrGet()
+{
+	return GWSystem.board;
+}
+
+static inline s32 BoardPartyFlagGet()
+{
+	s32 value = GWSystem.party;
+	return value;
+}
+
+extern BoardCameraData boardCamera;
+extern Process *boardObjMan;
+extern Process *boardMainProc;
+extern u32 boardRandSeed;
+extern omObjData *boardMainObj;
+
+typedef void (*BoardFunc)(void);
+
+typedef void (*BoardLightHook)(void);
+typedef void (*BoardCameraPosCalcFunc)(BoardCameraData *camera);
+
+void BoardCommonInit(BoardFunc create, BoardFunc destroy);
+void BoardKill(void);
+s32 BoardIsKill(void);
+void BoardPauseEnableSet(s32 value);
+s32 BoardPauseEnableGet();
+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);
+void BoardNextOvlSet(OverlayID overlay);
+s32 BoardStartCheck(void);
+void BoardCameraBackup(void);
+void BoardCameraRestore(void);
+void BoardCameraScissorSet(s32 x, s32 y, s32 w, s32 h);
+void BoardCameraViewSet(s32 type);
+s32 BoardCameraPosGet(Vec *dst);
+s32 BoardCameraTargetGet(Vec *dst);
+s32 BoardCameraRotGet(Vec *dst);
+float BoardCameraZoomGet();
+s32 BoardCameraDirGet(Vec *dst);
+s32 BoardCameraPointDirGet(Vec *point, Vec *dst);
+void BoardCameraMaskSet(u16 mask);
+void BoardCameraMoveSet(s32 move);
+void BoardCameraOffsetSet(float x, float y, float z);
+void BoardCameraTargetPlayerSet(s32 player);
+void BoardCameraTargetModelSet(s16 model);
+void BoardCameraTargetSpaceSet(s32 space);
+void BoardCameraPosCalcFuncSet(BoardCameraPosCalcFunc func);
+void BoardCameraQuakeSet(s32 duration, float strength);
+void BoardCameraQuakeReset();
+void BoardCameraTargetSet(float x, float y, float z);
+void BoardCameraPosSet(float x, float y, float z);
+void BoardCameraXRotZoomSet(float zoom, float x_rot);
+void BoardCameraZoomSet(float zoom);
+void BoardCameraRotSet(float x, float y);
+void BoardCameraNearFarSet(float near, float far);
+void BoardCameraNearFarGet(float *near, float *far);
+void BoardCameraMotionStart(s16 model_target, Vec *rot_target, float zoom_target, float fov_target);
+void BoardCameraMotionStartEx(s16 model_target, Vec *rot_target, Vec *offset_end, float zoom_target, float fov_target, s16 max_time);
+void BoardCameraFovSet(float fov);
+s32 BoardCameraCullCheck(Vec *point, float radius);
+s32 BoardCameraMotionIsDone(void);
+void BoardCameraMotionWait(void);
+void BoardCameraInit(void);
+float BoardArcSin(float value);
+float BoardArcCos(float value);
+void BoardRandInit(void);
+u32 BoardRand(void);
+u32 BoardRandMod(u32 value);
+float BoardRandFloat(void);
+float BoardVecDistXZCalc(Vec *vec1, Vec *vec2);
+s32 BoardVecMaxDistXZCheck(Vec *vec1, Vec *vec2, float max_dist);
+s32 BoardVecMinDistCheck(Vec *vec1, Vec *vec2, float min_dist);
+s32 BoardDataDirReadAsync(s32 data_num);
+void BoardDataAsyncWait(s32 status);
+
+#endif

include/game/board/player.h

@@ -0,0 +1,47 @@
+#ifndef _BOARD_PLAYER_H
+#define _BOARD_PLAYER_H
+
+#include "game/gamework_data.h"
+
+extern s16 boardPlayerMdl[4];
+
+static inline s16 BoardPlayerHandicapGet(s32 player)
+{
+	return GWPlayer[player].handicap;
+}
+
+static inline s32 BoardPlayerGetCurrIdx()
+{
+	return GWSystem.player_curr;
+}
+
+static inline PlayerState *BoardPlayerGet(s32 player)
+{
+	return &GWPlayer[player];
+}
+
+static inline PlayerState *BoardPlayerGetCurr()
+{
+	return &GWPlayer[BoardPlayerGetCurrIdx()];
+}
+
+static inline s16 BoardPlayerModelGet(s32 player)
+{
+	PlayerState *player_ptr = BoardPlayerGet(player);
+	return boardPlayerMdl[player_ptr->player_idx];
+}
+
+static inline s16 BoardPlayerModelGetCurr()
+{
+	PlayerState *player = BoardPlayerGetCurr();
+	return boardPlayerMdl[player->player_idx];
+}
+
+s32 BoardPlayerIsAllCom(void);
+void BoardPlayerRotSet(s32, f32, f32, f32);
+void BoardPlayerPosGet(s32, Vec*);
+void BoardPlayerCoinsSet(s32 player, s32 value);
+void BoardPlayerAutoSizeSet(s32 player, s32 value);
+void BoardPlayerMotionStart(s16, s32, s32);
+
+#endif

include/game/board/space.h

@@ -0,0 +1,52 @@
+#ifndef _BOARD_SPACE_H
+#define _BOARD_SPACE_H
+
+#include "dolphin.h"
+
+#define BOARD_SPACE_LINKMAX 4
+
+typedef s32 (*BoardSpaceEventFunc)(void);
+
+typedef struct board_space {
+	Vec pos;
+	u32 flag;
+	Vec scale;
+	Vec rot;
+	u16 type;
+	u16 link_cnt;
+	u16 link[BOARD_SPACE_LINKMAX+1];
+} BoardSpace;
+
+void BoardSpaceWalkEventFuncSet(BoardSpaceEventFunc func);
+void BoardSpaceWalkMiniEventFuncSet(BoardSpaceEventFunc func);
+void BoardSpaceLandEventFuncSet(BoardSpaceEventFunc func);
+s32 BoardSpaceWalkEventExec(void);
+s32 BoardSpaceWalkMiniEventExec(void);
+s16 BoardSpaceCountGet(s32 layer);
+s16 BoardSpaceCountGet(s32 layer);
+BoardSpace *BoardSpaceGet(s32 layer, s32 index);
+void BoardSpaceAttrSet(s32 layer, u32 attr);
+void BoardSpaceAttrReset(s32 layer, u32 attr);
+u32 BoardSpaceFlagGet(s32 layer, s32 index);
+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 BoardSpaceFlagSearch(s32 layer, u32 flag);
+s32 BoardSpaceFlagPosGet(s32 layer, u32 flag, Vec *pos);
+s32 BoardSpaceLinkFlagSearch(s32 layer, s32 index, u32 flag);
+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 BoardSpaceStarSetIndex(s32 index);
+s32 BoardSpaceStarGetNext(void);
+s32 BoardSpaceStarGetRandom(s32 excl_pos);
+void BoardSpaceStarMove(void);
+s32 BoardSpaceStarGet(s32 index);
+s32 BoardSpaceStarGetCurr(void);
+s32 BoardSpaceStarCheck(s32 index);
+void BoardSpaceLandExec(s32 player, s32 space);
+
+#endif

include/game/board/warp.h

@@ -1,13 +1,9 @@
-#include "common.h"
+#ifndef _BOARD_WARP_H
+#define _BOARD_WARP_H
+
 #include "game/process.h"
 #include "game/wipe.h"
-#include "math.h"
 
-void fn_80080D54(s32);
+void BoardWarpExec(s32 player, s16 space);
-void fn_80080DF8(void);
+
-void fn_80081048(void);
+#endif
-void fn_800810A4(s32);
-void fn_800811BC(s32);
-void fn_80081278(s32);
-void fn_80081428(s32);
-void fn_800814CC(s32);

include/game/board/window.h

@@ -1,10 +1,8 @@
 #ifndef _BOARD_WINDOW_H
 #define _BOARD_WINDOW_H
 
-#include "common.h"
 #include "game/window.h"
 #include "game/process.h"
-#include "game/gamework.h"
 
 typedef void (*BoardWinComKeyFunc)();
 

include/game/data.h

@@ -63,5 +63,6 @@ void *HuDataReadNumHeapShortForce(s32 data_id, s32 num, HeapID heap);
 
 void HuDecodeData(void *src, void *dst, u32 size, int decode_type);
 
+extern u32 DirDataSize;
 
 #endif

include/game/gamework_data.h

@@ -1,7 +1,6 @@
-#ifndef _COMMON_STRUCTS_H
+#ifndef _GAMEWORK_DATA_H
-#define _COMMON_STRUCTS_H
+#define _GAMEWORK_DATA_H
 
-#include "types.h"
 #include "dolphin.h"
 
 typedef struct player_config {
@@ -58,7 +57,7 @@ typedef struct player_state {
         u16 com : 1;
         u16 character : 4;
         u16 auto_size : 2;
-		u16 field01_bit9 : 1;
+		u16 field00_bit9 : 1;
     };
 /* 0x02 */ struct {
         u8 team : 1;
@@ -84,14 +83,14 @@ typedef struct player_state {
 /* 0x0E */ s16 space_prev;
 /* 0x10 */ s16 space_next;
 /* 0x12 */ s16 space_shock;
-/* 0x14 */ u8 blue_count;
+/* 0x14 */ s8 blue_count;
-/* 0x15 */ u8 red_count;
+/* 0x15 */ s8 red_count;
-/* 0x16 */ u8 question_count;
+/* 0x16 */ s8 question_count;
-/* 0x17 */ u8 fortune_count;
+/* 0x17 */ s8 fortune_count;
-/* 0x18 */ u8 bowser_count;
+/* 0x18 */ s8 bowser_count;
-/* 0x19 */ u8 battle_count;
+/* 0x19 */ s8 battle_count;
-/* 0x1A */ u8 mushroom_count;
+/* 0x1A */ s8 mushroom_count;
-/* 0x1B */ u8 warp_count;
+/* 0x1B */ s8 warp_count;
 /* 0x1C */ s16 coins;
 /* 0x1E */ s16 coins_mg;
 /* 0x20 */ s16 coins_total;
@@ -143,4 +142,9 @@ typedef struct game_stat {
     };
 } GameStat;
 
+extern PlayerConfig GWPlayerCfg[4];
+extern PlayerState GWPlayer[4];
+extern SystemState GWSystem;
+extern GameStat GWGameStat;
+
 #endif

include/game/hsfanim.h

@@ -1,7 +1,6 @@
 #ifndef GAME_HSFANIM_H
 #define GAME_HSFANIM_H
 
-#include "common.h"
 #include "game/hsfformat.h"
 #include "game/hsfman.h"
 #include "game/sprite.h"

include/game/hsfman.h

@@ -1,7 +1,6 @@
 #ifndef _GAME_HSFMAN_H
 #define _GAME_HSFMAN_H
 
-#include "common.h"
 #include "math.h"
 #include "game/memory.h"
 #include "game/hsfanim.h"
@@ -283,6 +282,7 @@ 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;

include/game/msm.h

@@ -1,7 +1,7 @@
 #ifndef _GAME_MSM_H
 #define _GAME_MSM_H
 
-#include "common.h"
+#include "dolphin.h"
 
 typedef struct {
     s32 unk00;

include/game/saveload.h

@@ -1,7 +1,7 @@
 #ifndef _GAME_SAVELOAD_H
 #define _GAME_SAVELOAD_H
 
-#include "common.h"
+#include "dolphin.h"
 
 s32 SLFileOpen(char *arg0);
 s32 SLFileCreate(char *arg0, u32 arg1, void *arg2);

include/unsplit.h

@@ -0,0 +1,30 @@
+#ifndef _UNSPLIT_H
+#define _UNSPLIT_H
+
+#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);
+
+#endif

include/variables.h

@@ -1,20 +0,0 @@
-#ifndef _VARIABLES_H
-#define _VARIABLES_H
-
-#include "dolphin.h"
-#include "common_structs.h"
-
-
-extern PlayerConfig GWPlayerCfg[4];
-
-
-extern u32 DirDataSize;
-
-extern u32 totalPolyCnted;
-extern u8 fadeStat;
-
-extern PlayerState GWPlayer[4];
-extern SystemState GWSystem;
-extern GameStat GWGameStat;
-
-#endif

src/REL/_minigameDLL/_minigameDLL.c

@@ -1,4 +1,3 @@
-#include "common.h"
 #include "REL/executor.h"
 #include "dolphin/os.h"
 

src/REL/bootDll/nintendo_data.c

@@ -1,4 +1,3 @@
-#include "common.h"
 #include "game/data.h"
 
 #include "logoNintendoData.inc"

src/REL/w10Dll/scene.c

@@ -210,7 +210,7 @@ void fn_1_13A4(void) {
     BoardCameraMotionStartEx(lbl_1_bss_0->unk8, &sp8, NULL, 3200.0f, -1.0f, 30);
     BoardCameraMotionWait();
     fn_1_BA0(0x2E0032);
-    BoardCameraTargetModelSet(fn_80083F84());
+    BoardCameraTargetModelSet(BoardStarHostMdlGet());
     BoardCameraMotionWait();
     fn_1_BA0(0x2E0033);
     fn_1_BA0(0x2E0034);

src/game/audio.c

@@ -3,7 +3,7 @@
 #include "game/msm.h"
 #include "game/object.h"
 #include "game/wipe.h"
-
+#include "game/gamework_data.h"
 
 typedef struct {
     /* 0x00 */ s16 unk00;

src/game/board/basic_space.c

@@ -1,7 +1,10 @@
 #include "game/board/basic_space.h"
+#include "game/board/main.h"
 #include "game/data.h"
 #include "game/flag.h"
-
+#include "game/object.h"
+#include "game/gamework_data.h"
+#include "board_unsplit.h"
 #include "math.h"
 
 typedef struct bit_copy {
@@ -61,7 +64,7 @@ static s32 coinDigitMdl[10] = {
 	MAKE_DATA_NUM(DATADIR_BOARD, 21),
 };
 
-void BoardEventLandBlue(s32 player, s16 space) {
+void BoardLandBlueExec(s32 player, s16 space) {
     Vec pos;
     s32 i;
     s8 coin_chg;
@@ -102,7 +105,7 @@ void BoardEventLandBlue(s32 player, s16 space) {
     BoardRotateDiceNumbers(player);
 }
 
-void BoardEventLandRed(s32 player, s16 space) {
+void BoardLandRedExec(s32 player, s16 space) {
     Vec pos;
     s32 i;
     s8 coin_chg;

src/game/board/main.c

@@ -1,4 +1,5 @@
-#include "common.h"
+#include "board_unsplit.h"
+#include "game/gamework_data.h"
 #include "math.h"
 #include "game/object.h"
 #include "game/flag.h"
@@ -6,52 +7,8 @@
 #include "game/wipe.h"
 #include "string.h"
 #include "game/hsfman.h"
-
+#include "game/board/main.h"
-
+#include "game/board/player.h"
-typedef struct board_focus_data {
-	u16 view_type;
-	s16 time;
-	s16 max_time;
-	float fov_start;
-	float fov_end;
-	float zoom_start;
-	float zoom_end;
-	Vec rot_start;
-	Vec rot_end;
-	Vec target_start;
-	Vec target_end;
-} BoardFocusData;
-
-typedef struct board_camera_data {
-	struct {
-		u8 hide_all : 1;
-		u8 moving : 1;
-		u8 quaking : 1;
-	};
-	u16 mask;
-	s16 target_mdl;
-	s16 target_space;
-	s32 quake_timer;
-	float quake_strength;
-	float fov;
-	float near;
-	float far;
-	float aspect;
-	float viewport_x;
-	float viewport_y;
-	float viewport_w;
-	float viewport_h;
-	float viewport_near;
-	float viewport_far;
-	Vec pos;
-	Vec up;
-	Vec target;
-	Vec offset;
-	Vec rot;
-	float zoom;
-	void (*pos_calc)(struct board_camera_data *camera);
-	BoardFocusData focus;
-} BoardCameraData;
 
 typedef struct camera_view {
 	s16 x_rot;
@@ -59,7 +16,6 @@ typedef struct camera_view {
 	s16 fov;
 } CameraView;
 
-typedef void (*VoidFunc)(void);
 
 omObjData *boardMainObj;
 u32 boardRandSeed;
@@ -70,11 +26,11 @@ void *boardTurnStartFunc;
 u32 lbl_801D3F00;
 u32 lbl_801D3EFC;
 u32 lbl_801D3EF8;
-VoidFunc boardTurnFunc;
+BoardFunc boardTurnFunc;
-void *boardLightSetHook;
+BoardLightHook boardLightSetHook;
-void *boardLightResetHook;
+BoardLightHook boardLightResetHook;
-static VoidFunc destroyFunc;
+static BoardFunc destroyFunc;
-static VoidFunc createFunc;
+static BoardFunc createFunc;
 static BOOL cameraUseBackup;
 static omObjData *tauntObj;
 static omObjData *cameraObj;
@@ -95,8 +51,7 @@ static CameraView camViewTbl[] = {
 	{ -33, 3200, 25 },
 };
 
-extern void BoardPlayerCoinsSet(s32 player, s32 value);
+
-extern void BoardPlayerAutoSizeSet(s32 player, s32 value);
 extern void BoardModelPosGet(s16 model, Vec *pos);
 extern void BoardSpacePosGet(s32 layer, s32 space, Vec *pos);
 
@@ -134,49 +89,6 @@ static void DestroyMainFunc(void);
 static void CreateBoard(void);
 static void DestroyBoard(void);
 
-static inline s32 BoardCurrGet()
-{
-	return GWSystem.board;
-}
-
-static inline s32 BoardPartyFlagGet()
-{
-	s32 value = GWSystem.party;
-	return value;
-}
-
-static inline s16 BoardHandicapGet(s32 player)
-{
-	return GWPlayer[player].handicap;
-}
-
-static inline s32 BoardPlayerCurrGetIdx()
-{
-	return GWSystem.player_curr;
-}
-
-static inline PlayerState *BoardPlayerGet(s32 player)
-{
-	return &GWPlayer[player];
-}
-
-static inline PlayerState *BoardPlayerCurrGet()
-{
-	return &GWPlayer[BoardPlayerCurrGetIdx()];
-}
-
-static inline s16 BoardPlayerModelGet(s32 player)
-{
-	PlayerState *player_ptr = BoardPlayerGet(player);
-	return boardPlayerMdl[player_ptr->player_idx];
-}
-
-static inline s16 BoardPlayerCurrModelGet()
-{
-	PlayerState *player = BoardPlayerCurrGet();
-	return boardPlayerMdl[player->player_idx];
-}
-
 static inline int GWMGTypeGet()
 {
 	return GWSystem.mg_type;
@@ -187,10 +99,9 @@ static inline int GWMessSpeedGet()
 	return GWSystem.mess_speed;
 }
 
+#define BOARD_FABS(value) ((value < 0) ? -(value) : (value))
 
-#define BoardFAbs(value) ((value < 0) ? -(value) : (value))
+void BoardCommonInit(BoardFunc create, BoardFunc destroy)
-
-void BoardCommonInit(VoidFunc create, VoidFunc destroy)
 {
 	omSysPauseEnable(FALSE);
 	if(!_CheckFlag(FLAG_ID_MAKE(1, 0))) {
@@ -339,7 +250,7 @@ void BoardKill(void)
 		BoardTutorialHookExec(29, 0);
 	}
 	HuAudFXAllStop();
-	if(!BoardIsStarted()) {
+	if(!BoardStartCheck()) {
 		WipeCreate(WIPE_MODE_OUT, WIPE_TYPE_NORMAL, -1);
 		boardTutorialF = 1;
 		while(WipeStatGet()) {
@@ -439,7 +350,7 @@ void BoardSaveInit(s32 board)
 		if(!BoardPartyFlagGet() || _CheckFlag(FLAG_ID_MAKE(1, 11))) {
 			GWStarsSet(i, 0);
 		} else {
-			GWStarsSet(i, BoardHandicapGet(i));
+			GWStarsSet(i, BoardPlayerHandicapGet(i));
 		}
 	}
 }
@@ -599,7 +510,7 @@ static void MainFunc(void)
 				while(WipeStatGet()) {
 					HuPrcVSleep();
 				}
-				BoardPlayerCurrMoveAwayStart(GWPlayer[i].space_curr, 1);
+				BoardPlayerMoveAwayStartCurr(GWPlayer[i].space_curr, 1);
 				fade_type = 0;
 			} else {
 				if(BoardCurrGet() == 7 || BoardCurrGet() == 8) {
@@ -609,7 +520,7 @@ static void MainFunc(void)
 						while(WipeStatGet()) {
 							HuPrcVSleep();
 						}
-						BoardPlayerCurrMoveAwayStart(GWPlayer[i].space_curr, 1);
+						BoardPlayerMoveAwayStartCurr(GWPlayer[i].space_curr, 1);
 						fade_type = 0;
 					}
 				} else {
@@ -669,7 +580,7 @@ void BoardNextOvlSet(OverlayID overlay)
 	BoardKill();
 }
 
-BOOL BoardIsStarted(void)
+s32 BoardStartCheck(void)
 {
 	if(_CheckFlag(FLAG_ID_MAKE(1, 2)) || _CheckFlag(FLAG_ID_MAKE(1, 3)) || _CheckFlag(FLAG_ID_MAKE(1, 4)) || _CheckFlag(FLAG_ID_MAKE(1, 5)) || _CheckFlag(FLAG_ID_MAKE(1, 6))) {
 		return 1;
@@ -868,7 +779,7 @@ void BoardCameraViewSet(s32 type)
 	} else {
 		size = 1.0f;
 	}
-	BoardCameraTargetModelSet(BoardPlayerCurrModelGet());
+	BoardCameraTargetModelSet(BoardPlayerModelGetCurr());
 	BoardPlayerPosGet(GWSystem.player_curr, &focus->target_end);
 	BoardCameraOffsetSet(0.0f, 100.0f*size, 0.0f);
 	focus->target_end.y += 100.0f*size;
@@ -1022,7 +933,7 @@ void BoardCameraTargetSpaceSet(s32 space)
 	camera->offset.x = camera->offset.y = camera->offset.z = 0;
 }
 
-void BoardCameraPosCalcFuncSet(void (*func)(struct board_camera_data *camera))
+void BoardCameraPosCalcFuncSet(BoardCameraPosCalcFunc func)
 {
 	BoardCameraData *camera = &boardCamera;
 	if(!camera) {
@@ -1042,7 +953,7 @@ void BoardCameraQuakeSet(s32 duration, float strength)
 	camera->quake_timer = duration;
 }
 
-void BoardCameraQuakeReset(s32 duration, float strength)
+void BoardCameraQuakeReset()
 {
 	BoardCameraData *camera = &boardCamera;
 	camera->quaking = 0;
@@ -1093,7 +1004,6 @@ void BoardCameraNearFarSet(float near, float far)
 	camera->far = far;
 }
 
-
 void BoardCameraNearFarGet(float *near, float *far)
 {
 	BoardCameraData *camera = &boardCamera;
@@ -1180,7 +1090,7 @@ s32 BoardCameraCullCheck(Vec *point, float radius)
 	}
 	BoardCameraPointDirGet(point, &pos);
 	dot = VECDotProduct(&dir, &pos);
-	if(BoardFAbs(dot) < cos((camera->fov*M_PI)/180)) {
+	if(BOARD_FABS(dot) < cos((camera->fov*M_PI)/180)) {
 		return 0;
 	} else {
 		return 1;
@@ -1365,7 +1275,7 @@ float BoardArcSin(float value)
 	s32 sign;
 	if(value < 0) {
 		sign = 1;
-		value = BoardFAbs(value);
+		value = BOARD_FABS(value);
 	} else {
 		sign = 0;
 	}
@@ -1378,14 +1288,14 @@ float BoardArcSin(float value)
 		result = 1.0f-atanf((float)sqrtf(1-(value*value))/value);
 	}
 	if(sign) {
-		result = BoardFAbs(result);
+		result = BOARD_FABS(result);
 	}
 	return result;
 }
 
 float BoardArcCos(float value)
 {
-	if(BoardFAbs(value) > 1) {
+	if(BOARD_FABS(value) > 1) {
 		return 0;
 	}
 	return 1.0f-BoardArcSin(value);

src/game/board/player.c

@@ -1,20 +1,13 @@
-#include "common.h"
+#include "board_unsplit.h"
+#include "game/gamework_data.h"
 #include "game/gamework.h"
 #include "game/window.h"
 #include "game/object.h"
 #include "game/process.h"
 #include "game/hsfman.h"
+#include "game/board/player.h"
+#include "game/board/main.h"
 
-//// #include "game/board/main.h"
-extern s32 BoardIsStarted(void);
-extern void BoardCameraMoveSet(s32);
-extern void BoardCameraViewSet(s32);
-extern void BoardPauseEnableSet(s32);
-extern void BoardCameraTargetPlayerSet(s32);
-extern void BoardCameraOffsetSet(float, float, float);
-extern void BoardCameraTargetModelSet(s16);
-extern void BoardCameraTargetPlayerSet(s32);
-extern Process* boardObjMan;
 //// #include "game/board/space.h"
 extern s32 BoardSpaceFlagPosGet(s32, s32, u32);
 extern void BoardSpaceDirPosGet(s32, s32, Vec*);
@@ -242,7 +235,7 @@ void BoardPlayerInit(void) {
             BoardPlayerSizeSet(var_r31, 0);
             GWPlayer[var_r31].color = 0;
             GWPlayer[var_r31].bowser_suit = 0;
-            GWPlayer[var_r31].field01_bit9 = 0;
+            GWPlayer[var_r31].field00_bit9 = 0;
             GWPlayer[var_r31].field08_bit3 = 0;
         }
         return;
@@ -258,7 +251,7 @@ void BoardPlayerInit(void) {
 }
 
 void BoardPlayerModelInit(void) {
-    s32 sp64[0x10];
+    s32 sp64[14];
     s32 var_r31;
     s32 var_r30;
     s32 temp_r29;
@@ -336,7 +329,7 @@ void BoardPlayerModelKill(void) {
     PlayerState* temp_r29;
 
     for (var_r31 = 0; var_r31 < 4; var_r31++) {
-        temp_r30 = GetPlayer(var_r31);
+        temp_r30 = BoardPlayerGet(var_r31);
         if (boardPlayerMdl[temp_r30->player_idx] != -1) {
             BoardModelKill(boardPlayerMdl[temp_r30->player_idx]);
             boardPlayerMdl[temp_r30->player_idx] = -1;
@@ -350,22 +343,22 @@ void BoardPlayerModelKill(void) {
 }
 
 void BoardPlayerLayerSet(s32 arg0, s32 arg1) {
-    BoardModelLayerSet(GetBoardPlayer(arg0), arg1);
+    BoardModelLayerSet(BoardPlayerModelGet(arg0), arg1);
 }
 
 void BoardPlayerCameraSet(s32 arg0, u16 arg1) {
-    BoardModelCameraSet(GetBoardPlayer(arg0), arg1);
+    BoardModelCameraSet(BoardPlayerModelGet(arg0), arg1);
 }
 
 void fn_80062A40(s32 arg0, f32 arg8) {
-    fn_8006DDE8(GetBoardPlayer(arg0), arg8);
+    fn_8006DDE8(BoardPlayerModelGet(arg0), arg8);
 }
 
 void BoardPlayerExistCheck(s32 arg0, s32 arg1) {
     if (arg1 == 0) {
-        BoardModelExistCheck(GetBoardPlayer(arg0), 0);
+        BoardModelExistCheck(BoardPlayerModelGet(arg0), 0);
     } else {
-        BoardModelExistCheck(GetBoardPlayer(arg0), 1);
+        BoardModelExistCheck(BoardPlayerModelGet(arg0), 1);
     }
 }
 
@@ -375,7 +368,7 @@ s32 BoardPlayerItemAdd(s32 arg0, s32 arg1) {
     s32 var_r31;
 
     var_r29 = -1;
-    var_r30 = GetPlayer(arg0);
+    var_r30 = BoardPlayerGet(arg0);
     for (var_r31 = 0; var_r31 < 3; var_r31++) {
         if (GWPlayer[arg0].items[var_r31] == -1) {
             HuAudFXPlay(0x360);
@@ -392,7 +385,7 @@ s32 BoardPlayerItemRemove(s32 arg0, s32 arg1) {
     s32 temp_r29;
     PlayerState* temp_r28;
 
-    temp_r28 = GetPlayer(arg0);
+    temp_r28 = BoardPlayerGet(arg0);
     temp_r29 = temp_r28->items[arg1];
     if (temp_r28->items[arg1] == -1) {
         return temp_r29;
@@ -464,15 +457,15 @@ void BoardPlayerCurrSpacePosDirGet(s32 arg0, Point3d* arg1) {
 }
 
 void BoardPlayerAmbSet(s32 arg0, f32 arg8, f32 arg9, f32 argA) {
-    BoardModelAmbSet(GetBoardPlayer(arg0), arg8, arg9, argA);
+    BoardModelAmbSet(BoardPlayerModelGet(arg0), arg8, arg9, argA);
 }
 
 void BoardPlayerMtxSet(s32 arg0, Mtx arg1) {
-    BoardModelMtxSet(GetBoardPlayer(arg0), arg1);
+    BoardModelMtxSet(BoardPlayerModelGet(arg0), arg1);
 }
 
 void BoardPlayerPosSetV(s32 arg0, Vec* arg1) {
-    BoardModelPosSetV(GetBoardPlayer(arg0), arg1);
+    BoardModelPosSetV(BoardPlayerModelGet(arg0), arg1);
 
     if (GWPlayer[arg0].bowser_suit != 0) {
         BoardModelPosSetV(suitMdl, arg1);
@@ -480,7 +473,7 @@ void BoardPlayerPosSetV(s32 arg0, Vec* arg1) {
 }
 
 void BoardPlayerPosSet(s32 arg0, f32 arg8, f32 arg9, f32 argA) {
-    BoardModelPosSet(GetBoardPlayer(arg0), arg8, arg9, argA);
+    BoardModelPosSet(BoardPlayerModelGet(arg0), arg8, arg9, argA);
     
     if (GWPlayer[arg0].bowser_suit != 0) {
         BoardModelPosSet(suitMdl, arg8, arg9, argA);
@@ -488,11 +481,11 @@ void BoardPlayerPosSet(s32 arg0, f32 arg8, f32 arg9, f32 argA) {
 }
 
 void BoardPlayerPosGet(s32 arg0, Vec* arg1) {
-    BoardModelPosGet(GetBoardPlayer(arg0), arg1);
+    BoardModelPosGet(BoardPlayerModelGet(arg0), arg1);
 }
 
 void BoardPlayerRotSetV(s32 arg0, Vec* arg1) {
-    BoardModelRotSetV(GetBoardPlayer(arg0), arg1);
+    BoardModelRotSetV(BoardPlayerModelGet(arg0), arg1);
 
     if (GWPlayer[arg0].bowser_suit != 0) {
         BoardModelRotSetV(suitMdl, arg1);
@@ -500,7 +493,7 @@ void BoardPlayerRotSetV(s32 arg0, Vec* arg1) {
 }
 
 void BoardPlayerRotSet(s32 arg0, f32 arg8, f32 arg9, f32 argA) {
-    BoardModelRotSet(GetBoardPlayer(arg0), arg8, arg9, argA);
+    BoardModelRotSet(BoardPlayerModelGet(arg0), arg8, arg9, argA);
     
     if (GWPlayer[arg0].bowser_suit != 0) {
         BoardModelRotSet(suitMdl, arg8, arg9, argA);
@@ -508,7 +501,7 @@ void BoardPlayerRotSet(s32 arg0, f32 arg8, f32 arg9, f32 argA) {
 }
 
 void BoardPlayerRotGet(s32 arg0, Vec* arg1) {
-    BoardModelRotGet(GetBoardPlayer(arg0), arg1);
+    BoardModelRotGet(BoardPlayerModelGet(arg0), arg1);
 }
 
 void BoardPlayerRotYSet(s32 arg0, f32 arg8) {
@@ -518,7 +511,7 @@ void BoardPlayerRotYSet(s32 arg0, f32 arg8) {
     if (arg8 > 360.0f) {
         arg8 -= 360.0f;
     }
-    BoardModelRotYSet(GetBoardPlayer(arg0), arg8);
+    BoardModelRotYSet(BoardPlayerModelGet(arg0), arg8);
     if (GWPlayer[arg0].bowser_suit != 0) {
         BoardModelRotYSet(suitMdl, arg8);
     }
@@ -530,47 +523,47 @@ f32 BoardPlayerRotYGet(s32 arg0) {
     if (GWPlayer[arg0].bowser_suit != 0) {
         var_f31 = BoardModelRotYGet(suitMdl);
     } else {
-        var_f31 = BoardModelRotYGet(GetBoardPlayer(arg0));
+        var_f31 = BoardModelRotYGet(BoardPlayerModelGet(arg0));
     }
     return var_f31;
 }
 
 void BoardPlayerScaleSetV(s32 arg0, Vec* arg1) {
-    BoardModelScaleSetV(GetBoardPlayer(arg0), arg1);
+    BoardModelScaleSetV(BoardPlayerModelGet(arg0), arg1);
 }
 
 void BoardPlayerScaleSet(s32 arg0, f32 arg8, f32 arg9, f32 argA) {
-    BoardModelScaleSet(GetBoardPlayer(arg0), arg8, arg9, argA);
+    BoardModelScaleSet(BoardPlayerModelGet(arg0), arg8, arg9, argA);
 }
 
 void BoardPlayerScaleGet(s32 arg0, s32 *arg1) {
-    BoardModelScaleGet(GetBoardPlayer(arg0), arg1);
+    BoardModelScaleGet(BoardPlayerModelGet(arg0), arg1);
 }
 
 s16 BoardPlayerCurrMotionGet(s32 arg0) {
-    PlayerState* player = GetPlayer(arg0);
+    PlayerState* player = BoardPlayerGet(arg0);
     
     return playerMot[player->player_idx];
 }
 
 void BoardPlayerVoiceEnableSet(s32 arg0, s32 arg1, s32 arg2) {
-    BoardModelVoiceEnableSet(GetBoardPlayer(arg0), arg1, arg2);
+    BoardModelVoiceEnableSet(BoardPlayerModelGet(arg0), arg1, arg2);
 }
 
 void BoardPlayerMotionCreate(s32 arg0, s32 arg1) {
-    BoardModelMotionCreate(GetBoardPlayer(arg0), arg1);
+    BoardModelMotionCreate(BoardPlayerModelGet(arg0), arg1);
 }
 
 void BoardPlayerMotionKill(s32 arg0, s32 arg1) {
-    BoardModelMotionKill(GetBoardPlayer(arg0), arg1);
+    BoardModelMotionKill(BoardPlayerModelGet(arg0), arg1);
 }
 
 void BoardPlayerMotionEndCheck(s32 arg0) {
-    BoardModelMotionEndCheck(GetBoardPlayer(arg0));
+    BoardModelMotionEndCheck(BoardPlayerModelGet(arg0));
 }
 
 void BoardPlayerMotionEndWait(s32 arg0) {
-    while (BoardModelMotionEndCheck(GetBoardPlayer(arg0)) == 0) {
+    while (BoardModelMotionEndCheck(BoardPlayerModelGet(arg0)) == 0) {
         HuPrcVSleep();
     }
 }
@@ -579,11 +572,11 @@ void BoardPlayerMotionStart(s32 arg0, s32 arg1, s32 arg2) {
     PlayerState* player;
     s32 temp_r29;
     
-    player = GetPlayer(arg0);
+    player = BoardPlayerGet(arg0);
     if (arg1 == 0) {
     }
     if (arg1 != playerMot[player->player_idx]) {
-        temp_r29 = BoardModelMotionStart(GetBoardPlayer(arg0), arg1, arg2);
+        temp_r29 = BoardModelMotionStart(BoardPlayerModelGet(arg0), arg1, arg2);
         if (temp_r29 == 0) {
             playerMot[player->player_idx] = arg1;
         }
@@ -594,11 +587,11 @@ void BoardPlayerMotionShiftSet(s32 arg0, s32 arg1, f32 arg8, f32 arg9, s32 arg2)
     PlayerState* player;
     s32 temp_r29;
     
-    player = GetPlayer(arg0);
+    player = BoardPlayerGet(arg0);
     if (arg1 == 0) {
     }
     if (arg1 != playerMot[player->player_idx]) {
-        temp_r29 = BoardModelMotionShiftSet(GetBoardPlayer(arg0), arg1, arg8, arg9, arg2);
+        temp_r29 = BoardModelMotionShiftSet(BoardPlayerModelGet(arg0), arg1, arg8, arg9, arg2);
         if (temp_r29 == 0) {
             playerMot[player->player_idx] = arg1;
         }
@@ -606,31 +599,31 @@ void BoardPlayerMotionShiftSet(s32 arg0, s32 arg1, f32 arg8, f32 arg9, s32 arg2)
 }
 
 void BoardPlayerMotionSpeedSet(s32 arg0, f32 arg8) {
-    BoardModelMotionSpeedSet(GetBoardPlayer(arg0), arg8);
+    BoardModelMotionSpeedSet(BoardPlayerModelGet(arg0), arg8);
 }
 
 void BoardPlayerMotionTimeSet(s32 arg0, f32 arg8) {
-    BoardModelMotionTimeSet(GetBoardPlayer(arg0), arg8);
+    BoardModelMotionTimeSet(BoardPlayerModelGet(arg0), arg8);
 }
 
 f32 BoardPlayerMotionTimeGet(s32 arg0) {
-    BoardModelMotionTimeGet(GetBoardPlayer(arg0));
+    BoardModelMotionTimeGet(BoardPlayerModelGet(arg0));
 }
 
 f32 BoardPlayerMotionMaxTimeGet(s32 arg0) {
-    BoardModelMotionMaxTimeGet(GetBoardPlayer(arg0));
+    BoardModelMotionMaxTimeGet(BoardPlayerModelGet(arg0));
 }
 
 void BoardPlayerMotionTimeRangeSet(s32 arg0, f32 arg8, f32 arg9) {
-    BoardModelMotionTimeRangeSet(GetBoardPlayer(arg0), arg8, arg9);
+    BoardModelMotionTimeRangeSet(BoardPlayerModelGet(arg0), arg8, arg9);
 }
 
 void BoardPlayerModelAttrSet(s32 arg0, s32 arg1) {
-    BoardModelAttrSet(GetBoardPlayer(arg0), arg1);
+    BoardModelAttrSet(BoardPlayerModelGet(arg0), arg1);
 }
 
 void BoardPlayerModelAttrReset(s32 arg0, s32 arg1) {
-    BoardModelAttrReset(GetBoardPlayer(arg0), arg1);
+    BoardModelAttrReset(BoardPlayerModelGet(arg0), arg1);
 }
 
 void BoardPlayerCoinsSet(s32 arg0, s32 arg1) {
@@ -645,7 +638,7 @@ void BoardPlayerCoinsAdd(s32 arg0, s32 arg1) {
     PlayerState* player;
     s16 coins;
 
-    player = GetPlayer(arg0);
+    player = BoardPlayerGet(arg0);
     if ((arg1 > 0) && (player->coins_total < 0x3E7)) {
         player->coins_total += arg1;
         if (player->coins_total > 0x3E7) {
@@ -663,7 +656,7 @@ void BoardPlayerSizeSet(s32 arg0, s32 arg1) {
     PlayerState* temp_r27;
     Vec temp_r4[3] = { { 1, 1, 1 }, { 0.3, 0.3, 0.3 }, { 2.5, 2.5, 2.5 } };
 
-    temp_r27 = GetPlayer(arg0);
+    temp_r27 = BoardPlayerGet(arg0);
     temp_r27->size = arg1;
     if (arg1 == 2) {
         CharModelSetStepType(GWPlayer[arg0].character, 4);
@@ -672,13 +665,13 @@ void BoardPlayerSizeSet(s32 arg0, s32 arg1) {
     } else {
         CharModelSetStepType(GWPlayer[arg0].character, 0);
     }
-    BoardModelScaleSetV(GetBoardPlayer(arg0), &temp_r4[arg1]);
+    BoardModelScaleSetV(BoardPlayerModelGet(arg0), &temp_r4[arg1]);
 }
 
 s32 BoardPlayerSizeGet(s32 arg0) {
     PlayerState* temp_r30;
 
-    temp_r30 = GetPlayer(arg0);
+    temp_r30 = BoardPlayerGet(arg0);
     if (temp_r30 != 0) {
         arg0 = temp_r30->size;
     }
@@ -713,22 +706,22 @@ s32 BoardPlayerTeamFind(s32 arg0) {
     return var_r31;
 }
 
-s32 BoardPlayerRankCalc(s32 arg0) {
+s32 BoardPlayerRankCalc(s32 player) {
-    s32 temp_r29;
+    s32 coins;
-    s32 var_r30;
+    s32 rank;
-    s32 var_r31;
+    s32 i;
-    s32 sp8[4];
+    s32 score[4];
 
-    for (var_r31 = 0; var_r31 < 4; var_r31++) {
+    for (i = 0; i < 4; i++) {
-        temp_r29 = GWCoinsGet(var_r31);
+        coins = GWCoinsGet(i);
-        sp8[var_r31] = temp_r29 | (GWStarsGet(var_r31) << 0xA);
+        score[i] = coins | (GWStarsGet(i) << 0xA);
     }
-    for (var_r30 = 0, var_r31 = 0; var_r31 < 4; var_r31++) {
+    for (rank = 0, i = 0; i < 4; i++) {
-        if ((var_r31 != arg0) && (sp8[arg0] < sp8[var_r31])) {
+        if ((i != player) && (score[player] < score[i])) {
-            var_r30++;
+            rank++;
         }
     }
-    return var_r30;
+    return rank;
 }
 
 void BoardPlayerPreTurnHookSet(s32 arg0, s32 (*arg1)()) {
@@ -930,12 +923,12 @@ void BoardPlayerSizeRestore(s32 arg0) {
     s32 var_r28;
     s32 var_r27;
 
-    temp_r24 = GetPlayer(arg0);
+    temp_r24 = BoardPlayerGet(arg0);
     if (temp_r24 != 0) {
         var_r28 = temp_r24->size;
     }
     if (var_r28 != 0) {
-        temp_r23 = GetPlayer(arg0);
+        temp_r23 = BoardPlayerGet(arg0);
         if (temp_r23 != 0) {
             var_r27 = temp_r23->size;
         }
@@ -962,8 +955,8 @@ void BoardPlayerZoomRestore(s32 arg0) {
     Vec sp18;
     Vec spC;
 
-    sp8 = GetPlayer(arg0);
+    sp8 = BoardPlayerGet(arg0);
-    BoardModelPosGet(GetBoardPlayer(arg0), &spC);
+    BoardModelPosGet(BoardPlayerModelGet(arg0), &spC);
     temp_r27 = GWPlayer[arg0].space_curr;
     var_r31 = GWSystem.player_curr;
     if (var_r31 == -1) {

src/game/board/space.c

@@ -0,0 +1,589 @@
+#include "game/gamework_data.h"
+#include "game/flag.h"
+#include "game/board/main.h"
+#include "game/board/space.h"
+
+#include "math.h"
+
+extern s16 BoardStarHostMdlGet(void);
+extern void BoardModelPosSetV(s16 model, Vec *pos);
+
+
+static GXTexObj spaceHiliteTex;
+static GXTexObj spaceTex;
+s16 boardSpaceStarTbl[8];
+static BoardSpace spaceData[2][256];
+
+static s16 spaceCnt[2];
+static u32 spaceAttr[2];
+static void *spaceTexData;
+static void *spaceHiliteTexData;
+static GXTexFmt spaceTexFmt;
+static GXTexFmt spaceHiliteTexFmt;
+s16 lbl_801D3FC4[4];
+static BoardSpaceEventFunc landEventFunc;
+static BoardSpaceEventFunc walkMiniEventFunc;
+static BoardSpaceEventFunc walkEventFunc;
+static s32 spaceDrawCnt;
+static s16 spaceDrawF;
+
+static s16 spaceDrawMdl = -1;
+static s16 starMdl = -1;
+
+s32 BoardSpaceRotGet(s32 layer, s32 index, Vec *rot);
+s32 BoardSpaceStarGet(s32 index);
+s32 BoardSpaceStarGetCurr(void);
+
+void BoardSpaceWalkEventFuncSet(BoardSpaceEventFunc func)
+{
+	walkEventFunc = func;
+}
+
+void BoardSpaceWalkMiniEventFuncSet(BoardSpaceEventFunc func)
+{
+	walkMiniEventFunc = func;
+}
+
+void BoardSpaceLandEventFuncSet(BoardSpaceEventFunc func)
+{
+	landEventFunc = func;
+}
+
+s32 BoardSpaceWalkEventExec(void)
+{
+	s32 ret = -1;
+	if(walkEventFunc) {
+		ret = walkEventFunc();
+	}
+	return ret;
+}
+
+s32 BoardSpaceWalkMiniEventExec(void)
+{
+	s32 ret = -1;
+	if(walkMiniEventFunc) {
+		_SetFlag(FLAG_ID_MAKE(1, 8));
+		ret = walkMiniEventFunc();
+		_ClearFlag(FLAG_ID_MAKE(1, 8));
+	}
+	return ret;
+}
+
+s16 BoardSpaceCountGet(s32 layer)
+{
+	return spaceCnt[layer];
+}
+
+BoardSpace *BoardSpaceGet(s32 layer, s32 index)
+{
+	if(index <= 0 || index > spaceCnt[layer]) {
+		return NULL;
+	} else {
+		return &spaceData[layer][index-1];
+	}
+}
+
+void BoardSpaceAttrSet(s32 layer, u32 attr)
+{
+	spaceAttr[layer] |= attr;
+}
+
+void BoardSpaceAttrReset(s32 layer, u32 attr)
+{
+	spaceAttr[layer] &= ~attr;
+}
+
+u32 BoardSpaceFlagGet(s32 layer, s32 index)
+{
+	if(index <= 0 || index > spaceCnt[layer]) {
+		return 0;
+	} else {
+		return spaceData[layer][index-1].flag;
+	}
+}
+
+s32 BoardSpaceTypeGet(s32 layer, s32 index)
+{
+	if(index <= 0 || index > spaceCnt[layer]) {
+		return 0;
+	} else {
+		return spaceData[layer][index-1].type;
+	}
+}
+
+void BoardSpaceTypeSet(s32 layer, s32 index, s32 type)
+{
+	if(index <= 0 || index > spaceCnt[layer]) {
+		return;
+	} else {
+		spaceData[layer][index-1].type = type;
+	}
+}
+
+s32 BoardSpacePosGet(s32 layer, s32 index, Vec *pos)
+{
+	BoardSpace *space = BoardSpaceGet(layer, index);
+	if(!space) {
+		return -1;
+	} else {
+		*pos = space->pos;
+		return 0;
+	}
+}
+
+void BoardSpaceCornerPosGet(s32 index, s32 corner, Vec *pos)
+{
+	Vec corner_ofs;
+	Vec rot;
+	s8 corner_pos[4][2] = {{-1, -1}, {1, -1}, {-1, 1}, {1, 1}};
+	BoardSpaceRotGet(0, index, &rot);
+	BoardSpacePosGet(0, index, pos);
+	corner_ofs.x = corner_pos[corner][0]*80.0f;
+	corner_ofs.y = 0;
+	corner_ofs.z = corner_pos[corner][1]*80.0f;
+	corner_ofs.x = (cos((M_PI*rot.z)/180)*corner_ofs.x)+(sin((M_PI*rot.z)/180)*corner_ofs.y);
+	corner_ofs.y = (cos((M_PI*rot.x)/180)*cos((M_PI*rot.z)/180)*corner_ofs.y)
+		+(sin((M_PI*rot.z)/180)*corner_ofs.x)
+		+(sin((M_PI*-rot.x)/180)*corner_ofs.z);
+	corner_ofs.z = (sin((M_PI*rot.x)/180)*corner_ofs.y)+(cos((M_PI*rot.x)/180)*corner_ofs.z);
+	pos->x += corner_ofs.x;
+	pos->y += corner_ofs.y;
+	pos->z += corner_ofs.z;
+}
+
+s32 BoardSpaceRotGet(s32 layer, s32 index, Vec *rot)
+{
+	BoardSpace *space = BoardSpaceGet(layer, index);
+	if(!space) {
+		return -1;
+	} else {
+		*rot = space->rot;
+		return 0;
+	}
+}
+
+s32 BoardSpaceFlagSearch(s32 layer, u32 flag)
+{
+	s32 i;
+	for(i=0; i<spaceCnt[layer]; i++) {
+		BoardSpace *space = &spaceData[layer][i];
+		if((space->flag & flag) == flag) {
+			return space-(&spaceData[layer][0])+1;
+		}
+	}
+	return -1;
+}
+
+s32 BoardSpaceFlagPosGet(s32 layer, u32 flag, Vec *pos)
+{
+	s32 space = BoardSpaceFlagSearch(layer, flag);
+	if(space == -1) {
+		return -1;
+	}
+	if(pos) {
+		BoardSpacePosGet(layer, space, pos);
+	}
+	return space;
+}
+
+s32 BoardSpaceLinkFlagSearch(s32 layer, s32 index, u32 flag)
+{
+	BoardSpace *link_space;
+	BoardSpace *space = BoardSpaceGet(layer, index);
+	s32 i;
+	if(!space) {
+		return -1;
+	}
+	for(i=0; i<space->link_cnt; i++) {
+		link_space = BoardSpaceGet(layer, space->link[i]);
+		if(link_space->flag & flag) {
+			return link_space-&spaceData[layer][0]+1;
+		}
+	}
+	return -1;
+}
+
+s32 BoardSpaceLinkTypeListGet(s32 layer, s32 index, s32 type, s16 *list)
+{
+	s32 count;
+	BoardSpace *space = BoardSpaceGet(layer, index);
+	s32 i;
+	if(!space) {
+		return -1;
+	}
+	for(count=i=0; i<space->link_cnt; i++) {
+		BoardSpace *link_space = BoardSpaceGet(layer, space->link[i]);
+		if(link_space->type == type && count < BOARD_SPACE_LINKMAX) {
+			list[count] = link_space-&spaceData[layer][0]+1;
+			count++;
+		}
+	}
+	return count;
+}
+
+s32 BoardSpaceLinkTargetListGet(s32 layer, s32 target, s16 *list)
+{
+	s32 i, j;
+	s32 count;
+	BoardSpace *space;
+	memset(list, 0, BOARD_SPACE_LINKMAX*sizeof(s16));
+	space = &spaceData[layer][0];
+	for(count=i=0; i<spaceCnt[layer]; i++, space++) {
+		for(j=0; j<space->link_cnt; j++) {
+			if(space->link[j] == target && count < BOARD_SPACE_LINKMAX) {
+				list[count++] = space-&spaceData[layer][0]+1;
+			}
+		}
+	}
+	return count;
+}
+
+s32 BoardSpaceLinkTypeSearch(s32 layer, s32 target, u16 type)
+{
+	s32 i;
+	BoardSpace *space = BoardSpaceGet(layer, target);
+	if(!space) {
+		return -1;
+	}
+	for(i=0; i<space->link_cnt; i++) {
+		BoardSpace *link_space = BoardSpaceGet(layer, space->link[i]);
+		if(link_space->type == type) {
+			return space->link[i];
+		}
+	}
+	return -1;
+}
+
+s32 BoardSpaceLinkTransformGet(s32 flag, Vec *pos, Vec *rot, Vec *scale)
+{
+	s32 i;
+	s32 space_flag = BoardSpaceFlagSearch(0, flag);
+	BoardSpace *space = BoardSpaceGet(0, space_flag);
+	
+	for(i=0; i<space->link_cnt; i++) {
+		BoardSpace *link_space = BoardSpaceGet(0, space->link[i]);
+		BoardSpace *src_space;
+		if(!(link_space->flag & 0x2000000)) {
+			continue;
+		}
+		src_space = BoardSpaceGet(0, link_space->link[0]);
+		if(pos) {
+			*pos = src_space->pos;
+		}
+		if(rot) {
+			*rot = src_space->rot;
+		}
+		if(scale) {
+			*scale = src_space->scale;
+		}
+		return 0;
+	}
+	return -1;
+}
+
+void BoardSpaceStarSet(s32 space)
+{
+	s16 host_space;
+	Vec pos;
+	BoardSpace *space_plat;
+	BoardSpaceTypeSet(0, space, 8);
+	host_space = BoardSpaceLinkFlagSearch(0, space, 0x04000000);
+	BoardSpacePosGet(0, host_space, &pos);
+	BoardModelPosSetV(BoardStarHostMdlGet(), &pos);
+}
+
+static inline s16 BoardStarMdlGet(void)
+{
+	return starMdl;
+}
+
+static inline s32 BoardStarSpaceTypeGet(s16 index)
+{
+	return BoardSpaceTypeGet(0, BoardSpaceStarGet(index));
+}
+
+void BoardSpaceStarSetIndex(s32 index)
+{
+	Vec pos;
+	Vec rot;
+	s16 space;
+	if(_CheckFlag(FLAG_ID_MAKE(1, 1))) {
+		BoardSpaceTypeSet(0, boardSpaceStarTbl[GWSystem.star_pos], 1);
+	}
+	GWSystem.star_pos = index & 0x7;
+	BoardSpaceStarSet(BoardSpaceStarGetCurr());
+	space = BoardSpaceLinkFlagSearch(0, BoardSpaceStarGetCurr(), 0x04000000);
+	BoardSpacePosGet(0, space, &pos);
+	BoardModelPosSetV(BoardStarMdlGet(), &pos);
+	BoardSpaceRotGet(0, space, &rot);
+	BoardModelRotYSet(BoardStarMdlGet(), rot.y);
+	BoardModelVisibilitySet(BoardStarMdlGet(), 1);
+}
+
+s32 BoardSpaceStarGetNext(void)
+{
+	s16 random_pos;
+	s16 star_total;
+	s16 star_pos;
+	star_total = GWSystem.star_total;
+	star_pos = GWSystem.star_pos;
+	if(BoardCurrGet() == 5) {
+		s16 i;
+		s32 count;
+		s32 last_free;
+		last_free = -1;
+		for(count=i=0; i<8; i++) {
+			if((1 << i) & GWSystem.star_flag) {
+				count++;
+			} else {
+				last_free = i;
+			}
+		}
+		if(count == 7) {
+			if(BoardSpaceTypeGet(0, BoardSpaceStarGet(last_free)) == 10) {
+				GWSystem.star_flag = 0;
+			}
+		}
+	}
+	begin:
+	random_pos = BoardRandMod(8);
+	if(star_pos == random_pos || BoardStarSpaceTypeGet(random_pos) == 10) {
+		goto begin;
+	}
+	switch(GWSystem.board) {
+		case 0:
+			if(star_total >= 2) {
+				break;
+			}
+			if(random_pos != 6 && random_pos != 7) {
+				break;
+			}
+			goto begin;
+			
+		case 1:
+			if(star_total >= 2) {
+				break;
+			}
+			if(random_pos != 6 && random_pos != 7) {
+				break;
+			}
+			goto begin;
+		
+		case 2:
+			if(star_total == 1) {
+				if(random_pos < 3 || random_pos > 5) {
+					break;
+				}
+				goto begin;
+			} else {
+				if(star_total != 2) {
+					break;
+				}
+				if(random_pos != 3 && random_pos != 4) {
+					break;
+				}
+				goto begin;
+			}
+			
+		case 3:
+			if(star_total == 1) {
+				if(random_pos < 5 || random_pos > 7) {
+					break;
+				}
+				goto begin;
+			} else {
+				if(star_total != 2) {
+					break;
+				}
+				if(random_pos == 5) {
+					goto begin;
+				}
+				break;
+			}
+			
+		case 4:
+			if(star_total == 1) {
+				if(random_pos <= 1 || random_pos >= 4) {
+					goto begin;
+				}
+			}
+			break;
+			
+		case 5:
+			if(star_total == 1) {
+				if(random_pos == 1 || random_pos == 4 || random_pos == 5) {
+					goto begin;
+				}
+			}
+			if(star_total != 2) {
+				break;
+			}
+			if(random_pos == 5) {
+				goto begin;
+			}
+	}
+	if((1 << random_pos) & GWSystem.star_flag) {
+		goto begin;
+	}
+	return random_pos;
+}
+
+s32 BoardSpaceStarGetRandom(s32 excl_pos)
+{
+	s8 new_pos;
+	int i;
+	for(i=0; i<1024; i++) {
+		new_pos = BoardRandMod(8);
+		if(new_pos == GWSystem.star_pos) {
+			continue;
+		}
+		if(GWSystem.turn == 1 && new_pos <= 2) {
+			continue;
+		}
+		if(new_pos != excl_pos) {
+			break;
+		}
+	}
+	return new_pos;
+}
+
+void BoardSpaceStarMove(void)
+{
+	u8 star_total;
+	s16 star_pos;
+	s16 star_next;
+	if(_CheckFlag(FLAG_ID_MAKE(1, 1))) {
+		star_pos = GWSystem.star_pos;
+		GWSystem.star_flag |= (u8)(1 << star_pos);
+		if(GWSystem.star_flag == 0xFF) {
+			GWSystem.star_flag = 0;
+		}
+		if(GWSystem.star_total >= 99) {
+			star_total = 99;
+			GWSystem.star_total = star_total;
+		} else {
+			star_total = GWSystem.star_total++;
+		}
+	}
+	star_next = BoardSpaceStarGetNext();
+	BoardSpaceStarSetIndex(star_next);
+}
+
+s32 BoardSpaceStarGet(s32 index)
+{
+	return boardSpaceStarTbl[index & 0x7];
+}
+
+s32 BoardSpaceStarGetCurr(void)
+{
+	return BoardSpaceStarGet(GWSystem.star_pos);
+}
+
+s32 BoardSpaceStarCheck(s32 index)
+{
+	s32 ret;
+	BoardSpace *space = BoardSpaceGet(0, index);
+	BoardSpace *star_space;
+	if(BoardCurrGet() == 7 || BoardCurrGet() == 8) {
+		ret = 0;
+		goto end;
+	}
+	star_space = BoardSpaceGet(0, boardSpaceStarTbl[GWSystem.star_pos]);
+	if(space == star_space) {
+		ret = 1;
+	} else {
+		ret = 0;
+	}
+	end:
+	return ret;
+}
+
+void BoardSpaceLandExec(s32 player, s32 space)
+{
+	BoardSpace *space_ptr = BoardSpaceGet(0, space);
+	switch(space_ptr->type) {
+		case 1:
+			GWPlayer[player].blue_count++;
+			if(GWPlayer[player].blue_count > 99) {
+				GWPlayer[player].blue_count = 99;
+			}
+			BoardLandBlueExec(player, space);
+			break;
+			
+		case 2:
+			GWPlayer[player].red_count++;
+			if(GWPlayer[player].red_count > 99) {
+				GWPlayer[player].red_count = 99;
+			}
+			BoardLandRedExec(player, space);
+			break;
+			
+		case 3:
+			GWPlayer[player].bowser_count++;
+			if(GWPlayer[player].bowser_count > 99) {
+				GWPlayer[player].bowser_count = 99;
+			}
+			BoardBowserExec(player, space);
+			break;
+			
+		case 4:
+			GWPlayer[player].mushroom_count++;
+			if(GWPlayer[player].mushroom_count > 99) {
+				GWPlayer[player].mushroom_count = 99;
+			}
+			BoardMushroomExec(player, space);
+			break;
+			
+		case 5:
+			GWPlayer[player].battle_count++;
+			if(GWPlayer[player].battle_count > 99) {
+				GWPlayer[player].battle_count = 99;
+			}
+			BoardBattleExec(player, space);
+			break;
+			
+		case 6:
+			GWPlayer[player].question_count++;
+			if(GWPlayer[player].question_count > 99) {
+				GWPlayer[player].question_count = 99;
+			}
+			if(_CheckFlag(FLAG_ID_MAKE(1, 11))) {
+				HuAudFXPlay(842);
+				BoardCameraViewSet(2);
+				BoardPlayerAnimBlendSet(player, 0, 15);
+				while(!BoardPlayerAnimBlendCheck(player)) {
+					HuPrcVSleep();
+				}
+				BoardCameraMotionWait();
+				BoardTutorialHookExec(16, 0);
+			} else {
+				if(landEventFunc) {
+					HuAudFXPlay(842);
+					omVibrate(player, 12, 4, 2);
+					landEventFunc();
+				}
+			}
+			GWPlayer[player].color = 3;
+			break;
+			
+		case 7:
+			GWPlayer[player].fortune_count++;
+			if(GWPlayer[player].fortune_count > 99) {
+				GWPlayer[player].fortune_count = 99;
+			}
+			BoardFortuneExec(player, space);
+			break;
+			
+		case 9:
+			GWPlayer[player].warp_count++;
+			if(GWPlayer[player].warp_count > 99) {
+				GWPlayer[player].warp_count = 99;
+			}
+			BoardWarpExec(player, space);
+			break;
+			
+		case 8:
+			BoardStarExec(player, space);
+			break;
+	}
+}

src/game/board/warp.c

@@ -1,4 +1,18 @@
 #include "game/board/warp.h"
+#include "game/board/main.h"
+#include "game/board/player.h"
+#include "game/wipe.h"
+#include "game/gamework_data.h"
+#include "board_unsplit.h"
+#include "unsplit.h"
+#include "math.h"
+
+static void WarpInit(s32);
+static void WarpLaunch(s32);
+static void WarpStartImpact(s32);
+static void WarpFall(s32);
+static void WarpImpact(s32);
+
 
 extern void omVibrate(s16, s16, s16, s16);
 extern void fn_800816CC(s32, s32);
@@ -12,102 +26,94 @@ extern void BoardPlayerPosSet(s32, f32, f32, f32);
 extern void BoardPlayerRotYSet(s32, f32);
 extern void Hu3DModelObjPosGet(s16, char*, Vec*);
 extern s32 BoardModelMotionEndCheck(s16);
-extern void BoardPlayerPosSetV(s32, Point3d*);
-void BoardPlayerRotSet(s32, f32, f32, f32);
-void BoardCameraMoveSet(s32);
-void BoardCameraTargetSpaceSet(s16);
-extern void BoardRotateDiceNumbers(s32);
-extern void BoardPlayerPosGet(s32, Vec*);
-void BoardPlayerMotionStart(s16, s32, s32);
 
-extern Process* boardMainProc;
 extern s32 boardTutorialData[4];
-extern s16 boardPlayerMdl[4];
 
-Vec lbl_801A4AC0;
+static Vec warpPos;
 
-s8 lbl_801D4038;
+static s8 warpState;
-s8 lbl_801D4037;
+static s8 warpTarget;
-s8 lbl_801D4036;
+static s8 warpImpactCnt;
-s16 lbl_801D4034;
+static s16 warpSpace;
-f32 lbl_801D4030;
+static f32 warpYFloor;
-f32 lbl_801D402C;
+static f32 warpYVel;
-Process* lbl_801D4028;
+static Process* warpProcess;
 
-s16 lbl_801D3748 = 0xFFFF;
+static s16 warpSpringMdl = -1;
-s16 lbl_801D374A = 0xFFFF;
+static s16 warpImpactMdl = -1;
-s8 lbl_801D374C[4] = {-1, -1, -1, -1};
+static s8 warpImpactPlayer[4] = {-1, -1, -1, -1};
-char lbl_801D3750[] = "warp01";
 
-void fn_80080D54(s32 arg0) {
+static void WarpProcess(void);
-    omVibrate(arg0, 0xC, 4, 2);
+static void WarpKill(void);
-    lbl_801D4028 = HuPrcChildCreate(fn_80080DF8, 0x2003U, 0x3800U, 0, boardMainProc);
-    HuPrcDestructorSet2(lbl_801D4028, fn_80081048);
 
-    while (lbl_801D4028 != NULL) {
+void BoardWarpExec(s32 player, s16 space) {
+    omVibrate(player, 12, 4, 2);
+    warpProcess = HuPrcChildCreate(WarpProcess, 8195, 14336, 0, boardMainProc);
+    HuPrcDestructorSet2(warpProcess, WarpKill);
+
+    while (warpProcess != NULL) {
         HuPrcVSleep();
     }
-    GWPlayer[arg0].color = 3;
+    GWPlayer[player].color = 3;
 }
 
-void fn_80080DF8(void) {
+void WarpProcess(void) {
-    s32 currPlayer;
+    s32 curr_player;
-    f32 var_f1;
+    s32 warp_sound[8] = {291, 355, 419, 483, 547, 611, 675, 739};
-    s32 temp_r3[8] = {291, 355, 419, 483, 547, 611, 675, 739};
     
-    lbl_801D4038 = 0;
+    warpState = 0;
-    currPlayer = GWSystem.player_curr;
+    curr_player = GWSystem.player_curr;
-    HuAudFXPlay(0x34A);
+    HuAudFXPlay(842);
     BoardCameraViewSet(3);
     BoardCameraMotionWait();
-    BoardPlayerAnimBlendSet(currPlayer, 0, 15);
+    BoardPlayerAnimBlendSet(curr_player, 0, 15);
 
-    while (BoardPlayerAnimBlendCheck(currPlayer) == 0) {
+    while (BoardPlayerAnimBlendCheck(curr_player) == 0) {
         HuPrcVSleep();
     }
     
-    BoardRotateDiceNumbers(currPlayer);
+    BoardRotateDiceNumbers(curr_player);
     if (_CheckFlag(0x1000B) != 0) {
-        BoardTutorialHookExec(0x12, 0);
+        BoardTutorialHookExec(18, 0);
         boardTutorialData[0] = 0;
     }
-    fn_800816CC(currPlayer, 3);
+    fn_800816CC(curr_player, 3);
     fn_80081884(18.0f);
     fn_8008181C();
-    lbl_801D4037 = fn_8008186C();
+    warpTarget = fn_8008186C();
     BoardCameraViewSet(1);
     BoardCameraMotionWait();
-    fn_800810A4(currPlayer);
+    WarpInit(curr_player);
 
     while (1) {
-        switch (lbl_801D4038) {
+        switch (warpState) {
             case 0:
-                if (BoardModelMotionTimeGet(lbl_801D3748) < 15.0f) {
+                if (BoardModelMotionTimeGet(warpSpringMdl) < 15.0f) {
                     break;
                 }
-                BoardModelHookReset(lbl_801D3748);
+                BoardModelHookReset(warpSpringMdl);
-                Hu3DModelObjPosGet(BoardModelIDGet(lbl_801D3748), lbl_801D3750, &lbl_801A4AC0);
+                Hu3DModelObjPosGet(BoardModelIDGet(warpSpringMdl), "warp01", &warpPos);
-                BoardSpacePosGet(0, GWPlayer[currPlayer].space_curr, &lbl_801A4AC0);
+                BoardSpacePosGet(0, GWPlayer[curr_player].space_curr, &warpPos);
-                lbl_801A4AC0.y += 700.0f;
+                warpPos.y += 700.0f;
-                BoardPlayerPosSetV(currPlayer, &lbl_801A4AC0);
+                BoardPlayerPosSetV(curr_player, &warpPos);
-                lbl_801D4038 = 1;
+                warpState = 1;
-                HuAudFXPlay(temp_r3[GWPlayer[currPlayer].character]);
+                HuAudFXPlay(warp_sound[GWPlayer[curr_player].character]);
                 break;
             case 1:
-                fn_800811BC(currPlayer);
+                WarpLaunch(curr_player);
                 break;
             case 2:
-                if (BoardModelMotionEndCheck(lbl_801D3748) == 0) break;
+                if (BoardModelMotionEndCheck(warpSpringMdl) == 0) break;
-                lbl_801D4038 = 6;
+                warpState = 6;
                 break;
             case 3:
-                fn_80081278(currPlayer);
+                WarpStartImpact(curr_player);
                 break;
             case 4:
-                fn_80081428(currPlayer);
+                WarpFall(curr_player);
                 break;
             case 5:
-                fn_800814CC(currPlayer);
+                WarpImpact(curr_player);
                 break;
             case 6:
                 HuPrcEnd();
@@ -117,147 +123,135 @@ void fn_80080DF8(void) {
     }
 }
 
-void fn_80081048(void) {
+void WarpKill(void) {
-    if (lbl_801D3748 != -1) {
+    if (warpSpringMdl != -1) {
-        BoardModelKill(lbl_801D3748);
+        BoardModelKill(warpSpringMdl);
-        lbl_801D3748 = -1;
+        warpSpringMdl = -1;
     }
-    if (lbl_801D374A != -1) {
+    if (warpImpactMdl != -1) {
-        BoardModelKill(lbl_801D374A);
+        BoardModelKill(warpImpactMdl);
-        lbl_801D374A = -1;
+        warpImpactMdl = -1;
     }
-    lbl_801D4028 = NULL;
+    warpProcess = NULL;
 }
 
-static inline PlayerState* GetPlayer(s32 index) {
+static void WarpInit(s32 player) {
-    return &GWPlayer[index];
+    Vec pos;
+    s16 player_mdl = BoardPlayerModelGet(player);
+
+    warpSpringMdl = BoardModelCreate(MAKE_DATA_NUM(DATADIR_BOARD, 1), NULL, 0);
+    BoardSpacePosGet(0, GWPlayer[player].space_curr, &pos);
+    warpYFloor = 1500.0f + pos.y;
+    BoardModelLayerSet(warpSpringMdl, 2);
+    BoardCameraTargetModelSet(warpSpringMdl);
+    BoardModelMotionStart(warpSpringMdl, 0, 0);
+    BoardModelHookSet(warpSpringMdl, "warp01", player_mdl);
+    BoardModelPosSetV(warpSpringMdl, &pos);
+    HuAudFXPlay(835);
+    BoardPlayerRotYSet(player, 0.0f);
+    BoardPlayerPosSet(player, 0.0f, 0.0f, 0.0f);
+    BoardRotateDiceNumbers(player);
 }
 
-static inline s16 GetBoardPlayer(s32 index) {
+static void WarpLaunch(s32 player) {
-    PlayerState *player = GetPlayer(index);
-    return boardPlayerMdl[player->player_idx];
-}
 
-void fn_800810A4(s32 arg0) {
+    warpPos.y += 20.0f;
-    Point3d sp8;
+    BoardPlayerPosSetV(player, &warpPos);
-    s16 temp_r30 = GetBoardPlayer(arg0);
+    if (!(warpPos.y < warpYFloor)) {
-
-    lbl_801D3748 = BoardModelCreate(0x70001, NULL, 0);
-    BoardSpacePosGet(0, GWPlayer[arg0].space_curr, &sp8);
-    lbl_801D4030 = 1500.0f + sp8.y;
-    BoardModelLayerSet(lbl_801D3748, 2);
-    BoardCameraTargetModelSet(lbl_801D3748);
-    BoardModelMotionStart(lbl_801D3748, 0, 0);
-    BoardModelHookSet(lbl_801D3748, lbl_801D3750, temp_r30);
-    BoardModelPosSetV(lbl_801D3748, &sp8);
-    HuAudFXPlay(0x343);
-    BoardPlayerRotYSet(arg0, 0.0f);
-    BoardPlayerPosSet(arg0, 0.0f, 0.0f, 0.0f);
-    BoardRotateDiceNumbers(arg0);
-}
-
-void fn_800811BC(s32 arg0) {
-    f32 temp_f1;
-
-    lbl_801A4AC0.y += 20.0f;
-    BoardPlayerPosSetV(arg0, &lbl_801A4AC0);
-    if (!(lbl_801A4AC0.y < lbl_801D4030)) {
         WipeColorSet(0U, 0U, 0U);
-        WipeCreate(2, 0, 0x15);
+        WipeCreate(2, 0, 21);
         
         while (WipeStatGet() != 0) {
             HuPrcVSleep();
         }
-        lbl_801A4AC0.y = lbl_801D4030;
+        warpPos.y = warpYFloor;
-        BoardModelVisibilitySet(lbl_801D3748, 0);
+        BoardModelVisibilitySet(warpSpringMdl, 0);
-        lbl_801D4038 = 3;
+        warpState = 3;
     }
 }
 
-void fn_80081278(s32 arg0) {
+static void WarpStartImpact(s32 player) {
-    f32 temp_f1;
+    s32 i;
-    s32 var_r31;
 
-    lbl_801D4034 = GWPlayer[lbl_801D4037].space_curr;
+    warpSpace = GWPlayer[warpTarget].space_curr;
-    GWPlayer[arg0].space_curr = lbl_801D4034;
+    GWPlayer[player].space_curr = warpSpace;
-    BoardSpacePosGet(0, lbl_801D4034, &lbl_801A4AC0);
+    BoardSpacePosGet(0, warpSpace, &warpPos);
-    lbl_801D4030 = lbl_801A4AC0.y;
+    warpYFloor = warpPos.y;
-    lbl_801A4AC0.y += 1500.0f;
+    warpPos.y += 1500.0f;
-    BoardPlayerPosSetV(arg0, &lbl_801A4AC0);
+    BoardPlayerPosSetV(player, &warpPos);
-    BoardPlayerRotSet(arg0, 180.0f, 180.0f, 0.0f);
+    BoardPlayerRotSet(player, 180.0f, 180.0f, 0.0f);
     
-    for (var_r31 = 0, lbl_801D4036 = var_r31; var_r31 < 4; var_r31++) {
+    for (i = 0, warpImpactCnt = i; i < 4; i++) {
-        if (lbl_801D4034 == GWPlayer[var_r31].space_curr) {
+        if (warpSpace == GWPlayer[i].space_curr) {
-            lbl_801D374C[lbl_801D4036] = var_r31;
+            warpImpactPlayer[warpImpactCnt] = i;
-            lbl_801D4036++;
+            warpImpactCnt++;
         }
     }
-    lbl_801D374A = BoardModelCreate(0x70002, NULL, 0);
+    warpImpactMdl = BoardModelCreate(MAKE_DATA_NUM(DATADIR_BOARD, 2), NULL, 0);
-    BoardModelVisibilitySet(lbl_801D374A, 0);
+    BoardModelVisibilitySet(warpImpactMdl, 0);
-    BoardModelMotionSpeedSet(lbl_801D374A, 0.0f);
+    BoardModelMotionSpeedSet(warpImpactMdl, 0.0f);
     BoardCameraMoveSet(0);
-    BoardCameraTargetSpaceSet(lbl_801D4034);
+    BoardCameraTargetSpaceSet(warpSpace);
     HuPrcSleep(1);
     WipeCreate(1, 0, 0x15);
     while (WipeStatGet() != 0) {
         HuPrcVSleep();
     }
     BoardCameraMoveSet(1);
-    lbl_801D402C = -10.0f;
+    warpYVel = -10.0f;
-    lbl_801D4038 = 4;
+    warpState = 4;
 }
 
-void fn_80081428(s32 arg0) {
+static void WarpFall(s32 player) {
-    lbl_801D402C += -2.0f;
+    warpYVel += -2.0f;
-    lbl_801A4AC0.y += lbl_801D402C;
+    warpPos.y += warpYVel;
-    if (lbl_801A4AC0.y <= (150.0f + lbl_801D4030)) {
+    if (warpPos.y <= (150.0f + warpYFloor)) {
-        lbl_801A4AC0.y = lbl_801D4030;
+        warpPos.y = warpYFloor;
-        lbl_801D4038 = 5;
+        warpState = 5;
-        HuAudFXPlay(0x345);
+        HuAudFXPlay(837);
-        HuAudFXPlay(0x33D);
+        HuAudFXPlay(829);
     }
-    BoardPlayerPosSetV(arg0, &lbl_801A4AC0);
+    BoardPlayerPosSetV(player, &warpPos);
 }
 
-void fn_800814CC(s32 arg0) {
+static void WarpImpact(s32 player) {
-    Vec sp18;
+    Vec pos;
-    Point3d spC;
+    Vec pos_player;
-    s16 sp8;
+    s16 temp;
-    f32 temp_f29;
+    f32 speed;
     f32 temp_f30;
-    f32 var_f31;
+    f32 angle;
-    s16 var_r31;
+    s16 i;
-    s32 temp_r30;
 
-    sp18.x = 288.0f;
+    pos.x = 288.0f;
-    sp18.y = 240.0f;
+    pos.y = 240.0f;
-    sp18.z = 700.0f;
+    pos.z = 700.0f;
-    Hu3D2Dto3D(&sp18, 1, &sp18);
+    Hu3D2Dto3D(&pos, 1, &pos);
-    BoardModelPosSetV(lbl_801D374A, &sp18);
+    BoardModelPosSetV(warpImpactMdl, &pos);
-    BoardModelVisibilitySet(lbl_801D374A, 1);
+    BoardModelVisibilitySet(warpImpactMdl, 1);
-    BoardModelMotionStart(lbl_801D374A, 0, 0x40000001);
+    BoardModelMotionStart(warpImpactMdl, 0, 0x40000001);
     
-    for (var_r31 = 0; var_r31 < lbl_801D4036; var_r31++) {
+    for (i = 0; i < warpImpactCnt; i++) {
-        temp_r30 = lbl_801D374C[var_r31];
+        s32 player = warpImpactPlayer[i];
-        omVibrate(temp_r30, 0xC, 4, 2);
+        omVibrate(player, 0xC, 4, 2);
-        BoardPlayerMotionStart(temp_r30, 6, 0x40000001);
+        BoardPlayerMotionStart(player, 6, 0x40000001);
     }
-    BoardPlayerRotSet(arg0, 0.0f, 0.0f, 0.0f);
+    BoardPlayerRotSet(player, 0.0f, 0.0f, 0.0f);
-    BoardPlayerPosGet(arg0, &spC);
+    BoardPlayerPosGet(player, &pos_player);
-    spC.y = lbl_801D4030;
+    pos_player.y = warpYFloor;
-    BoardPlayerPosSetV(arg0, &spC);
+    BoardPlayerPosSetV(player, &pos_player);
-    temp_f29 = 4.0f;
+    speed = 4.0f;
     
-    for (var_f31 = 0.0f, sp8 = var_f31; var_f31 < 180.0f; var_f31 += temp_f29) {
+    for (angle = 0.0f, temp = angle; angle < 180.0f; angle += speed) {
-        temp_f30 = sin((M_PI * var_f31) / 180.0);
+        temp_f30 = sin((M_PI * angle) / 180.0);
-        BoardModelScaleSet(lbl_801D374A, 0.5f + temp_f30, 0.5f + temp_f30, 0.5f + temp_f30);
+        BoardModelScaleSet(warpImpactMdl, 0.5f + temp_f30, 0.5f + temp_f30, 0.5f + temp_f30);
         HuPrcVSleep();
     }
-    BoardModelVisibilitySet(lbl_801D374A, 0);
+    BoardModelVisibilitySet(warpImpactMdl, 0);
-    HuPrcSleep(0x3C);
+    HuPrcSleep(60);
     
-    for (var_r31 = 0; var_r31 < lbl_801D4036; var_r31++) {
+    for (i = 0; i < warpImpactCnt; i++) {
-        BoardRotateDiceNumbers(lbl_801D374C[var_r31]);
+        BoardRotateDiceNumbers(warpImpactPlayer[i]);
     }
-    lbl_801D4038 = 6;
+    warpState = 6;
 }

src/game/board/window.c

@@ -1,7 +1,7 @@
 #include "game/board/window.h"
-
+#include "game/board/main.h"
-extern s32 BoardPlayerIsAllCom(void);
+#include "game/board/player.h"
-extern Process* boardMainProc;
+#include "game/gamework_data.h"
 
 static s8 winChoice;
 static s8 autoPickF;

src/game/data.c

@@ -1,4 +1,3 @@
-#include "common.h"
 #include "game/data.h"
 #include "game/armem.h"
 #include "dolphin/dvd.h"

src/game/decode.c

@@ -1,4 +1,3 @@
-#include "common.h"
 #include "game/data.h"
 #include "dolphin/os.h"
 

src/game/dvd.c

@@ -1,4 +1,3 @@
-#include "common.h"
 #include "game/dvd.h"
 #include "game/data.h"
 

src/game/flag.c

@@ -1,4 +1,5 @@
-#include "common.h"
+#include "dolphin.h"
+#include "game/gamework_data.h"
 
 static u8 _Sys_Flag[16];
 

src/game/frand.c

@@ -1,4 +1,4 @@
-#include "common.h"
+#include "dolphin.h"
 
 static u32 frand_seed;
 

src/game/gamework.c

@@ -1,6 +1,6 @@
-#include "common.h"
 #include "string.h"
 #include "game/gamework.h"
+#include "game/gamework_data.h"
 #include "game/flag.h"
 
 GameStat GWGameStatDefault;

src/game/init.c

@@ -1,4 +1,3 @@
-#include "common.h"
 #include "game/init.h"
 #include "dolphin/os.h"
 #include "dolphin/gx.h"

src/game/main.c

@@ -1,4 +1,4 @@
-#include "common.h"
+#include "game/gamework_data.h"
 #include "game/dvd.h"
 #include "game/printfunc.h"
 #include "game/object.h"

src/game/malloc.c

@@ -1,4 +1,3 @@
-#include "common.h"
 #include "game/memory.h"
 #include "game/init.h"
 #include "dolphin/os.h"

src/game/memory.c

@@ -1,4 +1,3 @@
-#include "common.h"
 #include "game/memory.h"
 #include "dolphin/os.h"
 

src/game/messdata.c

@@ -1,4 +1,4 @@
-#include "common.h"
+#include "dolphin.h"
 
 static void *MessData_MesDataGet(void *messdata, u32 id)
 {

src/game/objmain.c

@@ -1,4 +1,5 @@
-#include "common.h"
+#include "game/audio.h"
+#include "game/hsfman.h"
 #include "game/printfunc.h"
 #include "game/object.h"
 #include "game/pad.h"

src/game/ovllist.c

@@ -1,4 +1,3 @@
-#include "common.h"
 #include "game/dvd.h"
 #include "game/object.h"
 

src/game/pad.c

@@ -1,4 +1,3 @@
-#include "common.h"
 #include "dolphin.h"
 #include "game/msm.h"
 #include "game/pad.h"

src/game/printfunc.c

@@ -1,4 +1,3 @@
-#include "common.h"
 #include "dolphin.h"
 #include "game/printfunc.h"
 #include "game/init.h"

src/game/process.c

@@ -1,4 +1,3 @@
-#include "common.h"
 #include "game/process.h"
 #include "game/memory.h"
 #include "dolphin/os.h"

src/game/saveload.c

@@ -4,6 +4,7 @@
 #include "game/window.h"
 #include "game/flag.h"
 #include "game/card.h"
+#include "game/gamework_data.h"
 
 #include "string.h"
 

src/game/sprman.c

@@ -1,4 +1,3 @@
-#include "common.h"
 #include "game/sprite.h"
 #include "game/memory.h"
 #include "game/init.h"

src/game/sprput.c

@@ -1,5 +1,5 @@
-#include "common.h"
 #include "game/sprite.h"
+#include "game/hsfman.h"
 #include "game/init.h"
 #include "dolphin/mtx.h"
 #include "dolphin/gx.h"

src/game/window.c

@@ -1,4 +1,4 @@
-#include "common.h"
+#include "game/gamework_data.h"
 
 #include "game/window.h"
 #include "game/sprite.h"