diff --git a/config/GMPE01_00/symbols.txt b/config/GMPE01_00/symbols.txt
index c1a3fc7e..8a4b938c 100644
--- a/config/GMPE01_00/symbols.txt
+++ b/config/GMPE01_00/symbols.txt
@@ -1339,7 +1339,7 @@ ExecComKey = .text:0x80071410; // type:function size:0xE8 scope:local
 BoardComPreferItemGet = .text:0x800714F8; // type:function size:0x100
 BoardComPreferItemCheck = .text:0x800715F8; // type:function size:0x120
 BoardComItemWeightGet = .text:0x80071718; // type:function size:0x74
-BoardComTutorialItemGet = .text:0x8007178C; // type:function size:0xD0
+BoardComUseItemSlotGet = .text:0x8007178C; // type:function size:0xD0
 BoardComUseItemSet = .text:0x8007185C; // type:function size:0x6C
 BoardComUseItemCheck = .text:0x800718C8; // type:function size:0x68
 ChooseUseItem = .text:0x80071930; // type:function size:0x16C scope:local
@@ -1351,7 +1351,7 @@ CheckSwapUse = .text:0x80072370; // type:function size:0x198 scope:local
 CheckBooUse = .text:0x80072508; // type:function size:0x7C scope:local
 CheckLampUse = .text:0x80072584; // type:function size:0x74 scope:local
 BoardComJunctionInputGet = .text:0x800725F8; // type:function size:0x304
-BoardComBestPlayerFind = .text:0x800728FC; // type:function size:0xA8
+BoardComFarPlayerFind = .text:0x800728FC; // type:function size:0xA8
 BoardViewOverheadExec = .text:0x800729A4; // type:function size:0x134
 BoardViewFocusGetPos = .text:0x80072AD8; // type:function size:0x3C
 BoardViewFocusSet = .text:0x80072B14; // type:function size:0xF0
@@ -1517,7 +1517,7 @@ ShrinkCharWheel = .text:0x80082688; // type:function size:0x10C scope:local
 KillCharWheelSpr = .text:0x80082794; // type:function size:0x38 scope:local
 SetCharWheelChars = .text:0x800827CC; // type:function size:0xBC scope:local
 GetInput = .text:0x80082888; // type:function size:0x224 scope:local
-BoardCharWheelSetTarget = .text:0x80082AAC; // type:function size:0x10
+BoardCharWheelTargetSet = .text:0x80082AAC; // type:function size:0x10
 GetComDelay = .text:0x80082ABC; // type:function size:0x148 scope:local
 GetComInput = .text:0x80082C04; // type:function size:0x8C scope:local
 BoardMushroomExec = .text:0x80082C90; // type:function size:0xA4
@@ -1915,7 +1915,7 @@ BoardLast5Exec = .text:0x800A9708; // type:function size:0x84
 DestroyLast5 = .text:0x800A978C; // type:function size:0x30 scope:local
 ExecLast5 = .text:0x800A97BC; // type:function size:0x1D4 scope:local
 CreateLast5 = .text:0x800A9990; // type:function size:0x184 scope:local
-DestroyLast5 = .text:0x800A9B14; // type:function size:0x48 scope:local
+KillLast5 = .text:0x800A9B14; // type:function size:0x48 scope:local
 InitHost = .text:0x800A9B5C; // type:function size:0x10C scope:local
 KillHost = .text:0x800A9C68; // type:function size:0xA4 scope:local
 Last5Main = .text:0x800A9D0C; // type:function size:0xCC0 scope:local
@@ -1991,12 +1991,12 @@ AddValidLinks = .text:0x800B1CEC; // type:function size:0xD0 scope:local
 CheckPathSpace = .text:0x800B1DBC; // type:function size:0x30 scope:local
 FindValidLink = .text:0x800B1DEC; // type:function size:0xAC scope:local
 CheckEndSpace = .text:0x800B1E98; // type:function size:0xF0 scope:local
-BoardComPathReachCheck = .text:0x800B1F88; // type:function size:0x74C
+BoardComPathShortcutLenGet = .text:0x800B1F88; // type:function size:0x74C
 BoardComPathBestGet = .text:0x800B26D4; // type:function size:0x3E4
 BoardComPathLenGet = .text:0x800B2AB8; // type:function size:0x65C
 CheckPath = .text:0x800B3114; // type:function size:0x488 scope:local
-BoardComPathW20BestGet = .text:0x800B359C; // type:function size:0x45C
-CheckW20Path = .text:0x800B39F8; // type:function size:0x4E0 scope:local
+BoardComPathBestGetFlag = .text:0x800B359C; // type:function size:0x45C
+CheckPathFlag = .text:0x800B39F8; // type:function size:0x4E0 scope:local
 TutorialProcFunc = .text:0x800B3ED8; // type:function size:0x34 scope:local
 BoardTutorialInit = .text:0x800B3F0C; // type:function size:0x80
 BoardTutorialKill = .text:0x800B3F8C; // type:function size:0x4C
@@ -4621,9 +4621,9 @@ lbl_8011DEF0 = .rodata:0x8011DEF0; // type:object size:0x10 data:4byte
 lbl_8011DF00 = .rodata:0x8011DF00; // type:object size:0x90 data:4byte
 lbl_8011DF90 = .rodata:0x8011DF90; // type:object size:0x20 data:4byte
 lbl_8011DFB0 = .rodata:0x8011DFB0; // type:object size:0x20 data:4byte
-lbl_8011DFD0 = .rodata:0x8011DFD0; // type:object size:0x20
-lbl_8011DFF0 = .rodata:0x8011DFF0; // type:object size:0x20
-lbl_8011E010 = .rodata:0x8011E010; // type:object size:0x10
+pickSpr = .rodata:0x8011DFD0; // type:object size:0x20 scope:local
+handMdl = .rodata:0x8011DFF0; // type:object size:0x20 scope:local
+ticketSpr = .rodata:0x8011E010; // type:object size:0x10 scope:local
 lbl_8011E020 = .rodata:0x8011E020; // type:object size:0x20 data:4byte
 lbl_8011E040 = .rodata:0x8011E040; // type:object size:0x24
 lbl_8011E064 = .rodata:0x8011E064; // type:object size:0x4C
@@ -4649,7 +4649,7 @@ lbl_8011E300 = .rodata:0x8011E300; // type:object size:0x24 data:4byte
 lbl_8011E324 = .rodata:0x8011E324; // type:object size:0x20 data:4byte
 lbl_8011E344 = .rodata:0x8011E344; // type:object size:0x2C data:4byte
 lbl_8011E370 = .rodata:0x8011E370; // type:object size:0x10 data:4byte
-lbl_8011E380 = .rodata:0x8011E380; // type:object size:0x28 data:4byte
+lbl_8011E380 = .rodata:0x8011E380; // type:object size:0x24 data:4byte
 lbl_8011E3A8 = .rodata:0x8011E3A8; // type:object size:0x24 data:4byte
 lbl_8011E3D0 = .rodata:0x8011E3D0; // type:object size:0x20 data:4byte
 lbl_8011E3F0 = .rodata:0x8011E3F0; // type:object size:0x20 data:4byte
@@ -5192,7 +5192,7 @@ megaSquishSfxTbl = .data:0x80139A80; // type:object size:0x20 scope:local
 PortraitTbl = .data:0x80139AA0; // type:object size:0x24 scope:local
 StarPortraitTbl = .data:0x80139AC4; // type:object size:0x24 scope:local
 boardMusTbl = .data:0x80139AE8; // type:object size:0x12 scope:local
-comItemWeightTbl = .data:0x80139B00; // type:object size:0x60 scope:local
+comItemPreferTbl = .data:0x80139B00; // type:object size:0x60 scope:local
 comItemUseCheckFuncTbl = .data:0x80139B60; // type:object size:0x38 scope:local
 comJunctionDirTbl = .data:0x80139B98; // type:object size:0x30 scope:local
 overhead2DPos = .data:0x80139BC8; // type:object size:0x28 scope:local
@@ -5289,7 +5289,7 @@ bombFXTbl = .data:0x8013AA78; // type:object size:0x20 scope:local
 battleSprPrioTbl = .data:0x8013AA98; // type:object size:0x16 scope:local
 jumptable_8013AAB0 = .data:0x8013AAB0; // type:object size:0x24 scope:local
 battleChanceTbl = .data:0x8013AAD4; // type:object size:0x3C scope:local
-comFortuneMessTbl = .data:0x8013AB10; // type:object size:0x18 scope:local
+comPrizeMessTbl = .data:0x8013AB10; // type:object size:0x18 scope:local
 booPlayerMotTbl = .data:0x8013AB28; // type:object size:0xC0 scope:local
 booSfxTbl = .data:0x8013ABE8; // type:object size:0x80 scope:local
 hostMess = .data:0x8013AC68; // type:object size:0x18 scope:local
@@ -6417,7 +6417,7 @@ angleVal = .sbss:0x801D3FFC; // type:object size:0x2 scope:local data:2byte
 shopPlayer = .sbss:0x801D3FFE; // type:object size:0x1 scope:local data:byte
 shopMdlPtr = .sbss:0x801D4000; // type:object size:0x4 scope:local data:4byte
 shopMdlIdx = .sbss:0x801D4004; // type:object size:0x4 scope:local
-lotteryProc = .sbss:0x801D4008; // type:object size:0x4 data:4byte
+lotteryProc = .sbss:0x801D4008; // type:object size:0x4 scope:local data:4byte
 comInputDrawP = .sbss:0x801D400C; // type:object size:0x4 scope:local data:4byte
 lotteryTicketPickObj = .sbss:0x801D4010; // type:object size:0x4 scope:local data:4byte
 handUpdateF = .sbss:0x801D4014; // type:object size:0x4 scope:local data:4byte
@@ -6521,7 +6521,7 @@ explodeObj = .sbss:0x801D4180; // type:object size:0x4 scope:local data:4byte
 battleCoinPosF = .sbss:0x801D4184; // type:object size:0x4 scope:local data:float
 battleCoinSpeed = .sbss:0x801D4188; // type:object size:0x4 scope:local data:float
 totalCoinStr = .sbss:0x801D418C; // type:object size:0x8 scope:local
-battleMGIdx = .sbss:0x801D4194; // type:object size:0x1 scope:local data:byte
+battleMGIdx = .sbss:0x801D4194; // type:object size:0x2 scope:local data:byte
 battleCoinIdx = .sbss:0x801D4196; // type:object size:0x1 scope:local data:byte
 currSpace = .sbss:0x801D4198; // type:object size:0x2 scope:local data:2byte
 mgChoice = .sbss:0x801D419A; // type:object size:0x1 scope:local data:byte
@@ -6531,7 +6531,7 @@ fortuneProc = .sbss:0x801D41A0; // type:object size:0x4 scope:local data:4byte
 fortunePlatformObj = .sbss:0x801D41A4; // type:object size:0x4 scope:local data:4byte
 comStar = .sbss:0x801D41A8; // type:object size:0x1 scope:local data:byte
 comCoin = .sbss:0x801D41A9; // type:object size:0x1 scope:local data:byte
-comType = .sbss:0x801D41AA; // type:object size:0x1 scope:local data:byte
+comPrize = .sbss:0x801D41AA; // type:object size:0x1 scope:local data:byte
 comPlayer1 = .sbss:0x801D41AB; // type:object size:0x1 scope:local data:byte
 comPlayer2 = .sbss:0x801D41AC; // type:object size:0x1 scope:local data:byte
 currPlayer = .sbss:0x801D41AD; // type:object size:0x1 scope:local data:byte
diff --git a/configure.py b/configure.py
index 4246d6ed..09847e08 100644
--- a/configure.py
+++ b/configure.py
@@ -387,8 +387,8 @@ config.libs = [
             Object(Matching, "game/board/block.c"),
             Object(Matching, "game/board/item.c"),
             Object(NonMatching, "game/board/bowser.c"),
-            Object(NonMatching, "game/board/battle.c"),
-            Object(NonMatching, "game/board/fortune.c"),
+            Object(Matching, "game/board/battle.c"),
+            Object(Matching, "game/board/fortune.c"),
             Object(Matching, "game/board/boo.c"),
             Object(NonMatching, "game/board/mg_setup.c"),
             Object(NonMatching, "game/board/boo_house.c"),
diff --git a/include/board_unsplit.h b/include/board_unsplit.h
index 2c7dcf01..d3a3e53c 100644
--- a/include/board_unsplit.h
+++ b/include/board_unsplit.h
@@ -16,7 +16,7 @@ s32 BoardSpacePosGet(s32, s32, Vec*);
 void BoardShopTutorialExec(s32);
 void BoardMGSetupTutorialExec(void);
 void BoardBooHouseTutorialExec(void);
-void BoardCharWheelSetTarget(s32);
+void BoardCharWheelTargetSet(s32);
 void BoardSpaceStarSetIndex(s32);
 void BoardLightHookSet(BoardLightHook set, BoardLightHook reset);
 s32 fn_8006DDE8(s16, f32);
@@ -32,7 +32,6 @@ s32 BoardCameraRotGet(Vec*);
 s32 BoardIsKill(void);
 
 void BoardBowserExec(s32 player, s32 space);
-void BoardBattleExec(s32 player, s32 space);
 void BoardFortuneExec(s32 player, s32 space);
 
 #endif
diff --git a/include/game/board/battle.h b/include/game/board/battle.h
new file mode 100755
index 00000000..7434761d
--- /dev/null
+++ b/include/game/board/battle.h
@@ -0,0 +1,8 @@
+#ifndef _BOARD_BATTLE_H
+#define _BOARD_BATTLE_H
+
+#include "dolphin/types.h"
+
+void BoardBattleExec(s32 player, s32 space);
+
+#endif
diff --git a/include/game/board/com.h b/include/game/board/com.h
index a75d35ab..d0db30fa 100755
--- a/include/game/board/com.h
+++ b/include/game/board/com.h
@@ -10,7 +10,7 @@ void BoardComKeySetDown(void);
 s8 BoardComPreferItemGet(s32 arg0, s8 *arg1, s8 arg2);
 s8 BoardComPreferItemCheck(s32 arg0, s8 arg1, s8 arg2, s8 arg3);
 s32 BoardComItemWeightGet(s32 arg0, s32 arg1);
-s32 BoardComTutorialItemGet(s32 arg0);
+s32 BoardComUseItemSlotGet(s32 arg0);
 s32 BoardComUseItemSet(s32 arg0, s32 arg1);
 BOOL BoardComUseItemCheck(s32 arg0);
 s32 BoardComJunctionInputGet(s32 arg0, Vec *arg1, s32 arg2, float *arg3);
diff --git a/include/game/board/com_path.h b/include/game/board/com_path.h
index 2fa6e313..869d3b48 100755
--- a/include/game/board/com_path.h
+++ b/include/game/board/com_path.h
@@ -3,9 +3,9 @@
 
 #include "dolphin/types.h"
 
-s16 BoardComPathReachCheck(s16 arg0, u32 arg1, s32 arg2);
-s16 BoardComPathBestGet(s16 arg0);
-s16 BoardComPathLenGet(s16 arg0, s16 arg1);
-s16 BoardComPathW20BestGet(s16 arg0, u32 arg1, s16 arg2);
+s16 BoardComPathShortcutLenGet(s16 space, u32 type, s32 block_pipe);
+s16 BoardComPathBestGet(s16 space);
+s16 BoardComPathLenGet(s16 space, s16 space_other);
+s16 BoardComPathBestGetFlag(s16 space, u32 flag, s16 len);
 
 #endif
diff --git a/include/game/gamework_data.h b/include/game/gamework_data.h
index 874b1e71..1ab6b00d 100644
--- a/include/game/gamework_data.h
+++ b/include/game/gamework_data.h
@@ -180,14 +180,28 @@ static inline s32 GWMGShowComGet(void)
 
 static inline s32 GWMGListGet(void)
 {
+    if (GWSystem.mg_list == 3) {
+        GWSystem.mg_list = 0;
+    }
     return GWSystem.mg_list;
 }
 
 static inline s32 GWMessSpeedGet(void)
 {
+    if (GWSystem.mess_speed == 3) {
+        GWSystem.mess_speed = 1;
+    }
     return GWSystem.mess_speed;
 }
 
+static inline s32 GWSaveModeGet(void)
+{
+    if (GWSystem.save_mode == 3) {
+        GWSystem.save_mode = 1;
+    }
+    return GWSystem.save_mode;
+}
+
 static inline s32 GWTurnGet(void)
 {
     return GWSystem.turn;
diff --git a/src/REL/w10Dll/main.c b/src/REL/w10Dll/main.c
index c38b242f..00e96288 100644
--- a/src/REL/w10Dll/main.c
+++ b/src/REL/w10Dll/main.c
@@ -5,6 +5,7 @@
 #include "game/board/model.h"
 #include "game/board/star.h"
 #include "game/board/tutorial.h"
+#include "game/board/main.h"
 
 #include "math.h"
 
@@ -78,9 +79,9 @@ void BoardCreate(void) {
     s32 i;
     unkw10Dll* temp_r30;
     s32 temp;
-    s32 temp2;
+    s32 board;
 
-    temp2 = get_current_board();
+    board = BoardCurrGet();
     lbl_1_bss_0 = (W10State *)&GWSystem.board_data;
     lbl_1_bss_0->unk0 = 0;
     lbl_1_bss_0->unk4 = 0;
diff --git a/src/REL/w10Dll/scene.c b/src/REL/w10Dll/scene.c
index 0570fce7..52909d78 100644
--- a/src/REL/w10Dll/scene.c
+++ b/src/REL/w10Dll/scene.c
@@ -113,7 +113,7 @@ void fn_1_1134(void) {
     fn_1_1E3C(7, 0x122, 0x8C);
     fn_1_BA0(0x2E0017);
     fn_1_1FB0();
-    BoardCharWheelSetTarget(1);
+    BoardCharWheelTargetSet(1);
 }
 
 void fn_1_1178(void) {
diff --git a/src/game/board/battle.c b/src/game/board/battle.c
new file mode 100755
index 00000000..3dcddeee
--- /dev/null
+++ b/src/game/board/battle.c
@@ -0,0 +1,832 @@
+#include "game/board/battle.h"
+#include "game/audio.h"
+#include "game/chrman.h"
+#include "game/data.h"
+#include "game/gamework.h"
+#include "game/object.h"
+#include "game/objsub.h"
+#include "game/process.h"
+#include "game/wipe.h"
+#include "game/board/audio.h"
+#include "game/board/main.h"
+#include "game/board/model.h"
+#include "game/board/player.h"
+#include "game/board/tutorial.h"
+#include "game/board/ui.h"
+#include "game/board/window.h"
+
+#define ABS(x) ((x) < 0 ? -(x) : (x))
+
+typedef struct {
+    struct {
+        u8 unk00_field0 : 1;
+        u8 unk00_field1 : 2;
+    };
+    s8 unk01;
+    s16 unk02;
+    s16 unk04[4];
+} ExplodeWork;
+
+typedef struct {
+    struct {
+        u8 unk00_field0 : 1;
+        u8 unk00_field1 : 4;
+        u8 unk00_field2 : 1;
+        u8 unk00_field3 : 1;
+    };
+    u8 unk01;
+    s8 unk02;
+    s8 unk03;
+    s8 unk04;
+    char unk05[3];
+    s16 unk08;
+} BattleWork;
+
+extern s32 BoardMGSetupPlayPush(s32, s16);
+extern void BoardMGSetupPlayPop(s32, s16);
+
+static void DestroyBattle(void);
+static void ExecBattle(void);
+static void TakeCoins(void);
+static void InitExplode(void);
+static s32 CheckExplode(void);
+static void UpdateExplode(omObjData *arg0);
+static void CreateBattleMain(void);
+static void UpdateBattleMain(omObjData *arg0);
+static void DescendBattleBomb(BattleWork *arg0, omObjData *arg1);
+static void EndBattle(BattleWork *arg0, omObjData *arg1);
+static void ShowBattleGame(BattleWork *arg0, omObjData *arg1);
+static void RaiseBattleGame(BattleWork *arg0, omObjData *arg1);
+static void UpdateBattleCoin(BattleWork *arg0, omObjData *arg1);
+static void ShowBattleCoin(BattleWork *arg0, omObjData *arg1);
+static void InitBattleGameSpr(BattleWork *arg0, omObjData *arg1);
+static void HideBattleSpr(void);
+static void VibratePad(BattleWork *arg0, omObjData *arg1);
+static void StopBattleBomb(void);
+static s32 GetBattleBombState(void);
+static void SetBattleBombState(s32 arg0);
+static void SetBattleCoinValue(void);
+
+static s16 battleMGList[8];
+
+static s8 currPlayer;
+static s8 coinTakeMax;
+static u8 mgChoice;
+static s16 currSpace;
+static s8 battleCoinIdx;
+static s8 battleMGIdx[2];
+static char totalCoinStr[8];
+static float battleCoinSpeed;
+static float battleCoinPosF;
+static omObjData *explodeObj;
+static omObjData *battleObj;
+static Process *battleProc;
+
+static const s8 battleCoinTbl[] = {
+    0x05, 0x0A, 0x14, 0x1E, 0x32
+};
+
+static float battleCursorPosTbl[] = {
+    144.0f, 330.0f, 0.0f,
+    432.0f, 330.0f, 0.0f
+};
+
+static s32 bombFXTbl[] = {
+    0x00000123,
+    0x00000163,
+    0x000001A3,
+    0x000001E3,
+    0x00000223,
+    0x00000263,
+    0x000002A3,
+    0x000002E3
+};
+
+static s16 battleSprPrioTbl[] = {
+    1000, 990, 1000, 980,
+     980, 970,  970, 970,
+     970, 970,  970
+};
+
+void BoardBattleExec(s32 player, s32 space) {
+    if (_CheckFlag(0x1000B)) {
+        HuAudFXPlay(0x34A);
+        BoardCameraViewSet(2);
+        BoardPlayerMotBlendSet(player, 0, 0xF);
+        while (!BoardPlayerMotBlendCheck(player)) {
+            HuPrcVSleep();
+        }
+        BoardCameraMotionWait();
+        BoardTutorialHookExec(0xF, 0);
+        GWPlayer[player].color = 3;
+        return;
+    }
+    currPlayer = player;
+    currSpace = space;
+    battleProc = HuPrcChildCreate(ExecBattle, 0x2004, 0x3800, 0, boardMainProc);
+    HuPrcDestructorSet2(battleProc, DestroyBattle);
+    while (battleProc) {
+        HuPrcVSleep();
+    }
+    GWPlayer[player].color = 3;
+}
+
+static void DestroyBattle(void) {
+    HuDataDirClose(0x10000);
+    battleProc = NULL;
+}
+
+static void ExecBattle(void) {
+    s16 temp_r28;
+    s16 var_r26;
+    s32 temp_r22;
+    s32 var_r21;
+    s32 var_r30;
+    s32 var_r31;
+    s32 var_r25;
+    s32 var_r24;
+    s32 var_r23;
+    MgInfo *var_r29;
+    s32 var_r27 = 0;
+    s32 sp8[] = {
+        0x00750000,
+        0x00760000,
+        0x00770000,
+        0x00780000,
+        0x00790000,
+        0x007A0000,
+        0x007B0000,
+        0x007C0000,
+        0x007D0000
+    };
+
+    var_r29 = mgInfoTbl;
+    for (var_r31 = var_r30 = 0; var_r29->ovl != (u16) OVL_INVALID; var_r29++, var_r31++) {
+        if (var_r29->type == 4) {
+            battleMGList[var_r30] = var_r31 + 401;
+            var_r30++;
+        }
+    }
+    for (var_r30 = 0; var_r30 < 2; var_r30++) {
+        while (1) {
+            var_r31 = BoardRandMod(6);
+            temp_r28 = battleMGList[var_r31];
+            if (GWMGListGet() == 2) {
+                if (GWMGCustomGet(temp_r28) == 0) {
+                    continue;
+                }
+            } else {
+                if (GWMGListGet() == 1) {
+                    var_r29 = &mgInfoTbl[temp_r28 - 401];
+                    if (!(var_r29->flag & 1)) {
+                        continue;
+                    }
+                } else if (BoardMGSetupPlayPush(4, temp_r28) != 0) {
+                    continue;
+                }
+            }
+            if (var_r30 == 1 && var_r31 == battleMGIdx[var_r30 - 1]) {
+                continue;
+            }
+            break;
+        }
+        battleMGIdx[var_r30] = var_r31;
+        BoardMGSetupPlayPop(4, temp_r28);
+    }
+    if (_CheckFlag(0x10004)) {
+        BoardStatusItemSet(1);
+        WipeCreate(1, 0, -1);
+        while (WipeStatGet() != 0) {
+            HuPrcVSleep();
+        }
+        _ClearFlag(0x1001C);
+        HuPrcSleep(0x3C);
+        HuPrcEnd();
+    }
+    HuAudFXPlay(0x34A);
+    omVibrate(GWSystem.player_curr, 0xC, 6, 6);
+    BoardAudSeqPause(0, 1, 0x1F4);
+    temp_r22 = BoardDataDirReadAsync(0x10000);
+    BoardCameraViewSet(3);
+    BoardCameraMotionWait();
+    BoardPlayerMotBlendSet(currPlayer, 0, 0xF);
+    while (!BoardPlayerMotBlendCheck(currPlayer)) {
+        HuPrcVSleep();
+    }
+    BoardDataAsyncWait(temp_r22);
+    SetBattleCoinValue();
+    BoardMusStart(1, 4, 0x7F, 0);
+    omVibrate(GWSystem.player_curr, 0xC, 6, 6);
+    InitExplode();
+    while (CheckExplode() == 0) {
+        HuPrcVSleep();
+    }
+    HuPrcSleep(30);
+    CreateBattleMain();
+    while (GetBattleBombState() != 8) {
+        HuPrcVSleep();
+    }
+    var_r26 = 0;
+    for (var_r31 = 0; var_r31 < 4; var_r31++) {
+        if (BoardPlayerCoinsGet(var_r31) >= 10) {
+            var_r26 = 1;
+            break;
+        }
+    }
+    if (var_r26 == 0) {
+        BoardWinCreate(2, 0x20001, 1);
+        BoardWinWait();
+        BoardWinKill();
+        var_r27 = 1;
+    } else {
+        HuAudFXPlay(0x4F);
+        BoardWinCreate(2, 0x20000, 1);
+        BoardWinWait();
+        BoardWinKill();
+        SetBattleBombState(3);
+        while (GetBattleBombState() != 8) {
+            HuPrcVSleep();
+        }
+        SetBattleBombState(4);
+        while (GetBattleBombState() != 8) {
+            HuPrcVSleep();
+        }
+        TakeCoins();
+        if (GWPlayer[currPlayer].com) {
+            if (BoardRandFloat() < 0.5f) {
+                var_r23 = 0;
+            } else {
+                var_r23 = 1;
+            }
+            var_r25 = var_r23;
+            HuPrcSleep(0x3C);
+        } else {
+            var_r25 = -1;
+        }
+        SetBattleBombState(5);
+        BoardPickerCreate(currPlayer, 2, battleCursorPosTbl, var_r25);
+        BoardPickerBackFlagSet(0);
+        while (!BoardPickerDoneCheck()) {
+            HuPrcVSleep();
+        }
+        mgChoice = BoardPickerChoiceGet();
+        SetBattleBombState(6);
+        while (GetBattleBombState() != 8) {
+            HuPrcVSleep();
+        }
+        BoardAudSeqFadeOut(1, 1000);
+        BoardMusVolPanSet(0, 0, 1);
+        BoardAudSeqPause(0, 0, 1);
+        if (var_r27 == 0) {
+            HuDataDirClose(0x70000);
+            HuDataDirClose(0x20000);
+            HuDataDirClose(sp8[GWBoardGet()]);
+            HuPrcSleep(2);
+            temp_r28 = battleMGList[battleMGIdx[mgChoice]];
+            GWMGAvailSet(temp_r28);
+            GWSystem.mg_next = temp_r28 - 401;
+            if (_CheckFlag(0xB)) {
+                var_r24 = 0x140000;
+            } else {
+                var_r24 = mgInfoTbl[temp_r28 - 401].data_dir;
+            }
+            var_r21 = BoardDataDirReadAsync(var_r24);
+        }
+        _SetFlag(0x1000E);
+        WipeColorSet(0xFF, 0xFF, 0xFF);
+        WipeCreate(2, 0, -1);
+        while (WipeStatGet() != 0) {
+            HuPrcVSleep();
+        }
+        HuAudFXAllStop();
+        _SetFlag(0x1001C);
+        HideBattleSpr();
+        for (var_r31 = 0; var_r31 < 4; var_r31++) {
+            BoardPlayerMotionStart(var_r31, 1, 0x40000001);
+        }
+        BoardDataAsyncWait(var_r21);
+        if (var_r27 == 0) {
+            _SetFlag(0x10004);
+            BoardNextOvlSet(OVL_INST);
+            BoardFilterFadeOut(30);
+            StopBattleBomb();
+            HuPrcEnd();
+        }
+    }
+    BoardAudSeqFadeOut(1, 1000);
+    SetBattleBombState(1);
+    while (GetBattleBombState() != 8) {
+        HuPrcVSleep();
+    }
+    StopBattleBomb();
+    for (var_r31 = 0; var_r31 < 4; var_r31++) {
+        BoardRotateDiceNumbers(var_r31);
+        BoardPlayerVoiceEnableSet(var_r31, 6, 1);
+    }
+    BoardAudSeqPause(0, 0, 1000);
+    HuPrcEnd();
+}
+
+static void TakeCoins(void) {
+    u16 var_r30;
+    s32 temp_r26;
+    s32 var_r25;
+    s32 var_r24;
+    s32 var_r29;
+    s32 var_r28;
+    s32 var_r27;
+    s32 i;
+
+    for (var_r30 = i = 0; i < 4; i++) {
+        temp_r26 = BoardPlayerCoinsGet(i);
+        if (temp_r26 >= coinTakeMax) {
+            var_r30 += coinTakeMax;
+        } else {
+            var_r30 += temp_r26;
+        }
+    }
+    if (coinTakeMax >= 50) {
+        var_r27 = 1;
+    } else if (coinTakeMax >= 20) {
+        var_r27 = 3;
+    } else {
+        var_r27 = 6;
+    }
+    for (i = 0; i < 4; i++) {
+        if (BoardPlayerCoinsGet(i) < coinTakeMax) {
+            var_r25 = BoardPlayerCoinsGet(i);
+        } else {
+            var_r25 = coinTakeMax;
+        }
+        GWPlayer[i].coins_battle = var_r25;
+    }
+    for (var_r29 = 0; var_r29 < coinTakeMax; var_r29++) {
+        for (var_r28 = i = 0; i < 4; i++) {
+            BoardPlayerCoinsAdd(i, -1);
+            var_r28 += BoardPlayerCoinsGet(i);
+        }
+        if (var_r28 <= 0) {
+            break;
+        }
+        HuAudFXPlay(0xE);
+        HuPrcSleep(var_r27);
+    }
+    HuAudFXPlay(0xF);
+    sprintf(totalCoinStr, "%d", var_r30);
+    if (var_r30 != coinTakeMax * 4) {
+        var_r24 = 0x20003;
+    } else {
+        var_r24 = 0x20002;
+    }
+    BoardWinCreate(2, var_r24, 1);
+    BoardWinInsertMesSet((u32) totalCoinStr, 0);
+    BoardWinWait();
+    BoardWinKill();
+}
+
+static void InitExplode(void) {
+    Vec sp14;
+    Vec sp8;
+    s32 i;
+    ExplodeWork *temp_r31;
+    float sp20[4][2] = {
+        { -50.0f, -50.0f },
+        {  50.0f, -50.0f },
+        { -50.0f,  50.0f },
+        {  50.0f,  50.0f }
+    };
+
+    BoardPlayerPosGet(currPlayer, &sp14);
+    explodeObj = omAddObjEx(boardObjMan, 0x101, 0, 0, -1, UpdateExplode);
+    temp_r31 = OM_GET_WORK_PTR(explodeObj, ExplodeWork);
+    temp_r31->unk00_field0 = 0;
+    temp_r31->unk00_field1 = 0;
+    temp_r31->unk01 = 0x10;
+    temp_r31->unk02 = BoardModelCreate(0x20026, NULL, 0);
+    BoardModelLayerSet(temp_r31->unk02, 2);
+    explodeObj->trans.x = sp14.x;
+    explodeObj->trans.y = sp14.y - 100.0f;
+    explodeObj->trans.z = sp14.z;
+    BoardModelPosSet(temp_r31->unk02, explodeObj->trans.x, explodeObj->trans.y, explodeObj->trans.z);
+    BoardModelMotionStart(temp_r31->unk02, 0, 0x40000001);
+    for (i = 0; i < 4; i++) {
+        temp_r31->unk04[i] = BoardModelCreate(0x70066, NULL, 0);
+        sp8.x = sp14.x + sp20[i][0];
+        sp8.y = sp14.y;
+        sp8.z = sp14.z + sp20[i][1];
+        BoardModelPosSetV(temp_r31->unk04[i], &sp8);
+        BoardModelLayerSet(temp_r31->unk04[i], 2);
+    }
+    HuAudFXPlay(0x33C);
+}
+
+static s32 CheckExplode(void) {
+    ExplodeWork *temp_r31 = OM_GET_WORK_PTR(explodeObj, ExplodeWork);
+
+    return temp_r31->unk00_field1;
+}
+
+static void UpdateExplode(omObjData *arg0) {
+    Vec sp14;
+    Vec sp8;
+    float temp_f31;
+    ExplodeWork *temp_r30;
+    Mtx sp20;
+    s32 i;
+
+    (void) 1000.0f; // TODO: 1000.0f needs to appear right before 20.0f in sdata2 to match.
+    temp_r30 = OM_GET_WORK_PTR(arg0, ExplodeWork);
+    if (temp_r30->unk00_field0 != 0 || BoardIsKill()) {
+        BoardModelKill(temp_r30->unk02);
+        for (i = 0; i < 4; i++) {
+            BoardModelKill(temp_r30->unk04[i]);
+        }
+        explodeObj = NULL;
+        omDelObjEx(HuPrcCurrentGet(), arg0);
+        return;
+    }
+    switch (temp_r30->unk00_field1) {
+        case 0:
+            if (temp_r30->unk01 == 0) {
+                for (i = 0; i < 4; i++) {
+                    if (currSpace == GWPlayer[i].space_curr) {
+                        temp_f31 = 20.0f * BoardRandFloat();
+                        HuAudFXPlay(bombFXTbl[GWPlayer[i].character]);
+                        BoardPlayerMotionShiftSet(i, 6, temp_f31, 8.0f, 0x40000001);
+                    }
+                }
+                CharModelLayerSetAll(2);
+            }
+            if (temp_r30->unk01-- <= 0) {
+                arg0->trans.y += 50.0f;
+                if (arg0->trans.y >= 800.0f) {
+                    arg0->scale.x = 288.0f;
+                    arg0->scale.y = -128.0f;
+                    arg0->scale.z = 1000.0f;
+                    for (i = 0; i < 4; i++) {
+                        BoardModelVisibilitySet(temp_r30->unk04[i], 0);
+                    }
+                    temp_r30->unk00_field1 = 2;
+                }
+            }
+            break;
+        case 3:
+            BoardModelVisibilitySet(temp_r30->unk02, 0);
+            temp_r30->unk00_field0 = 1;
+            break;
+        case 2:
+            BoardCameraRotGet(&sp8);
+            PSMTXRotRad(sp20, 'x', MTXDegToRad(sp8.x + 10.0f));
+            BoardModelMtxSet(temp_r30->unk02, &sp20);
+            BoardModelRotSet(temp_r30->unk02, 0.0f, 0.0f, 0.0f);
+            sp14.x = arg0->scale.x;
+            sp14.y = arg0->scale.y;
+            sp14.z = arg0->scale.z;
+            Hu3D2Dto3D(&sp14, 1, &sp14);
+            arg0->trans.x = sp14.x;
+            arg0->trans.y = sp14.y;
+            arg0->trans.z = sp14.z;
+            break;
+    }
+    BoardModelPosSet(temp_r30->unk02, arg0->trans.x, arg0->trans.y, arg0->trans.z);
+}
+
+static void CreateBattleMain(void) {
+    s16 sp8;
+    s32 var_r29;
+    s32 i;
+    BattleWork *temp_r31;
+    s32 spC[] = {
+        0x00010000,
+        0x00010001,
+        0x00010002,
+        0x00010003,
+        0x00010003,
+        0x00010004,
+        0x00010005,
+        0x00010006,
+        0x00010007,
+        0x00010008,
+        0x00010009
+    };
+
+    battleObj = omAddObjEx(boardObjMan, 0x101, 0, 0, -1, UpdateBattleMain);
+    temp_r31 = OM_GET_WORK_PTR(battleObj, BattleWork);
+    temp_r31->unk00_field0 = 0;
+    temp_r31->unk00_field2 = 0;
+    temp_r31->unk01 = 0;
+    temp_r31->unk02 = 2;
+    temp_r31->unk03 = 2;
+    temp_r31->unk04 = 0;
+    temp_r31->unk00_field3 = 0;
+    temp_r31->unk00_field1 = 0;
+    battleCoinSpeed = 1.0f;
+    battleCoinPosF = 5.0f * BoardRandFloat();
+    coinTakeMax = 0;
+    temp_r31->unk08 = HuSprGrpCreate(11);
+    for (i = 0; i < 11; i++) {
+        var_r29 = spC[i];
+        BoardSpriteCreate(var_r29, battleSprPrioTbl[i], 0, &sp8);
+        HuSprGrpMemberSet(temp_r31->unk08, i, sp8);
+        HuSprAttrSet(temp_r31->unk08, i, 9);
+        HuSprAttrSet(temp_r31->unk08, i, 4);
+    }
+    HuSprGrpPosSet(temp_r31->unk08, 288.0f, 240.0f);
+    battleObj->trans.x = -308.0f;
+    BoardFilterFadeInit(0x1E, 0xA0);
+}
+
+static void UpdateBattleMain(omObjData *arg0) {
+    BattleWork *temp_r30;
+    ExplodeWork *temp_r29;
+    float var_f31;
+
+    temp_r30 = OM_GET_WORK_PTR(arg0, BattleWork);
+    if (temp_r30->unk00_field0 != 0 || BoardIsKill()) {
+        HuSprGrpKill(temp_r30->unk08);
+        battleObj = NULL;
+        omDelObjEx(HuPrcCurrentGet(), arg0);
+        return;
+    }
+    switch (temp_r30->unk00_field1) {
+        case 0:
+            DescendBattleBomb(temp_r30, arg0);
+            break;
+        case 1:
+            EndBattle(temp_r30, arg0);
+            break;
+        case 2:
+            ShowBattleGame(temp_r30, arg0);
+            break;
+        case 3:
+            RaiseBattleGame(temp_r30, arg0);
+            break;
+        case 4:
+            UpdateBattleCoin(temp_r30, arg0);
+            break;
+        case 5:
+            InitBattleGameSpr(temp_r30, arg0);
+            break;
+        case 6:
+            VibratePad(temp_r30, arg0);
+            break;
+        case 7:
+            ShowBattleCoin(temp_r30, arg0);
+            break;
+        case 8:
+            break;
+    }
+    var_f31 = arg0->trans.x + 240.0f;
+    temp_r29 = OM_GET_WORK_PTR(explodeObj, ExplodeWork);
+    if (temp_r29->unk00_field1 == 2) {
+        explodeObj->scale.x = 288.0f;
+        explodeObj->scale.y = var_f31;
+        explodeObj->scale.z = 1000.0f;
+    }
+    HuSprPosSet(temp_r30->unk08, 0, 0.0f, arg0->trans.y);
+    HuSprScaleSet(temp_r30->unk08, 0, arg0->trans.z, arg0->trans.z);
+}
+
+static void DescendBattleBomb(BattleWork *arg0, omObjData *arg1) {
+    float temp_f31 = -132.0f - arg1->trans.x;
+
+    if (temp_f31 < 0.1f) {
+        arg1->trans.x = -132.0f;
+        arg0->unk00_field1 = 2;
+    } else {
+        arg1->trans.x += 0.3f * temp_f31;
+    }
+}
+
+static void EndBattle(BattleWork *arg0, omObjData *arg1) {
+    float temp_f31 = 548.0f - arg1->trans.x;
+
+    if (temp_f31 < 0.1f) {
+        BoardFilterFadeOut(30);
+        arg0->unk00_field1 = 8;
+    } else {
+        arg1->trans.x += 0.3f * temp_f31;
+    }
+}
+
+static void ShowBattleGame(BattleWork *arg0, omObjData *arg1) {
+    float var_r29;
+
+    if (arg0->unk01 == 0) {
+        if (BoardFilterFadePauseCheck() != 0) {
+            arg0->unk01 = 1;
+            arg1->trans.z = 0.01f;
+            arg1->trans.y = 0.0f;
+            HuSprAttrReset(arg0->unk08, 0, 4);
+            HuSprPosSet(arg0->unk08, 0, 0.0f, 0.0f);
+        } else {
+            return;
+        }
+    }
+    if (arg0->unk01 >= 90) {
+        arg0->unk00_field1 = 8;
+        arg0->unk01 = 90;
+    }
+    OSs8tof32((s8*) &arg0->unk01, &var_r29);
+    arg1->trans.z = sin(var_r29 * M_PI / 180.0);
+    arg0->unk01 += 4;
+}
+
+static void RaiseBattleGame(BattleWork *arg0, omObjData *arg1) {
+    float temp_f31 = -60.0f - arg1->trans.y;
+
+    if (ABS(temp_f31) < 0.1f) {
+        arg1->trans.y = -60.0f;
+        arg0->unk00_field1 = 8;
+    } else {
+        arg1->trans.y += 0.2f * temp_f31;
+    }
+}
+
+static void UpdateBattleCoin(BattleWork *arg0, omObjData *arg1) {
+    s8 temp_r28;
+
+    if (arg0->unk00_field2 != 0) {
+        if (arg0->unk03++ < arg0->unk02) {
+            arg0->unk04++;
+            if (arg0->unk04 > 20) {
+                arg0->unk04 = 20;
+            }
+            return;
+        }
+        if (arg0->unk00_field3 == 0 && arg0->unk04 >= 20 && BoardRandMod(100) > 50) {
+            arg0->unk00_field3 = 1;
+        }
+        arg0->unk03 = 0;
+        if (arg0->unk00_field3 != 0) {
+            arg0->unk02 += 4;
+            if (arg0->unk02 > 30) {
+                arg0->unk02 = 30;
+            }
+        }
+        OSf32tos8(&battleCoinPosF, &temp_r28);
+        if (arg0->unk02 >= 30 && temp_r28 == battleCoinIdx) {
+            arg0->unk00_field1 = 7;
+            arg0->unk01 = 0;
+            coinTakeMax = battleCoinTbl[temp_r28];
+            HuAudFXPlay(0x305);
+        } else {
+            battleCoinPosF += 1.0f;
+            HuAudFXPlay(0x304);
+            if (battleCoinPosF >= 5.0f) {
+                battleCoinPosF = 0.0f;
+            }
+        }
+        HuSprBankSet(arg0->unk08, 1, temp_r28);
+        return;
+    }
+    HuSprAttrReset(arg0->unk08, 2, 4);
+    HuSprAttrReset(arg0->unk08, 1, 5);
+    HuSprPosSet(arg0->unk08, 2, 0.0f, 40.0f);
+    HuSprPosSet(arg0->unk08, 1, 34.0f, 40.0f);
+    HuSprScaleSet(arg0->unk08, 1, 0.9f, 0.9f);
+    arg0->unk00_field2 = 1;
+    arg0->unk01 = 0;
+    arg1->rot.x = 50.0f;
+}
+
+static void ShowBattleCoin(BattleWork *arg0, omObjData *arg1) {
+    float temp_f29;
+    float var_f30;
+
+    if (arg0->unk01 >= 90) {
+        arg0->unk01 = 0;
+        arg0->unk00_field1 = 8;
+        var_f30 = 90.0f;
+    } else {
+        arg0->unk01++;
+        OSu8tof32(&arg0->unk01, &var_f30);
+    }
+    if (coinTakeMax != 50) {
+        var_f30 *= 6.0f;
+    } else {
+        var_f30 *= 10.0f;
+    }
+    while (var_f30 > 180.0f) {
+        var_f30 -= 180.0f;
+    }
+    temp_f29 = 0.8999999761581421 + sin(var_f30 * M_PI / 180.0);
+    HuSprScaleSet(arg0->unk08, 1, temp_f29, temp_f29);
+}
+
+static void InitBattleGameSpr(BattleWork *arg0, omObjData *arg1) {
+    s8 temp_r30;
+    s8 temp_r29;
+    float sp8[2][2] = {
+        { -130.0f, 30.0f },
+        {  130.0f, 30.0f }
+    };
+
+    temp_r30 = battleMGIdx[0];
+    temp_r29 = battleMGIdx[1];
+    HuSprAttrReset(arg0->unk08, 3, 4);
+    HuSprAttrReset(arg0->unk08, 4, 4);
+    HuSprAttrReset(arg0->unk08, temp_r30 + 5, 4);
+    HuSprAttrReset(arg0->unk08, temp_r29 + 5, 4);
+    HuSprPosSet(arg0->unk08, 3, sp8[0][0], sp8[0][1]);
+    HuSprPosSet(arg0->unk08, 4, sp8[1][0], sp8[1][1]);
+    HuSprPosSet(arg0->unk08, temp_r30 + 5, sp8[0][0], sp8[0][1]);
+    HuSprPosSet(arg0->unk08, temp_r29 + 5, sp8[1][0], sp8[1][1]);
+    arg0->unk00_field1 = 8;
+}
+
+static void HideBattleSpr(void) {
+    BattleWork *temp_r30 = OM_GET_WORK_PTR(battleObj, BattleWork);
+    s32 i;
+
+    for (i = 0; i < 11; i++) {
+        HuSprAttrSet(temp_r30->unk08, i, 4);
+    }
+}
+
+
+static void VibratePad(BattleWork *arg0, omObjData *arg1) {
+    s32 i;
+
+    for (i = 0; i < 4; i++) {
+        omVibrate(i, 0xC, 0xC, 0);
+    }
+    arg0->unk00_field1 = 8;
+}
+
+static void StopBattleBomb(void) {
+    if (battleObj) {
+        OM_GET_WORK_PTR(battleObj, BattleWork)->unk00_field0 = 1;
+    }
+}
+
+static s32 GetBattleBombState(void) {
+    return OM_GET_WORK_PTR(battleObj, BattleWork)->unk00_field1;
+}
+
+static void SetBattleBombState(s32 arg0) {
+    BattleWork *var_r31 = OM_GET_WORK_PTR(battleObj, BattleWork);
+
+    var_r31->unk00_field1 = arg0;
+    var_r31->unk01 = 0;
+}
+
+static s8 battleChanceTbl[][3][5] = {
+    {
+        { 0x0A, 0x55, 0x05, 0x00, 0x00 },
+        { 0x0A, 0x4B, 0x0F, 0x00, 0x00 },
+        { 0x0A, 0x41, 0x19, 0x00, 0x00 },
+    },
+    {
+        { 0x05, 0x46, 0x14, 0x05, 0x00 },
+        { 0x05, 0x3C, 0x19, 0x0A, 0x00 },
+        { 0x05, 0x32, 0x1E, 0x0A, 0x00 },
+    },
+    {
+        { 0x05, 0x3C, 0x14, 0x0A, 0x05 },
+        { 0x05, 0x2D, 0x1E, 0x0F, 0x05 },
+        { 0x05, 0x23, 0x1E, 0x14, 0x0A },
+    },
+    {
+        { 0x05, 0x2D, 0x1E, 0x0F, 0x05 },
+        { 0x05, 0x1E, 0x23, 0x14, 0x0A },
+        { 0x05, 0x14, 0x23, 0x19, 0x0F }
+    }
+};
+
+static void SetBattleCoinValue(void) {
+    s32 temp_r26;
+    s32 temp_r25;
+    s32 var_r28;
+    s32 var_r29;
+    s32 var_r30;
+    s32 var_r27;
+    s32 i;
+
+    var_r30 = -1;
+    for (i = 0; i < 4; i++) {
+        if (BoardPlayerCoinsGet(i) > var_r30) {
+            var_r30 = BoardPlayerCoinsGet(i);
+        }
+    }
+    if (var_r30 >= 50) {
+        var_r29 = 3;
+    } else if (var_r30 >= 30) {
+        var_r29 = 2;
+    } else if (var_r30 >= 20) {
+        var_r29 = 1;
+    } else {
+        var_r29 = 0;
+    }
+    temp_r25 = 3.0f * ((float) GWSystem.turn / GWSystem.max_turn);
+    temp_r26 = BoardRandMod(100);
+    var_r27 = var_r28 = 0;
+    for (i = 4; i >= 0; i--) {
+        var_r28 += battleChanceTbl[var_r29][temp_r25][i];
+        if (temp_r26 < var_r28) {
+            var_r27 = i;
+            break;
+        }
+    }
+    battleCoinIdx = var_r27;
+}
diff --git a/src/game/board/com.c b/src/game/board/com.c
index fae9cae0..3f6cc4bf 100755
--- a/src/game/board/com.c
+++ b/src/game/board/com.c
@@ -7,28 +7,29 @@
 #include "game/board/space.h"
 #include "game/board/tutorial.h"
 #include "game/board/window.h"
+#include "game/board/boo.h"
 
 #include "math.h"
 
-s32 BoardBooComUseCheck(s32);
+typedef BOOL (*UseCheckFunc)(s32 player, s32 item);
 
 static void ExecComKeyLeft(void);
 static void ExecComKeyRight(void);
 static void ExecComKeyUp(void);
 static void ExecComKeyDown(void);
-static void ExecComKey(s32 arg0, s32 arg1, s32 arg2);
-static s32 ChooseUseItem(s32 arg0);
-static BOOL CheckMiniUse(s32 arg0, s32 arg1);
-static BOOL CheckMegaUse(s32 arg0, s32 arg1);
-static BOOL CheckSparkUse(s32 arg0, s32 arg1);
-static BOOL CheckBoardChangeUse(s32 arg0, s32 arg1);
-static BOOL CheckSwapUse(s32 arg0, s32 arg1);
-static BOOL CheckBooUse(s32 arg0, s32 arg1);
-static BOOL CheckLampUse(s32 arg0, s32 arg1);
+static void ExecComKey(s32 player, s32 move, s32 vertical);
+static s32 ChooseUseItem(s32 player);
+static BOOL CheckMiniUse(s32 player, s32 item);
+static BOOL CheckMegaUse(s32 player, s32 item);
+static BOOL CheckSparkUse(s32 player, s32 item);
+static BOOL CheckBoardChangeUse(s32 player, s32 item);
+static BOOL CheckSwapUse(s32 player, s32 item);
+static BOOL CheckBooUse(s32 player, s32 item);
+static BOOL CheckLampUse(s32 player, s32 item);
 
 static s8 itemUse = -1;
 
-static s8 comItemWeightTbl[8][12] = {
+static s8 comItemPreferTbl[8][12] = {
     { 0x0C, 0x0B, 0x05, 0x03, 0x01, 0x02, 0x06, 0x04, 0x00, 0x07, 0x09, 0x0A },
     { 0x0C, 0x0B, 0x05, 0x0A, 0x03, 0x01, 0x02, 0x00, 0x06, 0x04, 0x07, 0x09 },
     { 0x0C, 0x0B, 0x05, 0x06, 0x03, 0x01, 0x02, 0x0A, 0x07, 0x09, 0x00, 0x04 },
@@ -39,7 +40,7 @@ static s8 comItemWeightTbl[8][12] = {
     { 0x0C, 0x05, 0x07, 0x0B, 0x0A, 0x09, 0x04, 0x06, 0x03, 0x01, 0x02, 0x00 }
 };
 
-static BOOL (*comItemUseCheckFuncTbl[])(s32, s32) = {
+static UseCheckFunc comItemUseCheckFuncTbl[] = {
     CheckMiniUse,
     CheckMegaUse,
     CheckMiniUse,
@@ -95,322 +96,322 @@ void BoardComKeySetDown(void) {
     BoardWinComKeyFuncSet(ExecComKeyDown);
 }
 
-static void ExecComKey(s32 arg0, s32 arg1, s32 arg2) {
-    s32 sp14[4];
-    s32 temp_r31;
-    s16 temp_r30;
-    s32 var_r29;
+static void ExecComKey(s32 player, s32 move, s32 vertical) {
+    s32 comkey[4];
+    s32 port;
+    s16 delay;
+    s32 dpad;
 
-    sp14[0] = sp14[1] = sp14[2] = sp14[3] = 0;
-    temp_r31 = GWPlayer[arg0].port;
-    temp_r30 = GWMessDelayGet();
-    if (arg2 == 0) {
-        var_r29 = 4;
+    comkey[0] = comkey[1] = comkey[2] = comkey[3] = 0;
+    port = GWPlayer[player].port;
+    delay = GWMessDelayGet();
+    if (vertical == 0) {
+        dpad = PAD_BUTTON_DOWN;
     } else {
-        var_r29 = 2;
+        dpad = PAD_BUTTON_RIGHT;
     }
-    if (arg1 == 1) {
-        sp14[temp_r31] = var_r29;
-        HuWinComKeyWait(sp14[0], sp14[1], sp14[2], sp14[3], temp_r30);
+    if (move == 1) {
+        comkey[port] = dpad;
+        HuWinComKeyWait(comkey[0], comkey[1], comkey[2], comkey[3], delay);
     }
-    sp14[temp_r31] = 0x100;
-    HuWinComKeyWait(sp14[0], sp14[1], sp14[2], sp14[3], temp_r30);
+    comkey[port] = 0x100;
+    HuWinComKeyWait(comkey[0], comkey[1], comkey[2], comkey[3], delay);
 }
 
-s8 BoardComPreferItemGet(s32 arg0, s8 *arg1, s8 arg2) {
-    s32 temp_r26;
-    s32 var_r28;
-    s32 temp_r29;
-    s32 var_r27;
+s8 BoardComPreferItemGet(s32 player, s8 *items, s8 num_items) {
+    s32 character;
+    s32 weight;
+    s32 item;
+    s32 prefer;
     s32 i;
     s32 j;
 
-    temp_r26 = GWPlayer[arg0].character;
-    var_r27 = -1;
-    var_r28 = 0x64;
-    for (i = 0; i < arg2; i++) {
-        temp_r29 = arg1[i];
-        for (j = 0; j < 0xC; j++) {
-            if (temp_r29 == comItemWeightTbl[temp_r26][j]) {
-                if (j < var_r28 && (BoardPlayerItemFind(arg0, temp_r29) == -1 || temp_r29 == 0xC || temp_r29 == 0xB)) {
-                    var_r28 = j;
-                    var_r27 = i;
+    character = GWPlayer[player].character;
+    prefer = -1;
+    weight = 100;
+    for (i = 0; i < num_items; i++) {
+        item = items[i];
+        for (j = 0; j < 12; j++) {
+            if (item == comItemPreferTbl[character][j]) {
+                if (j < weight && (BoardPlayerItemFind(player, item) == -1 || item == 0xC || item == 0xB)) {
+                    weight = j;
+                    prefer = i;
                 }
                 break;
             }
         }
     }
-    if (var_r28 == 0x64) {
+    if (weight == 100) {
         return -1;
     }
-    return var_r27;
+    return prefer;
 }
 
-s8 BoardComPreferItemCheck(s32 arg0, s8 arg1, s8 arg2, s8 arg3) {
-    s8 spB[3];
-    s8 temp_r25;
+s8 BoardComPreferItemCheck(s32 player, s8 item1, s8 item2, s8 item3) {
+    s8 items[3];
+    s8 prefer;
 
-    spB[0] = arg1;
-    spB[1] = arg2;
-    spB[2] = arg3;
-    temp_r25 = BoardComPreferItemGet(arg0, spB, 3);
-    return temp_r25;
+    items[0] = item1;
+    items[1] = item2;
+    items[2] = item3;
+    prefer = BoardComPreferItemGet(player, items, 3);
+    return prefer;
 }
 
-s32 BoardComItemWeightGet(s32 arg0, s32 arg1) {
-    s32 var_r30;
+s32 BoardComItemWeightGet(s32 player, s32 item) {
+    s32 weight;
     s32 i;
 
-    for (i = 0; i < 0xC; i++) {
-        if (arg1 == comItemWeightTbl[GWPlayer[arg0].character][i]) {
+    for (i = 0; i < 12; i++) {
+        if (item == comItemPreferTbl[GWPlayer[player].character][i]) {
             break;
         }
     }
-    var_r30 = 0xB - i;
-    return var_r30;
+    weight = 12-1-i;
+    return weight;
 }
 
-s32 BoardComTutorialItemGet(s32 arg0) {
-    s32 var_r30;
-    s32 var_r31;
+s32 BoardComUseItemSlotGet(s32 player) {
+    s32 slot;
+    s32 item;
 
-    if (!GWPlayer[arg0].com) {
+    if (!GWPlayer[player].com) {
         return -1;
     }
     if (itemUse != -1) {
-        var_r31 = itemUse;
+        item = itemUse;
     }
-    if (boardTutorialUseItem >= 0 && boardTutorialUseItem <= 0xD) {
-        var_r31 = boardTutorialUseItem;
+    if (boardTutorialUseItem >= 0 && boardTutorialUseItem <= 13) {
+        item = boardTutorialUseItem;
         boardTutorialUseItem = -1;
     }
-    if (var_r31 != -1) {
-        var_r30 = BoardPlayerItemFind(arg0, var_r31);
+    if (item != -1) {
+        slot = BoardPlayerItemFind(player, item);
     } else {
-        var_r30 = -1;
+        slot = -1;
     }
-    return var_r30;
+    return slot;
 }
 
-s32 BoardComUseItemSet(s32 arg0, s32 arg1) {
-    if (arg1 == -1) {
+s32 BoardComUseItemSet(s32 player, s32 item) {
+    if (item == -1) {
         itemUse = -1;
         return 1;
     }
-    if (BoardPlayerItemFind(arg0, arg1) != -1) {
-        itemUse = arg1;
+    if (BoardPlayerItemFind(player, item) != -1) {
+        itemUse = item;
         return 1;
     }
     return 0;
 }
 
-BOOL BoardComUseItemCheck(s32 arg0) {
-    s32 var_r31;
+BOOL BoardComUseItemCheck(s32 player) {
+    s32 count;
 
-    var_r31 = BoardPlayerItemCount(arg0);
-    if (var_r31 <= 0) {
+    count = BoardPlayerItemCount(player);
+    if (count <= 0) {
         return FALSE;
     }
-    if (ChooseUseItem(arg0) != -1) {
+    if (ChooseUseItem(player) != -1) {
         return TRUE;
     }
     return FALSE;
 }
 
-static s32 ChooseUseItem(s32 arg0) {
+static s32 ChooseUseItem(s32 player) {
     s32 i;
     s32 j;
-    s32 temp_r29;
-    s32 var_r28;
-    s32 temp_r27;
-    s32 temp_r25;
-    BOOL (*temp_r24)(s32, s32);
-    s8 temp_r23;
+    s32 useItem;
+    s32 weight;
+    s32 item;
+    s32 character;
+    UseCheckFunc func;
+    s8 result;
 
-    temp_r29 = -1;
-    temp_r25 = GWPlayer[arg0].character;
-    var_r28 = 0x64;
+    useItem = -1;
+    character = GWPlayer[player].character;
+    weight = 0x64;
     for (i = 0; i < 3; i++) {
-        temp_r27 = GWPlayer[arg0].items[i];
-        if (temp_r27 == -1) {
+        item = GWPlayer[player].items[i];
+        if (item == -1) {
             continue;
         }
-        temp_r24 = comItemUseCheckFuncTbl[temp_r27];
-        if (!temp_r24) {
+        func = comItemUseCheckFuncTbl[item];
+        if (!func) {
             continue;
         }
-        temp_r23 = temp_r24(arg0, temp_r27);
-        if (temp_r23) {
+        result = func(player, item);
+        if (result) {
             for (j = 0; j < 0xC; j++) {
-                if (temp_r27 == comItemWeightTbl[temp_r25][j]) {
-                    if (j < var_r28) {
-                        var_r28 = j;
+                if (item == comItemPreferTbl[character][j]) {
+                    if (j < weight) {
+                        weight = j;
                     }
                     break;
                 }
             }
         }
     }
-    if (var_r28 == 0x64) {
+    if (weight == 0x64) {
         return -1;
     }
-    temp_r29 = comItemWeightTbl[temp_r25][var_r28];
-    if (temp_r29 == -1) {
+    useItem = comItemPreferTbl[character][weight];
+    if (useItem == -1) {
         itemUse = -1;
-    } else if (BoardPlayerItemFind(arg0, temp_r29) != -1) {
-        itemUse = temp_r29;
+    } else if (BoardPlayerItemFind(player, useItem) != -1) {
+        itemUse = useItem;
     }
-    return temp_r29;
+    return useItem;
 }
 
-static BOOL CheckMiniUse(s32 arg0, s32 arg1) {
-    s32 temp_r29;
-    s32 var_r26;
-    s32 var_r25;
-    s32 temp_r28;
-    s32 temp_r23;
-    s32 var_r24;
-    s32 var_r31;
-    s32 var_r30;
+static BOOL CheckMiniUse(s32 player, s32 item) {
+    s32 space;
+    s32 star_dist_pipe;
+    s32 star_dist_no_pipe;
+    s32 diff;
+    s32 character;
+    s32 force_use_mini;
+    s32 max_dist;
+    s32 chance;
 
-    var_r24 = 0;
-    temp_r29 = GWPlayer[arg0].space_curr;
-    temp_r28 = GWPlayer[arg0].diff;
-    temp_r23 = GWPlayer[arg0].character;
-    switch (temp_r28) {
+    force_use_mini = 0;
+    space = GWPlayer[player].space_curr;
+    diff = GWPlayer[player].diff;
+    character = GWPlayer[player].character;
+    switch (diff) {
         case 0:
-            var_r30 = 0x32;
+            chance = 50;
             break;
         case 1:
-            var_r30 = 0x19;
+            chance = 25;
             break;
         case 2:
-            var_r30 = 5;
+            chance = 5;
             break;
         case 3:
-            var_r30 = 0;
+            chance = 0;
             break;
     }
-    if ((temp_r28 == 0 || temp_r28 == 1) && temp_r23 == 1) {
-        var_r30 = 7;
+    if ((diff == 0 || diff == 1) && character == 1) {
+        chance = 7;
     }
     if (GWBoardGet() != 7 && GWBoardGet() != 8) {
-        var_r26 = BoardComPathReachCheck(temp_r29, 8, 0);
-        var_r25 = BoardComPathReachCheck(temp_r29, 8, 1);
+        star_dist_pipe = BoardComPathShortcutLenGet(space, 8, 0);
+        star_dist_no_pipe = BoardComPathShortcutLenGet(space, 8, 1);
     } else {
-        var_r26 = 0x3E7;
-        var_r25 = BoardComPathW20BestGet(temp_r29, 0x10000000, 0xA);
+        star_dist_pipe = 0x3E7;
+        star_dist_no_pipe = BoardComPathBestGetFlag(space, 0x10000000, 10);
         if ((GWBoardGet() == 8 || GWBoardGet() == 7) && BoardRandMod(0x64) < 0x3C) {
-            var_r24 = 1;
+            force_use_mini = 1;
         }
     }
-    switch (GWPlayer[arg0].diff) {
+    switch (GWPlayer[player].diff) {
         case 0:
-            var_r31 = 5;
+            max_dist = 5;
             break;
         case 1:
-            var_r31 = 7;
+            max_dist = 7;
             break;
         case 2:
-            var_r31 = 9;
+            max_dist = 9;
             break;
         case 3:
-            var_r31 = 0xA;
+            max_dist = 10;
             break;
     }
-    if ((var_r25 < var_r31 || var_r26 < var_r31 || var_r24 != 0) && BoardRandMod(0x64) >= var_r30) {
+    if ((star_dist_no_pipe < max_dist || star_dist_pipe < max_dist || force_use_mini != 0) && BoardRandMod(0x64) >= chance) {
         return TRUE;
     }
     return FALSE;
 }
 
-static BOOL CheckMegaUse(s32 arg0, s32 arg1) {
-    s32 temp_r27;
-    s32 temp_r26;
-    s32 temp_r24;
-    s32 temp_r29;
-    s16 temp_r25;
-    s16 var_r28;
-    s16 temp_r23;
-    s16 temp_r22;
+static BOOL CheckMegaUse(s32 player, s32 item) {
+    s32 short_len;
+    s32 character;
+    s32 space;
+    s32 diff;
+    s16 path_len;
+    s16 max_len;
+    s16 space_search;
+    s16 space_other;
     s16 i;
 
-    temp_r29 = GWPlayer[arg0].diff;
-    temp_r26 = GWPlayer[arg0].character;
-    switch (temp_r29) {
+    diff = GWPlayer[player].diff;
+    character = GWPlayer[player].character;
+    switch (diff) {
         case 0:
-            var_r28 = 5;
+            max_len = 5;
             break;
         case 1:
-            var_r28 = 7;
+            max_len = 7;
             break;
         case 2:
-            var_r28 = 9;
+            max_len = 9;
             break;
         case 3:
-            var_r28 = 0xA;
+            max_len = 10;
             break;
     }
-    if (((temp_r29 == 0 || temp_r29 == 1) && temp_r26 == 0) || ((temp_r29 == 0 || temp_r29 == 1) && temp_r26 == 5)) {
-        var_r28 = 8;
+    if (((diff == 0 || diff == 1) && character == 0) || ((diff == 0 || diff == 1) && character == 5)) {
+        max_len = 8;
     }
-    if (GWBoardGet() != 7 || BoardRandMod(0x64) >= 0x3C) {
-        temp_r24 = GWPlayer[arg0].space_curr;
-        temp_r27 = BoardComPathReachCheck(temp_r24, 8, 0);
-        temp_r23 = GWPlayer[arg0].space_curr;
+    if (GWBoardGet() != 7 || BoardRandMod(0x64) >= 60) {
+        space = GWPlayer[player].space_curr;
+        short_len = BoardComPathShortcutLenGet(space, 8, 0);
+        space_search = GWPlayer[player].space_curr;
         for (i = 0; i < 4; i++) {
-            if (i != arg0) {
-                temp_r22 = GWPlayer[i].space_curr;
-                temp_r25 = BoardComPathLenGet(temp_r23, temp_r22);
-                if (temp_r25 < var_r28 + 0x14 && temp_r25 > 0 && GWTeamGet() && i == BoardPlayerSameTeamFind(arg0)) {
+            if (i != player) {
+                space_other = GWPlayer[i].space_curr;
+                path_len = BoardComPathLenGet(space_search, space_other);
+                if (path_len < max_len + 20 && path_len > 0 && GWTeamGet() && i == BoardPlayerSameTeamFind(player)) {
                     return FALSE;
                 }
             }
         }
-        if (GWBoardGet() != 7 && GWBoardGet() != 8 && temp_r27 < 0xA && temp_r27 > 0) {
+        if (GWBoardGet() != 7 && GWBoardGet() != 8 && short_len < 10 && short_len > 0) {
             return FALSE;
         }
     }
-    if (BoardPlayerItemFind(arg0, arg1) != -1) {
+    if (BoardPlayerItemFind(player, item) != -1) {
         return TRUE;
     }
     return FALSE;
 }
 
-static BOOL CheckSparkUse(s32 arg0, s32 arg1) {
-    s32 temp_r27;
-    s32 temp_r28;
-    s32 temp_r26;
-    s32 temp_r25;
-    s32 temp_r24;
+static BOOL CheckSparkUse(s32 player, s32 item) {
+    s32 length;
+    s32 diff;
+    s32 space_other;
+    s32 space;
+    s32 character;
     s32 i;
-    s32 var_r30;
+    s32 chance;
 
-    temp_r25 = GWPlayer[arg0].space_curr;
-    temp_r28 = GWPlayer[arg0].diff;
-    temp_r24 = GWPlayer[arg0].character;
-    switch (temp_r28) {
+    space = GWPlayer[player].space_curr;
+    diff = GWPlayer[player].diff;
+    character = GWPlayer[player].character;
+    switch (diff) {
         case 0:
-            var_r30 = 0x32;
+            chance = 50;
             break;
         case 1:
-            var_r30 = 0x19;
+            chance = 25;
             break;
         case 2:
-            var_r30 = 5;
+            chance = 5;
             break;
         case 3:
-            var_r30 = 0;
+            chance = 0;
             break;
     }
-    if ((temp_r28 == 0 || temp_r28 == 1) && temp_r24 == 7) {
-        var_r30 = 7;
+    if ((diff == 0 || diff == 1) && character == 7) {
+        chance = 7;
     }
     for (i = 0; i < 4; i++) {
-        if (i != arg0) {
-            temp_r26 = GWPlayer[i].space_curr;
-            temp_r27 = BoardComPathLenGet(temp_r26, temp_r25);
-            if (temp_r27 > 0 && temp_r27 <= 0xF && BoardPlayerItemFind(arg0, arg1) != -1 && BoardRandMod(0x64) >= var_r30) {
+        if (i != player) {
+            space_other = GWPlayer[i].space_curr;
+            length = BoardComPathLenGet(space_other, space);
+            if (length > 0 && length <= 15 && BoardPlayerItemFind(player, item) != -1 && BoardRandMod(0x64) >= chance) {
                 return TRUE;
             }
         }
@@ -418,260 +419,260 @@ static BOOL CheckSparkUse(s32 arg0, s32 arg1) {
     return FALSE;
 }
 
-static BOOL CheckBoardChangeUse(s32 arg0, s32 arg1) {
-    s32 temp_r25;
-    s32 temp_r24;
-    s32 temp_r23;
-    s32 temp_r22;
-    s32 temp_r21;
-    s32 temp_r26;
-    s32 var_r30;
-    s32 var_r29;
-    s32 var_r27;
+static BOOL CheckBoardChangeUse(s32 player, s32 item) {
+    s32 diff;
+    s32 character;
+    s32 mini_len;
+    s32 non_mini_len;
+    s32 search_space;
+    s32 space;
+    s32 length_min;
+    s32 length;
+    s32 chance;
     s32 i;
 
-    temp_r25 = GWPlayer[arg0].diff;
-    temp_r24 = GWPlayer[arg0].character;
-    switch (temp_r25) {
+    diff = GWPlayer[player].diff;
+    character = GWPlayer[player].character;
+    switch (diff) {
         case 0:
-            var_r27 = 0x32;
+            chance = 0x32;
             break;
         case 1:
-            var_r27 = 0x19;
+            chance = 0x19;
             break;
         case 2:
-            var_r27 = 5;
+            chance = 5;
             break;
         case 3:
-            var_r27 = 0;
+            chance = 0;
             break;
     }
-    if (((arg1 == 4 && temp_r24 == 4) || (arg1 == 5 && (temp_r24 == 6 || temp_r24 == 3))) && (temp_r25 == 0 || temp_r25 == 1)) {
-        var_r27 = 7;
+    if (((item == 4 && character == 4) || (item == 5 && (character == 6 || character == 3))) && (diff == 0 || diff == 1)) {
+        chance = 7;
     }
-    var_r30 = 0x3E7;
+    length_min = 999;
     for (i = 0; i < 4; i++) {
-        if (arg0 == i) {
+        if (player == i) {
             continue;
         }
-        temp_r21 = GWPlayer[i].space_curr;
-        if (!GWTeamGet() || i != BoardPlayerSameTeamFind(arg0)) {
-            temp_r26 = GWPlayer[i].space_curr;
+        search_space = GWPlayer[i].space_curr;
+        if (!GWTeamGet() || i != BoardPlayerSameTeamFind(player)) {
+            space = GWPlayer[i].space_curr;
             if (GWBoardGet() == 7) {
-                if (BoardComPathW20BestGet(temp_r21, 0x10000000, 0xA) != -1) {
-                    var_r29 = 0xA;
+                if (BoardComPathBestGetFlag(search_space, 0x10000000, 10) != -1) {
+                    length = 10;
                 } else {
-                    var_r29 = 0;
+                    length = 0;
                 }
             } else if (GWBoardGet() == 8) {
-                if (BoardComPathW20BestGet(temp_r21, 0x200000, 0xA) != -1 || BoardComPathW20BestGet(temp_r21, 0x400000, 0xA) != -1) {
-                    var_r29 = 0xA;
+                if (BoardComPathBestGetFlag(search_space, 0x200000, 10) != -1 || BoardComPathBestGetFlag(search_space, 0x400000, 10) != -1) {
+                    length = 10;
                 } else {
-                    var_r29 = 0;
+                    length = 0;
                 }
             } else {
-                var_r29 = BoardComPathReachCheck(temp_r26, 8, 0);
+                length = BoardComPathShortcutLenGet(space, 8, 0);
             }
-            if (var_r29 != 0 && var_r29 < var_r30) {
-                var_r30 = var_r29;
+            if (length != 0 && length < length_min) {
+                length_min = length;
             }
         }
     }
-    if ((var_r30 > 0xF && var_r30 != 0x3E7) || (GWTeamGet() && i == BoardPlayerSameTeamFind(arg0))) {
+    if ((length_min > 0xF && length_min != 999) || (GWTeamGet() && i == BoardPlayerSameTeamFind(player))) {
         return FALSE;
     }
-    temp_r26 = GWPlayer[arg0].space_curr;
-    temp_r23 = BoardComPathReachCheck(temp_r26, 8, 0);
-    temp_r22 = BoardComPathReachCheck(temp_r26, 8, 1);
-    if (BoardPlayerItemFind(arg0, arg1) != -1 && BoardRandMod(0x64) >= var_r27) {
-        if ((temp_r23 == 0 || temp_r22 == 0) && var_r30 == 0x3E7) {
+    space = GWPlayer[player].space_curr;
+    mini_len = BoardComPathShortcutLenGet(space, 8, 0);
+    non_mini_len = BoardComPathShortcutLenGet(space, 8, 1);
+    if (BoardPlayerItemFind(player, item) != -1 && BoardRandMod(0x64) >= chance) {
+        if ((mini_len == 0 || non_mini_len == 0) && length_min == 999) {
             return TRUE;
         }
-        if (temp_r23 > var_r30 || temp_r22 > var_r30) {
+        if (mini_len > length_min || non_mini_len > length_min) {
             return TRUE;
         }
-        if (temp_r23 > 0xA || temp_r22 > 0xA) {
+        if (mini_len > 10 || non_mini_len > 10) {
             return TRUE;
         }
     }
     return FALSE;
 }
 
-BOOL CheckSwapUse(s32 arg0, s32 arg1) {
-    s32 temp_r27;
-    s32 temp_r26;
-    s32 temp_r25;
-    s32 var_r30;
-    s32 var_r29;
+static BOOL CheckSwapUse(s32 player, s32 item) {
+    s32 diff;
+    s32 team_player;
+    s32 character;
+    s32 item_count;
+    s32 chance;
     s32 i;
 
-    temp_r27 = GWPlayer[arg0].diff;
-    temp_r25 = GWPlayer[arg0].character;
-    switch (temp_r27) {
+    diff = GWPlayer[player].diff;
+    character = GWPlayer[player].character;
+    switch (diff) {
         case 0:
-            var_r29 = 0x32;
+            chance = 0x32;
             break;
         case 1:
-            var_r29 = 0x19;
+            chance = 0x19;
             break;
         case 2:
-            var_r29 = 5;
+            chance = 5;
             break;
         case 3:
-            var_r29 = 0;
+            chance = 0;
             break;
     }
-    if ((temp_r27 == 0 || temp_r27 == 1) && temp_r25 == 2) {
-        var_r29 = 7;
+    if ((diff == 0 || diff == 1) && character == 2) {
+        chance = 7;
     }
-    for (var_r30 = i = 0; i < 4; i++) {
-        if (i != arg0) {
-            var_r30 += BoardPlayerItemCount(i);
+    for (item_count = i = 0; i < 4; i++) {
+        if (i != player) {
+            item_count += BoardPlayerItemCount(i);
         }
     }
-    if (var_r30 == 0) {
+    if (item_count == 0) {
         return FALSE;
     }
     if (GWTeamGet()) {
-        temp_r26 = BoardPlayerSameTeamFind(arg0);
-        for (var_r30 = i = 0; i < 4; i++) {
-            if (temp_r26 != i && i != arg0) {
-                var_r30 += BoardPlayerItemCount(i);
+        team_player = BoardPlayerSameTeamFind(player);
+        for (item_count = i = 0; i < 4; i++) {
+            if (team_player != i && i != player) {
+                item_count += BoardPlayerItemCount(i);
             }
         }
-        if (var_r30 == 0) {
+        if (item_count == 0) {
             return FALSE;
         }
     }
-    if (BoardPlayerItemFind(arg0, arg1) != -1 && BoardRandMod(0x64) >= var_r29) {
+    if (BoardPlayerItemFind(player, item) != -1 && BoardRandMod(0x64) >= chance) {
         return TRUE;
     }
     return FALSE;
 }
 
-static BOOL CheckBooUse(s32 arg0, s32 arg1) {
-    if (BoardPlayerCoinsGet(arg0) < 5) {
+static BOOL CheckBooUse(s32 player, s32 item) {
+    if (BoardPlayerCoinsGet(player) < 5) {
         return FALSE;
     }
-    if (BoardBooComUseCheck(arg0) == 0) {
+    if (BoardBooComUseCheck(player) == 0) {
         return FALSE;
     }
-    if (BoardPlayerItemFind(arg0, arg1) == -1) {
+    if (BoardPlayerItemFind(player, item) == -1) {
         return FALSE;
     }
     return TRUE;
 }
 
-static BOOL CheckLampUse(s32 arg0, s32 arg1) {
-    if ((BoardPlayerCoinsGet(arg0) >= 0x14 || GWSystem.last5_effect == 4) && BoardPlayerItemFind(arg0, arg1) != -1) {
+static BOOL CheckLampUse(s32 player, s32 item) {
+    if ((BoardPlayerCoinsGet(player) >= 0x14 || GWSystem.last5_effect == 4) && BoardPlayerItemFind(player, item) != -1) {
         return TRUE;
     }
     return FALSE;
 }
 
-s32 BoardComJunctionInputGet(s32 arg0, Vec *arg1, s32 arg2, float *arg3) {
-    Vec sp28;
-    Vec sp1C;
-    Vec sp10;
-    float var_f30;
-    float var_f29;
-    float var_f31;
-    s32 var_r29;
-    s32 var_r27;
-    s32 temp_r26;
-    s32 var_r24;
-    s32 var_r23;
-    s32 var_r21;
+s32 BoardComJunctionInputGet(s32 item, Vec *input, s32 num_dirs, float *dirs) {
+    Vec pos_next;
+    Vec pos_junction;
+    Vec dir;
+    float dist_min;
+    float dist;
+    float angle;
+    s32 chance_random;
+    s32 best_dir;
+    s32 board;
+    s32 path_unknown;
+    s32 choose_path;
+    s32 dir_random;
     s32 i;
-    s16 var_r28;
-    s16 temp_r25;
-    s16 spC;
+    s16 space_next;
+    s16 space;
+    s16 roll;
 
-    temp_r26 = GWBoardGet();
-    var_r24 = 0;
-    temp_r25 = GWPlayer[arg0].space_curr;
-    var_r28 = -1;
-    spC = GWPlayer[arg0].roll;
-    switch (GWPlayer[arg0].diff) {
+    board = GWBoardGet();
+    path_unknown = 0;
+    space = GWPlayer[item].space_curr;
+    space_next = -1;
+    roll = GWPlayer[item].roll;
+    switch (GWPlayer[item].diff) {
         case 3:
-            var_r29 = 0;
+            chance_random = 0;
             break;
         case 2:
-            var_r29 = 0;
+            chance_random = 0;
             break;
         case 1:
-            var_r29 = 0xA;
+            chance_random = 10;
             break;
         default:
         case 0:
-            var_r29 = 0x1E;
+            chance_random = 0x1E;
             break;
     }
-    if (BoardRandMod(0x64) >= var_r29) {
-        var_r23 = 1;
+    if (BoardRandMod(0x64) >= chance_random) {
+        choose_path = 1;
     } else {
-        var_r23 = 0;
+        choose_path = 0;
     }
-    if (var_r23 != 0) {
-        if (temp_r26 >= 0 && temp_r26 <= 5) {
-            var_r28 = BoardComPathBestGet(temp_r25);
-        } else if (temp_r26 == 7) {
-            var_r28 = BoardComPathW20BestGet(temp_r25, 0x10000000, 0xA);
+    if (choose_path != 0) {
+        if (board >= 0 && board <= 5) {
+            space_next = BoardComPathBestGet(space);
+        } else if (board == 7) {
+            space_next = BoardComPathBestGetFlag(space, 0x10000000, 10);
         }
-        if (var_r28 == -1) {
-            var_r24 = 1;
+        if (space_next == -1) {
+            path_unknown = 1;
         } else {
-            BoardSpacePosGet(0, temp_r25, &sp1C);
-            BoardSpacePosGet(0, var_r28, &sp28);
-            PSVECSubtract(&sp28, &sp1C, &sp10);
-            var_f31 = BoardDAngleCalc(90.0 - 180.0 * (atan2(sp10.z, sp10.x) / M_PI));
-            if (var_f31 < 0.0f) {
-                var_f31 += 360.0f;
+            BoardSpacePosGet(0, space, &pos_junction);
+            BoardSpacePosGet(0, space_next, &pos_next);
+            PSVECSubtract(&pos_next, &pos_junction, &dir);
+            angle = BoardDAngleCalc(90.0 - 180.0 * (atan2(dir.z, dir.x) / M_PI));
+            if (angle < 0.0f) {
+                angle += 360.0f;
             }
-            if (var_f31 > 360.0f) {
-                var_f31 -= 360.0f;
+            if (angle > 360.0f) {
+                angle -= 360.0f;
             }
         }
     }
-    if (var_r24 != 0) {
-        var_r21 = BoardRandMod(arg2);
-        var_f31 = arg3[var_r21];
+    if (path_unknown != 0) {
+        dir_random = BoardRandMod(num_dirs);
+        angle = dirs[dir_random];
     }
-    var_f30 = 999.0f;
-    for (var_r27 = i = 0; i < 4; i++) {
-        var_f29 = (comJunctionDirTbl[i].x - var_f31 < 0.0f)
-            ? -(comJunctionDirTbl[i].x - var_f31)
-            : (comJunctionDirTbl[i].x - var_f31);
-        if (var_f29 < var_f30) {
-            var_r27 = i;
-            var_f30 = var_f29;
+    dist_min = 999.0f;
+    for (best_dir = i = 0; i < 4; i++) {
+        dist = (comJunctionDirTbl[i].x - angle < 0.0f)
+            ? -(comJunctionDirTbl[i].x - angle)
+            : (comJunctionDirTbl[i].x - angle);
+        if (dist < dist_min) {
+            best_dir = i;
+            dist_min = dist;
         }
     }
-    arg1->x = comJunctionDirTbl[var_r27].y;
-    arg1->z = comJunctionDirTbl[var_r27].z;
-    arg1->y = 0.0f;
+    input->x = comJunctionDirTbl[best_dir].y;
+    input->z = comJunctionDirTbl[best_dir].z;
+    input->y = 0.0f;
     return 0;
 }
 
-s32 BoardComBestPlayerFind(void) {
-    s32 temp_r30;
-    s32 var_r29;
-    s32 var_r28;
-    s32 var_r27;
+s32 BoardComFarPlayerFind(void) {
+    s32 len;
+    s32 max_len;
+    s32 far_player;
+    s32 space;
     s32 i;
 
     if (_CheckFlag(0x1000B) != 0) {
         return -1;
     }
-    var_r28 = -1;
-    var_r29 = -1;
+    far_player = -1;
+    max_len = -1;
     for (i = 0; i < 4; i++) {
-        var_r27 = GWPlayer[i].space_curr;
-        temp_r30 = BoardComPathReachCheck(var_r27, 8, 0);
-        if (temp_r30 > 0 && temp_r30 > var_r29) {
-            var_r29 = temp_r30;
-            var_r28 = i;
+        space = GWPlayer[i].space_curr;
+        len = BoardComPathShortcutLenGet(space, 8, 0);
+        if (len > 0 && len > max_len) {
+            max_len = len;
+            far_player = i;
         }
     }
-    return var_r28;
+    return far_player;
 }
diff --git a/src/game/board/com_path.c b/src/game/board/com_path.c
index c6b480a1..c4917348 100755
--- a/src/game/board/com_path.c
+++ b/src/game/board/com_path.c
@@ -5,20 +5,19 @@
 
 typedef struct {
     /* 0x00 */ struct {
-        u8 unk00_field0 : 1;
-        u8 unk00_field1 : 1;
-        s8 unk00_field2 : 1;
-        s8 unk00_field3 : 1;
-        u8 unk00_field4 : 1;
-        u8 unk00_field5 : 1;
+        u8 used : 1;
+        u8 star : 1;
+        u8 pipe : 1;
+        u8 shop : 1;
+        u8 boo : 1;
+        u8 lottery : 1;
     };
-    /* 0x01 */ s8 unk01;
-    /* 0x02 */ s8 unk02;
-    /* 0x03 */ s8 unk03;
-    /* 0x04 */ s16 unk04;
-    /* 0x06 */ s16 unk06[2]; // array size unknown
-    /* 0x0A */ char unk0A[0x3C];
-    /* 0x46 */ s16 unk46[5];
+    /* 0x01 */ s8 num_links;
+    /* 0x02 */ s8 num_children;
+    /* 0x03 */ s8 max_len;
+    /* 0x04 */ s16 start;
+    /* 0x06 */ s16 children[32];
+    /* 0x46 */ s16 links[BOARD_SPACE_LINKMAX+1];
 } PathNode; // Size 0x50
 
 static PathNode *SearchPathNodeSpace(s16 arg0);
@@ -30,7 +29,7 @@ static BOOL CheckPathSpace(BoardSpace *arg0);
 static s16 FindValidLink(BoardSpace *arg0);
 static BOOL CheckEndSpace(BoardSpace *arg0, PathNode *arg1);
 static BOOL CheckPath(PathNode *arg0);
-static BOOL CheckW20Path(PathNode *arg0, u32 arg1);
+static BOOL CheckPathFlag(PathNode *arg0, u32 arg1);
 
 static PathNode pathNodeData[16];
 static PathNode *candidateNodes[16];
@@ -40,89 +39,89 @@ static s16 startPathSpace[16];
 static s16 numCandidates;
 static s16 childNodeCnt;
 
-static PathNode *SearchPathNodeSpace(s16 arg0) {
-    PathNode *var_r31;
+static PathNode *SearchPathNodeSpace(s16 space) {
+    PathNode *node;
     s32 i;
 
-    for (var_r31 = pathNodeData, i = 0; i < 16; i++, var_r31++) {
-        if (var_r31->unk04 == arg0) {
+    for (node = pathNodeData, i = 0; i < 16; i++, node++) {
+        if (node->start == space) {
             break;
         }
     }
     if (i == 16) {
-        var_r31 = NULL;
+        node = NULL;
     }
-    return var_r31;
+    return node;
 }
 
-static s16 InitPathNode(PathNode *arg0) {
-    BoardSpace *temp_r30;
-    PathNode *var_r23;
-    s32 var_r29;
+static s16 InitPathNode(PathNode *node) {
+    BoardSpace *space_ptr;
+    PathNode *child;
+    s32 done;
     s16 i;
-    s16 var_r27;
-    s16 var_r26;
-    s16 var_r25;
-    s16 var_r24;
+    s16 space;
+    s16 num_links;
+    s16 path_len;
+    s16 space_link;
 
-    var_r24 = arg0->unk04;
-    var_r29 = 0;
-    arg0->unk02 = var_r25 = 0;
+    space_link = node->start;
+    done = 0;
+    node->num_children = path_len = 0;
     do {
-        var_r27 = var_r24;
-        temp_r30 = BoardSpaceGet(0, var_r27);
-        arg0->unk06[arg0->unk02] = var_r27;
-        var_r23 = FindChildNode(var_r27, arg0);
-        if (var_r23) {
-            AddValidLinks(temp_r30, arg0);
-            arg0->unk01 = 1;
-            arg0->unk46[0] = var_r27;
+        space = space_link;
+        space_ptr = BoardSpaceGet(0, space);
+        node->children[node->num_children] = space;
+        child = FindChildNode(space, node);
+        if (child) {
+            AddValidLinks(space_ptr, node);
+            node->num_links = 1;
+            node->links[0] = space;
             for (i = 1; i < 5; i++) {
-                arg0->unk46[i] = 0;
+                node->links[i] = 0;
             }
             return 0;
         }
-        if (temp_r30->link_cnt == 0) {
-            var_r26 = 0;
-            var_r29 = 1;
+        if (space_ptr->link_cnt == 0) {
+            num_links = 0;
+            done = 1;
         } else {
-            var_r26 = GetNumValidLinks(temp_r30, arg0);
-            if (var_r26 == 1) {
-                var_r24 = FindValidLink(temp_r30);
+            num_links = GetNumValidLinks(space_ptr, node);
+            if (num_links == 1) {
+                space_link = FindValidLink(space_ptr);
             } else {
-                var_r29 = 1;
+                done = 1;
             }
         }
-        if (CheckEndSpace(temp_r30, arg0)) {
-            var_r25++;
-            if (var_r25 >= arg0->unk03) {
-                var_r26 = 0;
-                var_r29 = 1;
+        if (CheckEndSpace(space_ptr, node)) {
+            path_len++;
+            if (path_len >= node->max_len) {
+                num_links = 0;
+                done = 1;
             }
         }
-        arg0->unk02++;
-    } while (var_r29 == 0);
-    AddValidLinks(temp_r30, arg0);
-    arg0->unk01 = var_r26;
-    return arg0->unk03 - var_r25;
+        node->num_children++;
+    } while (done == 0);
+    AddValidLinks(space_ptr, node);
+    node->num_links = num_links;
+    return node->max_len - path_len;
 }
 
 static PathNode *FindChildNode(s16 arg0, PathNode *arg1) {
-    PathNode *temp_r31;
-    s32 var_r28;
+    PathNode *node;
+    s32 node_idx;
     s32 i;
     s32 j;
 
-    var_r28 = NODE_INDEX(arg1);
-    if (var_r28 == -1) {
+    node_idx = NODE_INDEX(arg1);
+    if (node_idx == -1) {
         return NULL;
     }
     for (i = 0; i < childNodeCnt; i++) {
-        temp_r31 = &pathNodeData[i];
-        if (temp_r31 != arg1) {
-            for (j = 0; j < temp_r31->unk02; j++) {
-                if (arg0 == temp_r31->unk06[j]) {
-                    return temp_r31;
+        node = &pathNodeData[i];
+        if (node != arg1) {
+            for (j = 0; j < node->num_children; j++) {
+                if (arg0 == node->children[j]) {
+                    return node;
                 }
             }
         }
@@ -130,85 +129,85 @@ static PathNode *FindChildNode(s16 arg0, PathNode *arg1) {
     return NULL;
 }
 
-static s32 GetNumValidLinks(BoardSpace *arg0, PathNode *arg1) {
-    BoardSpace *var_r28;
+static s32 GetNumValidLinks(BoardSpace *space, PathNode *node) {
+    BoardSpace *link_space;
     s16 i;
-    s16 var_r29;
+    s16 invalid_links;
 
-    for (var_r29 = i = 0; i < arg0->link_cnt; i++) {
-        var_r28 = BoardSpaceGet(0, arg0->link[i]);
-        if (!CheckPathSpace(var_r28)) {
-            var_r29++;
+    for (invalid_links = i = 0; i < space->link_cnt; i++) {
+        link_space = BoardSpaceGet(0, space->link[i]);
+        if (!CheckPathSpace(link_space)) {
+            invalid_links++;
         }
     }
-    if (var_r29 >= arg0->link_cnt) {
+    if (invalid_links >= space->link_cnt) {
         return 0;
     }
-    return arg0->link_cnt - var_r29;
+    return space->link_cnt - invalid_links;
 }
 
-static void AddValidLinks(BoardSpace *arg0, PathNode *arg1) {
-    BoardSpace *var_r27;
-    s16 var_r30;
-    s16 var_r31;
+static void AddValidLinks(BoardSpace *space, PathNode *node) {
+    BoardSpace *link_space;
+    s16 i;
+    s16 link;
 
-    for (var_r31 = var_r30 = 0; var_r30 < arg0->link_cnt; var_r30++) {
-        var_r27 = BoardSpaceGet(0, arg0->link[var_r30]);
-        if (CheckPathSpace(var_r27)) {
-            arg1->unk46[var_r31] = arg0->link[var_r30];
-            var_r31++;
+    for (link = i = 0; i < space->link_cnt; i++) {
+        link_space = BoardSpaceGet(0, space->link[i]);
+        if (CheckPathSpace(link_space)) {
+            node->links[link] = space->link[i];
+            link++;
         }
     }
-    for (; var_r31 < 5; var_r31++) {
-        arg1->unk46[var_r31] = 0;
+    for (; link < BOARD_SPACE_LINKMAX+1; link++) {
+        node->links[link] = 0;
     }
 }
 
-static BOOL CheckPathSpace(BoardSpace *arg0) {
-    if ((arg0->flag & 0x02000000) || (arg0->flag & 0x04000000)) {
+static BOOL CheckPathSpace(BoardSpace *space) {
+    if ((space->flag & 0x02000000) || (space->flag & 0x04000000)) {
         return FALSE;
     } else {
         return TRUE;
     }
 }
 
-static s16 FindValidLink(BoardSpace *arg0) {
-    s16 var_r29;
+static s16 FindValidLink(BoardSpace *space) {
+    s16 space_link;
     s16 i;
-    BoardSpace *temp_r30;
+    BoardSpace *space_ptr;
 
-    for (var_r29 = i = 0; i < arg0->link_cnt; i++) {
-        var_r29 = arg0->link[i];
-        temp_r30 = BoardSpaceGet(0, var_r29);
-        if (CheckPathSpace(temp_r30)) {
+    for (space_link = i = 0; i < space->link_cnt; i++) {
+        space_link = space->link[i];
+        space_ptr = BoardSpaceGet(0, space_link);
+        if (CheckPathSpace(space_ptr)) {
             break;
         }
     }
-    return var_r29;
+    return space_link;
 }
 
-static BOOL CheckEndSpace(BoardSpace *arg0, PathNode *arg1) {
-    if (arg0->flag & 0x80000000) {
+static BOOL CheckEndSpace(BoardSpace *space, PathNode *node) {
+    if (space->flag & 0x80000000) {
     }
-    if (arg0->flag & 0x4000000) {
+    if (space->flag & 0x4000000) {
     }
-    if (arg0->flag & 0x2000000) {
+    if (space->flag & 0x2000000) {
     }
-    if (arg0->flag & 0x180000) {
-        arg1->unk00_field3 = 1;
+    if (space->flag & 0x180000) {
+        node->shop = 1;
     }
-    if (arg0->flag & 0x48000000) {
-        arg1->unk00_field4 = 1;
+    if (space->flag & 0x48000000) {
+        node->boo = 1;
     }
-    if (arg0->flag & 0x20000000) {
-        arg1->unk00_field2 = 1;
+    if (space->flag & 0x20000000) {
+        node->pipe = 1;
     }
-    if (arg0->flag & 0x10000000) {
-        arg1->unk00_field5 = 1;
+    if (space->flag & 0x10000000) {
+        node->lottery = 1;
     }
-    switch (arg0->type) {
+    switch (space->type) {
         case 8:
-            arg1->unk00_field1 = 1;
+            node->star = 1;
             return FALSE;
         case 10:
             return FALSE;
@@ -218,151 +217,151 @@ static BOOL CheckEndSpace(BoardSpace *arg0, PathNode *arg1) {
     return TRUE;
 }
 
-static inline void ComPathInlineFunc02(PathNode *arg0) {
+static inline void PushCandidate(PathNode *node) {
     if (numCandidates < 16) {
-        candidateNodes[numCandidates] = arg0;
+        candidateNodes[numCandidates] = node;
         numCandidates++;
     }
 }
 
-static inline PathNode *ComPathInlineFunc03(void) {
-    PathNode *ret;
+static inline PathNode *PopCandidate(void) {
+    PathNode *node;
 
     numCandidates--;
     if (numCandidates < 0) {
         return NULL;
     } else {
-        ret = candidateNodes[numCandidates];
+        node = candidateNodes[numCandidates];
         candidateNodes[numCandidates] = NULL;
-        return ret;
+        return node;
     }
 }
 
-static inline PathNode *ComPathInlineFunc04(s16 arg0, s16 arg1) {
-    PathNode *var_r26;
+static inline PathNode *CreateNode(s16 start, s16 len) {
+    PathNode *node;
     s32 i;
 
-    var_r26 = pathNodeData;
-    for (i = 0; i < 16; i++, var_r26++) {
-        if (var_r26->unk00_field0 == 0) {
+    node = pathNodeData;
+    for (i = 0; i < 16; i++, node++) {
+        if (node->used == 0) {
             break;
         }
     }
     if (i == 16) {
         return NULL;
     } else {
-        var_r26->unk00_field0 = 1;
-        var_r26->unk04 = arg0;
-        var_r26->unk03 = arg1;
+        node->used = 1;
+        node->start = start;
+        node->max_len = len;
         childNodeCnt++;
-        return var_r26;
+        return node;
     }
 }
 
-static inline void ComPathInlineFunc05(s16 arg0, s16 arg1) {
-    PathNode *var_r28;
-    s32 var_r24;
-    s32 temp_r17;
+static inline void PopulateCandidates(s16 start, s16 len) {
+    PathNode *node;
+    s32 num_paths;
+    s32 lookahead;
     s32 i;
-    PathNode *var_r23;
+    PathNode *new_node;
 
     memset(pathNodeData, 0, sizeof(pathNodeData));
     memset(candidateNodes, 0, sizeof(candidateNodes));
     numCandidates = 0;
     childNodeCnt = 0;
-    var_r23 = ComPathInlineFunc04(arg0, arg1);
-    ComPathInlineFunc02(var_r23);
-    var_r24 = 1;
-    temp_r17 = arg1;
+    new_node = CreateNode(start, len);
+    PushCandidate(new_node);
+    num_paths = 1;
+    lookahead = len;
     while (1) {
-        if (var_r24 <= 0) {
+        if (num_paths <= 0) {
             break;
         }
-        var_r28 = ComPathInlineFunc03();
-        if (!var_r28) {
+        node = PopCandidate();
+        if (!node) {
             break;
         }
-        var_r24--;
-        temp_r17 = InitPathNode(var_r28);
-        if (temp_r17 != 0) {
-            if (var_r28->unk01 <= 1) {
+        num_paths--;
+        lookahead = InitPathNode(node);
+        if (lookahead != 0) {
+            if (node->num_links <= 1) {
                 break;
             }
-            for (i = 0; i < var_r28->unk01; var_r24++, i++) {
-                var_r23 = ComPathInlineFunc04(var_r28->unk46[i], temp_r17);
-                if (!var_r23) {
+            for (i = 0; i < node->num_links; num_paths++, i++) {
+                new_node = CreateNode(node->links[i], lookahead);
+                if (!new_node) {
                     break;
                 }
-                ComPathInlineFunc02(var_r23);
+                PushCandidate(new_node);
             }
         }
     }
 }
 
-s16 BoardComPathReachCheck(s16 arg0, u32 arg1, s32 arg2) {
-    s16 sp80[10];
-    s16 sp6C[10];
-    PathNode *sp68;
-    PathNode *var_r29;
-    s16 sp1C;
-    s16 sp1A;
-    s16 temp_r20;
-    s16 var_r22;
-    s16 var_r28;
+s16 BoardComPathShortcutLenGet(s16 space, u32 type, s32 block_pipe) {
+    s16 len_tbl[10];
+    s16 node_tbl[10];
+    PathNode *node_link;
+    PathNode *node;
+    s16 node_idx;
+    s16 node_start_idx;
+    s16 node_idx_link;
+    s16 num_nodes;
+    s16 len;
     s16 i;
-    s32 var_r19;
+    s32 search_child;
 
     if (_CheckFlag(0x1000B)) {
         return 0;
     }
-    ComPathInlineFunc05(arg0, 0x1E);
+    PopulateCandidates(space, 30);
     memset(startPathSpaceSearch, 0, sizeof(startPathSpaceSearch));
-    memset(sp80, 0, sizeof(sp80));
+    memset(len_tbl, 0, sizeof(len_tbl));
     memset(candidateNodes, 0, sizeof(candidateNodes));
     numCandidates = 0;
-    var_r29 = SearchPathNodeSpace(arg0);
-    sp1A = NODE_INDEX(var_r29);
-    ComPathInlineFunc02(var_r29);
-    var_r28 = 0;
-    var_r22 = 0;
-    startPathSpaceSearch[sp1A] = var_r28;
-    var_r19 = 0;
+    node = SearchPathNodeSpace(space);
+    node_start_idx = NODE_INDEX(node);
+    PushCandidate(node);
+    len = 0;
+    num_nodes = 0;
+    startPathSpaceSearch[node_start_idx] = len;
+    search_child = 0;
     while (1) {
-        var_r29 = ComPathInlineFunc03();
-        sp1C = NODE_INDEX(var_r29);
-        if (sp1C == -1) {
-            if (var_r22 != 0) {
+        node = PopCandidate();
+        node_idx = NODE_INDEX(node);
+        if (node_idx == -1) {
+            if (num_nodes != 0) {
                 break;
             }
         } else {
-            var_r19 = 0;
-            var_r28 = startPathSpaceSearch[sp1C];
-            for (i = 0; i < var_r29->unk02; i++) {
-                if (arg2 == 0 && (BoardSpaceFlagGet(0, var_r29->unk06[i]) & 0x20000000)) {
+            search_child = 0;
+            len = startPathSpaceSearch[node_idx];
+            for (i = 0; i < node->num_children; i++) {
+                if (block_pipe == 0 && (BoardSpaceFlagGet(0, node->children[i]) & 0x20000000)) {
                     break;
                 }
-                if (arg1 == BoardSpaceTypeGet(0, var_r29->unk06[i])) {
-                    sp80[var_r22] = var_r28;
-                    sp6C[var_r22] = sp1C;
-                    if (++var_r22 < 0xA) {
-                        var_r19 = 1;
+                if (type == BoardSpaceTypeGet(0, node->children[i])) {
+                    len_tbl[num_nodes] = len;
+                    node_tbl[num_nodes] = node_idx;
+                    if (++num_nodes < 10) {
+                        search_child = 1;
                         break;
                     } else {
-                        goto return_r28;
+                        goto done;
                     }
                 }
-                if (var_r28++ >= 0x1E) {
-                    var_r19 = 1;
+                if (len++ >= 30) {
+                    search_child = 1;
                     break;
                 }
             }
-            if (var_r19 == 0) {
-                for (i = 0; i < var_r29->unk01; i++) {
-                    sp68 = SearchPathNodeSpace(var_r29->unk46[i]);
-                    temp_r20 = NODE_INDEX(sp68);
-                    if (temp_r20 != -1 && temp_r20 >= 0 && temp_r20 < 16) {
-                        startPathSpaceSearch[temp_r20] = var_r28;
-                        ComPathInlineFunc02(sp68);
+            if (search_child == 0) {
+                for (i = 0; i < node->num_links; i++) {
+                    node_link = SearchPathNodeSpace(node->links[i]);
+                    node_idx_link = NODE_INDEX(node_link);
+                    if (node_idx_link != -1 && node_idx_link >= 0 && node_idx_link < 16) {
+                        startPathSpaceSearch[node_idx_link] = len;
+                        PushCandidate(node_link);
                     }
                 }
             }
@@ -370,89 +369,89 @@ s16 BoardComPathReachCheck(s16 arg0, u32 arg1, s32 arg2) {
         }
         return 0;
     }
-return_r28:
-    var_r28 = 10000;
+done:
+    len = 10000;
     for (i = 0; i < 10; i++) {
-        if (var_r28 > sp80[i] && sp80[i] != 0) {
-            var_r28 = sp80[i];
+        if (len > len_tbl[i] && len_tbl[i] != 0) {
+            len = len_tbl[i];
         }
     }
-    return var_r28;
+    return len;
 }
 
-s16 BoardComPathBestGet(s16 arg0) {
-    PathNode *sp30;
-    PathNode *sp2C;
+s16 BoardComPathBestGet(s16 space) {
+    PathNode *link_node;
+    PathNode *node;
     s32 i;
 
-    ComPathInlineFunc05(arg0, 0x1E);
-    sp2C = SearchPathNodeSpace(arg0);
-    if (sp2C->unk00_field1 != 0) {
+    PopulateCandidates(space, 30);
+    node = SearchPathNodeSpace(space);
+    if (node->star != 0) {
         return -1;
     }
-    if (sp2C->unk01 <= 1) {
+    if (node->num_links <= 1) {
         return -1;
     }
-    for (i = 0; i < sp2C->unk01; i++) {
-        sp30 = SearchPathNodeSpace(sp2C->unk46[i]);
-        if (sp30 && CheckPath(sp30)) {
-            return sp2C->unk46[i];
+    for (i = 0; i < node->num_links; i++) {
+        link_node = SearchPathNodeSpace(node->links[i]);
+        if (link_node && CheckPath(link_node)) {
+            return node->links[i];
         }
     }
     return -1;
 }
 
-s16 BoardComPathLenGet(s16 arg0, s16 arg1) {
-    PathNode *var_r30;
-    s16 temp_r21;
-    s16 var_r25;
+s16 BoardComPathLenGet(s16 space, s16 space_other) {
+    PathNode *node;
+    s16 link_node_idx;
+    s16 len;
     s16 sp16;
-    s16 sp14;
-    s16 sp12;
+    s16 node_idx;
+    s16 node_start_idx;
     s16 i;
-    s32 sp5C;
-    PathNode *sp58;
+    s32 search_child;
+    PathNode *link_node;
 
-    ComPathInlineFunc05(arg0, 0x1E);
+    PopulateCandidates(space, 30);
     memset(startPathSpace, 0, sizeof(startPathSpace));
     memset(candidateNodes, 0, sizeof(candidateNodes));
     numCandidates = 0;
-    var_r30 = SearchPathNodeSpace(arg0);
-    sp12 = NODE_INDEX(var_r30);
-    ComPathInlineFunc02(var_r30);
-    var_r25 = 0;
+    node = SearchPathNodeSpace(space);
+    node_start_idx = NODE_INDEX(node);
+    PushCandidate(node);
+    len = 0;
     sp16 = 0;
-    startPathSpace[sp12] = var_r25;
-    sp5C = 0;
+    startPathSpace[node_start_idx] = len;
+    search_child = 0;
     while (1) {
-        var_r30 = ComPathInlineFunc03();
-        sp14 = NODE_INDEX(var_r30);
-        if (sp14 == -1) {
+        node = PopCandidate();
+        node_idx = NODE_INDEX(node);
+        if (node_idx == -1) {
             if (sp16 != 0) {
                 break;
             }
         } else {
-            sp5C = 0;
-            var_r25 = startPathSpace[sp14];
-            for (i = 0; i < var_r30->unk02; i++) {
-                if (BoardSpaceFlagGet(0, var_r30->unk06[i]) & 0x20000000) {
+            search_child = 0;
+            len = startPathSpace[node_idx];
+            for (i = 0; i < node->num_children; i++) {
+                if (BoardSpaceFlagGet(0, node->children[i]) & 0x20000000) {
                     break;
                 }
-                if (var_r30->unk06[i] == arg1) {
-                    goto return_r25;
+                if (node->children[i] == space_other) {
+                    goto done;
                 }
-                if (var_r25++ >= 0x1E) {
-                    sp5C = 1;
+                if (len++ >= 30) {
+                    search_child = 1;
                     break;
                 }
             }
-            if (sp5C == 0) {
-                for (i = 0; i < var_r30->unk01; i++) {
-                    sp58 = SearchPathNodeSpace(var_r30->unk46[i]);
-                    temp_r21 = NODE_INDEX(sp58);
-                    if (temp_r21 != -1 && temp_r21 >= 0 && temp_r21 < 16) {
-                        startPathSpace[temp_r21] = var_r25;
-                        ComPathInlineFunc02(sp58);
+            if (search_child == 0) {
+                for (i = 0; i < node->num_links; i++) {
+                    link_node = SearchPathNodeSpace(node->links[i]);
+                    link_node_idx = NODE_INDEX(link_node);
+                    if (link_node_idx != -1 && link_node_idx >= 0 && link_node_idx < 16) {
+                        startPathSpace[link_node_idx] = len;
+                        PushCandidate(link_node);
                     }
                 }
             }
@@ -460,84 +459,84 @@ s16 BoardComPathLenGet(s16 arg0, s16 arg1) {
         }
         return 0;
     }
-return_r25:
-    return var_r25;
+done:
+    return len;
 }
 
-static BOOL CheckPath(PathNode *arg0) {
+static BOOL CheckPath(PathNode *node) {
     s32 i;
-    PathNode *sp1C;
+    PathNode *link;
 
-    if (arg0->unk00_field1 != 0) {
+    if (node->star != 0) {
         return TRUE;
     }
-    if (arg0->unk01 <= 1) {
+    if (node->num_links <= 1) {
         return FALSE;
     }
-    for (i = 0; i < arg0->unk01; i++) {
-        sp1C = SearchPathNodeSpace(arg0->unk46[i]);
-        if (sp1C && CheckPath(sp1C)) {
+    for (i = 0; i < node->num_links; i++) {
+        link = SearchPathNodeSpace(node->links[i]);
+        if (link && CheckPath(link)) {
             return TRUE;
         }
     }
     return FALSE;
 }
 
-s16 BoardComPathW20BestGet(s16 arg0, u32 arg1, s16 arg2) {
-    PathNode *var_r31;
-    PathNode *sp38;
+s16 BoardComPathBestGetFlag(s16 space, u32 flag, s16 len) {
+    PathNode *node;
+    PathNode *node_link;
     s32 i;
 
-    ComPathInlineFunc05(arg0, arg2);
-    var_r31 = SearchPathNodeSpace(arg0);
-    if (arg1 & 0x180000) {
-        if (var_r31->unk00_field1 != 0) {
+    PopulateCandidates(space, len);
+    node = SearchPathNodeSpace(space);
+    if (flag & 0x180000) {
+        if (node->star != 0) {
             return -1;
         }
-    } else if (arg1 & 0x08000000) {
-        if (var_r31->unk00_field4 != 0) {
+    } else if (flag & 0x08000000) {
+        if (node->boo != 0) {
             return -1;
         }
-    } else if (arg1 & 0x10000000) {
-        if (var_r31->unk00_field5 != 0) {
+    } else if (flag & 0x10000000) {
+        if (node->lottery != 0) {
             return -1;
         }
     }
-    if (var_r31->unk01 <= 1) {
+    if (node->num_links <= 1) {
         return -1;
     }
-    for (i = 0; i < var_r31->unk01; i++) {
-        sp38 = SearchPathNodeSpace(var_r31->unk46[i]);
-        if (sp38 && CheckW20Path(sp38, arg1)) {
-            return var_r31->unk46[i];
+    for (i = 0; i < node->num_links; i++) {
+        node_link = SearchPathNodeSpace(node->links[i]);
+        if (node_link && CheckPathFlag(node_link, flag)) {
+            return node->links[i];
         }
     }
     return -1;
 }
 
-static BOOL CheckW20Path(PathNode *arg0, u32 arg1) {
+static BOOL CheckPathFlag(PathNode *node, u32 flag) {
     s32 i;
-    PathNode *sp1C;
+    PathNode *link_node;
 
-    if (arg1 & 0x180000) {
-        if (arg0->unk00_field1 != 0) {
+    if (flag & 0x180000) {
+        if (node->star != 0) {
             return TRUE;
         }
-    } else if (arg1 & 0x08000000) {
-        if (arg0->unk00_field4 != 0) {
+    } else if (flag & 0x08000000) {
+        if (node->boo != 0) {
             return TRUE;
         }
-    } else if (arg1 & 0x10000000) {
-        if (arg0->unk00_field5 != 0) {
+    } else if (flag & 0x10000000) {
+        if (node->lottery != 0) {
             return TRUE;
         }
     }
-    if (arg0->unk01 <= 1) {
+    if (node->num_links <= 1) {
         return FALSE;
     }
-    for (i = 0; i < arg0->unk01; i++) {
-        sp1C = SearchPathNodeSpace(arg0->unk46[i]);
-        if (sp1C && CheckW20Path(sp1C, arg1)) {
+    for (i = 0; i < node->num_links; i++) {
+        link_node = SearchPathNodeSpace(node->links[i]);
+        if (link_node && CheckPathFlag(link_node, flag)) {
             return TRUE;
         }
     }
diff --git a/src/game/board/fortune.c b/src/game/board/fortune.c
new file mode 100644
index 00000000..97b3fae0
--- /dev/null
+++ b/src/game/board/fortune.c
@@ -0,0 +1,409 @@
+#include "game/board/main.h"
+#include "game/board/model.h"
+#include "game/board/player.h"
+#include "game/board/tutorial.h"
+#include "game/board/audio.h"
+#include "game/board/ui.h"
+#include "game/board/space.h"
+
+#include "game/wipe.h"
+
+static Vec camTargetFortune;
+static Vec camPosFortune;
+
+typedef struct platform_work {
+    struct {
+        u8 kill : 1;
+		u8 state : 2;
+    };
+    s16 unk02;
+    s16 model;
+} PlatformWork;
+
+static u32 comPrizeMessTbl[] = {
+	0x1C0009,
+	0x1C000A,
+	0x1C000B,
+	0x1C000D,
+	0x1C000C,
+	0x1C000E
+};
+
+static s8 currPlayer;
+static s8 comPlayer2;
+static s8 comPlayer1;
+static s8 comPrize;
+static s8 comCoin;
+static s8 comStar;
+static omObjData *fortunePlatformObj;
+static Process *fortuneProc;
+
+static void FortuneExec(void);
+static void DestroyFortune(void);
+static void FortuneMain(void);
+static void FortunePostMG(void);
+
+static void CreateFortunePlatform(void);
+static void ExecFortunePlatform(omObjData *object);
+
+static void CameraCalcFortune(BoardCameraData *camera);
+
+static void ExecComFortuneWin(void);
+
+static void ConfigComFortune(void);
+
+static void ComFortuneAddStar(s32 player1, s32 player2, s32 max_stars);
+static void ComFortuneAddCoin(s32 player1, s32 player2, s32 max_coins);
+static void ComFortuneSwapCoin(s32 player1, s32 player2);
+static void ComFortuneSwapStar(s32 player1, s32 player2);
+
+void BoardFortuneExec(s32 player, s32 space)
+{
+	if(_CheckFlag(0x1000B)) {
+		HuAudFXPlay(842);
+		BoardCameraViewSet(2);
+		BoardPlayerMotBlendSet(player, 0, 15);
+		while(!BoardPlayerMotBlendCheck(player)) {
+			HuPrcVSleep();
+		}
+		BoardCameraMotionWait();
+		BoardTutorialHookExec(17, 0);
+		GWPlayer[player].color = 3;
+		return;
+	}
+	if(BoardPlayerSizeGet(player) == 2) {
+		return;
+	}
+	fortuneProc = HuPrcChildCreate(FortuneExec, 8195, 14336, 0, boardMainProc);
+	HuPrcDestructorSet2(fortuneProc, DestroyFortune);
+	currPlayer = player;
+	while(fortuneProc) {
+		HuPrcVSleep();
+	}
+	GWPlayer[player].color = 3;
+}
+
+static void FortuneExec(void)
+{
+	BoardAudSeqFadeOut(0, 1000);
+	if(!_CheckFlag(0x10005)) {
+		GWPlayer[currPlayer].show_next = 0;
+		FortuneMain();
+	} else {
+		FortunePostMG();
+	}
+	HuPrcEnd();
+}
+
+static void DestroyFortune(void)
+{
+	fortuneProc = NULL;
+}
+
+static void FortuneMain(void)
+{
+	s32 i;
+	s32 sp8 = -1;
+	s32 dir_table[] = {
+		DATADIR_W01,
+		DATADIR_W02,
+		DATADIR_W03,
+		DATADIR_W04,
+		DATADIR_W05,
+		DATADIR_W06,
+		DATADIR_W10,
+		DATADIR_W20,
+		DATADIR_W21
+	};
+	HuAudFXPlay(842);
+	BoardPlayerMotBlendSet(currPlayer, 0, 15);
+	while(!BoardPlayerMotBlendCheck(currPlayer)) {
+		HuPrcVSleep();
+	}
+	for(i=0; i<4; i++) {
+		if((int)(GWPlayer[i].team) != 0) {
+			GWPlayer[i].field08_bit11 = 1;
+		} else {
+			GWPlayer[i].field08_bit11 = 0;
+		}
+		if(i == currPlayer) {
+			GWPlayerCfg[i].group = 0;
+		} else {
+			GWPlayerCfg[i].group = 1;
+		}
+	}
+	BoardCameraViewSet(3);
+	BoardCameraMotionWait();
+	CreateFortunePlatform();
+	omVibrate(currPlayer, 60, 6, 6);
+	BoardCameraPosCalcFuncSet(CameraCalcFortune);
+	HuPrcSleep(60);
+	_SetFlag(0x1001C);
+	WipeColorSet(255, 255, 255);
+	WipeCreate(WIPE_MODE_OUT, WIPE_TYPE_NORMAL, -1);
+	while(WipeStatGet()) {
+		HuPrcVSleep();
+	}
+	HuAudFXAllStop();
+	BoardAudSeqFadeOutAll();
+	_SetFlag(0x1000E);
+	BoardCameraPosCalcFuncSet(NULL);
+	if(fortunePlatformObj) {
+		OM_GET_WORK_PTR(fortunePlatformObj, PlatformWork)->kill = 1;
+	}
+	while(fortunePlatformObj) {
+		HuPrcVSleep();
+	}
+	if(GWPlayer[GWSystem.player_curr].com) {
+		if((int)GWSystem.show_com_mg == 0) {
+			HuPrcSleep(60);
+			for(i=0; i<4; i++) {
+				s32 bit11 = GWPlayer[i].field08_bit11;
+				GWPlayer[i].team = bit11;
+				GWPlayerCfg[i].group = bit11;
+			}
+			ConfigComFortune();
+			FortunePostMG();
+			BoardMusStartBoard();
+			ExecComFortuneWin();
+			return;
+		}
+	}
+	GWMGAvailSet(444);
+	GWSystem.mg_next = 43;
+	_SetFlag(0x10005);
+	BoardNextOvlSet(OVL_M444);
+}
+
+static void FortunePostMG(void)
+{
+	s16 space;
+	Vec pos;
+	BoardStatusItemSet(1);
+	space = GWPlayer[GWSystem.player_curr].space_curr;
+	BoardSpacePosGet(0, space, &pos);
+	BoardPlayerPosSetV(GWSystem.player_curr, &pos);
+	BoardCameraMoveSet(0);
+	BoardCameraViewSet(2);
+	BoardCameraMotionWait();
+	BoardCameraMoveSet(1);
+	GWPlayer[currPlayer].show_next = 1;
+	WipeCreate(WIPE_MODE_IN, WIPE_TYPE_NORMAL, -1);
+	while(WipeStatGet()) {
+		HuPrcVSleep();
+	}
+	_ClearFlag(0x1001C);
+	HuPrcSleep(12);
+}
+
+static void CreateFortunePlatform(void)
+{
+	PlayerState *player;
+	Vec pos, rot;
+	PlatformWork *work;
+	fortunePlatformObj = omAddObjEx(boardObjMan, 257, 0, 0, -1, ExecFortunePlatform);
+	work = OM_GET_WORK_PTR(fortunePlatformObj, PlatformWork);
+	work->kill = 0;
+	work->unk02 = 0;
+	work->model = BoardModelCreate(DATA_MAKE_NUM(DATADIR_BOARD, 3), NULL, 0);
+	BoardSpacePosGet(0, GWPlayer[currPlayer].space_curr, &pos);
+	BoardSpaceRotGet(0, GWPlayer[currPlayer].space_curr, &rot);
+	BoardModelPosSetV(work->model, &pos);
+	BoardCameraTargetModelSet(work->model);
+	BoardModelHookSet(work->model, "player", BoardPlayerModelGet(currPlayer));
+	BoardModelMotionStart(work->model, 0, 0);
+	BoardCameraPosGet(&camPosFortune);
+	BoardCameraTargetGet(&camTargetFortune);
+	HuAudFXPlay(834);
+}
+
+static void CameraCalcFortune(BoardCameraData *camera)
+{
+	camera->pos = camPosFortune;
+	camera->up.x = 0;
+	camera->up.y = 1;
+	camera->up.z = 0;
+	camera->target = camTargetFortune;
+}
+
+static void ExecFortunePlatform(omObjData *object)
+{
+	PlatformWork *work = OM_GET_WORK_PTR(object, PlatformWork);
+	if(work->kill || BoardIsKill()) {
+		Vec pos;
+		fortunePlatformObj = NULL;
+		BoardModelHookReset(work->model);
+		BoardSpacePosGet(0, GWPlayer[currPlayer].space_curr, &pos);
+		BoardPlayerPosSetV(currPlayer, &pos);
+		BoardModelKill(work->model);
+		omDelObjEx(HuPrcCurrentGet(), object);
+		return;
+	}
+	switch(work->state) {
+		case 0:
+		{
+			s16 model;
+			ModelData *model_ptr;
+			HsfObject *focus_obj;
+			if(BoardModelMotionEndCheck(work->model)) {
+				work->state = 1;
+			}
+			model = BoardModelIDGet(work->model);
+			model_ptr = &Hu3DData[model];
+			Hu3DMotionExec(model, model_ptr->unk_08, model_ptr->unk_64, 0);
+			focus_obj = Hu3DModelObjPtrGet(model, "player");
+			BoardModelPosGet(work->model, &camTargetFortune);
+			camTargetFortune.x += focus_obj->data.curr.pos.x;
+			camTargetFortune.y += focus_obj->data.curr.pos.y;
+			camTargetFortune.z += focus_obj->data.curr.pos.z;
+		}
+			
+			break;
+			
+		case 1:
+			break;
+			
+		default:
+			break;
+	}
+}
+
+static void ExecComFortuneWin(void)
+{
+	s32 player_curr = GWSystem.player_curr;
+	u32 mess_player1;
+	u32 mess_player2;
+	u32 mess_main;
+	u32 mess_prize;
+
+	GWSystem.player_curr = -1;
+	mess_player1 = BoardPlayerGetCharMess(comPlayer1);
+	mess_player2 = BoardPlayerGetCharMess(comPlayer2);
+	mess_prize = comPrizeMessTbl[comPrize];
+	if(comPrize == 0 || comPrize == 5 || comPrize == 3) {
+		mess_main = 0x1C0012;
+	} else {
+		if(comPrize == 2) {
+			if(comCoin == 0) {
+				mess_main = 0x1C0013;
+			} else {
+				mess_main = 0x1C0011;
+			}
+		} else {
+			if(comPrize == 1 || comPrize == 4) {
+				if(comStar == 0) {
+					mess_main = 0x1C0014;
+				} else {
+					mess_main = 0x1C0011;
+				}
+			}
+		}
+	}
+	BoardWinCreate(2, mess_main, -1);
+	BoardWinInsertMesSet(mess_player1, 0);
+	BoardWinInsertMesSet(mess_prize, 1);
+	BoardWinInsertMesSet(mess_player2, 2);
+	BoardWinWait();
+	BoardWinKill();
+	GWSystem.player_curr = player_curr;
+}
+
+static void ConfigComFortune(void)
+{
+	s32 type;
+	s32 random;
+	s8 prizeTbl[] = { 5, 3, 0, 1, 4 };
+	random = BoardRandMod(100);
+	if(random > 95) {
+		type = 0;
+	} else if(random > 60) {
+		type = 1;
+	} else {
+		type = 2;
+	}
+	switch(type) {
+		case 0:
+			comPrize = prizeTbl[BoardRandMod(2)];
+			break;
+			
+		case 1:
+			comPrize = prizeTbl[BoardRandMod(3)+2];
+			break;
+			
+		case 2:
+			comPrize = 2;
+			break;
+
+		default:
+			break;
+	}
+	comPlayer1 = BoardRandMod(4);
+	comPlayer2 = comPlayer1;
+	while(comPlayer2 == comPlayer1) {
+		comPlayer2 = BoardRandMod(4);
+	}
+	switch(comPrize) {
+		case 4:
+			ComFortuneAddStar(comPlayer1, comPlayer2, 2);
+			break;
+			
+		case 1:
+			ComFortuneAddStar(comPlayer1, comPlayer2, 1);
+			break;
+			
+		case 2:
+			ComFortuneAddCoin(comPlayer1, comPlayer2, 20);
+			break;
+			
+		case 3:
+			ComFortuneSwapCoin(comPlayer1, comPlayer2);
+			ComFortuneSwapStar(comPlayer1, comPlayer2);
+			break;
+			
+		case 0:
+			ComFortuneSwapCoin(comPlayer1, comPlayer2);
+			break;
+			
+		case 5:
+			ComFortuneSwapStar(comPlayer1, comPlayer2);
+			break;
+	}
+}
+
+static void ComFortuneAddStar(s32 player1, s32 player2, s32 max_stars)
+{
+	s32 stars = GWStarsGet(player1);
+	comStar = stars;
+	if(stars > max_stars) {
+		stars = max_stars;
+	}
+	BoardPlayerStarsAdd(player1, -stars);
+	BoardPlayerStarsAdd(player2, stars);
+}
+
+static void ComFortuneAddCoin(s32 player1, s32 player2, s32 max_stars)
+{
+	s32 stars = BoardPlayerCoinsGet(player1);
+	comCoin = stars;
+	if(stars > max_stars) {
+		stars = max_stars;
+	}
+	BoardPlayerCoinsAdd(player1, -stars);
+	BoardPlayerCoinsAdd(player2, stars);
+}
+
+static void ComFortuneSwapCoin(s32 player1, s32 player2)
+{
+	s32 temp;
+	temp = BoardPlayerCoinsGet(player1);
+	BoardPlayerCoinsSet(player1, BoardPlayerCoinsGet(player2));
+	BoardPlayerCoinsSet(player2, temp);
+}
+
+static void ComFortuneSwapStar(s32 player1, s32 player2)
+{
+	s32 temp;
+	temp = GWStarsGet(player1);
+	GWStarsSet(player1, GWStarsGet(player2));
+	GWStarsSet(player2, temp);
+}
\ No newline at end of file
diff --git a/src/game/board/item.c b/src/game/board/item.c
index 5a330494..b020d72b 100755
--- a/src/game/board/item.c
+++ b/src/game/board/item.c
@@ -11,20 +11,17 @@
 #include "game/window.h"
 #include "game/wipe.h"
 #include "game/board/audio.h"
+#include "game/board/boo.h"
 #include "game/board/com.h"
 #include "game/board/main.h"
 #include "game/board/model.h"
 #include "game/board/player.h"
 #include "game/board/space.h"
+#include "game/board/star.h"
 #include "game/board/ui.h"
 #include "game/board/window.h"
 #include "game/board/view.h"
 
-#include "game/board/star.h"
-#include "game/board/boo.h"
-
-void BoardCharWheelWait(void);
-
 typedef struct {
     /* 0x00 */ s16 unk00;
     /* 0x02 */ s16 unk02;
@@ -52,9 +49,10 @@ typedef struct {
     /* 0x04 */ Vec unk10;
 } UnkGenieCameraStruct; // Size 0x1C
 
-u32 frandmod(u32);
-void BoardBowserSuitInit(s32);
-s16 BoardBowserSuitPlayerModelGet(void);
+extern u32 frandmod(u32);
+extern void BoardBowserSuitInit(s32);
+extern s16 BoardBowserSuitPlayerModelGet(void);
+extern void BoardCharWheelWait(void);
 
 static void ItemProcess(void);
 static void RestoreProcess(void);
@@ -93,14 +91,12 @@ static void RestoreItemMiniSuper(void);
 static void RestoreItemMegaSuper(void);
 static void RestoreItemBowser(void);
 
-// BSS
 static Vec booBallScale;
 static Vec booBallPos;
 static Vec booCamUp;
 static Vec booCamTarget;
 static Vec booCamPos;
 
-// SBSS
 static s16 itemBagItems[3];
 static s8 currItemRestore;
 static s8 currItem;
@@ -110,16 +106,13 @@ static s32 suitCommonMot[2];
 static s16 booBallMdl;
 static float booBallAlpha;
 static char booCoinStr[8];
-// ...
 static float genieFov;
 static AnimData *genieParticleAnim;
 static s16 geniePlayerMot[3];
 static Process *itemProc;
 
-// SDATA
 s32 lbl_801D37A0[2] = { 0x00070075, -1 };
 
-// DATA
 static void (*itemFuncTbl[])(void) = {
     ExecItemMini,
     ExecItemMega,
@@ -137,7 +130,6 @@ static void (*itemFuncTbl[])(void) = {
     ExecItemBag
 };
 
-// DATA + 0x38
 static void (*itemRestoreFuncTbl[])(void) = {
     RestoreItemMini,
     RestoreItemMega,
@@ -155,7 +147,6 @@ static void (*itemRestoreFuncTbl[])(void) = {
     RestoreItemNull
 };
 
-// DATA + 0x70
 static s32 itemMdlTbl[] = {
     0x0007006D,
     0x0007006E,
@@ -173,12 +164,10 @@ static s32 itemMdlTbl[] = {
     0x0007007B
 };
 
-// DATA + 0xA8
 static s32 forceMoveSfxTbl[] = {
     0x38, 0x45, 0x42, 0x4D, 0x48, 0x3F
 };
 
-// DATA + 0xC0
 static s32 callMotTbl[] = {
     0x005F0052,
     0x001A0052,
@@ -190,10 +179,6 @@ static s32 callMotTbl[] = {
     0x00810052
 };
 
-// DATA + 0xE0
-// callHookTbl items
-
-// DATA + 0x178
 static char *callHookTbl[] = {
     "c000m01-itemhook-r",
     "c001m01-itemhook-r",
@@ -205,7 +190,6 @@ static char *callHookTbl[] = {
     "c007m01-itemhook-r"
 };
 
-// DATA + 0x198
 static s32 callAttackMotTbl[] = {
     0x0075001F,
     0x00760005,
@@ -215,7 +199,6 @@ static s32 callAttackMotTbl[] = {
     0x007A0013
 };
 
-// DATA + 0x1B0
 static s32 callAttackMotTbl2[] = {
     0x00750020,
     0x00760006,
@@ -225,7 +208,6 @@ static s32 callAttackMotTbl2[] = {
     0x007A0014
 };
 
-// DATA + 0x1C8
 static s32 suitMotTbl[][2] = {
     { 0x00040001, 0x00040002 },
     { 0x00040004, 0x00040005 },
@@ -301,7 +283,7 @@ static void ItemSizeShowAnim(void) {
     BoardModelRotSetV(suitMdl, &spC);
     BoardModelPosSetV(suitMdl, &sp24);
     for (i = 0; i < 120; i++) {
-        sp24.y += 3.0 * sin(M_PI * var_f31 / 180.0);
+        sp24.y += 3.0 * sin(var_f31 * M_PI / 180.0);
         BoardModelPosSetV(suitMdl, &sp24);
         var_f31 += 9.0f;
         if (var_f31 >= 360.0f) {
@@ -334,7 +316,7 @@ static void ItemRotProc(void) {
     while (1) {
         if (temp_r31->unk00 == 0) {
             sp14 = sp20;
-            sp14.y += temp_r31->unk04 * sin(M_PI * temp_r31->unk0C / 180.0);
+            sp14.y += temp_r31->unk04 * sin(temp_r31->unk0C * M_PI / 180.0);
             BoardModelPosSetV(temp_r31->unk02, &sp14);
             temp_r31->unk0C += temp_r31->unk08;
             if (temp_r31->unk0C >= 360.0f) {
@@ -446,8 +428,8 @@ static void BoardUiInlineFunc02(void) {
 static inline void BoardUiInlineFunc03(s32 arg0) {
     Vec sp8;
     Vec sp14;
-	s32 space = GWPlayer[arg0].space_curr;
-	
+    s32 space = GWPlayer[arg0].space_curr;
+
     BoardSpacePosGet(0, space, &sp14);
     BoardPlayerPosGet(arg0, &sp8);
     BoardPlayerPosLerpStart(arg0, &sp8, &sp14, 0x14);
@@ -774,7 +756,7 @@ static void ExecItemHammer(void) {
 }
 
 static void ExecItemPipe(void) {
-	Vec spE4[2];
+    Vec spE4[2];
     Vec spCC[2];
     Vec spB4[2];
     Vec spA8;
@@ -987,10 +969,10 @@ static void ExecItemPipe(void) {
     for (var_r31 = 0; var_r31 < 2; var_r31++) {
         BoardModelKill(sp30[var_r31]);
     }
-	HuPrcKill(NULL);
-	while (1) {
-		HuPrcVSleep();
-	}
+    HuPrcKill(NULL);
+    while (1) {
+        HuPrcVSleep();
+    }
 }
 
 static void ExecItemSwap(void) {
@@ -1140,12 +1122,12 @@ static void ExecItemSwap(void) {
     for (var_r31 = 0; var_r31 < 0x3C; var_r31++) {
         for (var_r30 = 0; var_r30 < var_r28 / 2; var_r30++) {
             sp6C = sp1A4[var_r30];
-            sp6C.x += 3.0 * sin((M_PI * (frand() % 360)) / 180.0);
-            sp6C.y += 3.0 * sin((M_PI * (frand() % 360)) / 180.0);
+            sp6C.x += 3.0 * sin((frand() % 360) * M_PI / 180.0);
+            sp6C.y += 3.0 * sin((frand() % 360) * M_PI / 180.0);
             BoardModelPosSetV(sp54[var_r30], &sp6C);
             sp6C = sp180[var_r30];
-            sp6C.x += 3.0 * sin((M_PI * (frand() % 360)) / 180.0);
-            sp6C.y += 3.0 * sin((M_PI * (frand() % 360)) / 180.0);
+            sp6C.x += 3.0 * sin((frand() % 360) * M_PI / 180.0);
+            sp6C.y += 3.0 * sin((frand() % 360) * M_PI / 180.0);
             BoardModelPosSetV(sp54[var_r30 + 3], &sp6C);
         }
         HuPrcSleep(2);
@@ -1227,8 +1209,8 @@ static void ExecItemSpark(void) {
     s32 temp_r28;
     s16 temp_r30;
     s32 i;
-	
-	(void)106.0;
+
+    (void)106.0;
     temp_r30 = BoardModelCreate(0x70067, NULL, 0);
     BoardModelLayerSet(temp_r30, 3);
     BoardModelVisibilitySet(temp_r30, 0);
@@ -1279,8 +1261,8 @@ static void ExecItemSpark(void) {
     BoardSpaceRotGet(0, GWPlayer[currItemRestore].space_curr, &sp20);
     BoardModelRotSetV(suitMdl, &sp20);
     BoardModelPosGet(suitMdl, &sp2C);
-    sp2C.z += 106.0 * sin(M_PI * sp20.x / 180.0);
-    sp2C.x -= 106.0 * sin(M_PI * sp20.z / 180.0);
+    sp2C.z += 106.0 * sin(sp20.x * M_PI / 180.0);
+    sp2C.x -= 106.0 * sin(sp20.z * M_PI / 180.0);
     BoardModelPosSetV(suitMdl, &sp2C);
     HuAudFXPlay(0x31B);
     BoardModelMotionStart(suitMdl, 1, 0);
@@ -1335,7 +1317,6 @@ static void ExecItemLight(void) {
     }
 }
 
-// https://decomp.me/scratch/gbgTk
 static void ExecItemWhistle(void) {
     Vec spF0[4];
     Vec spC0[4];
@@ -1354,22 +1335,21 @@ static void ExecItemWhistle(void) {
     s16 sp8;
     float var_f30;
     float var_f31;
-	s32 temp_r23;
-	char *temp_r22;
+    s32 temp_r23;
+    char *temp_r22;
     s32 temp_r18;
-	s16 temp_r17;
+    s16 temp_r17;
     s16 temp_r21;
     s16 temp_r20;
     s32 temp_r31;
     s16 temp_r28;
-	s16 temp_r19;
-	s32 var_r26;
+    s16 temp_r19;
+    s32 var_r26;
     s16 var_r25;
     s16 var_r27;
     s32 var_r29;
     s32 var_r31;
-	
-	
+
     var_r31 = GWPlayerCfg[currItemRestore].character;
     temp_r23 = BoardPlayerMotionCreate(currItemRestore, callMotTbl[var_r31]);
     temp_r22 = callHookTbl[var_r31];
@@ -1379,7 +1359,7 @@ static void ExecItemWhistle(void) {
     temp_r19 = GWBoardGet();
     temp_r21 = BoardModelMotionCreate(temp_r28, callAttackMotTbl[temp_r19]);
     temp_r20 = BoardModelMotionCreate(temp_r28, callAttackMotTbl2[temp_r19]);
-    var_f31 = 360.0f * (0.003921569f * (s32)((u8) frand()));
+    var_f31 = 0.003921569f * (frand() & 0xFF) * 360.0f;
     spA8.x = spA8.y = spA8.z = 0.5f;
     for (var_r31 = 0; var_r31 < 4; var_r31++) {
         sp20[var_r31] = BoardModelCreate(0x20027, NULL, 1);
@@ -1387,9 +1367,9 @@ static void ExecItemWhistle(void) {
         temp_r17 = BoardModelMotionCreate(sp20[var_r31], 0x20028);
         BoardModelMotionStart(sp20[var_r31], temp_r17, 0x40000001);
         sp28[var_r31] = 120.0f;
-        spF0[var_r31].x = spB4.x + 120.0 * sin(M_PI * var_f31 / 180.0);
+        spF0[var_r31].x = spB4.x + 120.0 * sin(var_f31 * M_PI / 180.0);
         spF0[var_r31].y = 1000.0f + spB4.y + 100.0f * var_r31;
-        spF0[var_r31].z = spB4.z + 120.0 * cos(M_PI * var_f31 / 180.0);
+        spF0[var_r31].z = spB4.z + 120.0 * cos(var_f31 * M_PI / 180.0);
         spC0[var_r31].x = spC0[var_r31].z = 0.0f;
         spC0[var_r31].y = var_f31 + 90.0f;
         if (spC0[var_r31].y >= 360.0f) {
@@ -1508,8 +1488,8 @@ static void ExecItemWhistle(void) {
             if (spC0[var_r31].y >= 360.0f) {
                 spC0[var_r31].y -= 360.0f;
             }
-            spF0[var_r31].x = spB4.x + 120.0 * sin(M_PI * sp38[var_r31] / 180.0);
-            spF0[var_r31].z = spB4.z + 120.0 * cos(M_PI * sp38[var_r31] / 180.0);
+            spF0[var_r31].x = spB4.x + 120.0 * sin(sp38[var_r31] * M_PI / 180.0);
+            spF0[var_r31].z = spB4.z + 120.0 * cos(sp38[var_r31] * M_PI / 180.0);
             BoardModelPosSetV(sp20[var_r31], &spF0[var_r31]);
             BoardModelRotSetV(sp20[var_r31], &spC0[var_r31]);
         }
@@ -1541,8 +1521,8 @@ static void ExecItemWhistle(void) {
                     spF0[var_r31].y = spB4.y;
                     sp48[var_r31] = -1.0f;
                 }
-                spF0[var_r31].x = spB4.x + sp28[var_r31] * sin(M_PI * sp38[var_r31] / 180.0);
-                spF0[var_r31].z = spB4.z + sp28[var_r31] * cos(M_PI * sp38[var_r31] / 180.0);
+                spF0[var_r31].x = spB4.x + sp28[var_r31] * sin(sp38[var_r31] * M_PI / 180.0);
+                spF0[var_r31].z = spB4.z + sp28[var_r31] * cos(sp38[var_r31] * M_PI / 180.0);
                 BoardModelPosSetV(sp20[var_r31], &spF0[var_r31]);
             }
         }
@@ -1571,7 +1551,7 @@ static void ExecItemWhistle(void) {
         BoardModelKill(sp20[var_r31]);
     }
     BoardModelMotionKill(temp_r28, temp_r21);
-	BoardModelMotionKill(temp_r28, temp_r20);
+    BoardModelMotionKill(temp_r28, temp_r20);
     BoardStarShowNext(currItemRestore);
     HuPrcKill(NULL);
     while (1) {
@@ -1654,9 +1634,9 @@ static void ExecItemBowser(void) {
 }
 
 static s32 booMotTbl[3] = {
-	0x00020018,
-	0x00020016,
-	-1
+    0x00020018,
+    0x00020016,
+    -1
 };
 
 static inline void ExecItemBooBallInlineFunc01(s32 speed) {
@@ -1715,7 +1695,7 @@ static inline void ExecItemBooBallInlineFunc02(s32 speed) {
         BoardModelPosSetV(booBallMdl, &booBallPos);
         HuPrcVSleep();
     }
-	booBallPos.y = sp20.y + 20.0f;
+    booBallPos.y = sp20.y + 20.0f;
     booBallScale.x = booBallScale.y = booBallScale.z = 1.0f;
     booBallAlpha = 255.0f;
     BoardModelPosSetV(booBallMdl, &booBallPos);
@@ -1723,7 +1703,6 @@ static inline void ExecItemBooBallInlineFunc02(s32 speed) {
     BoardModelAlphaSet(booBallMdl, booBallAlpha);
 }
 
-// https://decomp.me/scratch/0M6lm
 static void ExecItemBooBall(void) {
     UnkItemShowProcStruct spA0;
     UnkItemShowProcStruct sp80;
@@ -1747,7 +1726,6 @@ static void ExecItemBooBall(void) {
     BoardModelLayerSet(booBallMdl, 2);
     BoardModelAttrSet(booBallMdl, 2);
     BoardModelVisibilitySet(booBallMdl, 0);
-    // Inline? (same pattern in ExecItemGenie)
     spA0.unk02 = suitMdl;
     spA0.unk04 = 4.0f;
     spA0.unk08 = 3.0f;
@@ -1755,17 +1733,14 @@ static void ExecItemBooBall(void) {
     spA0.unk1C = 1;
     HuAudFXPlay(0x350);
     temp_r17 = ItemShowProc(&spA0, NULL);
-    // ======================================
     BoardModelPosGet(suitMdl, &booBallPos);
     ExecItemBooBallInlineFunc02(60);
-    // Inline? =================================
     sp80.unk02 = booBallMdl;
     sp80.unk04 = 4.0f;
     sp80.unk08 = 4.0f;
     sp80.unk10 = sp80.unk14 = sp80.unk18 = 0.0f;
     sp80.unk1C = 1;
     sp1C = BoardUiInlineFunc05(&sp80);
-    // ======================================
     BoardMusStart(1, 1, 0x7F, 0);
     HuAudFXPlay(0x4C);
     BoardWinCreate(2, 0x120015, 3);
@@ -1791,14 +1766,14 @@ static void ExecItemBooBall(void) {
         do {
             BoardWinCreateChoice(4, 0x120018, 3, 0);
             BoardWinAttrSet(0x10);
-            if (BoardPlayerCoinsGet(currItemRestore) < 0x32 || var_r28 == 0) {
+            if (BoardPlayerCoinsGet(currItemRestore) < 50 || var_r28 == 0) {
                 BoardWinChoiceDisable(1);
             }
             if (var_r26 == 0) {
                 BoardWinChoiceDisable(0);
             }
             if (GWPlayer[currItemRestore].com) {
-                if (var_r28 != 0 && BoardPlayerCoinsGet(currItemRestore) >= 0x32) {
+                if (var_r28 != 0 && BoardPlayerCoinsGet(currItemRestore) >= 50) {
                     BoardComKeySetDown();
                 } else {
                     BoardComKeySetUp();
@@ -1944,9 +1919,9 @@ static void ExecItemBooBall(void) {
 
 static void ForceConsts(void)
 {
-	(void)-0.5f;
-	(void)40.0f;
-	(void)125.0f;
+    (void)-0.5f;
+    (void)40.0f;
+    (void)125.0f;
 }
 
 static void LampParticleUpdate(s32 arg0, ParticleData *arg1) {
@@ -2071,7 +2046,6 @@ static void GenieParticleUpdate(s32 arg0, ParticleData *arg1) {
     }
 }
 
-// DATA + 0x224
 static Vec shadowPos = { 0.0f, 4500.0f, 500.0f };
 static Vec shadowTarget = { 0.0f, 0.9f, -0.1f };
 static Vec shadowUp = { 0.0f, 0.0f, 500.0f };
@@ -2136,7 +2110,6 @@ static void GenieCameraCalc(UnkGenieCameraStruct *arg0, s32 arg1, float arg2, Ve
     }
 }
 
-// DATA + 0x248
 static s32 armUpMotTbl[] = {
     0x005F005C,
     0x001A005C,
@@ -2148,7 +2121,6 @@ static s32 armUpMotTbl[] = {
     0x0081005C
 };
 
-// DATA + 0x268
 static s32 scareMotTbl[] = {
     0x005F001C,
     0x001A001C,
@@ -2160,7 +2132,6 @@ static s32 scareMotTbl[] = {
     0x0081001C
 };
 
-// DATA + 0x288
 static s32 impactMotTbl[] = {
     0x005F005E,
     0x001A005E,
@@ -2172,7 +2143,6 @@ static s32 impactMotTbl[] = {
     0x0081005E
 };
 
-// DATA + 0x2A8
 static UnkGenieCameraStruct cameraDataTbl[] = {
     60.0f, {    0.0f, 100.0f,  950.0f }, { 0.0f, 100.0f, 600.0f },
     60.0f, { -353.0f, 100.0f,  662.5f }, { 0.0f, 100.0f, 600.0f },
@@ -2187,7 +2157,6 @@ static UnkGenieCameraStruct cameraDataTbl[] = {
      5.0f, {    0.0f, 100.0f, -200.0f }, { 0.0f, 500.0f, 600.0f }
 };
 
-// DATA + 0x3DC
 static s32 genieMotTbl[] = {
     0x0007007D,
     0x0007007E,
@@ -2594,7 +2563,7 @@ static void ExecItemBagShow(void) {
             break;
         }
         sp8 = sp14;
-        sp8.y += 15.0 * sin(M_PI * var_f31 / 180.0);
+        sp8.y += 15.0 * sin(var_f31 * M_PI / 180.0);
         BoardModelPosSetV(suitMdl, &sp8);
         var_f31 += 36.0f;
         HuPrcVSleep();
diff --git a/src/game/board/lottery.c b/src/game/board/lottery.c
index e08f6781..745fd903 100755
--- a/src/game/board/lottery.c
+++ b/src/game/board/lottery.c
@@ -101,7 +101,7 @@ static s32 handUpdateF;
 // ...
 static omObjData *lotteryTicketPickObj;
 static s8 (*comInputDrawP)[2];
-Process *lotteryProc;
+static Process *lotteryProc;
 
 static s16 hostMdl = -1;
 static s16 lotteryMot[4] = { -1, -1, -1, -1 };
@@ -1032,7 +1032,7 @@ static void ExecBallPrize(void) {
     }
 }
 
-const s32 lbl_8011DFD0[] = {
+static const s32 pickSpr[] = {
     0x0007001E,
     0x0007001F,
     0x00070020,
@@ -1043,7 +1043,7 @@ const s32 lbl_8011DFD0[] = {
     0x00070025
 };
 
-const s32 lbl_8011DFF0[] = {
+static const s32 handMdl[] = {
     0x00050009,
     0x0005000A,
     0x0005000B,
@@ -1054,7 +1054,7 @@ const s32 lbl_8011DFF0[] = {
     0x00050010
 };
 
-const s32 lbl_8011E010[] = {
+static const s32 ticketSpr[] = {
     0x0005001D,
     0x0005001E,
     0x0005001F,
@@ -1104,7 +1104,7 @@ static void ExecScratchTicket(s32 arg0) {
     var_r24 = GWPlayer[GWSystem.player_curr].character;
     var_r22 = ticketObj[arg0];
     temp_r30 = OM_GET_WORK_PTR(var_r22, TicketWork);
-    lotteryMdl[4] = BoardModelCreate(lbl_8011DFF0[var_r24], NULL, 0);
+    lotteryMdl[4] = BoardModelCreate(handMdl[var_r24], NULL, 0);
     BoardModelLayerSet(lotteryMdl[4], 6);
     BoardModelPassSet(lotteryMdl[4], 0);
     BoardCameraDirGet(&spC);
@@ -1295,7 +1295,7 @@ static void InitScratchSpr(void) {
         temp_r31->trans.y = 98.0f + 110.0f * (i / 4);
         temp_r31->rot.x = -56.0f;
         temp_r31->rot.y = temp_r31->trans.y;
-        BoardSpriteCreate(lbl_8011E010[ticketPrize[i]], 0x157C, NULL, &sp8);
+        BoardSpriteCreate(ticketSpr[ticketPrize[i]], 0x157C, NULL, &sp8);
         HuSprGrpMemberSet(temp_r28, i, sp8);
         HuSprPosSet(temp_r28, i, temp_r31->rot.x, temp_r31->rot.y);
         HuSprAttrSet(temp_r28, i, 8);
@@ -1417,7 +1417,7 @@ static void InitScratchPick(void) {
     var_r31->unk00_field0 = 0;
     var_r31->unk01 = GWPlayer[GWSystem.player_curr].character;
     var_r31->unk08 = HuSprGrpCreate(1);
-    BoardSpriteCreate(lbl_8011DFD0[var_r31->unk01], 0x1388, 0, &var_r31->unk06);
+    BoardSpriteCreate(pickSpr[var_r31->unk01], 0x1388, 0, &var_r31->unk06);
     HuSprGrpMemberSet(var_r31->unk08, 0, var_r31->unk06);
     HuSprAttrSet(var_r31->unk08, 0, 8);
     HuSprPosSet(var_r31->unk08, 0, temp_f31, temp_f30);
diff --git a/src/game/board/main.c b/src/game/board/main.c
index 41990f14..ba00341f 100644
--- a/src/game/board/main.c
+++ b/src/game/board/main.c
@@ -8,6 +8,7 @@
 #include "string.h"
 #include "game/hsfman.h"
 #include "game/hsfdraw.h"
+#include "game/board/battle.h"
 #include "game/board/lottery.h"
 #include "game/board/main.h"
 #include "game/board/model.h"
@@ -24,7 +25,6 @@ typedef struct camera_view {
 	s16 fov;
 } CameraView;
 
-
 omObjData *boardMainObj;
 u32 boardRandSeed;
 static omObjData *last5GfxObj;
@@ -619,16 +619,10 @@ static void CreateBoard(void)
 	GWSystem.mg_next = -1;
 	if(!GWGameStat.field10E_bit5) {
 		s32 type_temp;
-		if(GWSystem.mg_list == 3) {
-			GWSystem.mg_list = 0;
-		}
 		if(GWMGListGet() == 2) {
 			GWSystem.mg_list = 0;
 		}
 	}
-	if(GWSystem.mess_speed == 3) {
-		GWSystem.mess_speed = 1;
-	}
 	mess_speed = GWMessSpeedGet();
 	GWSystem.mess_speed = mess_speed;
 	switch(mess_speed) {
diff --git a/src/game/board/pause.c b/src/game/board/pause.c
index ed26e8a7..17e379e2 100755
--- a/src/game/board/pause.c
+++ b/src/game/board/pause.c
@@ -151,27 +151,6 @@ void BoardPauseStart(void) {
     HuPrcDestructorSet2(mainProcess, PauseExit);
 }
 
-static inline s32 PauseExitInlineFunc01(void) {
-    if (GWSystem.mg_list == 3) {
-        GWSystem.mg_list = 0;
-    }
-    return GWSystem.mg_list;
-}
-
-static inline s32 PauseExitInlineFunc02(void) {
-    if (GWSystem.mess_speed == 3) {
-        GWSystem.mess_speed = 1;
-    }
-    return GWSystem.mess_speed;
-}
-
-static inline s32 PauseExitInlineFunc03(void) {
-    if (GWSystem.save_mode == 3) {
-        GWSystem.save_mode = 1;
-    }
-    return GWSystem.save_mode;
-}
-
 static void PauseExit(void) {
     if (pauseQuitF == 0) {
         BoardRollWinDispSet(1);
@@ -200,15 +179,15 @@ static void PauseExit(void) {
     if (GWPartyGet() == 0) {
         GWGameStat.field10F_bit0 = GWMGExplainGet();
         GWGameStat.field10F_bit1 = GWMGShowComGet();
-        GWGameStat.field10F_bit2 = PauseExitInlineFunc01();
-        GWGameStat.field10F_bit4 = PauseExitInlineFunc02();
-        GWGameStat.field10F_bit6 = PauseExitInlineFunc03();
+        GWGameStat.field10F_bit2 = GWMGListGet();
+        GWGameStat.field10F_bit4 = GWMessSpeedGet();
+        GWGameStat.field10F_bit6 = GWSaveModeGet();
     } else {
         GWGameStat.field110_bit0 = GWMGExplainGet();
         GWGameStat.field110_bit1 = GWMGShowComGet();
-        GWGameStat.field110_bit2 = PauseExitInlineFunc01();
-        GWGameStat.field110_bit4 = PauseExitInlineFunc02();
-        GWGameStat.field110_bit6 = PauseExitInlineFunc03();
+        GWGameStat.field110_bit2 = GWMGListGet();
+        GWGameStat.field110_bit4 = GWMessSpeedGet();
+        GWGameStat.field110_bit6 = GWSaveModeGet();
     }
     mainProcess = NULL;
 }
@@ -390,7 +369,7 @@ void CreatePauseScreen(void) {
                 var_f31 = (var_r28 != 0) ? 0.0f : -90.0f;
                 break;
             case 3:
-                var_r28 = PauseExitInlineFunc01();
+                var_r28 = GWMGListGet();
                 switch (var_r28) {
                     case 1:
                         var_r28 = 0;
@@ -411,7 +390,7 @@ void CreatePauseScreen(void) {
                 var_f31 = (var_r28 != 0) ? 0.0f : -90.0f;
                 break;
             case 5:
-                var_r28 = PauseExitInlineFunc02();
+                var_r28 = GWMessSpeedGet();
                 switch (var_r28) {
                     case 2:
                         var_r28 = 0;
@@ -431,7 +410,7 @@ void CreatePauseScreen(void) {
                 if (temp_r29->unk00_field4 != 0) {
                     GWSystem.save_mode = 1;
                 }
-                var_r28 = PauseExitInlineFunc03();
+                var_r28 = GWSaveModeGet();
                 switch (var_r28) {
                     case 1:
                         var_r28 = 0;
diff --git a/src/game/board/space.c b/src/game/board/space.c
index cd504e5f..cf0118d0 100644
--- a/src/game/board/space.c
+++ b/src/game/board/space.c
@@ -1,5 +1,6 @@
 #include "game/gamework_data.h"
 #include "game/flag.h"
+#include "game/board/battle.h"
 #include "game/board/lottery.h"
 #include "game/board/main.h"
 #include "game/board/model.h"
diff --git a/src/game/board/ui.c b/src/game/board/ui.c
index 1087afd6..7b271d71 100755
--- a/src/game/board/ui.c
+++ b/src/game/board/ui.c
@@ -1339,7 +1339,7 @@ static void ExecItemPick(void) {
         itemPosTemp[j].x -= 8.0f;
         itemPosTemp[j].y += 16.0f;
     }
-    sp18 = BoardComTutorialItemGet(itemPlayer);
+    sp18 = BoardComUseItemSlotGet(itemPlayer);
     ExecItemPickInlineFunc02(itemPlayer, var_r23, sp18);
 }
 
diff --git a/src/game/board/window.c b/src/game/board/window.c
index 7dbd1780..6a5e2e0f 100644
--- a/src/game/board/window.c
+++ b/src/game/board/window.c
@@ -75,13 +75,13 @@ static void ExecBoardWindow(void) {
     f32 *size_win;
     WindowData *win_curr = NULL;
 
-    f32 var_50[7][2] = {
+    f32 size_all[7][2] = {
         {384.0f,  64.0f}, {432.0f, 192.0f},
         {504.0f,  96.0f}, {432.0f, 128.0f},
         {288.0f, 192.0f}, {432.0f,  96.0f},
         {432.0f,  96.0f},
     };
-    f32 var_18[7][2] = {
+    f32 pos_all[7][2] = {
         {96.0f, 328.0f},  {72.0f, 128.0f},
         {36.0f, 344.0f},  {128.0f, 312.0f},
         {144.0f, 144.0f}, {128.0f, 264.0f},
@@ -89,8 +89,8 @@ static void ExecBoardWindow(void) {
     };
     
     if (windowID < 0) {
-        size_win = var_50[winPosIdx];
-        pos_win = var_18[winPosIdx];
+        size_win = size_all[winPosIdx];
+        pos_win = pos_all[winPosIdx];
         HuWinMesMaxSizeGet(1, size, winMess);
         if (size[0] <= size_win[0]) {
             size[0] = size_win[0];
@@ -182,7 +182,6 @@ void BoardWinPause(void) {
 
 void BoardWinCreateChoice(s32 pos, u32 mess, s32 portrait, s32 choice) {
     s32 i;
-    
 
     winPosIdx = pos;
     winChoice = 0;
@@ -209,9 +208,6 @@ void BoardWinCreateChoice(s32 pos, u32 mess, s32 portrait, s32 choice) {
         HuPrcDestructorSet2(winProc, &BoardWinDestroy);
     }
     winMess = mess;
-    if (GWSystem.mess_speed == 3) {
-        GWSystem.mess_speed = 1;
-    }
     BoardWinSpeedSet(GWMessSpeedGet());
     BoardWinPlayerSet(GWSystem.player_curr);
 }
@@ -244,9 +240,6 @@ void BoardWinCreate(s32 pos, u32 mess, s32 portrait) {
         HuPrcDestructorSet2(winProc, &BoardWinDestroy);
     }
     winMess = mess;
-    if (GWSystem.mess_speed == 3) {
-        GWSystem.mess_speed = 1;
-    }
     BoardWinSpeedSet(GWMessSpeedGet());
     BoardWinPlayerSet(GWSystem.player_curr);
     autoPickF = 0;
@@ -300,13 +293,7 @@ void BoardWinKeyWait(void) {
 }
 
 int BoardWinSpeedGet(void) {
-    s32 speed;
-
-    if (GWSystem.mess_speed == 3) {
-        GWSystem.mess_speed = 1;
-    }
-    speed = GWSystem.mess_speed;
-    return winSpeedTbl[speed];
+    return winSpeedTbl[GWMessSpeedGet()];
 }
 
 void BoardWinSpeedSet(s32 value) {
@@ -348,12 +335,10 @@ s32 BoardWinPortraitGetStar(void) {
 }
 
 void BoardWinPlayerSet(s32 player) {
-    s32 temp;
     s32 i;
 
     if (player == -1) {
-        temp = GWSystem.party;
-        if (temp != 1) {
+        if (GWPartyGet() != 1) {
             for (i = 0, disablePlayer = i; i < 4; i++) {
                 if (GWPlayer[i].com != 0) {
                     disablePlayer |= 1 << GWPlayer[i].port;