Decompile more of board/main.c

config/GMPE01_00/splits.txt

@@ -347,7 +347,7 @@ game/board/window.c:
 	.sbss       start:0x801D3F68 end:0x801D3F90
 	.sdata2     start:0x801D5318 end:0x801D5328
 
-game/board/speaker.c:
+game/board/audio.c:
 	.text       start:0x80070D84 end:0x80071290
 	.data       start:0x80139AE8 end:0x80139B00
 	.sdata      start:0x801D36E8 end:0x801D36F0

config/GMPE01_00/symbols.txt

@@ -1013,14 +1013,14 @@ BoardPartyConfigSet = .text:0x8005BE30; // type:function size:0x160
 DestroyMainFunc = .text:0x8005BF90; // type:function size:0xC scope:local
 MainFunc = .text:0x8005BF9C; // type:function size:0x7D0 scope:local
 BoardTurnNext = .text:0x8005C76C; // type:function size:0x8C
-BoardTurnStartExec = .text:0x8005C7F8; // type:function size:0x28C
+ExecTurnStart = .text:0x8005C7F8; // type:function size:0x28C scope:local
 BoardNextOvlSet = .text:0x8005CA84; // type:function size:0xC4
 BoardIsStarted = .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
-BoardLightSet = .text:0x8005D118; // type:function size:0x44
+BoardLightSetExec = .text:0x8005D118; // type:function size:0x44
-BoardLightReset = .text:0x8005D15C; // type:function size:0x50
+BoardLightResetExec = .text:0x8005D15C; // type:function size:0x50
 BoardCameraBackup = .text:0x8005D1AC; // type:function size:0x3C
 BoardCameraRestore = .text:0x8005D1E8; // type:function size:0x48
 BoardCameraScissorSet = .text:0x8005D230; // type:function size:0x54
@@ -1031,32 +1031,32 @@ BoardCameraRotGet = .text:0x8005D5C0; // type:function size:0x48
 BoardCameraZoomGet = .text:0x8005D608; // type:function size:0x20
 BoardCameraDirGet = .text:0x8005D628; // type:function size:0xA8
 BoardCameraPointDirGet = .text:0x8005D6D0; // type:function size:0xBC
-BoardCameraSet = .text:0x8005D78C; // type:function size:0x28
+BoardCameraMaskSet = .text:0x8005D78C; // type:function size:0x28
-BoardCameraVisibleSet = .text:0x8005D7B4; // type:function size:0x50
+BoardCameraMoveSet = .text:0x8005D7B4; // type:function size:0x50
 BoardCameraOffsetSet = .text:0x8005D804; // type:function size:0x30
 BoardCameraTargetPlayerSet = .text:0x8005D834; // type:function size:0xB4
 BoardCameraTargetModelSet = .text:0x8005D8E8; // type:function size:0x40
 BoardCameraTargetSpaceSet = .text:0x8005D928; // type:function size:0x44
-BoardCameraVecCalcFuncSet = .text:0x8005D96C; // type:function size:0x28
+BoardCameraPosCalcFuncSet = .text:0x8005D96C; // type:function size:0x28
 BoardCameraQuakeSet = .text:0x8005D994; // type:function size:0x3C
 BoardCameraQuakeReset = .text:0x8005D9D0; // type:function size:0x3C
 BoardCameraTargetSet = .text:0x8005DA0C; // type:function size:0x28
 BoardCameraPosSet = .text:0x8005DA34; // type:function size:0x28
-BoardCameraAngleZoomSet = .text:0x8005DA5C; // type:function size:0x24
+BoardCameraXRotZoomSet = .text:0x8005DA5C; // type:function size:0x24
 BoardCameraZoomSet = .text:0x8005DA80; // type:function size:0x20
-BoardCameraAngleSet = .text:0x8005DAA0; // type:function size:0x24
+BoardCameraRotSet = .text:0x8005DAA0; // type:function size:0x24
 BoardCameraNearFarSet = .text:0x8005DAC4; // type:function size:0x24
 BoardCameraNearFarGet = .text:0x8005DAE8; // type:function size:0x3C
-BoardCameraStartMotion = .text:0x8005DB24; // type:function size:0x48
+BoardCameraMotionStart = .text:0x8005DB24; // type:function size:0x48
-BoardCameraStartMotion2 = .text:0x8005DB6C; // type:function size:0x230
+BoardCameraMotionStartEx = .text:0x8005DB6C; // type:function size:0x230
 BoardCameraFovSet = .text:0x8005DD9C; // type:function size:0x20
 BoardCameraCullCheck = .text:0x8005DDBC; // type:function size:0x2BC
 BoardCameraMotionIsDone = .text:0x8005E078; // type:function size:0x48
 BoardCameraMotionWait = .text:0x8005E0C0; // type:function size:0x58
 BoardCameraInit = .text:0x8005E118; // type:function size:0x24C
-BoardCameraUpdate = .text:0x8005E364; // type:function size:0x350
+UpdateCamera = .text:0x8005E364; // type:function size:0x350 scope:local
-BoardCameraCalcTarget = .text:0x8005E6B4; // type:function size:0xE4
+CalcCameraTarget = .text:0x8005E6B4; // type:function size:0xE4 scope:local
-BoardCameraCalcVec = .text:0x8005E798; // type:function size:0x764
+CalcCameraPos = .text:0x8005E798; // type:function size:0x764 scope:local
 BoardMGDoneFlagSet = .text:0x8005EEFC; // type:function size:0x48
 BoardMGDoneFlagGet = .text:0x8005EF44; // type:function size:0x48
 BoardMGExit = .text:0x8005EF8C; // type:function size:0x170

configure.py

@@ -363,7 +363,7 @@ config.libs = [
             Object(NonMatching, "game/board/player.c"),
             Object(NonMatching, "game/board/model.c"),
             Object(Matching, "game/board/window.c"),
-            Object(NonMatching, "game/board/speaker.c"),
+            Object(NonMatching, "game/board/audio.c"),
             Object(NonMatching, "game/board/com.c"),
             Object(NonMatching, "game/board/overhead.c"),
             Object(NonMatching, "game/board/space.c"),

include/functions.h

@@ -46,7 +46,7 @@ void fn_8004D6F4(s16 arg);
 s32 rand8(void);
 
 void BoardCameraTargetModelSet(s16 model); 
-void BoardCameraStartMotion2(s16, Vec*, s32, f32, f32, s32); 
+void BoardCameraMotionStartEx(s16, Vec*, s32, f32, f32, s32); 
 void BoardCameraMotionWait(void);
 void BoardSpacePosGet(s32, s32, Vec*);
 void fn_8007A360(s32);
@@ -65,7 +65,6 @@ f32 BoardModelRotYGet(s32);
 void BoardModelLayerSet(s16, s32);
 void BoardTutorialHostSet(s16);
 s16 BoardModelIDGet(s16);
-void BoardCommonInit(void*, void*);
 void BoardModelScaleSetV(s32, Vec*);
 void BoardLightHookSet(void*, void*);
 s16 BoardModelCreate(s32, void*, s32);
@@ -89,7 +88,7 @@ void fn_80083EDC(s16);
 void fn_800A4F6C(s16);
 void BoardTutorialHookSet(void*);
 void BoardTutorialBlockSetPos(s32, s32);
-void BoardCameraRotGet(Vec*);
+s32 BoardCameraRotGet(Vec*);
 void BoardModelScaleSet(s16, f32, f32, f32);
 s32 BoardIsKill(void);
 void BoardModelMtxSet(s16, Mtx);

include/game/hsfman.h

@@ -204,7 +204,7 @@ void Hu3DModelReflectTypeSet(s16, s16);
 void Hu3DCameraCreate(s32);
 void Hu3DCameraPerspectiveSet(s32, f32, f32, f32, f32);
 void Hu3DCameraViewportSet(s32, f32, f32, f32, f32, f32, f32);
-void Hu3DCameraScissorSet(s32, s32, s32, s32, s32);
+void Hu3DCameraScissorSet(s32, u32, u32, u32, u32);
 void Hu3DCameraPosSet(s32, f32, f32, f32, f32, f32, f32, f32, f32, f32);
 void Hu3DCameraPosSetV(s32 cam, Vec *pos, Vec *up, Vec *target);
 void Hu3DCameraKill(s32);

include/math.h

@@ -63,10 +63,17 @@ float acosf(float x);
 
 #define abs(x) __abs(x)
 
+extern inline double fabs(double x)
+{
+   return __fabs(x);
+}
+
 _MATH_INLINE float fabsf(float x) { return (float)fabs((double)x); }
 _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 fmodf(float x, float m) { return (float)fmod((double)x, (double)m); }
 
 _MATH_INLINE float floorf(float x) { return floor(x); }

src/REL/w10Dll/scene.c

@@ -185,29 +185,29 @@ void fn_1_13A4(void) {
     temp_r3_2 = BoardSpaceFlagSearch(0, 0x80000);
     BoardSpacePosGet(0, temp_r3_2, &sp14);
     BoardModelPosSetV(lbl_1_bss_0->unk8, &sp14);
-    BoardCameraStartMotion2(lbl_1_bss_0->unk8, &sp8, 0, 3200.0f, -1.0f, 0x1E);
+    BoardCameraMotionStartEx(lbl_1_bss_0->unk8, &sp8, 0, 3200.0f, -1.0f, 0x1E);
     BoardCameraMotionWait();
     fn_1_BA0(0x2E002C);
     fn_8007A360(temp_r3_2);
-    BoardCameraStartMotion2(lbl_1_bss_0->unk8, &sp8, 0, 3200.0f, -1.0f, 0x1E);
+    BoardCameraMotionStartEx(lbl_1_bss_0->unk8, &sp8, 0, 3200.0f, -1.0f, 0x1E);
     BoardCameraMotionWait();
     temp_r3_2 = BoardSpaceFlagSearch(0, 0x10000000);
     BoardSpacePosGet(0, temp_r3_2, &sp14);
     BoardModelPosSetV(lbl_1_bss_0->unk8, &sp14);
-    BoardCameraStartMotion2(lbl_1_bss_0->unk8, &sp8, 0, 3200.0f, -1.0f, 0x1E);
+    BoardCameraMotionStartEx(lbl_1_bss_0->unk8, &sp8, 0, 3200.0f, -1.0f, 0x1E);
     BoardCameraMotionWait();
     fn_1_BA0(0x2E002E);
     fn_8007F894();
-    BoardCameraStartMotion2(lbl_1_bss_0->unk8, &sp8, 0, 3200.0f, -1.0f, 0x1E);
+    BoardCameraMotionStartEx(lbl_1_bss_0->unk8, &sp8, 0, 3200.0f, -1.0f, 0x1E);
     BoardCameraMotionWait();
     temp_r3_2 = BoardSpaceFlagSearch(0, 0x08000000);
     BoardSpacePosGet(0, temp_r3_2, &sp14);
     BoardModelPosSetV(lbl_1_bss_0->unk8, &sp14);
-    BoardCameraStartMotion2(lbl_1_bss_0->unk8, &sp8, 0, 3200.0f, -1.0f, 0x1E);
+    BoardCameraMotionStartEx(lbl_1_bss_0->unk8, &sp8, 0, 3200.0f, -1.0f, 0x1E);
     BoardCameraMotionWait();
     fn_1_BA0(0x2E0030);
     fn_800A6B10();
-    BoardCameraStartMotion2(lbl_1_bss_0->unk8, &sp8, 0, 3200.0f, -1.0f, 0x1E);
+    BoardCameraMotionStartEx(lbl_1_bss_0->unk8, &sp8, 0, 3200.0f, -1.0f, 0x1E);
     BoardCameraMotionWait();
     fn_1_BA0(0x2E0032);
     BoardCameraTargetModelSet(fn_80083F84());

src/game/board/main.c

@@ -4,6 +4,60 @@
 #include "game/flag.h"
 #include "game/data.h"
 #include "game/wipe.h"
+#include "string.h"
+#include "game/hsfman.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;
+	s16 zoom;
+	s16 fov;
+} CameraView;
 
 typedef void (*VoidFunc)(void);
 
@@ -27,20 +81,44 @@ static omObjData *cameraObj;
 Process *boardObjMan;
 Process *boardMainProc;
 
+static BoardCameraData cameraBackup;
+BoardCameraData boardCamera;
+
 static OverlayID nextOvl = OVL_INVALID;
 
+static CameraView camViewTbl[] = {
+	{ 0, 0, 25 },
+	{ -33, 3200, 25 },
+	{ -33, 2100, 25 },
+	{ -33, 1800, 25 },
+	{ -33, 12640, 25 },
+	{ -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 fn_800A4A7C(void);
 extern void fn_800A6EE4(void);
 
 extern s8 boardTutorialF;
+extern s16 boardPlayerMdl[4];
 
 void BoardKill(void);
+void BoardCameraTargetPlayerSet(s32 player);
+void BoardCameraOffsetSet(float x, float y, float z);
+void BoardCameraMoveSet(s32 move);
+void BoardCameraMotionStartEx(s16 model_target, Vec *rot_target, Vec *offset_end, float zoom_target, float fov_target, s16 max_time);
+float BoardRandFloat(void);
 
 static void InitBoardFunc(omObjData *object);
 static void ExecBoardFunc(omObjData *object);
 static void KillBoardFunc(omObjData *object);
+static void UpdateCamera(omObjData *object);
+
+static void CalcCameraTarget(BoardCameraData *camera);
+static void CalcCameraPos(BoardCameraData *camera);
+
 
 static void MainFunc(void);
 static void DestroyMainFunc(void);
@@ -64,6 +142,35 @@ 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];
+}
+
+#define BoardFAbs(value) ((value < 0) ? -(value) : (value))
+
 void BoardCommonInit(VoidFunc create, VoidFunc destroy)
 {
 	omSysPauseEnable(FALSE);
@@ -396,7 +503,7 @@ static void MainFunc(void)
 	} else {
 		fade_enable = 0;
 	}
-	if(BoardIsTurnCont()) {
+	if(ExecTurnStart()) {
 		turn_cont = 1;
 	}
 	if((int)(GWSystem.max_turn-GWSystem.turn) < 5 && GWSystem.player_curr == 0 && !turn_cont) {
@@ -432,9 +539,9 @@ static void MainFunc(void)
 				BoardPlayerTurnExec(i);
 			} else {
 				if(!turn_cont) {
-					BoardCameraVisibleSet(0);
+					BoardCameraMoveSet(0);
 					GWSystem.player_curr = i;
-					BoardCameraTargetModelSet(i);
+					BoardCameraTargetPlayerSet(i);
 					BoardCameraMotionWait();
 					{
 						Vec pos;
@@ -508,7 +615,7 @@ static void MainFunc(void)
 			_SetFlag(FLAG_ID_MAKE(1, 28));
 			_SetFlag(FLAG_ID_MAKE(1, 14));
 			BoardPauseEnableSet(1);
-			_CheckFlag(FLAG_ID_MAKE(1, 9));
+			_ClearFlag(FLAG_ID_MAKE(1, 9));
 			if(_CheckFlag(FLAG_ID_MAKE(2, 0)) || _CheckFlag(FLAG_ID_MAKE(1, 11)) ) {
 				for(i=0; i<4; i++) {
 					GWPlayer[i].color = 0;
@@ -562,6 +669,540 @@ static void DestroyBoard(void)
 	
 }
 
+void BoardCameraBackup(void)
+{
+	cameraUseBackup = TRUE;
+	memcpy(&cameraBackup, &boardCamera, sizeof(BoardCameraData));
+}
+
+void BoardCameraRestore(void)
+{
+	if(cameraUseBackup) {
+		memcpy(&boardCamera, &cameraBackup, sizeof(BoardCameraData));
+		cameraUseBackup = FALSE;
+	}
+}
+
+void BoardCameraScissorSet(s32 x, s32 y, s32 w, s32 h)
+{
+	BoardCameraData *camera = &boardCamera;
+	Hu3DCameraScissorSet(camera->mask, x, y, w, h);
+}
+
+void BoardCameraViewSet(s32 type)
+{
+	BoardCameraData *camera = &boardCamera;
+	BoardFocusData *focus;
+	float size;
+	if(!cameraObj) {
+		return;
+	}
+	focus = &camera->focus;
+	if(type == 0) {
+		focus->view_type = 0;
+		return;
+	}
+	OSs16tof32(&camViewTbl[type].fov, &focus->fov_end);
+	focus->fov_start = camera->fov;
+	OSs16tof32(&camViewTbl[type].zoom, &focus->zoom_end);
+	focus->zoom_start = camera->zoom;
+	OSs16tof32(&camViewTbl[type].x_rot, &focus->rot_end.x);
+	focus->rot_end.y = 0;
+	focus->rot_end.z = 0;
+	focus->rot_start = camera->rot;
+	focus->target_start = camera->target;
+	if(BoardPlayerSizeGet(GWSystem.player_curr) == 2 || GWPlayer[GWSystem.player_curr].bowser_suit) {
+		focus->zoom_end += 400.0f;
+		size = 2.5f;
+	} else {
+		size = 1.0f;
+	}
+	BoardCameraTargetModelSet(BoardPlayerCurrModelGet());
+	BoardPlayerPosGet(GWSystem.player_curr, &focus->target_end);
+	BoardCameraOffsetSet(0.0f, 100.0f*size, 0.0f);
+	focus->target_end.y += 100.0f*size;
+	_SetFlag(FLAG_ID_MAKE(1, 21));
+	focus->view_type = type;
+	focus->time = 0;
+	if(camera->moving) {
+		focus->max_time = 21;
+	} else {
+		focus->max_time = 1;
+	}
+}
+
+s32 BoardCameraPosGet(Vec *dst)
+{
+	BoardCameraData *camera;
+	if(!dst) {
+		return -1;
+	}
+	camera = &boardCamera;
+	*dst = camera->pos;
+	return 0;
+}
+
+s32 BoardCameraTargetGet(Vec *dst)
+{
+	BoardCameraData *camera;
+	if(!dst) {
+		return -1;
+	}
+	camera = &boardCamera;
+	*dst = camera->target;
+	return 0;
+}
+
+s32 BoardCameraRotGet(Vec *dst)
+{
+	BoardCameraData *camera;
+	if(!dst) {
+		return -1;
+	}
+	camera = &boardCamera;
+	*dst = camera->rot;
+	return 0;
+}
+
+float BoardCameraZoomGet()
+{
+	BoardCameraData *camera;
+	camera = &boardCamera;
+	return camera->zoom;
+}
+
+s32 BoardCameraDirGet(Vec *dst)
+{
+	BoardCameraData *camera;
+	if(!dst) {
+		return -1;
+	}
+	camera = &boardCamera;
+	if(!camera) {
+		return -1;
+	}
+	VECSubtract(&camera->target, &camera->pos, dst);
+	if(dst->x != 0 || dst->y != 0 || dst->z != 0) {
+		VECNormalize(dst, dst);
+	}
+	return 0;
+}
+
+s32 BoardCameraPointDirGet(Vec *point, Vec *dst)
+{
+	BoardCameraData *camera;
+	if(!dst || !point) {
+		return -1;
+	}
+	camera = &boardCamera;
+	if(!camera) {
+		return -1;
+	}
+	VECSubtract(point, &camera->pos, dst);
+	if(dst->x != 0 || dst->y != 0 || dst->z != 0) {
+		VECNormalize(dst, dst);
+	}
+	return 0;
+}
+
+void BoardCameraMaskSet(u16 mask)
+{
+	BoardCameraData *camera = &boardCamera;
+	if(!camera) {
+		return;
+	}
+	camera->mask = mask;
+}
+
+void BoardCameraMoveSet(s32 move)
+{
+	BoardCameraData *camera = &boardCamera;
+	if(!camera) {
+		return;
+	}
+	if(!move) {
+		camera->moving = 0;
+	} else {
+		camera->moving = 1;
+	}
+}
+
+void BoardCameraOffsetSet(float x, float y, float z)
+{
+	BoardCameraData *camera = &boardCamera;
+	if(!camera) {
+		return;
+	}
+	camera->offset.x = x;
+	camera->offset.y = y;
+	camera->offset.z = z;
+}
+
+void BoardCameraTargetPlayerSet(s32 player)
+{
+	PlayerState *player_ptr = BoardPlayerGet(player);
+	if(!player_ptr) {
+		BoardCameraTargetModelSet(-1);
+		return;
+	}
+	BoardCameraTargetModelSet(BoardPlayerModelGet(player));
+	BoardCameraOffsetSet(0, 100, 0);
+}
+
+void BoardCameraTargetModelSet(s16 model)
+{
+	BoardCameraData *camera = &boardCamera;
+	if(!camera) {
+		return;
+	}
+	camera->target_mdl = model;
+	camera->target_space = -1;
+	camera->offset.x = camera->offset.y = camera->offset.z = 0;
+}
+
+void BoardCameraTargetSpaceSet(s32 space)
+{
+	BoardCameraData *camera = &boardCamera;
+	if(!camera) {
+		return;
+	}
+	camera->target_mdl = -1;
+	camera->target_space = space;
+	camera->offset.x = camera->offset.y = camera->offset.z = 0;
+}
+
+void BoardCameraPosCalcFuncSet(void (*func)(struct board_camera_data *camera))
+{
+	BoardCameraData *camera = &boardCamera;
+	if(!camera) {
+		return;
+	}
+	camera->pos_calc = func;
+}
+
+void BoardCameraQuakeSet(s32 duration, float strength)
+{
+	BoardCameraData *camera = &boardCamera;
+	if(!camera) {
+		return;
+	}
+	camera->quaking = 1;
+	camera->quake_strength = strength;
+	camera->quake_timer = duration;
+}
+
+void BoardCameraQuakeReset(s32 duration, float strength)
+{
+	BoardCameraData *camera = &boardCamera;
+	camera->quaking = 0;
+	camera->quake_strength = 0;
+	camera->quake_timer = 0;
+}
+
+void BoardCameraTargetSet(float x, float y, float z)
+{
+	BoardCameraData *camera = &boardCamera;
+	camera->target.x = x;
+	camera->target.y = y;
+	camera->target.z = z;
+}
+
+void BoardCameraPosSet(float x, float y, float z)
+{
+	BoardCameraData *camera = &boardCamera;
+	camera->pos.x = x;
+	camera->pos.y = y;
+	camera->pos.z = z;
+}
+
+void BoardCameraXRotZoomSet(float zoom, float x_rot)
+{
+	BoardCameraData *camera = &boardCamera;
+	camera->zoom = zoom;
+	camera->rot.x = x_rot;
+}
+
+void BoardCameraZoomSet(float zoom)
+{
+	BoardCameraData *camera = &boardCamera;
+	camera->zoom = zoom;
+}
+
+void BoardCameraRotSet(float x, float y)
+{
+	BoardCameraData *camera = &boardCamera;
+	camera->rot.x = x;
+	camera->rot.y = y;
+}
+
+void BoardCameraNearFarSet(float near, float far)
+{
+	BoardCameraData *camera = &boardCamera;
+	camera->near = near;
+	camera->far = far;
+}
+
+
+void BoardCameraNearFarGet(float *near, float *far)
+{
+	BoardCameraData *camera = &boardCamera;
+	if(near) {
+		*near = camera->near;
+	}
+	if(far) {
+		*far = camera->far;
+	}
+}
+
+void BoardCameraMotionStart(s16 model_target, Vec *rot_target, float zoom_target, float fov_target)
+{
+	BoardCameraMotionStartEx(model_target, rot_target, 0, zoom_target, fov_target, 21);
+}
+
+void BoardCameraMotionStartEx(s16 model_target, Vec *rot_target, Vec *offset_end, float zoom_target, float fov_target, s16 max_time)
+{
+	BoardCameraData *camera = &boardCamera;
+	BoardFocusData *focus;
+	if(!cameraObj) {
+		return;
+	}
+	focus = &camera->focus;
+	focus->fov_start = camera->fov;
+	focus->zoom_start = camera->zoom;
+	focus->rot_start = camera->rot;
+	focus->target_start = camera->target;
+	if(fov_target == -1) {
+		focus->fov_end = focus->fov_start;
+	} else {
+		focus->fov_end = fov_target;
+	}
+	if(zoom_target == -1) {
+		focus->zoom_end = focus->zoom_start;
+	} else {
+		focus->zoom_end = zoom_target;
+	}
+	if(!rot_target) {
+		focus->rot_end = focus->rot_start;
+	} else {
+		focus->rot_end = *rot_target;
+	}
+	if(model_target == -1) {
+		focus->target_end = focus->target_start;
+	} else {
+		BoardCameraTargetModelSet(model_target);
+		BoardModelPosGet(model_target, &focus->target_end);
+	}
+	if(offset_end) {
+		BoardCameraOffsetSet(offset_end->x, offset_end->y, offset_end->z);
+		VECAdd(offset_end, &focus->target_end, &focus->target_end);
+	}
+	_SetFlag(FLAG_ID_MAKE(1, 21));
+	focus->view_type = 5;
+	focus->time = 0;
+	if(max_time < 0) {
+		max_time = 1;
+	}
+	focus->max_time = max_time;
+}
+
+void BoardCameraFovSet(float fov)
+{
+	BoardCameraData *camera = &boardCamera;
+	camera->fov = fov;
+}
+
+s32 BoardCameraCullCheck(Vec *point, float radius)
+{
+	Vec dir;
+	Vec pos;
+	float dist;
+	float dot;
+	BoardCameraData *camera = &boardCamera;
+	if(!camera->hide_all) {
+		return 0;
+	}
+	BoardCameraDirGet(&dir);
+	VECSubtract(point, &camera->pos, &pos);
+	dist = sqrtf((pos.x*pos.x)+(pos.y*pos.y)+(pos.z*pos.z));
+	if(25000 < dist-(radius*2.0f)) {
+		return 0;
+	}
+	BoardCameraPointDirGet(point, &pos);
+	dot = VECDotProduct(&dir, &pos);
+	if(BoardFAbs(dot) < cos((camera->fov*M_PI)/180)) {
+		return 0;
+	} else {
+		return 1;
+	}
+}
+
+s32 BoardCameraMotionIsDone(void)
+{
+	return (_CheckFlag(FLAG_ID_MAKE(1, 21))) ? 0 : 1;
+}
+
+void BoardCameraMotionWait(void)
+{
+	while(!BoardCameraMotionIsDone()) {
+		HuPrcVSleep();
+	}
+	HuPrcVSleep();
+}
+
+void BoardCameraInit(void)
+{
+	BoardCameraData *camera;
+	cameraUseBackup = FALSE;
+	memset(&cameraBackup, 0, sizeof(BoardCameraData));
+	memset(&boardCamera, 0, sizeof(BoardCameraData));
+	camera = &boardCamera;
+	camera->fov = 25;
+	camera->near = 100;
+	camera->far = 13000;
+	camera->aspect = 1.2;
+	camera->viewport_x = 0;
+	camera->viewport_y = 0;
+	camera->viewport_h = 480;
+	camera->viewport_w = 640;
+	camera->viewport_near = 0;
+	camera->viewport_far = 1;
+	camera->up.y = 1;
+	camera->moving = 0;
+	camera->quaking = 0;
+	camera->quake_timer = 0;
+	camera->pos.x = 0;
+	camera->pos.y = 5000;
+	camera->pos.z = 5000;
+	camera->offset.x = 0;
+	camera->offset.y = 0;
+	camera->offset.z = 0;
+	camera->pos_calc = NULL;
+	BoardSpaceFlagPosGet(0, 0x80000000, &camera->target);
+	camera->rot.x = camViewTbl[1].x_rot;
+	camera->zoom = camViewTbl[1].zoom;
+	camera->hide_all = 1;
+	camera->mask = 1;
+	Hu3DCameraCreate(1);
+	Hu3DCameraScissorSet(1, camera->viewport_x, camera->viewport_y, camera->viewport_w, camera->viewport_h);
+	Hu3DCameraScissorSet(2, 0, 0, 0, 0);
+	Hu3DCameraPerspectiveSet(2, -1, 100, 13000, 1.2);
+	cameraObj = omAddObjEx(boardObjMan, 32258, 0, 0, -1, UpdateCamera);
+}
+
+static void CalcCameraView(void)
+{
+	BoardCameraData *camera = &boardCamera;
+	CalcCameraTarget(camera);
+	CalcCameraPos(camera);
+}
+
+static void UpdateCamera(omObjData *object)
+{
+	BoardCameraData *camera;
+	Vec *target;
+	float x, y, z;
+	if(BoardIsKill()) {
+		omDelObjEx(HuPrcCurrentGet(), object);
+		return;
+	}
+	CalcCameraView();
+	camera = &boardCamera;
+	Hu3DCameraPerspectiveSet(camera->mask, camera->fov, camera->near, camera->far, camera->aspect);
+	Hu3DCameraViewportSet(camera->mask, camera->viewport_x, camera->viewport_y, camera->viewport_w, camera->viewport_h, camera->viewport_near, camera->viewport_far);
+	target = &camera->target;
+	if(camera->pos_calc) {
+		camera->pos_calc(camera);
+	} else {
+		
+		x = camera->rot.x;
+		y = camera->rot.y;
+		camera->pos.x = target->x+(sin((y*M_PI)/180.0)*cos((x*M_PI)/180.0)*camera->zoom);
+		camera->pos.y = target->y+(-sin((x*M_PI)/180.0)*camera->zoom);
+		camera->pos.z = target->z+(cos((y*M_PI)/180.0)*cos((x*M_PI)/180.0)*camera->zoom);
+		camera->up.x = sin((y*M_PI)/180.0)*sin((x*M_PI)/180.0);
+		camera->up.y = cos((x*M_PI)/180.0);
+		camera->up.z = cos((y*M_PI)/180.0)*sin((x*M_PI)/180.0);
+		if(camera->quaking) {
+			x = BoardRandFloat();
+			y = BoardRandFloat();
+			z = BoardRandFloat();
+			camera->pos.x += (x-0.5f)*camera->quake_strength;
+			camera->pos.y += (y-0.5f)*camera->quake_strength;
+			camera->pos.z += (z-0.5f)*camera->quake_strength;
+			if(--camera->quake_timer <= 0) {
+				camera->quaking = 0;
+				camera->quake_timer = 0;
+				camera->quake_strength = 0;
+			}
+		}
+	}
+	Hu3DCameraPosSetV(camera->mask, &camera->pos, &camera->up, target);
+}
+
+static void CalcCameraTarget(BoardCameraData *camera)
+{
+	Vec offset;
+	Vec pos = { 0, 0, 0 };
+	BoardFocusData *focus = &camera->focus;
+	if(camera->target_mdl != -1) {
+		BoardModelPosGet(camera->target_mdl, &pos);
+	} else {
+		if(camera->target_space != -1) {
+			BoardSpacePosGet(0, camera->target_space, &pos);
+		} else {
+			return;
+		}
+	}
+	VECAdd(&camera->offset, &pos, &pos);
+	VECSubtract(&pos, &camera->target, &offset);
+	if(camera->moving) {
+		VECScale(&offset, &offset, 0.2f);
+	}
+	VECAdd(&offset, &camera->target, &camera->target);
+}
+
+static void CalcCameraPos(BoardCameraData *camera)
+{
+	
+}
+
+float BoardArcSin(float value)
+{
+	float result;
+	s32 sign;
+	if(value < 0) {
+		sign = 1;
+		value = BoardFAbs(value);
+	} else {
+		sign = 0;
+	}
+	if(value > 1.0f) {
+		return 0;
+	}
+	if(value <= (float)(M_PI/2)) {
+		result = atanf(value/(float)sqrtf(1-(value*value)));
+	} else {
+		result = 1.0f-atanf((float)sqrtf(1-(value*value))/value);
+	}
+	if(sign) {
+		result = BoardFAbs(result);
+	}
+	return result;
+}
+
+float BoardArcCos(float value)
+{
+	if(BoardFAbs(value) > 1) {
+		return 0;
+	}
+	return 1.0f-BoardArcSin(value);
+}
+
+void BoardRandInit(void)
+{
+	boardRandSeed = OSGetTime();
+}
+
 u32 BoardRand(void)
 {
 	boardRandSeed = (boardRandSeed*0x19660D)+(0x3C6EF35F);

src/game/board/warp.c

@@ -14,7 +14,7 @@ extern void Hu3DModelObjPosGet(s16, char*, Vec*);
 extern s32 BoardModelMotionEndCheck(s16);
 extern void BoardPlayerPosSetV(s32, Point3d*);
 void BoardPlayerRotSet(s32, f32, f32, f32);
-void BoardCameraVisibleSet(s32);
+void BoardCameraMoveSet(s32);
 void BoardCameraTargetSpaceSet(s16);
 extern void BoardRotateDiceNumbers(s32);
 extern void BoardPlayerPosGet(s32, Vec*);
@@ -195,14 +195,14 @@ void fn_80081278(s32 arg0) {
     lbl_801D374A = BoardModelCreate(0x70002, NULL, 0);
     BoardModelVisibilitySet(lbl_801D374A, 0);
     BoardModelMotionSpeedSet(lbl_801D374A, 0.0f);
-    BoardCameraVisibleSet(0);
+    BoardCameraMoveSet(0);
     BoardCameraTargetSpaceSet(lbl_801D4034);
     HuPrcSleep(1);
     WipeCreate(1, 0, 0x15);
     while (WipeStatGet() != 0) {
         HuPrcVSleep();
     }
-    BoardCameraVisibleSet(1);
+    BoardCameraMoveSet(1);
     lbl_801D402C = -10.0f;
     lbl_801D4038 = 4;
 }

src/game/hsfman.c

@@ -1129,7 +1129,7 @@ void Hu3DCameraViewportSet(s32 cam, f32 vx, f32 vy, f32 vw, f32 vh, f32 nz, f32
     }
 }
 
-void Hu3DCameraScissorSet(s32 cam, s32 x, s32 y, s32 w, s32 h) {
+void Hu3DCameraScissorSet(s32 cam, u32 x, u32 y, u32 w, u32 h) {
     s16 mask;
     s16 i;
     CameraData* cam_ptr;