diff --git a/include/game/board/player.h b/include/game/board/player.h
index cce446c9..88ed7be8 100644
--- a/include/game/board/player.h
+++ b/include/game/board/player.h
@@ -10,6 +10,7 @@
 #include "game/object.h"
 #include "game/process.h"
 #include "game/hsfman.h"
+#include "game/hsfmotion.h"
 #include "game/gamework_data.h"
 #include "game/board/main.h"
 #include "game/board/space.h"
@@ -113,17 +114,41 @@ void BoardJunctionMaskSet(s32);
 void BoardJunctionMaskReset(s32);
 void BoardJunctionMaskZero(void);
 void InitJunction(s32, s32, f32);
+static void UpdateJunctionGfx(omObjData*);
+static void StopJunctionPlayer(s32);
+static void RestoreJunction(f32, s32);
+static s32 GetDefaultDirection(f32, f32*, s32);
+static s32 DoDebugMove(s32, s16*);
+static s32 ExecJunction(s32, s16*);
 void BoardPlayerMoveTo(s32, s32);
+void BoardPlayerMoveBetween(s32, s32, s32);
+void BoardPlayerMoveToAsync(s32, s32);
+void BoardPlayerPosLerpStart(s32, Vec*, Vec*, s16);
+static void PlayerPosLerpFunc(omObjData*);
+void BoardPlayerDiceJumpStart(s32);
+s32 BoardPlayerDiceJumpCheck(s32);
+static void DiceJumpFunc(omObjData*);
+void BoardRotateDiceNumbers(s32);
+void BoardPlayerMotBlendSet(s32 arg0, s16 arg1, s16 arg2);
 //...
+void BoardPlayerMotBlendExec(omObjData*);
 s32 BoardPlayerAutoSizeGet(s32);
 void BoardPlayerAutoSizeSet(s32, s32);
 void BoardPlayerCopyMat(s32);
 void BoardBowserSuitKill(s32);
 void SetRollPlayerSize(s32);
 void BoardDiceDigit2DUpdateEnable(s32);
-void BoardRotateDiceNumbers(s32);
 s32 DoSparkSpace(s32, s16*);
 s32 MegaPlayerPassFunc(s32, s16);
 s32 BoardPlayerAnimBlendCheck(s32);
+void BoardBowserSuitMotionSetWait(void);
+void BoardBowserSuitPlayerModelKill(void);
+void BoardDiceDigit2DShowSet(s32);
+s32 DoSparkSpace(s32, s16*);
+s32 MegaPlayerPassFunc(s32, s16);
+s32 BoardPlayerMotBlendCheck(s32);
+void BoardPlayerMoveAwayStartCurr(s16, s32);
+void BoardBowserSuitMotionSetWalk(void);
+s16 BoardBowserSuitModelGet(void);
 
 #endif
diff --git a/src/game/board/player.c b/src/game/board/player.c
index 787f4e85..7ec54c4b 100644
--- a/src/game/board/player.c
+++ b/src/game/board/player.c
@@ -1,5 +1,7 @@
 #include "game/board/player.h"
 
+//// #include "game/objsub.h"
+extern void omVibrate(s16, s16, s16, s16);
 //// #include "game/board/ui.h"
 extern void BoardStatusHammerShowSet(s32, s32);
 extern void BoardYourTurnExec(s32);
@@ -62,32 +64,6 @@ extern s8 boardTutorialDirInputY;
 void BoardViewMapExec(s32);
 ////
 
-static void UpdateJunctionGfx(omObjData*);
-static void StopJunctionPlayer(s32);
-static void RestoreJunction(f32, s32);
-static s32 GetDefaultDirection(f32, f32*, s32);
-static s32 DoDebugMove(s32, s16*);
-static s32 ExecJunction(s32, s16*);
-//...
-s32 BoardPlayerAutoSizeGet(s32);
-void BoardPlayerAutoSizeSet(s32, s32);
-void BoardPlayerCopyMat(s32);
-void BoardBowserSuitKill(s32);
-void SetRollPlayerSize(s32);
-void BoardDiceDigit2DUpdateEnable(s32);
-void BoardPlayerMoveTo(s32, s32);
-void BoardPlayerZoomRestore(s32);
-void BoardRotateDiceNumbers(s32);
-void BoardBowserSuitMotionSetWait(void);
-void BoardBowserSuitPlayerModelKill(void);
-void BoardDiceDigit2DShowSet(s32);
-void BoardPlayerPosLerpStart(s32, Vec*, Vec*, s16);
-void PlayerPosLerpFunc(omObjData*);
-s32 DoSparkSpace(s32, s16*);
-s32 ExecJunction(s32, s16*);
-s32 MegaPlayerPassFunc(s32, s16);
-s32 BoardPlayerMotBlendCheck(s32);
-
 typedef struct bitcopy {
     struct {
         u8 field00_bit0 : 1;
@@ -99,9 +75,31 @@ typedef struct bitcopy {
     u8 unk_01;
     s16 unk_02;
     s16 unk_04;
-    s16 unk_06[6];
+    s16 unk_06[5];
 } bitcopy;
 
+typedef struct bitcopy2 {
+    struct {
+        u8 field00_bit0 : 1;
+        u8 field00_bit1 : 2;
+        u8 field00_bit3 : 1;
+        u8 field00_bit4 : 1;
+        u8 field00_bit5 : 2;
+        u8 field00_bit7 : 1;
+    };
+    s8 unk_01;
+    s16 unk_02;
+    union{
+        s32 unk_04;
+        struct {
+            s16 unk_04h;
+            s16 unk_06h;
+        };
+    };
+    f32 unk_08;
+    f32 unk_0C;
+} bitcopy2;
+
 static HsfMaterial *playerMatCopy[4];
 static s32 (*postTurnHook[4])();
 static s32 (*preTurnHook[4])();
@@ -118,8 +116,8 @@ static s16 suitMdl = -1;
 static s16 suitPlayerMdl = -1;
 static s16 suitCurrMot = -1;
 
-static s32 diceJumpObj[4] = {0, 0, 0, 0};
-static s32 motDoneF[4] = {0, 0, 0, 0};
+static omObjData* diceJumpObj[4] = {0, 0, 0, 0};
+static omObjData* motDoneF[4] = {0, 0, 0, 0};
 static s16 bowserSuitMot[5] = {-1, -1, -1, -1, -1};
 char* lbl_8013993C[] = {
     "eye1",
@@ -231,7 +229,7 @@ void BoardPlayerInit(void) {
     s32 temp_r30;
     s32 var_r31;
 
-    if (BoardIsStarted() == 0) {
+    if (BoardStartCheck() == 0) {
         GWSystem.player_curr = 0;
         temp_r30 = BoardSpaceFlagPosGet(0, 0x80000000, 0);
         
@@ -303,7 +301,7 @@ void BoardPlayerModelInit(void) {
         BoardPlayerCopyMat(var_r31);
         playerMot[var_r31] = 1;
         BoardModelMotionStart(temp_r3, playerMot[var_r31], 0x40000001);
-        if (BoardIsStarted() == 0) {
+        if (BoardStartCheck() == 0) {
             
             for (var_r30 = 0; var_r30 < 3; var_r30++) {
                 temp_r27->items[var_r30] = -1;
@@ -613,11 +611,11 @@ void BoardPlayerMotionTimeSet(s32 arg0, f32 arg8) {
 }
 
 f32 BoardPlayerMotionTimeGet(s32 arg0) {
-    BoardModelMotionTimeGet(BoardPlayerModelGet(arg0));
+    return BoardModelMotionTimeGet(BoardPlayerModelGet(arg0));
 }
 
 f32 BoardPlayerMotionMaxTimeGet(s32 arg0) {
-    BoardModelMotionMaxTimeGet(BoardPlayerModelGet(arg0));
+    return BoardModelMotionMaxTimeGet(BoardPlayerModelGet(arg0));
 }
 
 void BoardPlayerMotionTimeRangeSet(s32 arg0, f32 arg8, f32 arg9) {
@@ -739,7 +737,7 @@ void BoardPlayerPostTurnHookSet(s32 arg0, s32 (*arg1)()) {
 }
 
 void BoardPlayerTurnExec(s32 arg0) {
-    BoardPauseEnableSet(1);
+    BoardPauseDisableSet(1);
     BoardComUseItemSet(arg0, -1);
     GWSystem.field31_bit4 = 0xF;
     _ClearFlag(0x10016);
@@ -778,12 +776,12 @@ void BoardPlayerTurnRollExec(s32 arg0) {
 
     GWPlayer[arg0].roll = 0;
     GWPlayer[arg0].field08_bit7 = 1;
-    BoardPauseEnableSet(0);
+    BoardPauseDisableSet(0);
     do {
         temp_r30 = BoardRollExec(arg0);
         switch (temp_r30) {
         case -2:
-            BoardPauseEnableSet(1);
+            BoardPauseDisableSet(1);
             BoardRollKill();
             BoardCameraTargetPlayerSet(arg0);
             BoardCameraMotionWait();
@@ -795,7 +793,7 @@ void BoardPlayerTurnRollExec(s32 arg0) {
                 BoardCameraViewSet(2);
                 _ClearFlag(0x10016);
             }
-            BoardPauseEnableSet(0);
+            BoardPauseDisableSet(0);
             break;
         case -3:
             BoardRollKill();
@@ -818,7 +816,7 @@ void BoardPlayerTurnMoveExec(s32 arg0) {
     s32 temp_r0;
     s32 temp_r1;
 
-    BoardPauseEnableSet(1);
+    BoardPauseDisableSet(1);
     var_r28 = 0;
     if (_CheckFlag(0x10006U) == 0) {
         BoardCameraMoveSet(1);
@@ -840,7 +838,7 @@ void BoardPlayerTurnMoveExec(s32 arg0) {
         goto block_14;
     }
     do {
-        BoardPauseEnableSet(1);
+        BoardPauseDisableSet(1);
         GWPlayer[arg0].space_prev = GWPlayer[arg0].space_curr;
         if (_CheckFlag(0x20001U) == 0) {
             if (ExecJunction(arg0, &sp8) != 0) {
@@ -853,14 +851,14 @@ void BoardPlayerTurnMoveExec(s32 arg0) {
         GWPlayer[arg0].space_next = sp8;
         StopJunctionPlayer(0);
         if (MegaPlayerPassFunc(arg0, sp8) == 0) {
-            BoardPauseEnableSet(0);
+            BoardPauseDisableSet(0);
             BoardPlayerMoveTo(arg0, sp8);
-            BoardPauseEnableSet(1);
+            BoardPauseDisableSet(1);
         }
         GWPlayer[arg0].space_prev = GWPlayer[arg0].space_curr;
         GWPlayer[arg0].space_curr = sp8;
         if (var_r29 != 0) {
-            BoardPlayerCurrMoveAwayStart(GWPlayer[arg0].space_prev, 0);
+            BoardPlayerMoveAwayStartCurr(GWPlayer[arg0].space_prev, 0);
             var_r29 = 0;
         }
         DoSparkSpace(arg0, 0);
@@ -881,7 +879,7 @@ block_14:
         
         if (--GWPlayer[arg0].roll == 0) break;
     } while (1);
-    BoardPauseEnableSet(1);
+    BoardPauseDisableSet(1);
     BoardDiceDigit2DUpdateEnable(arg0);
     BoardRotateDiceNumbers(arg0);
     if (GWPlayer[arg0].bowser_suit != 0) {
@@ -891,8 +889,8 @@ block_14:
         BoardTutorialHookExec(7, 0);
     }
     if (BoardRollTypeGet() != -1) {
-        fn_8008EEB8(arg0, BoardRollTypeGet());
-        while (fn_8008EE9C() == 0) {
+        BoardItemPlayerRestore(arg0, BoardRollTypeGet());
+        while (BoardItemDoneCheck() == 0) {
             HuPrcVSleep();
         }
         rollType = -1;
@@ -902,7 +900,7 @@ block_14:
     if (_CheckFlag(0x1000BU) != 0) {
         BoardTutorialHookExec(8, 0);
     }
-    BoardSpaceHiddenBlockExec(arg0, sp8);
+    BoardSpaceBlockExec(arg0, sp8);
     BoardSpaceLandExec(arg0, sp8);
     _SetFlag(0x1000E);
     if (GWSystem.field31_bit4 != 1) {
@@ -946,7 +944,7 @@ void BoardPlayerSizeRestore(s32 arg0) {
         BoardPlayerResizeAnimExec(arg0, 0);
         BoardPlayerSizeSet(arg0, 0);
 
-        while (fn_8008EE9C() == 0) {
+        while (BoardItemDoneCheck() == 0) {
             HuPrcVSleep();
         }
     }
@@ -1587,8 +1585,8 @@ void BoardPlayerMoveBetween(s32 arg0, s32 arg1, s32 arg2) {
 }
 
 void BoardPlayerMoveToAsync(s32 arg0, s32 arg1) {
-    Point3d sp18;
-    Point3d spC;
+    Vec sp18;
+    Vec spC;
     s32 sp8;
 
     BoardModelPosGet(BoardPlayerModelGet(arg0), &sp18);
@@ -1596,24 +1594,16 @@ void BoardPlayerMoveToAsync(s32 arg0, s32 arg1) {
     BoardPlayerPosLerpStart(arg0, &sp18, &spC, 0x19);
 }
 
-void BoardPlayerPosLerpStart(s32 arg0, Point3d* arg1, Point3d* arg2, s16 arg3) {
-    Point3d sp18;
-    void* sp14;
-    s16 sp10;
-    s16 spE;
-    s16 spC;
-    s16 spA;
+void BoardPlayerPosLerpStart(s32 arg0, Vec* arg1, Vec* arg2, s16 arg3) {
+    Vec sp18;
     f32 var_f28;
     f32 var_f27;
     f32 var_f26;
     f32 var_f29;
     f32 var_f30;
     omObjData* temp_r3;
-    s16 temp_r0;
-    s16 temp_r0_2;
     s32 var_r25;
     PlayerState* temp_r21;
-    void* temp_r3_2;
 
     if ((arg1->x != arg2->x) || (arg1->y != arg2->y) || (arg1->z != arg2->z)) {
         var_f28 = BoardVecDistXZCalc(arg2, arg1);
@@ -1675,7 +1665,7 @@ void BoardPlayerPosLerpStart(s32 arg0, Point3d* arg1, Point3d* arg2, s16 arg3) {
     }
 }
 
-void PlayerPosLerpFunc(omObjData* arg0) {
+static void PlayerPosLerpFunc(omObjData* arg0) {
     f32 temp_f28;
     f32 temp_f27;
     f32 temp_f26;
@@ -1705,6 +1695,195 @@ void PlayerPosLerpFunc(omObjData* arg0) {
     BoardPlayerPosSet(temp_r30, temp_f31, temp_f30, temp_f29);
 }
 
+void BoardPlayerDiceJumpStart(s32 arg0) {
+    Point3d sp8;
+    PlayerState* temp_r25;
+    bitcopy2* temp_r31;
+    s32 var_r28;
+
+    if (GWPlayer[arg0].bowser_suit != 0) {
+        BoardBowserSuitMotionSetJump();
+    }
+    temp_r25 = BoardPlayerGet(arg0);
+    if (playerMot[temp_r25->player_idx] != 11) {
+        var_r28 = BoardModelMotionStart(BoardPlayerModelGet(arg0), 11, 0);
+        if (var_r28 == 0) {
+            playerMot[temp_r25->player_idx] = 0xB;
+        }
+    }
+    diceJumpObj[arg0] = omAddObjEx(boardObjMan, 0x100, 0, 0, -1, DiceJumpFunc);
+    BoardModelPosGet(BoardPlayerModelGet(arg0), &sp8);
+    temp_r31 = (bitcopy2*) diceJumpObj[arg0]->work;
+    temp_r31->field00_bit0 = 0;
+    temp_r31->field00_bit1 = arg0;
+    temp_r31->unk_04 = 0;
+    temp_r31->field00_bit3 = 0;
+    temp_r31->unk_08 = 0.0f;
+    temp_r31->unk_0C = sp8.y;
+    GWPlayer[arg0].field08_bit3 = 1;
+}
+
+s32 BoardPlayerDiceJumpCheck(s32 arg0) {
+    if (diceJumpObj[arg0] == 0) {
+        return 0;
+    }
+    if (diceJumpObj[arg0]->work[1] == 0) {
+        return 0;
+    }
+    return 1;
+}
+
+static void DiceJumpFunc(omObjData* arg0) {
+    Vec sp38;
+    f32 temp_f31;
+    PlayerState* var_r30;
+    bitcopy2* temp_r31;
+    s16 var_r28;
+    s32 var_r23;
+    s32 var_r17;
+
+    temp_r31 = (bitcopy2*) arg0->work;
+    if ((temp_r31->field00_bit0 != 0) || (BoardIsKill() != 0)) {
+        GWPlayer[temp_r31->field00_bit1].field08_bit3 = 0;
+        BoardRotateDiceNumbers(temp_r31->field00_bit1);
+        diceJumpObj[temp_r31->field00_bit1] = 0;
+        omDelObjEx(HuPrcCurrentGet(), arg0);
+        return;
+    }
+
+    if (BoardPlayerMotionEndCheck(temp_r31->field00_bit1)) {
+        temp_r31->field00_bit0 = 1;
+        return;
+    }
+    var_r28 = BoardModelIDGet(BoardPlayerModelGet(temp_r31->field00_bit1));
+    if (Hu3DMotionShiftIDGet(var_r28) == -1) {
+        temp_f31 = BoardPlayerMotionTimeGet(temp_r31->field00_bit1);
+        if (BoardPlayerSizeGet(temp_r31->field00_bit1) == 1) {
+            BoardPlayerPosGet(temp_r31->field00_bit1, &sp38);
+            sp38.y += 10.0f + (-(49.0f/2400.0f) * temp_r31->unk_08 * temp_r31->unk_08);
+            temp_r31->unk_08 += 1.0f;
+            if (sp38.y < temp_r31->unk_0C) {
+                sp38.y = temp_r31->unk_0C;
+            }
+            BoardPlayerPosSetV(temp_r31->field00_bit1, &sp38);
+        }
+        if (temp_r31->unk_04 != 0) {
+            if (temp_f31 >= 35.0f) {
+                temp_r31->unk_04 = 0;
+                return;
+            }
+        }
+        if (temp_r31->unk_04 == 0) {
+            if (temp_f31 >= 30.0f) {
+                temp_r31->unk_04 = 1;
+                if (temp_r31->field00_bit3 == 0) {
+                    omVibrate(temp_r31->field00_bit1, 0xC, 4, 2);
+                    temp_r31->field00_bit3 = 1;
+                }
+                return;
+            }
+        }
+    }
+}
+
+void BoardRotateDiceNumbers(s32 arg0) {
+    PlayerState* temp_r27;
+    s32 var_r29;
+
+    if (GWPlayer[arg0].bowser_suit != 0) {
+        BoardBowserSuitMotionSetWait();
+        BoardBowserSuitPlayerModelKill();
+    }
+    temp_r27 = BoardPlayerGet(arg0);
+    if (playerMot[temp_r27->player_idx] != 1) {
+        var_r29 = BoardModelMotionShiftSet(BoardPlayerModelGet(arg0), 1, 0.0f, 8.0f, 0x40000001);
+        if (var_r29 == 0) {
+            playerMot[temp_r27->player_idx] = 1;
+        }
+    }
+}
+
+void BoardPlayerMotBlendSet(s32 arg0, s16 arg1, s16 arg2) {
+    s16 sp1C;
+    f32 temp_f25;
+    f32 temp_f26;
+    f32 var_f24;
+    f32 var_f27;
+    f32 var_f22;
+    f32 var_f21;
+    f32 var_f19;
+    omObjData* temp_r3;
+    s32 var_r22;
+    s32 var_r20;
+    s16 var_r19;
+    s16 var_r18;
+    bitcopy2* temp_r26;
+
+    var_r20 = 0;
+    if (motDoneF[arg0] != 0) {
+        temp_r3 = motDoneF[arg0];
+        temp_r26 = (bitcopy2*) temp_r3->work;
+        temp_r26->field00_bit0 = 1;
+        
+        for (var_r19 = 0; var_r19 < 0xB4U; var_r19++) {
+            if (BoardPlayerMotBlendCheck(arg0) != 0)
+                break;
+            HuPrcVSleep();
+        }
+    }
+    if (arg2 > 0) {
+        var_r18 = GWPlayer[arg0].character;
+        temp_r3 = omAddObjEx(boardObjMan, 0x100, 0, 0, -1, &BoardPlayerMotBlendExec);
+        temp_r26 = (bitcopy2*) temp_r3->work;
+        temp_r26->field00_bit0 = 0;
+        temp_r26->unk_02 = arg2;
+        temp_r26->unk_01 = arg0;
+        temp_r26->unk_04h = 0;
+        OSs16tof32(&arg1, &temp_r26->unk_08);
+        temp_r26->unk_08 = BoardDAngleCalc(temp_r26->unk_08);
+        var_f22 = BoardDAngleCalc(BoardPlayerRotYGet(arg0));
+        temp_f25 = BoardDAngleCalc(temp_r26->unk_08 - var_f22);
+        OSf32tos16(&temp_f25, &sp1C);
+        if (sp1C > 0) {
+            var_f24 = 59.0f;
+        } else {
+            var_f24 = 0.0f;
+        }
+        
+        if (abs(sp1C) == 0) {
+            temp_r26->field00_bit0 = 1;
+            return;
+        }
+        if (abs(sp1C) <= 0x5A) {
+            var_r20 = boardMotTbl[var_r18];
+        } else if (abs(sp1C) <= 0xB4) {
+            var_r20 = boardMotRevTbl[var_r18];
+        } else {
+            temp_r26->field00_bit0 = 1;
+            return;
+        }
+        temp_r26->unk_04h = BoardPlayerMotionCreate(arg0, var_r20);
+        OSs16tof32(&arg2, &var_f27);
+        temp_f26 = var_f27 / 59.0f;
+        if (0.0f != temp_f26) {
+            var_f27 = 1.0f / temp_f26;
+        } else {
+            var_f27 = 1.0f;
+        }
+        if (GWPlayer[arg0].bowser_suit != 0) {
+            BoardBowserSuitMotionSetWalk();
+            BoardModelMotionSpeedSet(BoardBowserSuitModelGet(), var_f27 / 2);
+        } else if (var_f21 = 8.0f * temp_f26, abs(sp1C) > 0x2D) {
+            var_r22 = temp_r26->unk_04h;
+            BoardPlayerMotionShiftSet(arg0, var_r22, var_f24, var_f21, 0);
+            BoardPlayerMotionSpeedSet(arg0, var_f27);
+        }
+        OSs16tof32(&arg2, &var_f27);
+        temp_r26->unk_0C = temp_f25 / var_f27;
+        motDoneF[arg0] = temp_r3;
+    }
+}
+
 // ...
 
 void BoardPlayerCopyMat(s32 arg0) {