From 620c6766570a88184ba49e4908e382f1b693e309 Mon Sep 17 00:00:00 2001
From: gamemasterplc <gamemasterplc@gmail.com>
Date: Fri, 8 Mar 2024 22:56:12 -0600
Subject: [PATCH 1/7] Decompile more of board/player.c

DoSparkSpace incomplete
---
 config/GMPE01_00/symbols.txt |   3 +-
 include/game/board/player.h  |  21 +--
 include/game/chrman.h        |   2 +-
 src/game/board/player.c      | 321 +++++++++++++++++++++++++++++++----
 src/game/chrman.c            |   2 +-
 5 files changed, 295 insertions(+), 54 deletions(-)

diff --git a/config/GMPE01_00/symbols.txt b/config/GMPE01_00/symbols.txt
index 8a4b938c..bcb359ee 100644
--- a/config/GMPE01_00/symbols.txt
+++ b/config/GMPE01_00/symbols.txt
@@ -5184,7 +5184,8 @@ lbl_8013997C = .data:0x8013997C; // type:object size:0x20
 boardMotTbl = .data:0x8013999C; // type:object size:0x20 scope:local
 boardMotRevTbl = .data:0x801399BC; // type:object size:0x20 scope:local
 bowserSuitCharMdlTbl = .data:0x801399DC; // type:object size:0x20 scope:local
-bowserSuitMotTbl = .data:0x801399FC; // type:object size:0x34 scope:local
+bowserSuitMotTbl = .data:0x801399FC; // type:object size:0x14 scope:local
+sparkMotTbl = .data:0x80139A10; // type:object size:0x20 scope:local
 boardSparkSfxTbl = .data:0x80139A30; // type:object size:0x20 scope:local
 boardSparkSfxTblAlt = .data:0x80139A50; // type:object size:0x20 scope:local
 megaSquishObj = .data:0x80139A70; // type:object size:0x10 scope:local
diff --git a/include/game/board/player.h b/include/game/board/player.h
index 3956df8b..3f47a342 100644
--- a/include/game/board/player.h
+++ b/include/game/board/player.h
@@ -115,32 +115,23 @@ void BoardJunctionMaskSet(s32);
 void BoardJunctionMaskReset(s32);
 void BoardJunctionMaskZero(void);
 void BoardPlayerVoiceEnableSet(s32, s32, s32);
-void InitJunction(s32, s32, f32);
-static void UpdateJunctionGfx(omObjData*);
-static void StopJunctionPlayer(s32);
-static void RestoreJunction(f32, s32);
-static s32 GetDefaultDirection(f32, f32*, s32);
-static s32 DoDebugMove(s32, s16*);
-static s32 ExecJunction(s32, s16*);
+
+
 void BoardPlayerMoveTo(s32, s32);
 void BoardPlayerMoveBetween(s32, s32, s32);
 void BoardPlayerMoveToAsync(s32, s32);
 void BoardPlayerPosLerpStart(s32, Vec*, Vec*, s16);
-static void PlayerPosLerpFunc(omObjData*);
 void BoardPlayerDiceJumpStart(s32);
 s32 BoardPlayerDiceJumpCheck(s32);
-static void DiceJumpFunc(omObjData*);
 void BoardRotateDiceNumbers(s32);
 void BoardPlayerMotBlendSet(s32 arg0, s16 arg1, s16 arg2);
-static void UpdateDiceDigitSprite(omObjData*);
-static void UpdateDiceDigit2D(omObjData*);
+
 void BoardPlayerBtnDownWait(s32, u32);
 void BoardPlayerAutoSizeSet(s32, s32);
 s32 BoardPlayerAutoSizeGet(s32);
 u32 BoardPlayerMoveAwayIsDone(void);
 void BoardPlayerMoveAwayStart(s32, s32, s32);
 void BoardPlayerMoveAwayStartCurr(s32, s32);
-static void MoveAwayObjFunc(omObjData*);
 void BoardPlayerCopyMat(s32);
 void BoardBowserSuitMotionSetJump(void);
 //...
@@ -149,21 +140,17 @@ s32 BoardPlayerAutoSizeGet(s32);
 void BoardPlayerAutoSizeSet(s32, s32);
 void BoardPlayerCopyMat(s32);
 void BoardBowserSuitKill(s32);
-void SetRollPlayerSize(s32);
 void BoardDiceDigit2DInit(s32, s32);
 void BoardDiceDigit2DUpdateEnable(s32);
-s32 DoSparkSpace(s32, s32);
-s32 MegaPlayerPassFunc(s32, s16);
+void BoardPlayerResizeAnimExec(s32 player, s32 size);
 s32 BoardPlayerAnimBlendCheck(s32);
 void BoardBowserSuitMotionSetWait(void);
 void BoardBowserSuitPlayerModelKill(void);
 void BoardDiceDigit2DShowSet(s32);
-s32 MegaPlayerPassFunc(s32, s16);
 s32 BoardPlayerMotBlendCheck(s32);
 void BoardPlayerMoveAwayStartCurr(s32, s32);
 void BoardBowserSuitMotionSetWalk(void);
 s16 BoardBowserSuitModelGet(void);
-void UpdateDiceDigit2D(omObjData*);
 void MoveAwayObjFunc(omObjData*);
 void UpdateBowserSuit(omObjData*);
 
diff --git a/include/game/chrman.h b/include/game/chrman.h
index 05f5033d..0dd38dc2 100755
--- a/include/game/chrman.h
+++ b/include/game/chrman.h
@@ -42,6 +42,6 @@ void fn_8004F52C(s16 character, s32 arg1);
 void CharModelEffectEnableSet(s16 character, s32 arg1);
 s32 CharModelEffectNpcInit(s16 arg0, s16 arg1, s16 arg2, s16 arg3);
 s32 CharModelEffectNpcInitSilent(s16 arg0, s16 arg1, s16 arg2);
-void CharModelStepTypeSet(s16 character, s32 arg1);
+s32 CharModelStepTypeSet(s16 character, s32 arg1);
 
 #endif
diff --git a/src/game/board/player.c b/src/game/board/player.c
index f7d23fc0..11904f3d 100644
--- a/src/game/board/player.c
+++ b/src/game/board/player.c
@@ -10,8 +10,35 @@
 #include "game/board/ui.h"
 #include "game/board/view.h"
 #include "game/board/model.h"
+#include "game/board/item.h"
+#include "game/board/basic_space.h"
+#include "game/board/audio.h"
 #include "game/pad.h"
 
+static void InitJunction(s32, s32, f32);
+static void UpdateJunctionGfx(omObjData*);
+static void StopJunctionPlayer(s32);
+static void RestoreJunction(f32, s32);
+
+static s32 GetDefaultDirection(f32, f32*, s32);
+static s32 DoDebugMove(s32, s16*);
+static s32 ExecJunction(s32, s16*);
+
+static void PlayerPosLerpFunc(omObjData*);
+static void DiceJumpFunc(omObjData*);
+
+static void UpdateDiceDigitSprite(omObjData*);
+static void UpdateDiceDigit2D(omObjData*);
+static void MoveAwayObjFunc(omObjData*);
+
+static void MoveAwayObjFunc(omObjData*);
+static void UpdateBowserSuit(omObjData*);
+
+static s32 DoSparkSpace(s32 player, s32 pause_cam);
+static void RemoveSparkSpace(s32 player);
+static void SetRollPlayerSize(s32 player);
+static s32 MegaPlayerPassFunc(s32, s16);
+
 //TODO: Give better name
 typedef struct bitcopy {
     struct {
@@ -89,9 +116,12 @@ static s32 bowserSuitCharMdlTbl[] = {
 
 static s32 bowserSuitMotTbl[] = {
     0x40019, 0x4001A, 0x4001B, 0x4001E,
-    0x4001F, 0x70095, 0x70096, 0x70097,
-    0x70098, 0x70099, 0x7009A, 0x7009B,
-    0x7009C,
+    0x4001F
+};
+
+static s32 sparkMotTbl[] = {
+	0x70095, 0x70096, 0x70097, 0x70098,
+	0x70099, 0x7009A, 0x7009B, 0x7009C,
 };
 
 static s32 boardSparkSfxTbl[] = {
@@ -113,15 +143,6 @@ static s32 megaSquishSfxTbl[] = {
     0x228, 0x268, 0x2A8, 0x2E8,
 };
 
-inline PlayerState* GetPlayer(s32 index) {
-    return &GWPlayer[index];
-}
-
-inline s16 GetBoardPlayer(s32 index) {
-    PlayerState *player = GetPlayer(index);
-    return boardPlayerMdl[player->player_idx];
-}
-
 s32 BoardRollTypeGet(void) {
     return rollType;
 }
@@ -511,8 +532,9 @@ void BoardPlayerMotionStart(s32 arg0, s32 arg1, s32 arg2) {
 }
 
 void BoardPlayerMotionShiftSet(s32 arg0, s32 arg1, f32 arg8, f32 arg9, u32 arg2) {
+	s32 temp_r29;
     PlayerState* player;
-    s32 temp_r29;
+    
     
     player = BoardPlayerGet(arg0);
     if (arg1 == 0) {
@@ -592,7 +614,7 @@ void BoardPlayerSizeSet(s32 arg0, s32 arg1) {
     } else {
         CharModelStepTypeSet(GWPlayer[arg0].character, 0);
     }
-    BoardModelScaleSetV(BoardPlayerModelGet(arg0), &temp_r4[arg1]);
+    BoardPlayerScaleSetV(arg0, &temp_r4[arg1]);
 }
 
 s32 BoardPlayerSizeGet(s32 idx) {
@@ -1725,21 +1747,14 @@ static void DiceJumpFunc(omObjData* arg0) {
     }
 }
 
-void BoardRotateDiceNumbers(s32 arg0) {
-    PlayerState* temp_r27;
-    s32 var_r29;
 
-    if (GWPlayer[arg0].bowser_suit != 0) {
+void BoardRotateDiceNumbers(s32 arg0)
+{
+    if (GWPlayer[arg0].bowser_suit) {
         BoardBowserSuitMotionSetWait();
         BoardBowserSuitPlayerModelKill();
     }
-    temp_r27 = BoardPlayerGet(arg0);
-    if (playerMot[temp_r27->player_idx] != 1) {
-        var_r29 = BoardModelMotionShiftSet(BoardPlayerModelGet(arg0), 1, 0.0f, 8.0f, 0x40000001);
-        if (var_r29 == 0) {
-            playerMot[temp_r27->player_idx] = 1;
-        }
-    }
+	BoardPlayerMotionShiftSet(arg0, 1, 0.0f, 8.0f, 0x40000001);
 }
 
 void BoardPlayerMotBlendSet(s32 arg0, s16 arg1, s16 arg2) {
@@ -2029,12 +2044,13 @@ void BoardPlayerAutoSizeSet(s32 player, s32 value) {
 }
 
 s32 BoardPlayerAutoSizeGet(s32 arg0) {
-    PlayerState* temp_r30 = BoardPlayerGet(arg0);
-    
-    if (temp_r30 != 0 ) {
-        arg0 = temp_r30->auto_size;
+    PlayerState* player;
+
+    player = BoardPlayerGet(arg0);
+    if(!player) {
+        return;
     }
-    return arg0;
+    return player->auto_size;
 }
 
 u32 BoardPlayerMoveAwayIsDone(void) {
@@ -2239,10 +2255,247 @@ void BoardPlayerSparkSet(s32 arg0) {
     GWPlayer[arg0].space_shock = currSpace;
 }
 
-// ...
+static s32 DoSparkSpace(s32 player, s32 pause_cam)
+{
+	s32 i;
+	s16 temp_r28;
+	s32 coin;
+	s32 temp_r17;
+	Vec pos, rot;
+	Vec coin_pos;
+	s16 sp15C[4] = { -1, -1, -1, -1 };
+	s32 sp138;
+	s32 sp134;
+	s32 sp130;
+	s32 sp12C;
+	s32 sp128;
+	s8 sp124[4] = { -1, -1, -1, -1 };
+	s8 sp120[4] = { -1, -1, -1, -1 };
+	s16 sp34;
+	s16 sp32;
+	s16 sp30;
+	s16 sp2E;
+	s16 sp2C;
+	sp30 = GWSystem.player_curr;
+	sp138 = 0;
+	sp34 = GWPlayer[player].space_curr;
+	
+	BoardSpacePosGet(0, sp34, &pos);
+	BoardSpaceRotGet(0, sp34, &rot);
+	for(i=0; i<4; i++) {
+		if(GWPlayer[i].space_shock == sp34) {
+			sp32 = i;
+			sp138 = 1;
+		}
+	}
+	if(!sp138) {
+		return 0;
+	}
+	BoardDiceDigit2DShowSet(0);
+	if(pause_cam) {
+		BoardCameraMoveSet(0);
+	} else {
+		BoardCameraMoveSet(1);
+	}
+	BoardCameraMotionWait();
+	BoardCameraTargetPlayerSet(player);
+	BoardRotateDiceNumbers(player);
+	temp_r28 = BoardModelCreate(0x70074, NULL, 0);
+	BoardModelMotionStart(temp_r28, 0, 0x40000002);
+	BoardModelMotionTimeSet(temp_r28, 30.0f);
+	BoardModelAttrSet(temp_r28, 0x40000002);
+	BoardModelRotSet(temp_r28, rot.x-90.0f, rot.y, rot.z);
+	BoardModelScaleSet(temp_r28, 2.0f, 2.0f, 2.0f);
+	BoardModelVisibilitySet(temp_r28, 0);
+	BoardModelLayerSet(temp_r28, 1);
+	sp2E = BoardModelCreate(0x70067, NULL, 0);
+	BoardModelLayerSet(sp2E, 1);
+	BoardModelMotionStart(sp2E, 0, 0);
+	HuAudFXPlay(796);
+	HuPrcSleep(2);
+	BoardModelAttrReset(temp_r28, 0x40000002);
+	BoardModelVisibilitySet(temp_r28, 1);
+	BoardModelPosSet(temp_r28, pos.x, 8.0f+pos.y, pos.z);
+	BoardModelPosSetV(sp2E, &pos);
+	sp128 = -1;
+	for(sp134=i=0; i<4; i++) {
+		if(GWPlayer[i].space_curr == sp34) {
+			sp124[sp134++] = i;
+			sp15C[i] = BoardPlayerMotionCreate(i, sparkMotTbl[GWPlayer[i].character]);
+			BoardPlayerMotionShiftSet(i, sp15C[i], 0, 8, 0);
+			HuAudFXPlay(boardSparkSfxTblAlt[GWPlayer[i].character]);
+			if(GWPlayer[i].bowser_suit) {
+				BoardModelMotionShiftSet(suitMdl, bowserSuitMot[4], 0.0f, 4.0f, 0);
+				sp128 = i;
+			}
+		}
+	}
+	sp130 = sp134;
+	HuPrcSleep(60);
+	while(!BoardModelMotionEndCheck(sp2E)) {
+		HuPrcVSleep();
+	}
+	sp2C = 255;
+	for(i=0; i<45; i++) {
+		sp2C -= 5;
+		if(sp2C < 0) {
+			sp2C = 0;
+		}
+		BoardModelAlphaSet(temp_r28, sp2C);
+		BoardModelAlphaSet(sp2E, sp2C);
+		HuPrcVSleep();
+	}
+	temp_r17 = BoardRollTypeGet();
+	if(temp_r17 == 0 || temp_r17 == 1 || temp_r17 == 2 || temp_r17 == 3 || temp_r17 == 10) {
+		BoardCameraTargetPlayerSet(player);
+		BoardRotateDiceNumbers(player);
+		HuPrcSleep(12);
+		BoardItemPlayerRestore(player, temp_r17);
+		while(!BoardItemDoneCheck()) {
+			HuPrcVSleep();
+		}
+		rollType = -1;
+	}
+	if(rollResized) {
+		BoardPlayerSizeRestore(player);
+		rollResized = 0;
+	}
+	if(sp128 != -1) {
+		HuAudFXPlay(boardSparkSfxTbl[GWPlayer[sp128].character]);
+	}
+	for(i=0; i<sp130; i++) {
+		coin = BoardPlayerCoinsGet(sp124[i]);
+		if(coin > 10) {
+			coin = 10;
+		}
+		if(coin > 0) {
+			
+			BoardPlayerPosGet(sp124[i], &coin_pos);
+			coin_pos.y += 250.0f;
+			sp120[i] = BoardCoinChgCreate(&coin_pos, -coin);
+		}
+	}
+	for(sp12C=i=0; i<sp130; i++) {
+		sp12C += BoardPlayerCoinsGet(sp124[i]);
+	}
+	if(sp12C) {
+		HuAudFXPlay(840);
+		for(coin=0; coin<10; coin++) {
+			for(i=0; i<sp130; i++) {
+				BoardPlayerCoinsAdd(sp124[i], -1);
+			}
+			HuAudFXPlay(14);
+			HuPrcSleep(6);
+		}
+		HuAudFXPlay(15);
+		HuPrcSleep(90);
+	}
+	BoardModelKill(temp_r28);
+	BoardModelKill(sp2E);
+	for(i=0; i<4; i++) {
+		BoardRotateDiceNumbers(sp124[i]);
+	}
+	HuPrcSleep(10);
+	GWSystem.player_curr = -1;
+	RemoveSparkSpace(sp32);
+	GWSystem.player_curr = sp30;
+	for(i=0; i<4; i++) {
+		if(sp15C[i] != -1) {
+			BoardPlayerMotionKill(i, sp15C[i]);
+		}
+	}
+	if(pause_cam) {
+		BoardCameraMoveSet(0);
+		BoardCameraMotionWait();
+	}
+	
+	BoardCameraTargetPlayerSet(sp30);
+	BoardCameraMotionWait();
+	BoardCameraMoveSet(1);
+	BoardDiceDigit2DShowSet(1);
+	return 1;
+}
 
-static inline s32 test(s32 arg0) {
-    return BoardModelIDGet(BoardPlayerModelGet(arg0));
+static void RemoveSparkSpace(s32 player)
+{
+	if(GWPlayer[player].field02_bit1) {
+		BoardWinCreate(0, 0x12001C, -1);
+		BoardWinWait();
+		BoardWinKill();
+		GWPlayer[player].field02_bit1 = 0;
+		GWPlayer[player].space_shock = 0;
+	}
+}
+
+static void SetRollPlayerSize(s32 player)
+{
+	s32 auto_size = BoardPlayerAutoSizeGet(player);
+	if(auto_size != 0) {
+		BoardStatusHammerKill(player);
+		BoardPlayerAutoSizeSet(player, 0);
+		HuPrcSleep(30);
+		omVibrate(player, 90, 6, 6);
+		if(auto_size == 1) {
+			HuAudFXPlay(788);
+			HuAudFXPlay(787);
+		} else if(auto_size == 2) {
+			HuAudFXPlay(786);
+			HuAudFXPlay(785);
+		}
+		BoardPlayerResizeAnimExec(player, auto_size);
+		BoardPlayerSizeSet(player, auto_size);
+		HuPrcSleep(30);
+		rollResized = 1;
+	}
+	
+}
+
+s32 BoardRollResizeCheck(void)
+{
+	return rollResized;
+}
+
+void BoardPlayerResizeAnimExec(s32 player, s32 size)
+{
+	s32 j;
+	s32 i;
+	s16 modelid;
+	s32 frame;
+	s16 model;
+	float mdl_size;
+	float frame_data[9];
+	float steps[4];
+	float player_sizes[] = { 1, 0.3, 2.5 };
+	
+	mdl_size = player_sizes[BoardPlayerSizeGet(player)];
+	steps[0] = mdl_size;
+	steps[1] = mdl_size+((player_sizes[size]-mdl_size)/3);
+	steps[2] = mdl_size+((player_sizes[size]-mdl_size)/1.5f);
+	steps[3] = player_sizes[size];
+	frame_data[0] = steps[1];
+	frame_data[1] = steps[0];
+	frame_data[2] = steps[1];
+	frame_data[3] = steps[2];
+	frame_data[4] = steps[1];
+	frame_data[5] = steps[2];
+	frame_data[6] = steps[3];
+	frame_data[7] = steps[2];
+	frame_data[8] = steps[3];
+	model = BoardPlayerModelGet(player);
+	modelid = BoardModelIDGet(model);
+	Hu3DModelAttrSet(modelid, 0x40000002);
+	frame = 0;
+	for(j=0; j<9; j++) {
+		float size_vel;
+		size_vel = (frame_data[frame++]-mdl_size)/10.0f;
+		for(i=0; i<10; i++) {
+			BoardPlayerScaleSet(player, mdl_size, mdl_size, mdl_size);
+			mdl_size += size_vel;
+			HuPrcVSleep();
+		}
+	}
+	Hu3DModelAttrReset(modelid, 0x40000002);
+	BoardPlayerSizeSet(player, size);
 }
 
 void BoardPlayerCopyEyeMat(s32 arg0, s32 arg1) {
@@ -2297,7 +2550,7 @@ void BoardPlayerCopyMat(s32 arg0) {
     void* temp_r3;
     HsfData* temp_r31;
 
-    modelID = BoardModelIDGet(GetBoardPlayer(arg0));
+    modelID = BoardModelIDGet(BoardPlayerModelGet(arg0));
     model = &Hu3DData[modelID];
     temp_r31 = model->hsfData;
     temp_r3 = HuMemDirectMallocNum(HEAP_SYSTEM, temp_r31->materialCnt * 0x3C, 0x10000000U);
diff --git a/src/game/chrman.c b/src/game/chrman.c
index ba9bd32e..676c6793 100755
--- a/src/game/chrman.c
+++ b/src/game/chrman.c
@@ -2050,7 +2050,7 @@ static void UpdateNpcEffect(void) {
     }
 }
 
-void CharModelStepTypeSet(s16 character, s32 arg1) {
+s32 CharModelStepTypeSet(s16 character, s32 arg1) {
     UnkCharInstanceStruct *temp_r31 = &charInstance[character];
 
     temp_r31->unkB0 = arg1;

From 4334e6e361f5a42c9fbd448b21972cc94470141f Mon Sep 17 00:00:00 2001
From: gamemasterplc <gamemasterplc@gmail.com>
Date: Sat, 9 Mar 2024 21:21:12 -0600
Subject: [PATCH 2/7] Nearly match board/player.c

All but DoSparkSpace matched. BoardRotateDiceNumbers renamed to BoardPlayerIdleSet
---
 config/GMPE01_00/symbols.txt |   2 +-
 include/game/board/player.h  |   4 +-
 src/REL/w03Dll/mg_coin.c     |   2 +-
 src/REL/w03Dll/mg_item.c     |   4 +-
 src/REL/w03Dll/river.c       |   6 +-
 src/REL/w03Dll/statue.c      |  12 +-
 src/game/board/basic_space.c |   6 +-
 src/game/board/battle.c      |   2 +-
 src/game/board/block.c       |   6 +-
 src/game/board/item.c        |  16 +-
 src/game/board/lottery.c     |   8 +-
 src/game/board/player.c      | 364 +++++++++++++++++++++++++++++++++--
 src/game/board/space.c       |   2 +-
 src/game/board/star.c        |   4 +-
 src/game/board/ui.c          |   2 +-
 src/game/board/warp.c        |   6 +-
 16 files changed, 389 insertions(+), 57 deletions(-)

diff --git a/config/GMPE01_00/symbols.txt b/config/GMPE01_00/symbols.txt
index bcb359ee..cc2ddca6 100644
--- a/config/GMPE01_00/symbols.txt
+++ b/config/GMPE01_00/symbols.txt
@@ -1181,7 +1181,7 @@ PlayerPosLerpFunc = .text:0x80067374; // type:function size:0x218 scope:local
 BoardPlayerDiceJumpStart = .text:0x8006758C; // type:function size:0x1D4
 BoardPlayerDiceJumpCheck = .text:0x80067760; // type:function size:0x54
 DiceJumpFunc = .text:0x800677B4; // type:function size:0x3E4 scope:local
-BoardRotateDiceNumbers = .text:0x80067B98; // type:function size:0xF8
+BoardPlayerIdleSet = .text:0x80067B98; // type:function size:0xF8
 BoardPlayerMotBlendSet = .text:0x80067C90; // type:function size:0x5A0
 BoardPlayerMotBlendExec = .text:0x80068230; // type:function size:0x51C
 BoardPlayerMotBlendCheck = .text:0x8006874C; // type:function size:0x2C
diff --git a/include/game/board/player.h b/include/game/board/player.h
index 3f47a342..229e5bdd 100644
--- a/include/game/board/player.h
+++ b/include/game/board/player.h
@@ -123,7 +123,7 @@ void BoardPlayerMoveToAsync(s32, s32);
 void BoardPlayerPosLerpStart(s32, Vec*, Vec*, s16);
 void BoardPlayerDiceJumpStart(s32);
 s32 BoardPlayerDiceJumpCheck(s32);
-void BoardRotateDiceNumbers(s32);
+void BoardPlayerIdleSet(s32);
 void BoardPlayerMotBlendSet(s32 arg0, s16 arg1, s16 arg2);
 
 void BoardPlayerBtnDownWait(s32, u32);
@@ -151,7 +151,5 @@ s32 BoardPlayerMotBlendCheck(s32);
 void BoardPlayerMoveAwayStartCurr(s32, s32);
 void BoardBowserSuitMotionSetWalk(void);
 s16 BoardBowserSuitModelGet(void);
-void MoveAwayObjFunc(omObjData*);
-void UpdateBowserSuit(omObjData*);
 
 #endif
diff --git a/src/REL/w03Dll/mg_coin.c b/src/REL/w03Dll/mg_coin.c
index c73112fd..29b3aad1 100644
--- a/src/REL/w03Dll/mg_coin.c
+++ b/src/REL/w03Dll/mg_coin.c
@@ -541,7 +541,7 @@ void fn_1_9044(omObjData* arg0, someBits3* arg1) {
             arg0->trans.x *= 0.5f;
             if (arg0->trans.x <= 1.0f) {
                 arg0->trans.y = 0.0f;
-                BoardRotateDiceNumbers(arg1->unk00_bit5);
+                BoardPlayerIdleSet(arg1->unk00_bit5);
                 BoardModelMotionShiftSet(lbl_1_bss_C[10], 1, 0.0f, 10.0f, 0x40000001U);
                 arg1->unk00_bit0 = 1;
             }
diff --git a/src/REL/w03Dll/mg_item.c b/src/REL/w03Dll/mg_item.c
index 6740b263..6ef4f514 100644
--- a/src/REL/w03Dll/mg_item.c
+++ b/src/REL/w03Dll/mg_item.c
@@ -248,7 +248,7 @@ s32 fn_1_9CF4(s32 arg0) {
     while (GWPlayer[arg0].moving != 0) {
         HuPrcVSleep();
     }
-    BoardRotateDiceNumbers(arg0);
+    BoardPlayerIdleSet(arg0);
     HuPrcSleep(0x3C);
     fn_1_B0A4(arg0);
     fn_1_9F78();
@@ -526,7 +526,7 @@ void fn_1_ACD8(s32 arg0) {
     temp_r31->unk00_bit1 = arg0;
     switch (arg0) {
     case 0:
-        BoardRotateDiceNumbers(temp_r31->unk00_bit4);
+        BoardPlayerIdleSet(temp_r31->unk00_bit4);
         return;
     case 2:
         temp_r31->unk00_bit6 = 1;
diff --git a/src/REL/w03Dll/river.c b/src/REL/w03Dll/river.c
index b77ebef2..fab310b1 100644
--- a/src/REL/w03Dll/river.c
+++ b/src/REL/w03Dll/river.c
@@ -168,7 +168,7 @@ s32 fn_1_6898(s32 arg0) {
     s32 i, j;
     s32 temp, temp2;
 
-    BoardRotateDiceNumbers(arg0);
+    BoardPlayerIdleSet(arg0);
     BoardCameraViewSet(2);
     BoardCameraMotionWait();
     
@@ -351,7 +351,7 @@ void fn_1_6F9C(s32 arg0) {
     
     BoardPlayerMotionShiftSet(arg0, 5, 0.0f, 8.0f, 0U);
     HuPrcSleep(10);
-    BoardRotateDiceNumbers(arg0);
+    BoardPlayerIdleSet(arg0);
     if (GWPlayer[arg0].bowser_suit != 0) {
         BoardModelHookSet(lbl_1_data_388, "chara01", BoardPlayerModelGet(arg0));
     } else {
@@ -410,7 +410,7 @@ void fn_1_735C(s32 arg0) {
     while (BoardPlayerMotBlendCheck(arg0) == 0) {
         HuPrcVSleep();
     }
-    BoardRotateDiceNumbers(arg0);
+    BoardPlayerIdleSet(arg0);
     GWPlayer[arg0].space_curr = temp_r29;
     GWPlayer[arg0].space_prev = -1;
     BoardPlayerPostTurnHookSet(arg0, fn_1_6698);
diff --git a/src/REL/w03Dll/statue.c b/src/REL/w03Dll/statue.c
index f5b5fd67..0a41ab69 100644
--- a/src/REL/w03Dll/statue.c
+++ b/src/REL/w03Dll/statue.c
@@ -172,7 +172,7 @@ s32 fn_1_1650(s32 arg0) {
     f32 temp;
     s32 temp2;
 
-    BoardRotateDiceNumbers(arg0);
+    BoardPlayerIdleSet(arg0);
     
     if (lbl_1_bss_0->unk2) {
         BoardWinCreate(0, 0x160000, -1);
@@ -207,7 +207,7 @@ s32 fn_1_1650(s32 arg0) {
         HuPrcVSleep();
     }
     
-    BoardRotateDiceNumbers(arg0);
+    BoardPlayerIdleSet(arg0);
     BoardWinCreate(2, 0x160001, 2);
     BoardWinWait();
     BoardWinCreateChoice(0, 0x160002, -1, 0);
@@ -284,7 +284,7 @@ void fn_1_19DC(s32 arg0, s32 arg1) {
             HuPrcVSleep();
         }
     }
-    BoardRotateDiceNumbers(arg0);
+    BoardPlayerIdleSet(arg0);
     HuPrcSleep(0x14);
     temp = (180.0f + BoardPlayerRotYGet(arg0));
     BoardPlayerMotBlendSet(arg0, temp, 0xF);
@@ -376,7 +376,7 @@ void fn_1_1ED4(s32 arg0) {
     while (BoardFilterFadePauseCheck() == 0) {
         HuPrcVSleep();
     }
-    BoardRotateDiceNumbers(arg0);
+    BoardPlayerIdleSet(arg0);
     
     while (BoardMusStatusGet(1) != 0) {
         HuPrcVSleep();
@@ -448,7 +448,7 @@ void fn_1_20E0(s32 arg0) {
         BoardCameraMotionWait();
     }
     
-    BoardRotateDiceNumbers(arg0);
+    BoardPlayerIdleSet(arg0);
     while (BoardMusStatusGet(1) != 0) {
         HuPrcVSleep();
     }
@@ -520,7 +520,7 @@ void fn_1_26E0(s32 arg0) {
     }
     BoardCameraMotionWait();
     BoardModelMotionStart(lbl_1_bss_C[1], 0, 0);
-    BoardRotateDiceNumbers(arg0);
+    BoardPlayerIdleSet(arg0);
 }
 
 void fn_1_2818(void) {
diff --git a/src/game/board/basic_space.c b/src/game/board/basic_space.c
index 7dc7f24b..cdf3cb61 100644
--- a/src/game/board/basic_space.c
+++ b/src/game/board/basic_space.c
@@ -40,7 +40,7 @@ extern void BoardCameraViewSet(s32);
 extern void BoardPlayerPosGet(s32, Vec*);
 extern void BoardPlayerMotionEndWait(s32);
 extern void BoardPlayerCoinsAdd(s32, s32);
-extern void BoardRotateDiceNumbers(s32);
+extern void BoardPlayerIdleSet(s32);
 extern void BoardCameraMotBlendSet(s32, s16, s16);
 extern s32 BoardPlayerMotBlendCheck(s32);
 
@@ -102,7 +102,7 @@ void BoardLandBlueExec(s32 player, s32 space) {
     }
     GWPlayer[player].color = 1;
     BoardPlayerMotionEndWait(player);
-    BoardRotateDiceNumbers(player);
+    BoardPlayerIdleSet(player);
 }
 
 void BoardLandRedExec(s32 player, s32 space) {
@@ -143,7 +143,7 @@ void BoardLandRedExec(s32 player, s32 space) {
     }
     GWPlayer[player].color = 2;
     BoardPlayerMotionEndWait(player);
-    BoardRotateDiceNumbers(player);
+    BoardPlayerIdleSet(player);
 }
 
 s8 BoardCoinChgCreate(Vec *pos, s8 value) {
diff --git a/src/game/board/battle.c b/src/game/board/battle.c
index 3dcddeee..544ee051 100755
--- a/src/game/board/battle.c
+++ b/src/game/board/battle.c
@@ -320,7 +320,7 @@ static void ExecBattle(void) {
     }
     StopBattleBomb();
     for (var_r31 = 0; var_r31 < 4; var_r31++) {
-        BoardRotateDiceNumbers(var_r31);
+        BoardPlayerIdleSet(var_r31);
         BoardPlayerVoiceEnableSet(var_r31, 6, 1);
     }
     BoardAudSeqPause(0, 0, 1000);
diff --git a/src/game/board/block.c b/src/game/board/block.c
index f7836acc..1c735ed9 100644
--- a/src/game/board/block.c
+++ b/src/game/board/block.c
@@ -97,7 +97,7 @@ static void BlockProc(void) {
 
     player_character = GWPlayer[player].character;
     jumpMot = BoardPlayerMotionCreate(player, sp14[player_character]);
-    BoardRotateDiceNumbers(player);
+    BoardPlayerIdleSet(player);
     BoardPlayerMotBlendSet(player, 0, 0xF);
     omVibrate(player, 12, 12, 0);
     CreateBlockObj(player);
@@ -122,7 +122,7 @@ static void BlockProc(void) {
     while (BoardPlayerMotionEndCheck(player) == 0) {
         HuPrcVSleep();
     }
-    BoardRotateDiceNumbers(player);
+    BoardPlayerIdleSet(player);
     
     if (work->contains_star != 0) {
         SetBlockStop();
@@ -162,7 +162,7 @@ static void BlockProc(void) {
     KillCoinMdl();
     work->kill = 1;
     
-    BoardRotateDiceNumbers((s32) player);
+    BoardPlayerIdleSet((s32) player);
     HuPrcVSleep();
     
     if ((_CheckFlag(0x1000B) != 0) && work->contains_star == 0) {
diff --git a/src/game/board/item.c b/src/game/board/item.c
index b020d72b..97aa67df 100755
--- a/src/game/board/item.c
+++ b/src/game/board/item.c
@@ -440,7 +440,7 @@ static inline void BoardUiInlineFunc03(s32 arg0) {
     while (!BoardPlayerMotBlendCheck(arg0)) {
         HuPrcVSleep();
     }
-    BoardRotateDiceNumbers(arg0);
+    BoardPlayerIdleSet(arg0);
 }
 
 static inline void BoardUiInlineFunc04(Process *arg0, s32 arg1) {
@@ -943,7 +943,7 @@ static void ExecItemPipe(void) {
         BoardPlayerMotionShiftSet(sp2C[1], 6, 0.0f, 8.0f, 0x40000001);
         BoardModelVoiceEnableSet(BoardPlayerModelGet(sp2C[1]), 6, 0);
         CharModelLayerSetAll(2);
-        BoardRotateDiceNumbers(sp2C[0]);
+        BoardPlayerIdleSet(sp2C[0]);
         for (var_r31 = 0; var_r31 < 0x2D; var_r31++) {
             sp9C.y -= 0.044444446f;
             for (var_r30 = 0; var_r30 < 2; var_r30++) {
@@ -960,7 +960,7 @@ static void ExecItemPipe(void) {
         BoardWinInsertMesSet(GWPlayerCfg[sp2C[1]].character, 1);
         BoardWinWait();
         BoardWinKill();
-        BoardRotateDiceNumbers(sp2C[1]);
+        BoardPlayerIdleSet(sp2C[1]);
         HuPrcSleep(8);
         BoardModelVoiceEnableSet(BoardPlayerModelGet(sp2C[1]), 6, 1);
     }
@@ -1240,7 +1240,7 @@ static void ExecItemSpark(void) {
     while (!BoardPlayerMotBlendCheck(currItemRestore)) {
         HuPrcVSleep();
     }
-    BoardRotateDiceNumbers(currItemRestore);
+    BoardPlayerIdleSet(currItemRestore);
     BoardSpacePosGet(0, temp_r28, &sp5C);
     BoardModelPosSetV(temp_r30, &sp5C);
     sp5C.y += 106.0f;
@@ -1423,7 +1423,7 @@ static void ExecItemWhistle(void) {
         HuPrcVSleep();
     }
     BoardModelHookObjReset(sp8, temp_r22);
-    BoardRotateDiceNumbers(currItemRestore);
+    BoardPlayerIdleSet(currItemRestore);
     BoardModelKill(suitMdl);
     BoardCameraMoveSet(0);
     temp_r18 = BoardSpaceStarGetCurr();
@@ -2280,7 +2280,7 @@ static void GenieSceneExec(void) {
     }
     GenieCameraCalc(&cameraDataTbl[0], var_r26, 1.0f, &booCamPos, &booCamUp);
     HuPrcSleep(0x96);
-    BoardRotateDiceNumbers(currItemRestore);
+    BoardPlayerIdleSet(currItemRestore);
     sp2C = booCamPos;
     sp20 = booCamUp;
     booCamUp.x = sp38.x + (sp50.x - sp38.x) * 0.7f;
@@ -2431,7 +2431,7 @@ static void ExecItemGenie(void) {
     Hu3DModelKill(temp_r31);
     BoardModelKill(suitMdl);
     HuPrcKill(temp_r27);
-    BoardRotateDiceNumbers(currItemRestore);
+    BoardPlayerIdleSet(currItemRestore);
     GenieSceneExec();
     BoardCameraMoveSet(0);
     BoardCameraViewSet(2);
@@ -2482,7 +2482,7 @@ static void ExecItemGenie(void) {
         BoardPlayerPosSetV(currItemRestore, &spC);
         HuPrcVSleep();
     }
-    BoardRotateDiceNumbers(currItemRestore);
+    BoardPlayerIdleSet(currItemRestore);
     CharModelEffectEnableSet(GWPlayer[currItemRestore].character, 1);
     HuSprAnimKill(genieParticleAnim);
     BoardPlayerMotionKill(currItemRestore, geniePlayerMot[0]);
diff --git a/src/game/board/lottery.c b/src/game/board/lottery.c
index 745fd903..9c57220a 100755
--- a/src/game/board/lottery.c
+++ b/src/game/board/lottery.c
@@ -418,7 +418,7 @@ static void ExecLottery(void) {
     temp_r29 = BoardDataDirReadAsync(0x50000);
     temp_r31 = GWSystem.player_curr;
     temp_r28 = GWPlayer[temp_r31].space_curr;
-    BoardRotateDiceNumbers(temp_r31);
+    BoardPlayerIdleSet(temp_r31);
     BoardWinCreateChoice(0, 0x60000, -1, 0);
     if (GWPlayer[temp_r31].com) {
         if (BoardPlayerCoinsGet(temp_r31) >= 5) {
@@ -503,7 +503,7 @@ static void ExecLottery(void) {
         }
     }
     BoardMusStart(1, 2, 0x7F, 0);
-    BoardRotateDiceNumbers(temp_r31);
+    BoardPlayerIdleSet(temp_r31);
     while (!BoardStatusStopCheck(temp_r31)) {
         HuPrcVSleep();
     }
@@ -533,7 +533,7 @@ static void ExecLottery(void) {
     while (GWPlayer[temp_r31].moving) {
         HuPrcVSleep();
     }
-    BoardRotateDiceNumbers(temp_r31);
+    BoardPlayerIdleSet(temp_r31);
     BoardModelVisibilitySet(ballMdl[currPrize & 3], 0);
     BoardAudSeqFadeOut(1, 1000);
     BoardCameraTargetPlayerSet(temp_r31);
@@ -591,7 +591,7 @@ static void DoMiniJumpUp(s32 arg0) {
     }
     sp1C.y = sp28.y;
     BoardPlayerPosSetV(arg0, &sp1C);
-    BoardRotateDiceNumbers(arg0);
+    BoardPlayerIdleSet(arg0);
 }
 
 static void DoMiniJumpDown(s32 arg0) {
diff --git a/src/game/board/player.c b/src/game/board/player.c
index 11904f3d..b0212376 100644
--- a/src/game/board/player.c
+++ b/src/game/board/player.c
@@ -34,10 +34,14 @@ static void MoveAwayObjFunc(omObjData*);
 static void MoveAwayObjFunc(omObjData*);
 static void UpdateBowserSuit(omObjData*);
 
+static void MegaSquishFunc(omObjData *object);
+
+
 static s32 DoSparkSpace(s32 player, s32 pause_cam);
 static void RemoveSparkSpace(s32 player);
 static void SetRollPlayerSize(s32 player);
-static s32 MegaPlayerPassFunc(s32, s16);
+static s32 MegaPlayerPassFunc(s32 player, s32 space);
+static s32 MegaExecJump(s32 player, s32 space);
 
 //TODO: Give better name
 typedef struct bitcopy {
@@ -134,7 +138,7 @@ static s32 boardSparkSfxTblAlt[] = {
     0x223, 0x263, 0x2A3, 0x2E3,
 };
 
-static s32 megaSquishObj[] = {
+static omObjData *megaSquishObj[] = {
     0, 0, 0, 0,
 };
 
@@ -826,7 +830,7 @@ block_14:
     } while (1);
     BoardPauseDisableSet(1);
     BoardDiceDigit2DUpdateEnable(arg0);
-    BoardRotateDiceNumbers(arg0);
+    BoardPlayerIdleSet(arg0);
     if (GWPlayer[arg0].bowser_suit != 0) {
         BoardCameraTargetPlayerSet(arg0);
     }
@@ -911,7 +915,7 @@ void BoardPlayerZoomRestore(s32 arg0) {
     while (BoardPlayerMotBlendCheck(arg0) == 0) {
         HuPrcVSleep();
     }
-    BoardRotateDiceNumbers(arg0);
+    BoardPlayerIdleSet(arg0);
 }
 
 void BoardJunctionMaskSet(s32 arg0) {
@@ -1243,7 +1247,7 @@ static s32 DoDebugMove(s32 arg0, s16* arg1) {
             } else {
                 if (HuPadBtnDown[var_r20] == 0x10) {
                     BoardDiceDigit2DShowSet(0);
-                    BoardRotateDiceNumbers(arg0);
+                    BoardPlayerIdleSet(arg0);
                     StopJunctionPlayer(0);
                     BoardViewMapExec(arg0);
                     InitJunction(arg0, sp28->space_curr, -1.0f);
@@ -1283,7 +1287,7 @@ static s32 DoDebugMove(s32 arg0, s16* arg1) {
                     }
                 } else {
                     if (BoardPlayerMotGet(arg0) != 1) {
-                        BoardRotateDiceNumbers(arg0);
+                        BoardPlayerIdleSet(arg0);
                     }
                     if (GWPlayer[arg0].bowser_suit != 0) {
                         BoardBowserSuitMotionSetWait();
@@ -1397,7 +1401,7 @@ static s32 ExecJunction(s32 arg0, s16* arg1) {
     var_f28 = -1.0f;
     sp8 = 0;
     InitJunction(arg0, sp30->space_curr, var_f28);
-    BoardRotateDiceNumbers(arg0);
+    BoardPlayerIdleSet(arg0);
     HuPrcSleep(10);
     while (1) {
         
@@ -1440,7 +1444,7 @@ static s32 ExecJunction(s32 arg0, s16* arg1) {
         } else if (var_r20 == 0x20 || var_r20 == 0x10) {
             HuAudFXPlay(1);
             BoardDiceDigit2DShowSet(0);
-            BoardRotateDiceNumbers(arg0);
+            BoardPlayerIdleSet(arg0);
             StopJunctionPlayer(0);
             if (var_r20 == 0x10) {
                 BoardViewMapExec(arg0);
@@ -1475,7 +1479,7 @@ static s32 ExecJunction(s32 arg0, s16* arg1) {
                 }
             } else {
                 if (BoardPlayerMotGet(arg0) != 1) {
-                    BoardRotateDiceNumbers(arg0);
+                    BoardPlayerIdleSet(arg0);
                 }
                 if (GWPlayer[arg0].bowser_suit != 0) {
                     BoardBowserSuitMotionSetWait();
@@ -1706,7 +1710,7 @@ static void DiceJumpFunc(omObjData* arg0) {
     temp_r31 = OM_GET_WORK_PTR(arg0, bitcopy2);
     if ((temp_r31->field00_bit0 != 0) || (BoardIsKill() != 0)) {
         GWPlayer[temp_r31->field00_bit1].field08_bit3 = 0;
-        BoardRotateDiceNumbers(temp_r31->field00_bit1);
+        BoardPlayerIdleSet(temp_r31->field00_bit1);
         diceJumpObj[temp_r31->field00_bit1] = 0;
         omDelObjEx(HuPrcCurrentGet(), arg0);
         return;
@@ -1748,7 +1752,7 @@ static void DiceJumpFunc(omObjData* arg0) {
 }
 
 
-void BoardRotateDiceNumbers(s32 arg0)
+void BoardPlayerIdleSet(s32 arg0)
 {
     if (GWPlayer[arg0].bowser_suit) {
         BoardBowserSuitMotionSetWait();
@@ -2299,7 +2303,7 @@ static s32 DoSparkSpace(s32 player, s32 pause_cam)
 	}
 	BoardCameraMotionWait();
 	BoardCameraTargetPlayerSet(player);
-	BoardRotateDiceNumbers(player);
+	BoardPlayerIdleSet(player);
 	temp_r28 = BoardModelCreate(0x70074, NULL, 0);
 	BoardModelMotionStart(temp_r28, 0, 0x40000002);
 	BoardModelMotionTimeSet(temp_r28, 30.0f);
@@ -2348,7 +2352,7 @@ static s32 DoSparkSpace(s32 player, s32 pause_cam)
 	temp_r17 = BoardRollTypeGet();
 	if(temp_r17 == 0 || temp_r17 == 1 || temp_r17 == 2 || temp_r17 == 3 || temp_r17 == 10) {
 		BoardCameraTargetPlayerSet(player);
-		BoardRotateDiceNumbers(player);
+		BoardPlayerIdleSet(player);
 		HuPrcSleep(12);
 		BoardItemPlayerRestore(player, temp_r17);
 		while(!BoardItemDoneCheck()) {
@@ -2393,7 +2397,7 @@ static s32 DoSparkSpace(s32 player, s32 pause_cam)
 	BoardModelKill(temp_r28);
 	BoardModelKill(sp2E);
 	for(i=0; i<4; i++) {
-		BoardRotateDiceNumbers(sp124[i]);
+		BoardPlayerIdleSet(sp124[i]);
 	}
 	HuPrcSleep(10);
 	GWSystem.player_curr = -1;
@@ -2498,6 +2502,337 @@ void BoardPlayerResizeAnimExec(s32 player, s32 size)
 	BoardPlayerSizeSet(player, size);
 }
 
+typedef struct mega_squish_work {
+	struct {
+		u8 kill : 1;
+		u8 no_coinchg : 1;
+		u8 played_snd : 1;
+		u8 gain_player : 2;
+	};
+	s8 player;
+	s8 state;
+	s8 coinchg;
+	s8 loss;
+	s8 disappear_time;
+	s8 disappear_len;
+	u16 hide_time;
+} MegaSquishWork;
+
+static void MegaSquishFunc(omObjData *object)
+{
+	MegaSquishWork *work = OM_GET_WORK_PTR(object, MegaSquishWork);
+	Vec pos;
+	if(work->kill || BoardIsKill()) {
+		if(work->coinchg != -1) {
+			BoardCoinChgHide(work->coinchg);
+		}
+		megaSquishObj[work->player] = NULL;
+		omDelObjEx(HuPrcCurrentGet(), object);
+		return;
+	}
+	if(work->hide_time != 0) {
+		work->hide_time--;
+		return;
+	}
+	switch(work->state) {
+		case 1:
+			if(!work->played_snd) {
+				HuAudFXPlay(798);
+				HuAudFXPlay(megaSquishSfxTbl[GWPlayer[work->player].character]);
+				work->played_snd = 1;
+			}
+			BoardPlayerMotionStart(work->player, 10, 0);
+			BoardPlayerMotionSpeedSet(work->player, 2.0f);
+			work->state = 2;
+			break;
+			
+		case 2:
+		{
+			if(!BoardModelMotionTimeGet(BoardPlayerModelGet(work->player) >= 50.0f)) {
+				return;
+			}
+			BoardPlayerMotionSpeedSet(work->player, 0.0f);
+			BoardPlayerPosGet(work->player, &pos);
+			pos.y += 10.0f;
+			BoardPlayerPosSetV(work->player, &pos);
+			work->hide_time = 20;
+			work->state = 3;
+			work->coinchg = -1;
+			work->disappear_time = 0;
+		}
+			
+			break;
+			
+		case 3:
+			if(work->coinchg == -1) {
+				BoardPlayerPosGet(work->player, &pos);
+				
+				pos.y += 250.0f;
+				if(!work->no_coinchg) {
+					work->coinchg = BoardCoinChgCreate(&pos, -work->loss);
+				} else {
+					work->state = 4;
+					work->hide_time = work->disappear_len;
+				}
+			}
+			if(work->disappear_time++ < work->disappear_len) {
+				return;
+			}
+			work->disappear_time = 0;
+			if(work->loss <= 0) {
+				work->state = 4;
+				HuAudFXPlay(15);
+			} else {
+				work->loss--;
+				BoardPlayerCoinsAdd(work->player, -1);
+				HuAudFXPlay(14);
+				BoardPlayerCoinsAdd(work->gain_player, 1);
+			}
+			break;
+			
+		case 4:
+			BoardPlayerMotionSpeedSet(work->player, 2.0f);
+			BoardPlayerPosGet(work->player, &pos);
+			pos.y -= 10.0f;
+			BoardPlayerPosSetV(work->player, &pos);
+			work->state = 5;
+			break;
+			
+		case 5:
+			if(!BoardPlayerMotionEndCheck(work->player)) {
+				return;
+			}
+			BoardPlayerIdleSet(work->player);
+			work->kill = 1;
+			break;
+			
+		case 0:
+			break;
+			
+		default:
+			break;
+	}
+}
+
+static s32 MegaPlayerPassFunc(s32 player, s32 space)
+{
+	float temp_f30;
+	float temp_f29;
+	MegaSquishWork *temp_r31;
+	s32 temp_r29;
+	MegaSquishWork *temp_r28;
+	s32 temp_r27;
+	s32 temp_r26;
+	s32 temp_r24;
+	omObjData *temp_r23;
+	s32 spD0[4];
+	Vec spC4;
+	Vec spB8;
+	Vec spAC;
+	Vec spA0;
+	float sp98[2];
+	
+	
+	if(GWPlayer[player].bowser_suit) {
+		return MegaExecJump(player, space);
+	}
+	if(BoardPlayerSizeGet(player) != 2) {
+		return 0;
+	}
+	spD0[0] = spD0[1] = spD0[2] = -1;
+	for(temp_r26=temp_r29=0; temp_r29<4; temp_r29++) {
+		if(temp_r29 != player && GWPlayer[temp_r29].space_curr == space) {
+			spD0[temp_r26++] = temp_r29;
+			BoardPlayerPosGet(temp_r29, &spA0);
+			temp_r23 = omAddObjEx(boardObjMan, 256, 0, 0, -1, MegaSquishFunc);
+			megaSquishObj[temp_r29] = temp_r23;
+			temp_r31 = OM_GET_WORK_PTR(temp_r23, MegaSquishWork);
+			temp_r31->kill = 0;
+			temp_r31->player = temp_r29;
+			temp_r31->gain_player = player;
+			temp_r31->state = 0;
+			temp_r31->hide_time = 0;
+			temp_r31->loss = 0;
+			temp_r31->disappear_len = 3;
+			temp_r31->disappear_time = 0;
+			temp_r31->played_snd = 0;
+			if(BoardPlayerCoinsGet(temp_r31->player) <= 0) {
+				temp_r31->no_coinchg = 1;
+			} else {
+				temp_r31->no_coinchg = 0;
+			}
+			if(BoardPlayerCoinsGet(temp_r31->player) >= 10) {
+				temp_r31->loss = 10;
+			} else {
+				temp_r31->loss = BoardPlayerCoinsGet(temp_r31->player);
+			}
+		}
+	}
+	if(temp_r26 == 0) {
+		return 0;
+	}
+	if (_CheckFlag(0x1000BU) != 0) {
+        BoardTutorialHookExec(24, 0);
+    }
+	BoardPlayerPosGet(player, &spB8);
+	BoardSpacePosGet(0, space, &spC4);
+	sp98[0] = spB8.y;
+	if(spC4.y > spB8.y) {
+		spB8.y += 300.0f;
+	} else {
+		spB8.y += 200.0f;
+	}
+	VECSubtract(&spC4, &spB8, &spAC);
+	spAC.x /= 60.0f;
+	spAC.z /= 60.0f;
+	BoardPlayerRotYSet(player, 90.0-(180.0*(atan2(spAC.z, spAC.x)/M_PI)));
+	sp98[1] = BoardVecDistXZCalc(&spC4, &spB8);
+	BoardPlayerMotionShiftSet(player, 4, 0, 8, 0);
+	HuPrcSleep(8);
+	temp_r24 = 0;
+	for(temp_f30=0; temp_f30<60.0f; temp_f30++) {
+		temp_f29 = spB8.y;
+		spB8.x += spAC.x;
+		spB8.z += spAC.z;
+		spB8.y += 10.0f + (0.9f*(-0.020416668f * temp_f30 * temp_f30));
+		if(temp_f29 > spB8.y) {
+			temp_r24 = 1;
+		}
+		if(spB8.y <= 200.0f+spC4.y && temp_r24) {
+			for(temp_r27=0; temp_r27<4; temp_r27++) {
+				if(megaSquishObj[temp_r27]) {
+					temp_r28 = OM_GET_WORK_PTR(megaSquishObj[temp_r27], MegaSquishWork);
+					if((s16)space == GWPlayer[temp_r28->player].space_curr && temp_r28->state != 1) {
+						temp_r28->state = 1;
+					}
+				}
+			}
+		}
+		if(spB8.y <= spC4.y) {
+			spB8.y = spC4.y;
+			BoardPlayerMotionShiftSet(player, 5, 0, 4, 0);
+		}
+		BoardPlayerPosSetV(player, &spB8);
+		HuPrcVSleep();
+	}
+	BoardCameraQuakeSet(30, 500.0f);
+	omVibrate(0, 12, 4, 2);
+	omVibrate(1, 12, 4, 2);
+	omVibrate(2, 12, 4, 2);
+	omVibrate(3, 12, 4, 2);
+	BoardPlayerIdleSet(player);
+	HuPrcSleep(30);
+}
+
+static s32 MegaExecJump(s32 player, s32 space)
+{
+	float temp_f30;
+	float temp_f29;
+	MegaSquishWork *temp_r31;
+	s32 temp_r29;
+	MegaSquishWork *temp_r28;
+	s32 temp_r27;
+	s32 temp_r26;
+	s32 temp_r25;
+	s32 temp_r24;
+	omObjData *temp_r23;
+	s32 spD0[4];
+	Vec spC4;
+	Vec spB8;
+	Vec spAC;
+	Vec spA0;
+	float sp90[2];
+	spD0[0] = spD0[1] = spD0[2] = -1;
+	for(temp_r26=temp_r29=0; temp_r29<4; temp_r29++) {
+		if(temp_r29 != player && GWPlayer[temp_r29].space_curr == space) {
+			spD0[temp_r26++] = temp_r29;
+			BoardPlayerPosGet(temp_r29, &spA0);
+			temp_r23 = omAddObjEx(boardObjMan, 256, 0, 0, -1, MegaSquishFunc);
+			megaSquishObj[temp_r29] = temp_r23;
+			temp_r31 = OM_GET_WORK_PTR(temp_r23, MegaSquishWork);
+			temp_r31->kill = 0;
+			temp_r31->player = temp_r29;
+			temp_r31->gain_player = player;
+			temp_r31->state = 0;
+			temp_r31->hide_time = 0;
+			temp_r31->loss = 0;
+			temp_r31->disappear_len = 3;
+			temp_r31->disappear_time = 0;
+			if(BoardPlayerCoinsGet(temp_r31->player) <= 0) {
+				temp_r31->no_coinchg = 1;
+			} else {
+				temp_r31->no_coinchg = 0;
+			}
+			if(BoardPlayerCoinsGet(temp_r31->player) >= 30) {
+				temp_r31->loss = 30;
+			} else {
+				temp_r31->loss = BoardPlayerCoinsGet(temp_r31->player);
+			}
+		}
+	}
+	if(temp_r26 == 0) {
+		return 0;
+	}
+	BoardPlayerPosGet(player, &spB8);
+	BoardSpacePosGet(0, space, &spC4);
+	sp90[0] = spB8.y;
+	if(spC4.y > spB8.y) {
+		spB8.y += 300.0f;
+	} else {
+		spB8.y += 200.0f;
+	}
+	VECSubtract(&spC4, &spB8, &spAC);
+	spAC.x /= 60.0f;
+	spAC.z /= 60.0f;
+	BoardPlayerRotYSet(player, 90.0-(180.0*(atan2(spAC.z, spAC.x)/M_PI)));
+	BoardPlayerIdleSet(player);
+	HuPrcSleep(10);
+	sp90[1] = BoardVecDistXZCalc(&spC4, &spB8);
+	BoardModelMotionShiftSet(suitMdl, bowserSuitMot[3], 0.0f, 8.0f, 0);
+	BoardModelMotionSpeedSet(suitMdl, 2.0f);
+	HuPrcSleep(8);
+	HuAudFXPlay(809);
+	temp_r24 = 0;
+	temp_r25 = 0;
+	for(temp_f30=0; temp_f30<60.0f; temp_f30++) {
+		temp_f29 = spB8.y;
+		spB8.x += spAC.x;
+		spB8.z += spAC.z;
+		spB8.y += 10.0f + (0.9f*(-0.020416668f * temp_f30 * temp_f30));
+		if(temp_f29 > spB8.y) {
+			temp_r25 = 1;
+		}
+		if(spB8.y <= 200.0f+spC4.y && temp_r25) {
+			for(temp_r27=0; temp_r27<4; temp_r27++) {
+				if(megaSquishObj[temp_r27]) {
+					temp_r28 = OM_GET_WORK_PTR(megaSquishObj[temp_r27], MegaSquishWork);
+					if((s16)space == GWPlayer[temp_r28->player].space_curr && temp_r28->state != 1) {
+						temp_r28->state = 1;
+					}
+				}
+			}
+		}
+		if(spB8.y <= spC4.y) {
+			spB8.y = spC4.y;
+			if(!temp_r24) {
+				BoardPlayerIdleSet(player);
+				HuAudFXPlay(810);
+				temp_r24 = 1;
+			}
+			
+		}
+		BoardPlayerPosSetV(player, &spB8);
+		HuPrcVSleep();
+	}
+	BoardCameraQuakeSet(30, 500.0f);
+	omVibrate(0, 12, 4, 2);
+	omVibrate(1, 12, 4, 2);
+	omVibrate(2, 12, 4, 2);
+	omVibrate(3, 12, 4, 2);
+	BoardPlayerIdleSet(player);
+	HuPrcSleep(30);
+}
+
 void BoardPlayerCopyEyeMat(s32 arg0, s32 arg1) {
     HsfMaterial* var_r29;
     s32 var_r24;
@@ -2543,7 +2878,6 @@ void BoardPlayerCopyEyeMat(s32 arg0, s32 arg1) {
     DCStoreRange(hsfData->material, hsfData->materialCnt * 0x3C);
 }
 
-
 void BoardPlayerCopyMat(s32 arg0) {
     s16 modelID;
     ModelData *model;
diff --git a/src/game/board/space.c b/src/game/board/space.c
index cf0118d0..5c8c0cf2 100644
--- a/src/game/board/space.c
+++ b/src/game/board/space.c
@@ -639,7 +639,7 @@ s32 BoardSpaceWalkExec(s32 player, s32 space)
 	if(space_ptr->flag & 0x600000) {
 		s32 mg_param = GWSystem.unk_38;
 		if(BoardPlayerSizeGet(player) == 1) {
-			BoardRotateDiceNumbers(player);
+			BoardPlayerIdleSet(player);
 			BoardMGCreate(mg_param);
 		}
 		return 1;
diff --git a/src/game/board/star.c b/src/game/board/star.c
index c761b559..99b05702 100755
--- a/src/game/board/star.c
+++ b/src/game/board/star.c
@@ -211,7 +211,7 @@ static void ExecStar(void) {
     temp_f30 = 90.0 - 180.0 * (atan2(spC.z, spC.x) / M_PI);
     temp_f30 = 90.0f * ((temp_f30 + 3.0f) / 90.0f);
     temp_f29 = BoardPlayerRotYGet(temp_r31);
-    BoardRotateDiceNumbers(temp_r31);
+    BoardPlayerIdleSet(temp_r31);
     if (BoardDAngleCalc(temp_f30 - temp_f29) < 0.0f) {
         var_f28 = -BoardDAngleCalc(temp_f30 - temp_f29);
     } else {
@@ -689,7 +689,7 @@ void BoardStarShowNext(s32 arg0) {
         BoardAudSeqFadeOut(0, 1000);
     }
     showNextObj = omAddObjEx(boardObjMan, 0x7E03, 0, 0, -1, ShowNextUpdate);
-    BoardRotateDiceNumbers(arg0);
+    BoardPlayerIdleSet(arg0);
     BoardModelMotionStart(BoardStarHostMdlGet(), 1, 0x40000001);
     BoardModelPosGet(BoardStarHostMdlGet(), &sp50);
     showNextObj->scale.x = sp50.x;
diff --git a/src/game/board/ui.c b/src/game/board/ui.c
index 7b271d71..81ec4bed 100755
--- a/src/game/board/ui.c
+++ b/src/game/board/ui.c
@@ -1152,7 +1152,7 @@ static void FinishItemUse(s16 arg0, s32 arg1) {
         case 10:
             HuPrcSleep(2);
             BoardBowserSuitMotionCreate();
-            BoardRotateDiceNumbers(itemPlayer);
+            BoardPlayerIdleSet(itemPlayer);
             BoardModelLayerSet(BoardBowserSuitModelGet(), 0);
             BoardModelLayerSet(BoardBowserSuitPlayerModelGet(), 0);
             break;
diff --git a/src/game/board/warp.c b/src/game/board/warp.c
index f5b45068..8505051a 100644
--- a/src/game/board/warp.c
+++ b/src/game/board/warp.c
@@ -66,7 +66,7 @@ void WarpProcess(void) {
         HuPrcVSleep();
     }
     
-    BoardRotateDiceNumbers(curr_player);
+    BoardPlayerIdleSet(curr_player);
     if (_CheckFlag(0x1000B) != 0) {
         BoardTutorialHookExec(18, 0);
         boardTutorialData[0] = 0;
@@ -144,7 +144,7 @@ static void WarpInit(s32 player) {
     HuAudFXPlay(835);
     BoardPlayerRotYSet(player, 0.0f);
     BoardPlayerPosSet(player, 0.0f, 0.0f, 0.0f);
-    BoardRotateDiceNumbers(player);
+    BoardPlayerIdleSet(player);
 }
 
 static void WarpLaunch(s32 player) {
@@ -245,7 +245,7 @@ static void WarpImpact(s32 player) {
     HuPrcSleep(60);
     
     for (i = 0; i < warpImpactCnt; i++) {
-        BoardRotateDiceNumbers(warpImpactPlayer[i]);
+        BoardPlayerIdleSet(warpImpactPlayer[i]);
     }
     warpState = 6;
 }
\ No newline at end of file

From 16e5f3995430c2f994b894decedfb4f7a0aa01c4 Mon Sep 17 00:00:00 2001
From: mrshigure <mrshigure64@gmail.com>
Date: Sun, 10 Mar 2024 00:26:44 -0800
Subject: [PATCH 3/7] Matched game/board/char_wheel + some unsplit cleanup

---
 config/GMPE01_00/symbols.txt    |   3 +-
 configure.py                    |   2 +-
 include/board_unsplit.h         |  14 -
 include/game/board/char_wheel.h |  13 +
 include/game/board/com.h        |   2 +-
 include/game/board/space.h      |   3 -
 src/REL/w03Dll/mg_coin.c        |   1 +
 src/REL/w10Dll/main.c           |   1 +
 src/REL/w10Dll/scene.c          |   2 +
 src/game/board/char_wheel.c     | 532 ++++++++++++++++++++++++++++++++
 src/game/board/item.c           |   2 +-
 src/game/board/main.c           |   3 +-
 src/game/board/player.c         |   1 +
 src/game/board/star.c           |   1 +
 src/game/board/warp.c           |   8 +-
 15 files changed, 558 insertions(+), 30 deletions(-)
 create mode 100755 include/game/board/char_wheel.h
 create mode 100755 src/game/board/char_wheel.c

diff --git a/config/GMPE01_00/symbols.txt b/config/GMPE01_00/symbols.txt
index cc2ddca6..6315e23d 100644
--- a/config/GMPE01_00/symbols.txt
+++ b/config/GMPE01_00/symbols.txt
@@ -5232,8 +5232,7 @@ coinChgObj = .data:0x8013A1F0; // type:object size:0x10 scope:local
 coinDigitMdl = .data:0x8013A200; // type:object size:0x28 scope:local
 jumptable_8013A228 = .data:0x8013A228; // type:object size:0x1C scope:local
 wheelSprTbl = .data:0x8013A248; // type:object size:0x28 scope:local
-wheelSprPrio = .data:0x8013A270; // type:object size:0xA scope:local
-wheelCharIconPrioTbl = .data:0x8013A27A; // type:object size:0x4 scope:local data:byte
+wheelSprPrio = .data:0x8013A270; // type:object size:0xE scope:local data:byte
 wheelCharIconTbl = .data:0x8013A280; // type:object size:0x20 scope:local
 lbl_8013A2A0 = .data:0x8013A2A0; // type:object size:0xF data:string
 boardStarSndTbl = .data:0x8013A2B0; // type:object size:0x20
diff --git a/configure.py b/configure.py
index 09847e08..2296aa50 100644
--- a/configure.py
+++ b/configure.py
@@ -379,7 +379,7 @@ config.libs = [
             Object(Matching, "game/board/lottery.c"),
             Object(Matching, "game/board/basic_space.c"),
             Object(Matching, "game/board/warp.c"),
-            Object(NonMatching, "game/board/char_wheel.c"),
+            Object(Matching, "game/board/char_wheel.c"),
             Object(NonMatching, "game/board/mushroom.c"),
             Object(Matching, "game/board/star.c"),
             Object(Matching, "game/board/roll.c"),
diff --git a/include/board_unsplit.h b/include/board_unsplit.h
index d3a3e53c..941d3d53 100644
--- a/include/board_unsplit.h
+++ b/include/board_unsplit.h
@@ -3,29 +3,15 @@
 
 #include "dolphin.h"
 
-#ifndef _BOARD_SPACE_EVENT_FUNC
-#define _BOARD_SPACE_EVENT_FUNC
-typedef s32 (*BoardSpaceEventFunc)(void);
-#endif
-
 #ifndef _BOARD_MAIN_H
 typedef void (*BoardLightHook)(void);
 #endif
 
-s32 BoardSpacePosGet(s32, s32, Vec*);
 void BoardShopTutorialExec(s32);
 void BoardMGSetupTutorialExec(void);
 void BoardBooHouseTutorialExec(void);
-void BoardCharWheelTargetSet(s32);
-void BoardSpaceStarSetIndex(s32);
 void BoardLightHookSet(BoardLightHook set, BoardLightHook reset);
 s32 fn_8006DDE8(s16, f32);
-void BoardSpaceWalkEventFuncSet(BoardSpaceEventFunc func);
-void BoardSpaceWalkMiniEventFuncSet(BoardSpaceEventFunc func);
-void BoardSpaceLandEventFuncSet(BoardSpaceEventFunc func);
-s32 BoardSpaceFlagSearch(s32, u32);
-void BoardSpaceInit(s32);
-void BoardSpaceDestroy(void);
 void BoardShopHostSet(s16);
 void BoardBooHouseHostSet(s16);
 s32 BoardCameraRotGet(Vec*);
diff --git a/include/game/board/char_wheel.h b/include/game/board/char_wheel.h
new file mode 100755
index 00000000..ffbf333f
--- /dev/null
+++ b/include/game/board/char_wheel.h
@@ -0,0 +1,13 @@
+#ifndef _BOARD_CHAR_WHEEL_H
+#define _BOARD_CHAR_WHEEL_H
+
+#include "dolphin/types.h"
+
+s32 BoardCharWheelInit(s32 arg0, s32 arg1);
+BOOL BoardCharWheelCheck(void);
+void BoardCharWheelWait(void);
+s32 BoardCharWheelResultGet(void);
+void BoardCharWheelSpeedSet(float arg0);
+void BoardCharWheelTargetSet(s16 arg0);
+
+#endif
diff --git a/include/game/board/com.h b/include/game/board/com.h
index d0db30fa..f15542ab 100755
--- a/include/game/board/com.h
+++ b/include/game/board/com.h
@@ -14,6 +14,6 @@ s32 BoardComUseItemSlotGet(s32 arg0);
 s32 BoardComUseItemSet(s32 arg0, s32 arg1);
 BOOL BoardComUseItemCheck(s32 arg0);
 s32 BoardComJunctionInputGet(s32 arg0, Vec *arg1, s32 arg2, float *arg3);
-s32 BoardComBestPlayerFind(void);
+s32 BoardComFarPlayerFind(void);
 
 #endif
diff --git a/include/game/board/space.h b/include/game/board/space.h
index 44dc791f..d361da39 100644
--- a/include/game/board/space.h
+++ b/include/game/board/space.h
@@ -5,10 +5,7 @@
 
 #define BOARD_SPACE_LINKMAX 4
 
-#ifndef _BOARD_SPACE_EVENT_FUNC
-#define _BOARD_SPACE_EVENT_FUNC
 typedef s32 (*BoardSpaceEventFunc)(void);
-#endif
 
 typedef struct board_space {
 	Vec pos;
diff --git a/src/REL/w03Dll/mg_coin.c b/src/REL/w03Dll/mg_coin.c
index 29b3aad1..b0fb110f 100644
--- a/src/REL/w03Dll/mg_coin.c
+++ b/src/REL/w03Dll/mg_coin.c
@@ -6,6 +6,7 @@
 #include "game/board/main.h"
 #include "game/board/model.h"
 #include "game/board/player.h"
+#include "game/board/space.h"
 
 extern u16 HuPadBtnDown[4];
 extern s16 lbl_1_bss_C[14];
diff --git a/src/REL/w10Dll/main.c b/src/REL/w10Dll/main.c
index 00e96288..0f3dd29d 100644
--- a/src/REL/w10Dll/main.c
+++ b/src/REL/w10Dll/main.c
@@ -3,6 +3,7 @@
 #include "game/hsfman.h"
 #include "game/board/lottery.h"
 #include "game/board/model.h"
+#include "game/board/space.h"
 #include "game/board/star.h"
 #include "game/board/tutorial.h"
 #include "game/board/main.h"
diff --git a/src/REL/w10Dll/scene.c b/src/REL/w10Dll/scene.c
index 52909d78..6d5b6783 100644
--- a/src/REL/w10Dll/scene.c
+++ b/src/REL/w10Dll/scene.c
@@ -1,7 +1,9 @@
 #include "include/REL/w10Dll.h"
+#include "game/board/char_wheel.h"
 #include "game/board/lottery.h"
 #include "game/board/main.h"
 #include "game/board/model.h"
+#include "game/board/space.h"
 #include "game/board/star.h"
 #include "game/board/tutorial.h"
 #include "game/board/ui.h"
diff --git a/src/game/board/char_wheel.c b/src/game/board/char_wheel.c
new file mode 100755
index 00000000..75b8510f
--- /dev/null
+++ b/src/game/board/char_wheel.c
@@ -0,0 +1,532 @@
+#include "game/board/char_wheel.h"
+#include "game/audio.h"
+#include "game/flag.h"
+#include "game/gamework.h"
+#include "game/object.h"
+#include "game/pad.h"
+#include "game/board/com.h"
+#include "game/board/main.h"
+#include "game/board/tutorial.h"
+#include "game/board/ui.h"
+
+#include "math.h"
+
+typedef struct {
+    struct {
+        u8 unk00_field0 : 1;
+        u8 unk00_field1 : 1;
+        u8 unk00_field2 : 1;
+        u8 unk00_field3 : 4;
+    };
+    s8 unk01;
+    s8 unk02;
+    u8 unk03;
+    s16 unk04;
+    s16 unk06;
+    s16 unk08;
+} CharWheelWork;
+
+static void ExecCharWheel(omObjData *arg0);
+static void InitCharWheel(CharWheelWork *arg0);
+static void UpdateCharWheel(CharWheelWork *arg0);
+static void StopCharWheel(CharWheelWork *arg0);
+static void GrowCharWheel(CharWheelWork *arg0);
+static void ShrinkCharWheel(CharWheelWork *arg0);
+static void KillCharWheelSpr(void);
+static void SetCharWheelChars(s32 arg0, s32 arg1, s8 *arg2);
+static s32 GetInput(CharWheelWork *arg0);
+static s16 GetComDelay(s32 arg0, s32 arg1);
+static s32 GetComInput(CharWheelWork *arg0);
+
+static s8 wheelChars[4];
+static s16 comDelay;
+static s16 wheelTimer;
+static float wheelSpeed;
+static s16 targetVal;
+static float angleOfs;
+static s16 targetF;
+static omObjData *charWheelObj;
+
+static s8 wheelPos = -1;
+static s16 wheelSprGrp = -1;
+static s32 wheelFXStat = -1;
+
+static s32 wheelSprTbl[] = {
+    0x00070036,
+    0x00070038,
+    0x00070038,
+    0x00070038,
+    0x00070037,
+    0x00070037,
+    0x00070037,
+    0x00070037,
+    0x0007003A,
+    0x00070039
+};
+
+static s8 wheelSprPrio[] = {
+    0x3C, 0x50, 0x50, 0x50,
+    0x50, 0x50, 0x50, 0x50,
+    0x14, 0x1E,
+    // wheelCharIconPrioTbl
+    0x46, 0x46, 0x46, 0x46
+};
+
+static s32 wheelCharIconTbl[] = {
+    0x0007003B,
+    0x0007003C,
+    0x0007003D,
+    0x0007003E,
+    0x0007003F,
+    0x00070040,
+    0x00070041,
+    0x00070042
+};
+
+s32 BoardCharWheelInit(s32 arg0, s32 arg1) {
+    CharWheelWork *temp_r31;
+
+    arg1 = 3;
+    charWheelObj = omAddObjEx(boardObjMan, 0x104, 0, 0, -1, ExecCharWheel);
+    temp_r31 = OM_GET_WORK_PTR(charWheelObj, CharWheelWork);
+    temp_r31->unk00_field0 = 0;
+    temp_r31->unk00_field2 = 0;
+    temp_r31->unk00_field1 = (arg1 == 3) ? 0 : 1;
+    temp_r31->unk01 = arg0;
+    temp_r31->unk02 = 0;
+    temp_r31->unk03 = 0;
+    temp_r31->unk06 = 0;
+    wheelSpeed = 18.0f;
+    if (GWPlayer[temp_r31->unk01].com) {
+        temp_r31->unk04 = 360;
+    } else {
+        temp_r31->unk04 = 3600;
+    }
+}
+
+BOOL BoardCharWheelCheck(void) {
+    return (charWheelObj != NULL) ? FALSE : TRUE;
+}
+
+void BoardCharWheelWait(void) {
+    while (!BoardCharWheelCheck()) {
+        HuPrcVSleep();
+    }
+}
+
+s32 BoardCharWheelResultGet(void) {
+    return wheelChars[wheelPos];
+}
+
+void BoardCharWheelSpeedSet(float arg0) {
+    if (arg0 <= 0.0f) {
+        arg0 = 18.0f;
+    }
+    wheelSpeed = arg0;
+}
+
+static void ExecCharWheel(omObjData *arg0) {
+    CharWheelWork *temp_r31;
+
+    temp_r31 = OM_GET_WORK_PTR(arg0, CharWheelWork);;
+    if (temp_r31->unk00_field0 != 0 || BoardIsKill()) {
+        KillCharWheelSpr();
+        charWheelObj = NULL;
+        omDelObjEx(HuPrcCurrentGet(), arg0);
+        return;
+    }
+    if (wheelTimer < temp_r31->unk04) {
+        wheelTimer++;
+    }
+    switch (temp_r31->unk00_field3) {
+        case 0:
+            InitCharWheel(temp_r31);
+            break;
+        case 1:
+            GrowCharWheel(temp_r31);
+            break;
+        case 2:
+            UpdateCharWheel(temp_r31);
+            break;
+        case 3:
+            StopCharWheel(temp_r31);
+            break;
+        case 4:
+            ShrinkCharWheel(temp_r31);
+            break;
+    }
+}
+
+static void InitCharWheel(CharWheelWork *arg0) {
+    GXColor spE;
+    float temp_f29;
+    float temp_f28;
+    float temp_f27;
+    s32 var_r26;
+    s16 var_r27;
+    s16 var_r25;
+    s16 i;
+    s16 spA;
+    s16 sp8;
+
+    wheelChars[0] = wheelChars[1] = wheelChars[2] = wheelChars[3] = -1;
+    wheelFXStat = -1;
+    wheelTimer = 0;
+    if (arg0->unk00_field1 != 0) {
+        spA = 4;
+        var_r26 = 4;
+        temp_f27 = 45.0f;
+    } else {
+        spA = 3;
+        var_r26 = 1;
+        temp_f27 = 60.0f;
+    }
+    wheelSprGrp = HuSprGrpCreate(spA + 14);
+    SetCharWheelChars(arg0->unk00_field1, arg0->unk01, wheelChars);
+    if (GWPlayer[arg0->unk01].com) {
+        comDelay = GetComDelay(arg0->unk01, arg0->unk00_field1);
+        switch (GWPlayer[arg0->unk01].diff) {
+            case 0:
+                var_r27 = BoardRandMod(120);
+                break;
+            case 1:
+                var_r27 = BoardRandMod(60);
+                break;
+            case 2:
+                var_r27 = BoardRandMod(30);
+                break;
+            case 3:
+                var_r27 = 0;
+                break;
+        }
+        comDelay += var_r27;
+        if (comDelay > 360.0f) {
+            comDelay -= 360.0f;
+        }
+        if (comDelay < 0) {
+            comDelay += 360.0f;
+        }
+    } else {
+        comDelay = 0;
+    }
+    for (i = 0; i <= 9; i++) {
+        BoardSpriteCreate(wheelSprTbl[i], wheelSprPrio[i], 0, &sp8);
+        HuSprGrpMemberSet(wheelSprGrp, i, sp8);
+        HuSprAttrSet(wheelSprGrp, i, 8);
+    }
+    if (arg0->unk00_field1 == 0) {
+        for (i = 0; i < 4; i++) {
+            HuSprAttrSet(wheelSprGrp, i + 4, 4);
+        }
+    } else {
+        for (i = 0; i < 3; i++) {
+            HuSprAttrSet(wheelSprGrp, i + 1, 4);
+        }
+    }
+    for (i = 0; i < spA; i++) {
+        var_r25 = GWPlayer[wheelChars[i]].character;
+        BoardSpriteCreate(wheelCharIconTbl[var_r25], wheelSprPrio[i + 10], 0, &sp8);
+        HuSprGrpMemberSet(wheelSprGrp, i + 10, sp8);
+        HuSprAttrSet(wheelSprGrp, i + 10, 8);
+    }
+    HuSprPosSet(wheelSprGrp, 9, 3.0f, 3.0f);
+    HuSprColorSet(wheelSprGrp, 9, 0x40, 0x40, 0x40);
+    HuSprGrpPosSet(wheelSprGrp, 288.0f, 240.0f);
+    HuSprGrpScaleSet(wheelSprGrp, 0.01f, 0.01f);
+    OSs16tof32(&spA, &temp_f29);
+    temp_f29 = 360.0f / temp_f29;
+    for (i = 0; i < spA; i++) {
+        if (arg0->unk00_field1 != 0) {
+            switch (i) {
+                case 0:
+                    HuSprPosSet(wheelSprGrp, i + 10, 50.0f, -57.0f);
+                    break;
+                case 1:
+                    HuSprPosSet(wheelSprGrp, i + 10, -50.0f, -57.0f);
+                    break;
+                case 2:
+                    HuSprPosSet(wheelSprGrp, i + 10, 50.0f, 57.0f);
+                    break;
+                case 3:
+                    HuSprPosSet(wheelSprGrp, i + 10, -50.0f, 57.0f);
+                    break;
+            }
+        } else {
+            switch (i) {
+                case 0:
+                    HuSprPosSet(wheelSprGrp, i + 10, 50.0f, -35.0f);
+                    break;
+                case 1:
+                    HuSprPosSet(wheelSprGrp, i + 10, 0.0f, 57.0f);
+                    break;
+                case 2:
+                    HuSprPosSet(wheelSprGrp, i + 10, -50.0f, -35.0f);
+                    break;
+            }
+        }
+        OSs16tof32(&i, &temp_f28);
+        HuSprZRotSet(wheelSprGrp, var_r26 + i, temp_f29 * temp_f28);
+        GWCharColorGet(GWPlayer[wheelChars[i]].character, &spE);
+        HuSprColorSet(wheelSprGrp, var_r26 + i, spE.r, spE.g, spE.b);
+    }
+    for (i = 0; i < 3; i++) {
+        if (wheelChars[i] == targetVal) {
+            break;
+        }
+    }
+    angleOfs = 120.0f * i;
+    if (angleOfs > 180.0f) {
+        angleOfs -= 360.0f;
+    }
+    arg0->unk00_field3 = 1;
+}
+
+static void UpdateCharWheel(CharWheelWork *arg0) {
+    float var_f24;
+    float var_f25;
+    float var_f23;
+    u32 var_r18;
+    s16 temp_r20;
+    s16 var_r19;
+    s16 var_r17;
+
+    OSs16tof32(&arg0->unk06, &var_f24);
+    OSs16tof32(&arg0->unk08, &var_f25);
+    var_f24 = var_f24 * 0.0625f;
+    var_f25 = var_f25 * 0.0625f;
+    if (arg0->unk00_field2 == 0) {
+        if (var_f25 < 18.0f) {
+            var_f25 += 0.7f;
+            if (var_f25 > wheelSpeed) {
+                var_f25 = wheelSpeed;
+            }
+        } else {
+            var_r18 = GetInput(arg0);
+            if (var_r18 & 0x100) {
+                arg0->unk00_field2 = 1;
+            }
+        }
+    } else {
+        OSf32tos16(&var_f24, &temp_r20);
+        if (arg0->unk00_field1 == 0) {
+            var_r19 = 120;
+        } else {
+            var_r19 = 90;
+        }
+        temp_r20 %= var_r19;
+        if (var_f25 < 0.5f && (temp_r20 < 2 || temp_r20 >= var_r19 - 2)) {
+            var_f25 += var_f25 / 2;
+        }
+        var_f25 *= 0.92f;
+    }
+    var_f23 = 8191.0f - 8191.0f * (var_f25 / wheelSpeed);
+    OSf32tos16(&var_f23, &var_r17);
+    HuAudFXPitchSet(wheelFXStat, -var_r17);
+    if (var_f25 > -0.0000001f && var_f25 < 0.0000001f) {
+        arg0->unk00_field3 = 3;
+        if (wheelFXStat != -1) {
+            HuAudFXStop(wheelFXStat);
+            wheelFXStat = -1;
+        }
+        HuAudFXPlay(0x30B);
+    }
+    var_f24 += var_f25;
+    if (var_f24 > 360.0f) {
+        var_f24 -= 360.0f;
+    }
+    HuSprZRotSet(wheelSprGrp, 8, var_f24);
+    HuSprZRotSet(wheelSprGrp, 9, var_f24);
+    var_f24 *= 16.0f;
+    var_f25 *= 16.0f;
+    OSf32tos16(&var_f24, &arg0->unk06);
+    OSf32tos16(&var_f25, &arg0->unk08);
+}
+
+static void StopCharWheel(CharWheelWork *arg0) {
+    u8 var_r30;
+
+    if (arg0->unk03 == 0) {
+        arg0->unk06 >>= 4;
+        if (arg0->unk00_field1 == 0) {
+            wheelPos = arg0->unk06 / 120;
+        } else {
+            wheelPos = arg0->unk06 / 90;
+        }
+    }
+    var_r30 = arg0->unk03 % 6;
+    if (var_r30 < 3) {
+        HuSprAttrSet(wheelSprGrp, wheelPos + 10, 4);
+    } else {
+        HuSprAttrReset(wheelSprGrp, wheelPos + 10, 4);
+    }
+    if (arg0->unk03 < 90) {
+        arg0->unk03++;
+    } else {
+        HuSprAttrReset(wheelSprGrp, wheelPos + 10, 4);
+        arg0->unk00_field3 = 4;
+    }
+}
+
+static void GrowCharWheel(CharWheelWork *arg0) {
+    float temp_f30;
+
+    if (arg0->unk02 < 90) {
+        arg0->unk02 += 3;
+    } else {
+        if (_CheckFlag(0x1000B)) {
+            BoardTutorialHookExec(0x14, 0);
+        }
+        arg0->unk02 = 90;
+        arg0->unk00_field3 = 2;
+        wheelFXStat = HuAudFXPlay(0x30A);
+    }
+    OSs8tof32(&arg0->unk02, &temp_f30);
+    HuSprGrpScaleSet(wheelSprGrp, sin(temp_f30 * M_PI / 180.0), sin(temp_f30 * M_PI / 180.0));
+}
+
+static void ShrinkCharWheel(CharWheelWork *arg0) {
+    float temp_f30;
+
+    if (arg0->unk02 > 0) {
+        arg0->unk02 -= 3;
+    } else {
+        arg0->unk02 = 0;
+        arg0->unk00_field0 = 1;
+        arg0->unk00_field3 = -1;
+        targetF = 0;
+    }
+    OSs8tof32(&arg0->unk02, &temp_f30);
+    HuSprGrpScaleSet(wheelSprGrp, sin(temp_f30 * M_PI / 180.0), sin(temp_f30 * M_PI / 180.0));
+}
+
+static void KillCharWheelSpr(void) {
+    if (wheelSprGrp != -1) {
+        HuSprGrpKill(wheelSprGrp);
+        wheelSprGrp = -1;
+    }
+}
+
+static void SetCharWheelChars(s32 arg0, s32 arg1, s8 *arg2) {
+    s32 var_r29;
+    s32 var_r28;
+    s32 var_r31;
+    s32 var_r30;
+
+    for (var_r28 = var_r29 = 0; var_r29 < 4; var_r29++) {
+        if (var_r29 == arg1 && arg0 == 0) {
+            continue;
+        }
+        do {
+            do {
+                var_r30 = BoardRandMod(4);
+            } while (var_r30 == arg1 && arg0 == 0);
+            for (var_r31 = 0; var_r31 < 4; var_r31++) {
+                if (var_r30 == arg2[var_r31]) {
+                    var_r30 = -1;
+                    break;
+                }
+            }
+        } while (var_r30 == -1);
+        arg2[var_r28] = var_r30;
+        var_r28++;
+    }
+}
+
+static s32 GetInput(CharWheelWork *arg0) {
+    CharWheelWork *var_r27;
+    float temp_f26;
+    float temp_f27;
+    float var_f28;
+    float var_f29;
+    s32 var_r28;
+
+    if (wheelTimer >= arg0->unk04) {
+        return 0x100;
+    }
+    if (!GWPlayer[arg0->unk01].com) {
+        var_r28 = HuPadBtnDown[GWPlayer[arg0->unk01].port];
+        return  var_r28;
+    }
+    var_r28 = GetComInput(arg0);
+    if (targetF != 0) {
+        var_r27 = OM_GET_WORK_PTR(charWheelObj, CharWheelWork);
+        OSs16tof32(&var_r27->unk06, &temp_f26);
+        OSs16tof32(&var_r27->unk08, &temp_f27);
+        temp_f26 = temp_f26 * 0.0625f;
+        temp_f27 = temp_f27 * 0.0625f;
+        var_f29 = temp_f26 + 46.0f * temp_f27;
+        var_f29 = fmod(var_f29, 360.0);
+        if (var_f29 > 180.0f) {
+            var_f29 -= 360.0f;
+        }
+        var_f28 = angleOfs - var_f29;
+        if (var_f28 >= 360.0f) {
+            var_f28 += 360.0f;
+        }
+        if (var_f28 >= 0.0f && var_f28 < 120.0f - 2.0f * temp_f27) {
+            var_r28 = 0x100;
+        } else {
+            var_r28 = 0;
+        }
+        OSReport("%f %f : %f %f\n", temp_f26, temp_f27, var_f29, var_f28);
+    }
+    return var_r28;
+}
+
+void BoardCharWheelTargetSet(s16 arg0) {
+    targetF = 1;
+    targetVal = arg0;
+}
+
+static s16 GetComDelay(s32 arg0, s32 arg1) {
+    float var_f30;
+    s16 var_r26;
+    s32 var_r27;
+    s32 var_r28;
+    s32 i;
+
+    var_r28 = BoardComFarPlayerFind();
+    if (var_r28 == -1 || var_r28 == arg0) {
+        do {
+            var_r28 = BoardRandMod(4);
+        } while (var_r28 == arg0);
+    }
+    if (arg1 != 0) {
+        var_r27 = 4;
+    } else {
+        var_r27 = 3;
+    }
+    for (var_r26 = i = 0; i < var_r27; i++) {
+        if (var_r28 == wheelChars[i]) {
+            var_f30 = i * (360 / var_r27);
+            var_f30 += 45.0f;
+            var_f30 -= 180.0f;
+            if (var_f30 < 0.0f) {
+                var_f30 += 360.0f;
+            }
+            if (var_f30 >= 360.0f) {
+                var_f30 -= 360.0f;
+            }
+            OSf32tos16(&var_f30, &var_r26);
+            break;
+        }
+    }
+    return var_r26;
+}
+
+static s32 GetComInput(CharWheelWork *arg0) {
+    s16 temp_r31;
+    s32 var_r29;
+    s32 var_r28;
+    s32 var_r27;
+
+    temp_r31 = (arg0->unk06 >> 4);
+    var_r27 = (arg0->unk00_field1 != 0) ? 90 : 120;
+    var_r28 = comDelay;
+    var_r29 = comDelay + var_r27;
+    if (temp_r31 >= var_r28 && temp_r31 < var_r29) {
+        return 0x100;
+    } else {
+        return 0;
+    }
+}
diff --git a/src/game/board/item.c b/src/game/board/item.c
index 97aa67df..60d48ff8 100755
--- a/src/game/board/item.c
+++ b/src/game/board/item.c
@@ -12,6 +12,7 @@
 #include "game/wipe.h"
 #include "game/board/audio.h"
 #include "game/board/boo.h"
+#include "game/board/char_wheel.h"
 #include "game/board/com.h"
 #include "game/board/main.h"
 #include "game/board/model.h"
@@ -52,7 +53,6 @@ typedef struct {
 extern u32 frandmod(u32);
 extern void BoardBowserSuitInit(s32);
 extern s16 BoardBowserSuitPlayerModelGet(void);
-extern void BoardCharWheelWait(void);
 
 static void ItemProcess(void);
 static void RestoreProcess(void);
diff --git a/src/game/board/main.c b/src/game/board/main.c
index ba00341f..e446a4dc 100644
--- a/src/game/board/main.c
+++ b/src/game/board/main.c
@@ -14,6 +14,7 @@
 #include "game/board/model.h"
 #include "game/board/pause.h"
 #include "game/board/player.h"
+#include "game/board/space.h"
 #include "game/board/tutorial.h"
 #include "game/board/ui.h"
 #include "game/pad.h"
@@ -60,8 +61,6 @@ static CameraView camViewTbl[] = {
 };
 
 
-extern s32 BoardSpacePosGet(s32 layer, s32 space, Vec *pos);
-
 extern void BoardMGSetupPlayClear(void);
 extern void BoardStartExec(void);
 
diff --git a/src/game/board/player.c b/src/game/board/player.c
index b0212376..702924a7 100644
--- a/src/game/board/player.c
+++ b/src/game/board/player.c
@@ -6,6 +6,7 @@
 #include "game/board/com.h"
 #include "game/board/main.h"
 #include "game/board/roll.h"
+#include "game/board/space.h"
 #include "game/board/tutorial.h"
 #include "game/board/ui.h"
 #include "game/board/view.h"
diff --git a/src/game/board/star.c b/src/game/board/star.c
index 99b05702..aab8fa90 100755
--- a/src/game/board/star.c
+++ b/src/game/board/star.c
@@ -14,6 +14,7 @@
 #include "game/board/main.h"
 #include "game/board/model.h"
 #include "game/board/player.h"
+#include "game/board/space.h"
 #include "game/board/tutorial.h"
 #include "game/board/ui.h"
 #include "game/board/window.h"
diff --git a/src/game/board/warp.c b/src/game/board/warp.c
index 8505051a..dfd50ab9 100644
--- a/src/game/board/warp.c
+++ b/src/game/board/warp.c
@@ -1,7 +1,9 @@
 #include "game/board/warp.h"
+#include "game/board/char_wheel.h"
 #include "game/board/main.h"
 #include "game/board/model.h"
 #include "game/board/player.h"
+#include "game/board/space.h"
 #include "game/board/tutorial.h"
 #include "game/wipe.h"
 #include "game/gamework_data.h"
@@ -17,12 +19,6 @@ static void WarpStartImpact(s32);
 static void WarpFall(s32);
 static void WarpImpact(s32);
 
-
-extern void BoardCharWheelInit(s32, s32);
-extern void BoardCharWheelSpeedSet(f32);
-extern void BoardCharWheelWait(void);
-extern s32 BoardCharWheelResultGet(void);
-
 static Vec warpPos;
 
 static s8 warpState;

From 504e565727f41e83720772c2eac3fcc0d8f1c518 Mon Sep 17 00:00:00 2001
From: gamemasterplc <gamemasterplc@gmail.com>
Date: Sun, 10 Mar 2024 22:36:14 -0500
Subject: [PATCH 4/7] Clean Up Sprite Constant Labeling

Also improved struct labeling.
---
 include/game/animdata.h |  85 +++++++++++
 include/game/sprite.h   | 221 +++++++++------------------
 src/REL/bootDll/main.c  |  48 +++---
 src/game/board/main.c   |  14 +-
 src/game/board/space.c  |  12 +-
 src/game/minigame_seq.c |  84 +++++------
 src/game/sprman.c       | 327 ++++++++++++++++++++--------------------
 src/game/sprput.c       |  40 ++---
 src/game/thpmain.c      |   4 +-
 src/game/window.c       |  24 +--
 10 files changed, 434 insertions(+), 425 deletions(-)
 create mode 100644 include/game/animdata.h

diff --git a/include/game/animdata.h b/include/game/animdata.h
new file mode 100644
index 00000000..815367f0
--- /dev/null
+++ b/include/game/animdata.h
@@ -0,0 +1,85 @@
+#ifndef _GAME_ANIMDATA_H
+#define _GAME_ANIMDATA_H
+
+#include "dolphin.h"
+
+#define ANIM_BMP_RGBA8 0
+#define ANIM_BMP_RGB5A3 1
+#define ANIM_BMP_RGB5A3_DUPE 2
+#define ANIM_BMP_C8 3
+#define ANIM_BMP_C4 4
+#define ANIM_BMP_IA8 5
+#define ANIM_BMP_IA4 6
+#define ANIM_BMP_I8 7
+#define ANIM_BMP_I4 8
+#define ANIM_BMP_A8 9
+#define ANIM_BMP_CMPR 10
+
+#define ANIM_BMP_FMTMASK 0xF
+#define ANIM_BMP_ALLOC 0x8000
+#define ANIM_BMP_NUM_MASK 0x7FFF
+
+#define ANIM_LAYER_FLIPX 0x1
+#define ANIM_LAYER_FLIPY 0x2
+
+typedef void (*SpriteFunc)(struct sprite_data *);
+
+typedef struct anim_frame_data {
+    s16 pat;
+    s16 time;
+    s16 shiftX;
+    s16 shiftY;
+    s16 flip;
+    s16 pad;
+} AnimFrameData;
+
+typedef struct anim_bank_data {
+    s16 timeNum;
+    s16 unk;
+    AnimFrameData *frame;
+} AnimBankData;
+
+typedef struct anim_layer_data {
+    u8 alpha;
+    u8 flip;
+    s16 bmpNo;
+    s16 startX;
+    s16 startY;
+    s16 sizeX;
+    s16 sizeY;
+    s16 shiftX;
+    s16 shiftY;
+    s16 vtx[8];
+} AnimLayerData;
+
+typedef struct anim_pat_data {
+    s16 layerNum;
+    s16 centerX;
+    s16 centerY;
+    s16 sizeX;
+    s16 sizeY;
+    AnimLayerData *layer;
+} AnimPatData;
+
+typedef struct anim_bmp_data {
+    u8 pixSize;
+    u8 dataFmt;
+    s16 palNum;
+    s16 sizeX;
+    s16 sizeY;
+    u32 dataSize;
+    void *palData;
+    void *data;
+} AnimBmpData;
+
+typedef struct anim_data {
+    s16 bankNum;
+    s16 patNum;
+    s16 bmpNum;
+    s16 useNum;
+    AnimBankData *bank;
+    AnimPatData *pat;
+    AnimBmpData *bmp;
+} AnimData;
+
+#endif
\ No newline at end of file
diff --git a/include/game/sprite.h b/include/game/sprite.h
index 946bf244..42dcba76 100644
--- a/include/game/sprite.h
+++ b/include/game/sprite.h
@@ -5,111 +5,36 @@
 #include "game/data.h"
 #include "game/memory.h"
 
-#define SPRITE_MAX 384
-#define SPRITE_GROUP_MAX 256
+#define HUSPR_MAX 384
+#define HUSPR_GRP_MAX 256
 
-#define SPRITE_INVALID -1
-#define SPRITE_GROUP_INVALID -1
+#define HUSPR_NONE -1
+#define HUSPR_GRP_NONE -1
 
-#define SPRITE_ATTR_PAUSED 0x1
-#define SPRITE_ATTR_LOOP 0x2
-#define SPRITE_ATTR_HIDDEN 0x4
-#define SPRITE_ATTR_BILINEAR 0x8
-#define SPRITE_ATTR_FUNC 0x10
-#define SPRITE_ATTR_NOPAUSE 0x20
-#define SPRITE_ATTR_REVERSE 0x40
-#define SPRITE_ATTR_ADDITIVE 0x80
-#define SPRITE_ATTR_INVERT 0x100
+#define HUSPR_ATTR_NOANIM 0x1
+#define HUSPR_ATTR_LOOP 0x2
+#define HUSPR_ATTR_DISPOFF 0x4
+#define HUSPR_ATTR_LINEAR 0x8
+#define HUSPR_ATTR_FUNC 0x10
+#define HUSPR_ATTR_NOPAUSE 0x20
+#define HUSPR_ATTR_REVERSE 0x40
+#define HUSPR_ATTR_ADDCOL 0x80
+#define HUSPR_ATTR_INVCOL 0x100
 
-#define SPRITE_BMP_RGBA8 0
-#define SPRITE_BMP_RGB5A3 1
-#define SPRITE_BMP_RGB5A3_DUPE 2
-#define SPRITE_BMP_C8 3
-#define SPRITE_BMP_C4 4
-#define SPRITE_BMP_IA8 5
-#define SPRITE_BMP_IA4 6
-#define SPRITE_BMP_I8 7
-#define SPRITE_BMP_I4 8
-#define SPRITE_BMP_A8 9
-#define SPRITE_BMP_CMPR 10
+#include "game/animdata.h"
 
-#define SPRITE_BMP_FMTMASK 0xF
-#define SPRITE_BMP_ALLOC 0x8000
-#define SPRITE_BMP_NUM_MASK 0x7FFF
+typedef void (*HuSprFunc)(struct hu_sprite *);
 
-#define SPRITE_LAYER_FLIPX 0x1
-#define SPRITE_LAYER_FLIPY 0x2
-
-typedef void (*SpriteFunc)(struct sprite_data *);
-
-typedef struct anim_frame_data {
-    s16 pat;
-    s16 time;
-    s16 shiftX;
-    s16 shiftY;
-    s16 flip;
-    s16 pad;
-} AnimFrameData;
-
-typedef struct anim_bank_data {
-    s16 timeNum;
-    s16 unk;
-    AnimFrameData *frame;
-} AnimBankData;
-
-typedef struct anim_layer_data {
-    u8 alpha;
-    u8 flip;
-    s16 bmpNo;
-    s16 startX;
-    s16 startY;
-    s16 sizeX;
-    s16 sizeY;
-    s16 shiftX;
-    s16 shiftY;
-    s16 vtx[8];
-} AnimLayerData;
-
-typedef struct anim_pat_data {
-    s16 layerNum;
-    s16 centerX;
-    s16 centerY;
-    s16 sizeX;
-    s16 sizeY;
-    AnimLayerData *layer;
-} AnimPatData;
-
-typedef struct anim_bmp_data {
-    u8 pixSize;
-    u8 dataFmt;
-    s16 palNum;
-    s16 sizeX;
-    s16 sizeY;
-    u32 dataSize;
-    void *palData;
-    void *data;
-} AnimBmpData;
-
-typedef struct anim_data {
-    s16 bankNum;
-    s16 patNum;
-    s16 bmpNum;
-    s16 useNum;
-    AnimBankData *bank;
-    AnimPatData *pat;
-    AnimBmpData *bmp;
-} AnimData;
-
-typedef struct sprite_data {
+typedef struct hu_sprite {
     u8 r;
     u8 g;
     u8 b;
-    char draw_no;
-    short frame;
-    short bank;
-    short attr;
-    short dirty_flag;
-    short prio;
+    u8 draw_no;
+    s16 frame;
+    s16 bank;
+    s16 attr;
+    s16 dirty_flag;
+    s16 prio;
     float time;
     float x;
     float y;
@@ -120,26 +45,26 @@ typedef struct sprite_data {
     float a;
     GXTexWrapMode wrap_s;
     GXTexWrapMode wrap_t;
-    short tex_scale_x;
-    short tex_scale_y;
+    s16 tex_scale_x;
+    s16 tex_scale_y;
     Mtx *group_mtx;
     union {
         AnimData *data;
-        SpriteFunc func;
+        HuSprFunc func;
     };
     AnimPatData *pat_data;
     AnimFrameData *frame_data;
-    short work[4];
+    s16 work[4];
     AnimData *bg;
-    unsigned short bg_bank;
-    short scissor_x;
-    short scissor_y;
-    short scissor_w;
-    short scissor_h;
-} SpriteData;
+    u16 bg_bank;
+    s16 scissor_x;
+    s16 scissor_y;
+    s16 scissor_w;
+    s16 scissor_h;
+} HuSprite;
 
-typedef struct sprite_group_data {
-    short capacity;
+typedef struct hu_spr_grp {
+    s16 capacity;
     float x;
     float y;
     float z_rot;
@@ -147,60 +72,60 @@ typedef struct sprite_group_data {
     float scale_y;
     float center_x;
     float center_y;
-    short *members;
+    s16 *members;
     Mtx mtx;
-} SpriteGroupData;
+} HuSprGrp;
 
-extern SpriteData HuSprData[SPRITE_MAX];
-extern SpriteGroupData HuSprGrpData[SPRITE_GROUP_MAX];
+extern HuSprite HuSprData[HUSPR_MAX];
+extern HuSprGrp HuSprGrpData[HUSPR_GRP_MAX];
 
 #define HuSprAnimReadFile(data_id) (HuSprAnimRead(HuDataSelHeapReadNum((data_id), MEMORY_DEFAULT_NUM, HEAP_DATA)))
 
 void HuSprInit(void);
 void HuSprClose(void);
-void HuSprExec(short draw_no);
+void HuSprExec(s16 draw_no);
 void HuSprBegin(void);
-SpriteData *HuSprCall(void);
+HuSprite *HuSprCall(void);
 void HuSprFinish(void);
 void HuSprPauseSet(BOOL value);
 AnimData *HuSprAnimRead(void *data);
 void HuSprAnimLock(AnimData *anim);
-short HuSprCreate(AnimData *anim, short prio, short bank);
-short HuSprFuncCreate(SpriteFunc func, short prio);
-short HuSprGrpCreate(short capacity);
-short HuSprGrpCopy(short group);
-void HuSprGrpMemberSet(short group, short member, short sprite);
-void HuSprGrpMemberKill(short group, short member);
-void HuSprGrpKill(short group);
-void HuSprKill(short sprite);
+s16 HuSprCreate(AnimData *anim, s16 prio, s16 bank);
+s16 HuSprFuncCreate(HuSprFunc func, s16 prio);
+s16 HuSprGrpCreate(s16 capacity);
+s16 HuSprGrpCopy(s16 group);
+void HuSprGrpMemberSet(s16 group, s16 member, s16 sprite);
+void HuSprGrpMemberKill(s16 group, s16 member);
+void HuSprGrpKill(s16 group);
+void HuSprKill(s16 sprite);
 void HuSprAnimKill(AnimData *anim);
-void HuSprAttrSet(short group, short member, int attr);
-void HuSprAttrReset(short group, short member, int attr);
-void HuSprPosSet(short group, short member, float x, float y);
-void HuSprZRotSet(short group, short member, float z_rot);
-void HuSprScaleSet(short group, short member, float x, float y);
-void HuSprTPLvlSet(short group, short member, float tp_lvl);
-void HuSprColorSet(short group, short member, u8 r, u8 g, u8 b);
-void HuSprSpeedSet(short group, short member, float speed);
-void HuSprBankSet(short group, short member, short bank);
-void HuSprGrpPosSet(short group, float x, float y);
-void HuSprGrpCenterSet(short group, float x, float y);
-void HuSprGrpZRotSet(short group, float z_rot);
-void HuSprGrpScaleSet(short group, float x, float y);
-void HuSprGrpTPLvlSet(short group, float tp_lvl);
-s32 HuSprGrpDrawNoSet(short group, int draw_no);
-void HuSprDrawNoSet(short group, short member, int draw_no);
-void HuSprPriSet(short group, short member, short prio);
-void HuSprGrpScissorSet(short group, short x, short y, short w, short h);
-void HuSprScissorSet(short group, short member, short x, short y, short w, short h);
-AnimData *HuSprAnimMake(short sizeX, short sizeY, short dataFmt);
-void HuSprBGSet(short group, short member,  AnimData *bg, short bg_bank);
-void HuSprSprBGSet(short sprite, AnimData *bg, short bg_bank);
+void HuSprAttrSet(s16 group, s16 member, s32 attr);
+void HuSprAttrReset(s16 group, s16 member, s32 attr);
+void HuSprPosSet(s16 group, s16 member, float x, float y);
+void HuSprZRotSet(s16 group, s16 member, float z_rot);
+void HuSprScaleSet(s16 group, s16 member, float x, float y);
+void HuSprTPLvlSet(s16 group, s16 member, float tp_lvl);
+void HuSprColorSet(s16 group, s16 member, u8 r, u8 g, u8 b);
+void HuSprSpeedSet(s16 group, s16 member, float speed);
+void HuSprBankSet(s16 group, s16 member, s16 bank);
+void HuSprGrpPosSet(s16 group, float x, float y);
+void HuSprGrpCenterSet(s16 group, float x, float y);
+void HuSprGrpZRotSet(s16 group, float z_rot);
+void HuSprGrpScaleSet(s16 group, float x, float y);
+void HuSprGrpTPLvlSet(s16 group, float tp_lvl);
+s32 HuSprGrpDrawNoSet(s16 group, s32 draw_no);
+void HuSprDrawNoSet(s16 group, s16 member, s32 draw_no);
+void HuSprPriSet(s16 group, s16 member, s16 prio);
+void HuSprGrpScissorSet(s16 group, s16 x, s16 y, s16 w, s16 h);
+void HuSprScissorSet(s16 group, s16 member, s16 x, s16 y, s16 w, s16 h);
+AnimData *HuSprAnimMake(s16 sizeX, s16 sizeY, s16 dataFmt);
+void HuSprBGSet(s16 group, s16 member,  AnimData *bg, s16 bg_bank);
+void HuSprSprBGSet(s16 sprite, AnimData *bg, s16 bg_bank);
 void AnimDebug(AnimData *anim);
 
 void HuSprDispInit(void);
-void HuSprDisp(SpriteData *sprite);
-void HuSprTexLoad(AnimData *anim, short bmp, short slot, GXTexWrapMode wrap_s, GXTexWrapMode wrap_t, GXTexFilter filter);
-void HuSprExecLayerSet(short draw_no, short layer);
+void HuSprDisp(HuSprite *sprite);
+void HuSprTexLoad(AnimData *anim, s16 bmp, s16 slot, GXTexWrapMode wrap_s, GXTexWrapMode wrap_t, GXTexFilter filter);
+void HuSprExecLayerSet(s16 draw_no, s16 layer);
 
 #endif
\ No newline at end of file
diff --git a/src/REL/bootDll/main.c b/src/REL/bootDll/main.c
index 2282e16c..b5b6f749 100644
--- a/src/REL/bootDll/main.c
+++ b/src/REL/bootDll/main.c
@@ -84,14 +84,14 @@ static void BootProc(void)
 	sprite_nintendo = HuSprCreate(data, 0, 0);
 	HuSprGrpMemberSet(group, 0, sprite_nintendo);
 	HuSprPosSet(group, 0, 288, 240);
-	HuSprAttrSet(group, 0, SPRITE_ATTR_HIDDEN);
+	HuSprAttrSet(group, 0, HUSPR_ATTR_DISPOFF);
 	if(omovlevtno != 0) {
 		HuAudSndGrpSetSet(0);
 		data = HuSprAnimReadFile(TITLE_HUDSON_ANM);
 		sprite_hudson = HuSprCreate(data, 0, 0);
 		HuSprGrpMemberSet(group, 1, sprite_hudson);
 		HuSprPosSet(group, 1, 288, 240);
-		HuSprAttrSet(group, 1, SPRITE_ATTR_HIDDEN);
+		HuSprAttrSet(group, 1, HUSPR_ATTR_DISPOFF);
 		HuWinInit(1);
 		TitleInit();
 		SystemInitF = 1;
@@ -104,7 +104,7 @@ static void BootProc(void)
 			GWPlayerCfg[i].pad_idx = i;
 		}
 		repeat:
-		HuSprAttrReset(group, 0, SPRITE_ATTR_HIDDEN);
+		HuSprAttrReset(group, 0, HUSPR_ATTR_DISPOFF);
 		WipeCreate(WIPE_MODE_IN, WIPE_TYPE_NORMAL, 30);
 		while(WipeStatGet()) {
 			HuPrcVSleep();
@@ -121,7 +121,7 @@ static void BootProc(void)
 			sprite_hudson = HuSprCreate(data, 0, 0);
 			HuSprGrpMemberSet(group, 1, sprite_hudson);
 			HuSprPosSet(group, 1, 288, 240);
-			HuSprAttrSet(group, 1, SPRITE_ATTR_HIDDEN);
+			HuSprAttrSet(group, 1, HUSPR_ATTR_DISPOFF);
 			while(OSTicksToMilliseconds(OSGetTick()-tick_prev) < 3000) {
 				HuPrcVSleep();
 			}
@@ -137,8 +137,8 @@ static void BootProc(void)
 		while(WipeStatGet()) {
 			HuPrcVSleep();
 		}
-		HuSprAttrSet(group, 0, SPRITE_ATTR_HIDDEN);
-		HuSprAttrReset(group, 1, SPRITE_ATTR_HIDDEN);
+		HuSprAttrSet(group, 0, HUSPR_ATTR_DISPOFF);
+		HuSprAttrReset(group, 1, HUSPR_ATTR_DISPOFF);
 		HuPrcSleep(60);
 		WipeCreate(WIPE_MODE_IN, WIPE_TYPE_NORMAL, 30);
 		while(WipeStatGet()) {
@@ -173,8 +173,8 @@ static void BootProc(void)
 		while(OSTicksToMilliseconds(OSGetTick()-tick_prev) < 1000) {
 			HuPrcVSleep();
 		}
-		HuSprAttrSet(group, 0, SPRITE_ATTR_HIDDEN);
-		HuSprAttrSet(group, 1, SPRITE_ATTR_HIDDEN);
+		HuSprAttrSet(group, 0, HUSPR_ATTR_DISPOFF);
+		HuSprAttrSet(group, 1, HUSPR_ATTR_DISPOFF);
 		group_thp = HuSprGrpCreate(1);
 		sprite_thp = HuTHPSprCreateVol("movie/opmov_a00.thp", 0, 100, 122);
 		HuSprGrpMemberSet(group_thp, 0, sprite_thp);
@@ -300,7 +300,7 @@ static void ProgressiveProc(void)
 	sprite = HuSprCreate(data, 0, 0);
 	HuSprGrpMemberSet(group, 2, sprite);
 	HuSprPosSet(group, 2, progressivePosTbl[option*2], progressivePosTbl[(option*2)+1]);
-	HuSprAttrSet(group, 2, SPRITE_ATTR_HIDDEN);
+	HuSprAttrSet(group, 2, HUSPR_ATTR_DISPOFF);
 	WipeCreate(WIPE_MODE_IN, WIPE_TYPE_NORMAL, 30);
 	while(WipeStatGet()) {
 		HuPrcVSleep();
@@ -312,9 +312,9 @@ static void ProgressiveProc(void)
 			i=0;
 		}
 		if(HU_PAD_BTNDOWN_ALL & PAD_BUTTON_A) {
-			HuSprAttrSet(group, 1, SPRITE_ATTR_HIDDEN);
+			HuSprAttrSet(group, 1, HUSPR_ATTR_DISPOFF);
 			HuSprPosSet(group, 2, progressivePosTbl[option*2], progressivePosTbl[(option*2)+1]);
-			HuSprAttrReset(group, 2, SPRITE_ATTR_HIDDEN);
+			HuSprAttrReset(group, 2, HUSPR_ATTR_DISPOFF);
 			break;
 		}
 		HuPrcVSleep();
@@ -468,23 +468,23 @@ static void TitleInit(void)
 	sprite_data = HuSprAnimReadFile(TITLE_BG_ANM);
 	sprite = HuSprCreate(sprite_data, 0, 0);
 	HuSprGrpMemberSet(titleGroup, 0, sprite);
-	HuSprAttrSet(titleGroup, 0, SPRITE_ATTR_HIDDEN);
+	HuSprAttrSet(titleGroup, 0, HUSPR_ATTR_DISPOFF);
 	HuSprDrawNoSet(titleGroup, 0, 127);
 	HuSprPosSet(titleGroup, 0, 288, 240);
 	sprite_data = HuSprAnimReadFile(TITLE_COPYRIGHT_ANM);
 	sprite = HuSprCreate(sprite_data, 1, 0);
 	HuSprGrpMemberSet(titleGroup, 1, sprite);
-	HuSprAttrSet(titleGroup, 1, SPRITE_ATTR_HIDDEN);
+	HuSprAttrSet(titleGroup, 1, HUSPR_ATTR_DISPOFF);
 	HuSprPosSet(titleGroup, 1, 288, 420);
 	sprite_data = HuSprAnimReadFile(TITLE_PRESS_START_ANM);
 	sprite = HuSprCreate(sprite_data, 2, 0);
 	HuSprGrpMemberSet(titleGroup, 2, sprite);
-	HuSprAttrSet(titleGroup, 2, SPRITE_ATTR_HIDDEN|SPRITE_ATTR_BILINEAR);
+	HuSprAttrSet(titleGroup, 2, HUSPR_ATTR_DISPOFF|HUSPR_ATTR_LINEAR);
 	HuSprPosSet(titleGroup, 2, 288, 380);
 	sprite_data = HuSprAnimReadFile(TITLE_LOGO_ANM);
 	sprite = HuSprCreate(sprite_data, 0, 0);
 	HuSprGrpMemberSet(titleGroup, 3, sprite);
-	HuSprAttrSet(titleGroup, 3, SPRITE_ATTR_HIDDEN|SPRITE_ATTR_BILINEAR);
+	HuSprAttrSet(titleGroup, 3, HUSPR_ATTR_DISPOFF|HUSPR_ATTR_LINEAR);
 	HuSprPosSet(titleGroup, 3, 288, 200);
 }
 
@@ -496,8 +496,8 @@ static BOOL TitleProc(void)
 	s16 i;
 	Hu3DModelAttrReset(titleModel[0], 1);
 	Hu3DModelAttrReset(titleModel[1], 1);
-	HuSprAttrReset(titleGroup, 0, SPRITE_ATTR_HIDDEN);
-	HuSprAttrReset(titleGroup, 1, SPRITE_ATTR_HIDDEN);
+	HuSprAttrReset(titleGroup, 0, HUSPR_ATTR_DISPOFF);
+	HuSprAttrReset(titleGroup, 1, HUSPR_ATTR_DISPOFF);
 	OSReport(">>>>>>>>MSM_SE_SEL_01 %d\n", msmSeGetEntryID(2092, y_offset));
 	OSReport(">>>>>>>>SE Num %d\n", msmSeGetNumPlay(0));
 	HuAudSStreamPlay(20);
@@ -505,14 +505,14 @@ static BOOL TitleProc(void)
 	while(WipeStatGet()) {
 		HuPrcVSleep();
 	}
-	HuSprAttrReset(titleGroup, 3, SPRITE_ATTR_HIDDEN);
+	HuSprAttrReset(titleGroup, 3, HUSPR_ATTR_DISPOFF);
 	for(i=1; i<=50; i++) {
 		scale = (cos((i*1.8)*M_PI/180.0)*10.0)+1.0;
 		HuSprScaleSet(titleGroup, 3, scale, scale);
 		HuSprTPLvlSet(titleGroup, 3, i/50.0);
 		HuPrcVSleep();
 	}
-	HuSprAttrReset(titleGroup, 2, SPRITE_ATTR_HIDDEN);
+	HuSprAttrReset(titleGroup, 2, HUSPR_ATTR_DISPOFF);
 	for(i=scale_time=0; i<1800; i++) {
 		if(i <= 10) {
 			HuSprTPLvlSet(titleGroup, 2, i/10.0);
@@ -522,7 +522,7 @@ static BOOL TitleProc(void)
 			if(ret < 0) {
 				OSReport(">>>>>Error %d\n", ret);
 			}
-			HuSprAttrSet(titleGroup, 2, SPRITE_ATTR_HIDDEN);
+			HuSprAttrSet(titleGroup, 2, HUSPR_ATTR_DISPOFF);
 			return 1;
 		}
 		scale = (sin((i*scale_time)*M_PI/180.0)*0.1)+0.9;
@@ -541,10 +541,10 @@ static BOOL TitleProc(void)
 	Hu3DModelAttrSet(titleModel[0], 1);
 	Hu3DModelAttrSet(titleModel[1], 1);
 	Hu3DModelAttrSet(titleModel[2], 1);
-	HuSprAttrSet(titleGroup, 0, SPRITE_ATTR_HIDDEN);
-	HuSprAttrSet(titleGroup, 1, SPRITE_ATTR_HIDDEN);
-	HuSprAttrSet(titleGroup, 2, SPRITE_ATTR_HIDDEN);
-	HuSprAttrSet(titleGroup, 3, SPRITE_ATTR_HIDDEN);
+	HuSprAttrSet(titleGroup, 0, HUSPR_ATTR_DISPOFF);
+	HuSprAttrSet(titleGroup, 1, HUSPR_ATTR_DISPOFF);
+	HuSprAttrSet(titleGroup, 2, HUSPR_ATTR_DISPOFF);
+	HuSprAttrSet(titleGroup, 3, HUSPR_ATTR_DISPOFF);
 	return 0;
 }
 
diff --git a/src/game/board/main.c b/src/game/board/main.c
index e446a4dc..e6f6d717 100644
--- a/src/game/board/main.c
+++ b/src/game/board/main.c
@@ -2018,17 +2018,17 @@ void BoardLast5GfxInit(void)
 			}
 			BoardSpriteCreate(spr_file, prio, NULL, &work->sprites[i]);
 			HuSprGrpMemberSet(work->group, i, work->sprites[i]);
-			HuSprAttrSet(work->group, i, SPRITE_ATTR_BILINEAR);
+			HuSprAttrSet(work->group, i, HUSPR_ATTR_LINEAR);
 			HuSprPosSet(work->group, i, last5GfxPosTbl[lastF][i][0], last5GfxPosTbl[lastF][i][1]);
 		}
 		if(!work->is_last) {
-			SpriteData *sprite = &HuSprData[HuSprGrpData[work->group].members[1]];
+			HuSprite *sprite = &HuSprData[HuSprGrpData[work->group].members[1]];
 			HuSprBankSet(work->group, 1, 0);
 			sprite->frame = turn_remain;
 		} else {
-			HuSprAttrSet(work->group, 1, SPRITE_ATTR_HIDDEN);
+			HuSprAttrSet(work->group, 1, HUSPR_ATTR_DISPOFF);
 		}
-		HuSprAttrSet(work->group, 1, SPRITE_ATTR_PAUSED);
+		HuSprAttrSet(work->group, 1, HUSPR_ATTR_NOANIM);
 		object->trans.x = 0.0f;
 		HuSprGrpTPLvlSet(work->group, object->trans.x);
 		HuSprGrpPosSet(work->group, 288, 72);
@@ -2105,12 +2105,12 @@ void BoardLast5GfxShowSet(s32 show)
 	work = OM_GET_WORK_PTR(last5GfxObj, Last5GfxWork);
 	for(i=0; i<3; i++) {
 		if(show) {
-			HuSprAttrReset(work->group, i, SPRITE_ATTR_HIDDEN);
+			HuSprAttrReset(work->group, i, HUSPR_ATTR_DISPOFF);
 		} else {
-			HuSprAttrSet(work->group, i, SPRITE_ATTR_HIDDEN);
+			HuSprAttrSet(work->group, i, HUSPR_ATTR_DISPOFF);
 		}
 		if(work->is_last) {
-			HuSprAttrSet(work->group, 1, SPRITE_ATTR_HIDDEN);
+			HuSprAttrSet(work->group, 1, HUSPR_ATTR_DISPOFF);
 		}
 	}
 }
diff --git a/src/game/board/space.c b/src/game/board/space.c
index 5c8c0cf2..acd4ee9a 100644
--- a/src/game/board/space.c
+++ b/src/game/board/space.c
@@ -1000,15 +1000,15 @@ void BoardSpaceInit(s32 data_num)
 		size = bmp->sizeX;
 		spaceHiliteTexFmt = -1;
 		switch(bmp->dataFmt) {
-			case SPRITE_BMP_RGBA8:
+			case ANIM_BMP_RGBA8:
 				spaceHiliteTexFmt = GX_TF_RGBA8;
 				break;
 				
-			case SPRITE_BMP_RGB5A3_DUPE:
+			case ANIM_BMP_RGB5A3_DUPE:
 				spaceHiliteTexFmt = GX_TF_RGB5A3;
 				break;
 				
-			case SPRITE_BMP_CMPR:
+			case ANIM_BMP_CMPR:
 				spaceHiliteTexFmt = GX_TF_CMPR;
 				break;
 		}
@@ -1032,15 +1032,15 @@ void BoardSpaceInit(s32 data_num)
 		size = bmp->sizeX;
 		spaceTexFmt = -1;
 		switch(bmp->dataFmt) {
-			case SPRITE_BMP_RGBA8:
+			case ANIM_BMP_RGBA8:
 				spaceTexFmt = GX_TF_RGBA8;
 				break;
 				
-			case SPRITE_BMP_RGB5A3_DUPE:
+			case ANIM_BMP_RGB5A3_DUPE:
 				spaceTexFmt = GX_TF_RGB5A3;
 				break;
 				
-			case SPRITE_BMP_CMPR:
+			case ANIM_BMP_CMPR:
 				spaceTexFmt = GX_TF_CMPR;
 				break;
 		}
diff --git a/src/game/minigame_seq.c b/src/game/minigame_seq.c
index dc8d41cd..fe87daa3 100644
--- a/src/game/minigame_seq.c
+++ b/src/game/minigame_seq.c
@@ -428,7 +428,7 @@ static int SeqInitTimer(SeqWork *work, va_list params)
 	if(seqPauseF) {
 		work->work_s16[1] = 1;
 		for(i=0; i<2; i++) {
-			HuSprAttrSet(spr_grp, i, SPRITE_ATTR_HIDDEN);
+			HuSprAttrSet(spr_grp, i, HUSPR_ATTR_DISPOFF);
 			(void)i; //Hack for Matching
 		}		
 	}
@@ -497,7 +497,7 @@ static int SeqUpdateTimer(SeqWork *work)
 				
 			case 3:
 				for(i=0; i<2; i++) {
-					HuSprAttrReset(spr_grp, i, SPRITE_ATTR_HIDDEN);
+					HuSprAttrReset(spr_grp, i, HUSPR_ATTR_DISPOFF);
 				}
 				work->work_s16[1] = 3;
 				work->param[0] = 0;
@@ -684,7 +684,7 @@ static int SeqInitType2(SeqWork *work, va_list params)
 	if(seqPauseF) {
 		work->work_s16[1] = 1;
 		for(i=0; i<work->work_s16[3]; i++) {
-			HuSprAttrSet(spr_grp, i, SPRITE_ATTR_HIDDEN);
+			HuSprAttrSet(spr_grp, i, HUSPR_ATTR_DISPOFF);
 		}
 	}
 	return 1;
@@ -718,7 +718,7 @@ static int SeqUpdateType2(SeqWork *work)
 			{
 				s32 i;
 				for(i=0; i<work->work_s16[3]; i++) {
-					HuSprAttrReset(spr_grp, i, SPRITE_ATTR_HIDDEN);
+					HuSprAttrReset(spr_grp, i, HUSPR_ATTR_DISPOFF);
 					(void)i;
 				}
 				work->work_s16[1] = 0;
@@ -988,7 +988,7 @@ static int SeqInitMGBasic(SeqWork *work, va_list params)
 	}
 	if(seqPauseF) {
 		work->type = 2;
-		HuSprAttrSet(word_grp, 0, SPRITE_ATTR_HIDDEN);
+		HuSprAttrSet(word_grp, 0, HUSPR_ATTR_DISPOFF);
 	} else {
 		work->param[0] = 3;
 	}
@@ -1091,14 +1091,14 @@ static int SeqUpdateMGBasic(SeqWork *work)
 						time = work->time;
 						scale = work->scale_x+(0.5*sin(((time*9.0f)*M_PI)/180.0));
 						for(i=0; i<work->work_s16[3]; i++) {
-							HuSprAttrReset(work->spr_grp[0], i, SPRITE_ATTR_HIDDEN);
+							HuSprAttrReset(work->spr_grp[0], i, HUSPR_ATTR_DISPOFF);
 							pos_x = ((28.0f*scale)+(work->x-(0.5f*(scale*(work->work_s16[3]*56)))))+(scale*(i*56));
 							HuSprPosSet(work->spr_grp[0], i, pos_x, work->y);
 							HuSprScaleSet(work->spr_grp[0], i, work->scale_x+sin(((time*9.0f)*M_PI)/180.0), work->scale_y+sin(((time*9.0f)*M_PI)/180.0));
 						}
 						if(time == 20.0f) {
 							for(i=0; i<work->work_s16[3]; i++) {
-								HuSprAttrReset(work->spr_grp[0], i, SPRITE_ATTR_HIDDEN);
+								HuSprAttrReset(work->spr_grp[0], i, HUSPR_ATTR_DISPOFF);
 							}
 						}
 					} else {
@@ -1110,7 +1110,7 @@ static int SeqUpdateMGBasic(SeqWork *work)
 								}
 								pos_x = (28.0f+(work->x-(0.5f*(work->work_s16[3]*56))))+(i*56);
 								if(time == 20.0f) {
-									HuSprAttrSet(work->spr_grp[0], i, SPRITE_ATTR_HIDDEN);
+									HuSprAttrSet(work->spr_grp[0], i, HUSPR_ATTR_DISPOFF);
 								} else {
 									HuSprPosSet(work->spr_grp[0], i, pos_x+((1.0-cos(((time*4.5f)*M_PI)/180.0f))*(work->work_s16[3]*56*2)), work->y);
 									HuSprZRotSet(work->spr_grp[0], i, (time/20.0f)*390.0f);
@@ -1215,7 +1215,7 @@ static int SeqInitMGCommon(SeqWork *work, va_list params)
 			HuSprTPLvlSet(work->spr_grp[word_grp], j, tp_lvl);
 			HuSprPosSet(work->spr_grp[word_grp], j, -100.0f, 240.0f);
 			HuSprPriSet(work->spr_grp[word_grp], j, i+5);
-			HuSprAttrSet(work->spr_grp[word_grp], i, SPRITE_ATTR_BILINEAR);
+			HuSprAttrSet(work->spr_grp[word_grp], i, HUSPR_ATTR_LINEAR);
 		}
 		if(i == 0) {
 			tp_lvl -= 0.5;
@@ -1225,7 +1225,7 @@ static int SeqInitMGCommon(SeqWork *work, va_list params)
 	}
 	if(seqPauseF) {
 		work->type = 2;
-		HuSprAttrSet(word_grp, 0, SPRITE_ATTR_HIDDEN);
+		HuSprAttrSet(word_grp, 0, HUSPR_ATTR_DISPOFF);
 	} else {
 		work->param[0] = 3;
 	}
@@ -1302,7 +1302,7 @@ static int SeqUpdateMGBattle(SeqWork *work)
 									HuSprZRotSet(work->spr_grp[i], j, 0.0f);
 									HuSprScaleSet(work->spr_grp[i], j, work->scale_x, work->scale_y);
 									if(i != 0) {
-										HuSprAttrSet(work->spr_grp[i], j, SPRITE_ATTR_HIDDEN);
+										HuSprAttrSet(work->spr_grp[i], j, HUSPR_ATTR_DISPOFF);
 									}
 								} else {
 									s16 discard_cnt;
@@ -1383,20 +1383,20 @@ static int SeqUpdateMGBattle(SeqWork *work)
 					if(work->time <= 20) {
 						for(i=1; i<4; i++) {
 							for(j=0; j<work->work_s16[3]; j++) {
-								HuSprAttrSet(work->spr_grp[i], j, SPRITE_ATTR_HIDDEN);
+								HuSprAttrSet(work->spr_grp[i], j, HUSPR_ATTR_DISPOFF);
 							}
 						}
 						time = work->time;
 						scale = work->scale_x+(0.5*sin((M_PI*(time*9.0f))/180.0));
 						for(j=0; j<work->work_s16[3]; j++) {
-							HuSprAttrReset(work->spr_grp[0], j, SPRITE_ATTR_HIDDEN);
+							HuSprAttrReset(work->spr_grp[0], j, HUSPR_ATTR_DISPOFF);
 							pos_x = ((28.0f*scale)+(work->x-(0.5f*(scale*(work->work_s16[3]*56)))))+(scale*(j*56));
 							HuSprPosSet(work->spr_grp[0], j, pos_x, work->y);
 							HuSprScaleSet(work->spr_grp[0], j, work->scale_x+(sin((M_PI*(time*9.0f))/180.0)), work->scale_y+(sin((M_PI*(time*9.0f))/180.0)));
 						}
 						if(time == 20.0f) {
 							for(j=0; j<work->work_s16[3]; j++) {
-								HuSprAttrReset(work->spr_grp[0], j, SPRITE_ATTR_HIDDEN);
+								HuSprAttrReset(work->spr_grp[0], j, HUSPR_ATTR_DISPOFF);
 							}
 						}
 					} else {
@@ -1408,7 +1408,7 @@ static int SeqUpdateMGBattle(SeqWork *work)
 							}
 							if(time == 15.0f) {
 								for(j=0; j<work->work_s16[3]; j++) {
-									HuSprAttrReset(work->spr_grp[1], j, SPRITE_ATTR_HIDDEN);
+									HuSprAttrReset(work->spr_grp[1], j, HUSPR_ATTR_DISPOFF);
 									HuSprPosSet(work->spr_grp[1], j, 288.0f, work->y);
 									HuSprTPLvlSet(work->spr_grp[1], j, 1.0f);
 								}
@@ -1560,7 +1560,7 @@ static int SeqUpdateMG1vs3(SeqWork *work)
 							if(work->time == 60) {
 								for(i=1; i<4; i++) {
 									for(j=0; j<work->work_s16[3]; j++) {
-										HuSprAttrSet(work->spr_grp[i], j, SPRITE_ATTR_HIDDEN);
+										HuSprAttrSet(work->spr_grp[i], j, HUSPR_ATTR_DISPOFF);
 									}
 								}
 							}
@@ -1600,13 +1600,13 @@ static int SeqUpdateMG1vs3(SeqWork *work)
 					if(work->time <= 20) {
 						for(i=1; i<4; i++) {
 							for(j=0; j<work->work_s16[3]; j++) {
-								HuSprAttrSet(work->spr_grp[i], j, SPRITE_ATTR_HIDDEN);
+								HuSprAttrSet(work->spr_grp[i], j, HUSPR_ATTR_DISPOFF);
 							}
 						}
 						time = work->time;
 						scale = work->scale_x+(0.5*sin((M_PI*(time*9.0f))/180.0));
 						for(j=0; j<work->work_s16[3]; j++) {
-							HuSprAttrReset(work->spr_grp[0], j, SPRITE_ATTR_HIDDEN);
+							HuSprAttrReset(work->spr_grp[0], j, HUSPR_ATTR_DISPOFF);
 							pos_x = ((28.0f*scale)+(work->x-(0.5f*(scale*(work->work_s16[3]*56)))))+(scale*(j*56));
 							HuSprPosSet(work->spr_grp[0], j, pos_x, work->y);
 							HuSprScaleSet(work->spr_grp[0], j, work->scale_x+(sin((M_PI*(time*9.0f))/180.0)), work->scale_y+(sin((M_PI*(time*9.0f))/180.0)));
@@ -1614,7 +1614,7 @@ static int SeqUpdateMG1vs3(SeqWork *work)
 						if(time == 20.0f) {
 							for(i=1; i<4; i++) {
 								for(j=0; j<work->work_s16[3]; j++) {
-									HuSprAttrReset(work->spr_grp[i], j, SPRITE_ATTR_HIDDEN);
+									HuSprAttrReset(work->spr_grp[i], j, HUSPR_ATTR_DISPOFF);
 								}
 							}
 						}
@@ -1746,7 +1746,7 @@ static int SeqUpdateMGStory(SeqWork *work)
 						}
 						if(work->time == 30) {
 							for(j=0; j<work->work_s16[3]; j++) {
-								HuSprAttrSet(work->spr_grp[1], j, SPRITE_ATTR_HIDDEN);
+								HuSprAttrSet(work->spr_grp[1], j, HUSPR_ATTR_DISPOFF);
 							}
 						}
 					} else {
@@ -1792,13 +1792,13 @@ static int SeqUpdateMGStory(SeqWork *work)
 					if(work->time <= 20) {
 						for(i=1; i<4; i++) {
 							for(j=0; j<work->work_s16[3]; j++) {
-								HuSprAttrSet(work->spr_grp[i], j, SPRITE_ATTR_HIDDEN);
+								HuSprAttrSet(work->spr_grp[i], j, HUSPR_ATTR_DISPOFF);
 							}
 						}
 						time = work->time;
 						scale = work->scale_x+(0.5*sin((M_PI*(time*9.0f))/180.0));
 						for(j=0; j<work->work_s16[3]; j++) {
-							HuSprAttrReset(work->spr_grp[0], j, SPRITE_ATTR_HIDDEN);
+							HuSprAttrReset(work->spr_grp[0], j, HUSPR_ATTR_DISPOFF);
 							pos_x = ((28.0f*scale)+(work->x-(0.5f*(scale*(work->work_s16[3]*56)))))+(scale*(j*56));
 							HuSprPosSet(work->spr_grp[0], j, pos_x, work->y);
 							HuSprScaleSet(work->spr_grp[0], j, work->scale_x+(sin((M_PI*(time*9.0f))/180.0)), work->scale_y+(sin((M_PI*(time*9.0f))/180.0)));
@@ -1806,7 +1806,7 @@ static int SeqUpdateMGStory(SeqWork *work)
 						if(time == 20.0f){ 
 							for(i=1; i<4; i++) {
 								for(j=0; j<work->work_s16[3]; j++) {
-									HuSprAttrReset(work->spr_grp[i], j, SPRITE_ATTR_HIDDEN);
+									HuSprAttrReset(work->spr_grp[i], j, HUSPR_ATTR_DISPOFF);
 								}
 							}
 						}
@@ -1988,13 +1988,13 @@ static int SeqUpdateMG2vs2(SeqWork *work)
 					if(work->time <= 20) {
 						for(i=1; i<4; i++) {
 							for(j=0; j<work->work_s16[3]; j++) {
-								HuSprAttrSet(work->spr_grp[i], j, SPRITE_ATTR_HIDDEN);
+								HuSprAttrSet(work->spr_grp[i], j, HUSPR_ATTR_DISPOFF);
 							}
 						}
 						time = work->time;
 						scale = work->scale_x+(0.5*sin((M_PI*(time*9.0f))/180.0));
 						for(j=0; j<work->work_s16[3]; j++) {
-							HuSprAttrReset(work->spr_grp[0], j, SPRITE_ATTR_HIDDEN);
+							HuSprAttrReset(work->spr_grp[0], j, HUSPR_ATTR_DISPOFF);
 							pos_x = ((28.0f*scale)+(work->x-(0.5f*(scale*(work->work_s16[3]*56)))))+(scale*(j*56));
 							HuSprPosSet(work->spr_grp[0], j, pos_x, work->y);
 							HuSprScaleSet(work->spr_grp[0], j, work->scale_x+(sin((M_PI*(time*9.0f))/180.0)), work->scale_y+(sin((M_PI*(time*9.0f))/180.0)));
@@ -2002,7 +2002,7 @@ static int SeqUpdateMG2vs2(SeqWork *work)
 						if(time == 20.0f) {
 							for(i=1; i<4; i++) {
 								for(j=0; j<work->work_s16[3]; j++) {
-									HuSprAttrReset(work->spr_grp[i], j, SPRITE_ATTR_HIDDEN);
+									HuSprAttrReset(work->spr_grp[i], j, HUSPR_ATTR_DISPOFF);
 								}
 							}
 						}
@@ -2102,8 +2102,8 @@ static int SeqInitFlip(SeqWork *work, va_list params)
 	for(i=0; i<work->work_s16[3]; i++) {
 		HuSprTPLvlSet(work->spr_grp[word_grp], i, 0.0f);
 		HuSprPosSet(work->spr_grp[word_grp], i, (28.0f+(work->x-(0.5f*(work->work_s16[3]*56))))+(i*56), work->y);
-		HuSprAttrSet(work->spr_grp[word_grp], i, SPRITE_ATTR_BILINEAR);
-		HuSprAttrReset(work->spr_grp[word_grp], i, SPRITE_ATTR_HIDDEN);
+		HuSprAttrSet(work->spr_grp[word_grp], i, HUSPR_ATTR_LINEAR);
+		HuSprAttrReset(work->spr_grp[word_grp], i, HUSPR_ATTR_DISPOFF);
 	}
 	work->work_s16[2] = work->work_s16[3];
 	{
@@ -2133,12 +2133,12 @@ static int SeqInitFlip(SeqWork *work, va_list params)
 	for(i=0; i<work->work_s16[3]; i++) {
 		HuSprTPLvlSet(work->spr_grp[word_grp], i, 0.0f);
 		HuSprPosSet(work->spr_grp[word_grp], i, (28.0f+(work->x-(0.5f*(work->work_s16[3]*56))))+(i*56), work->y);
-		HuSprAttrSet(work->spr_grp[word_grp], i, SPRITE_ATTR_BILINEAR);
-		HuSprAttrReset(work->spr_grp[word_grp], i, SPRITE_ATTR_HIDDEN);
+		HuSprAttrSet(work->spr_grp[word_grp], i, HUSPR_ATTR_LINEAR);
+		HuSprAttrReset(work->spr_grp[word_grp], i, HUSPR_ATTR_DISPOFF);
 	}
 	if(seqPauseF) {
 		work->type = 2;
-		HuSprAttrSet(word_grp, 0, SPRITE_ATTR_HIDDEN);
+		HuSprAttrSet(word_grp, 0, HUSPR_ATTR_DISPOFF);
 	} else {
 		work->param[0] = 3;
 	}
@@ -2445,13 +2445,13 @@ static int SeqUpdateMGBowser(SeqWork *work)
 					if(work->time <= 20) {
 						for(j=1; j<4; j++) {
 							for(i=0; i<work->work_s16[3]; i++) {
-								HuSprAttrSet(work->spr_grp[j], i, SPRITE_ATTR_HIDDEN);
+								HuSprAttrSet(work->spr_grp[j], i, HUSPR_ATTR_DISPOFF);
 							}
 						}
 						time = work->time;
 						scale = work->scale_x+(0.5*sin(((time*9.0f)*M_PI)/180.0));
 						for(i=0; i<work->work_s16[3]; i++) {
-							HuSprAttrReset(work->spr_grp[0], i, SPRITE_ATTR_HIDDEN);
+							HuSprAttrReset(work->spr_grp[0], i, HUSPR_ATTR_DISPOFF);
 							pos_x = ((28.0f*scale)+(work->x-(0.5f*(scale*(work->work_s16[3]*56)))))+(scale*(i*56));
 							HuSprPosSet(work->spr_grp[0], i, pos_x, work->y);
 							HuSprScaleSet(work->spr_grp[0], i, work->scale_x+(sin((M_PI*(time*9.0f))/180.0)), work->scale_y+(sin((M_PI*(time*9.0f))/180.0)));
@@ -2459,7 +2459,7 @@ static int SeqUpdateMGBowser(SeqWork *work)
 						if(time == 20.0f) {
 							for(j=1; j<4; j++) {
 								for(i=0; i<work->work_s16[3]; i++) {
-									HuSprAttrReset(work->spr_grp[j], i, SPRITE_ATTR_HIDDEN);
+									HuSprAttrReset(work->spr_grp[j], i, HUSPR_ATTR_DISPOFF);
 								}
 							}
 						}
@@ -2754,7 +2754,7 @@ static int SeqInitWin(SeqWork *work, va_list params)
 	winnerNameW[0] = work->work_s16[3]*50;
 	for(i=0; i<work->work_s16[3]; i++) {
 		HuSprPosSet(work->spr_grp[word_grp], i, 25.0f+((i*50)-(0.5f*(work->work_s16[3]*50))), 0.0f);
-		HuSprAttrSet(work->spr_grp[word_grp], i, SPRITE_ATTR_BILINEAR);
+		HuSprAttrSet(work->spr_grp[word_grp], i, HUSPR_ATTR_LINEAR);
 	}
 	num_winners = 0;
 	work->work_float[1] = 1.0f;
@@ -2778,7 +2778,7 @@ static int SeqInitWin(SeqWork *work, va_list params)
 			word_x = 0.0f;
 			for(i=word_x; i<work->work_s16[3]; i++, name++) {
 				HuSprPosSet(work->spr_grp[word_grp], i, 25.0+(word_x-(0.5*word_w)), 0.0f);
-				HuSprAttrSet(work->spr_grp[word_grp], i, SPRITE_ATTR_BILINEAR);
+				HuSprAttrSet(work->spr_grp[word_grp], i, HUSPR_ATTR_LINEAR);
 				if(*name == ' ') {
 					word_x += 30.0f;
 				} else {
@@ -2795,7 +2795,7 @@ static int SeqInitWin(SeqWork *work, va_list params)
 			if(winner == 7 || winner == 13) {
 				for(i=0;i<work->work_s16[3]; i++) {
 					HuSprPosSet(work->spr_grp[word_grp], i, 26.0f+((i*52)-(0.5f*(work->work_s16[3]*52))), 0.0f);
-					HuSprAttrSet(work->spr_grp[word_grp], i, SPRITE_ATTR_BILINEAR);
+					HuSprAttrSet(work->spr_grp[word_grp], i, HUSPR_ATTR_LINEAR);
 				}
 				work->work_float[1] = 0.8f;
 				winnerNameW[num_winners+1] = work->work_s16[3]*52;
@@ -2844,7 +2844,7 @@ static int SeqInitWin(SeqWork *work, va_list params)
 		work->type = 1;
 		num_winners++;
 		for(j=0; j<num_winners; j++) {
-			HuSprAttrSet(work->spr_grp[j], 0, SPRITE_ATTR_HIDDEN);
+			HuSprAttrSet(work->spr_grp[j], 0, HUSPR_ATTR_DISPOFF);
 		}
 	} else {
 		work->param[0] = 3;
@@ -3028,7 +3028,7 @@ static int SeqInitRecord(SeqWork *work, va_list params)
 		HuSprBankSet(spr_grp, digit_idx+2, seqRecordVal);
 		digit_idx++;
 		for(i=digit_idx; i<8; i++) {
-			HuSprAttrSet(spr_grp, i+2, SPRITE_ATTR_HIDDEN);
+			HuSprAttrSet(spr_grp, i+2, HUSPR_ATTR_DISPOFF);
 		}
 		HuSprPosSet(spr_grp, 1, (-((digit_idx*44)+48)/2)+24, 32.0f);
 		for(i=0; i<digit_idx; i++) {
@@ -3073,7 +3073,7 @@ static int SeqInitRecord(SeqWork *work, va_list params)
 		HuSprBankSet(spr_grp, digit_idx+2, seqRecordVal);
 		digit_idx++;
 		for(i=digit_idx; i<8; i++) {
-			HuSprAttrSet(spr_grp, i+2, SPRITE_ATTR_HIDDEN);
+			HuSprAttrSet(spr_grp, i+2, HUSPR_ATTR_DISPOFF);
 		}
 		HuSprPosSet(spr_grp, 1, (-((digit_idx*44)+4)/2)+24, 32.0f);
 		x = (-((digit_idx*44)+4)/2)+70;
@@ -3444,11 +3444,11 @@ static void PracticeProc(void)
 	HuSprPosSet(group, 0, 288.0f, yPosTbl[practice[1]]);
 	do {
 		if(!wipeFadeInF || WipeStatGet()) {
-			HuSprAttrSet(group, 0, SPRITE_ATTR_HIDDEN);
+			HuSprAttrSet(group, 0, HUSPR_ATTR_DISPOFF);
 			HuPrcVSleep();
 			continue;
 		}
-		HuSprAttrReset(group, 0, SPRITE_ATTR_HIDDEN);
+		HuSprAttrReset(group, 0, HUSPR_ATTR_DISPOFF);
 		for(i=0; i<4; i++) {
 			if(!(HuPadBtnDown[GWPlayerCfg[i].pad_idx] & PAD_TRIGGER_Z)) {
 				continue;;
diff --git a/src/game/sprman.c b/src/game/sprman.c
index e0f940ab..089af883 100644
--- a/src/game/sprman.c
+++ b/src/game/sprman.c
@@ -8,34 +8,33 @@
 #define SPRITE_DIRTY_XFORM 0x2
 #define SPRITE_DIRTY_COLOR 0x4
 
-typedef struct sprite_order_data {
-    unsigned short group;
-    unsigned short sprite;
-    unsigned short prio;
-    unsigned short next;
-} SpriteOrderData;
+typedef struct sprite_order {
+    u16 group;
+    u16 sprite;
+    u16 prio;
+    u16 next;
+} SpriteOrder;
 
-SpriteData HuSprData[SPRITE_MAX];
-SpriteGroupData HuSprGrpData[SPRITE_GROUP_MAX];
-static SpriteOrderData HuSprOrder[SPRITE_MAX*2];
+HuSprite HuSprData[HUSPR_MAX];
+HuSprGrp HuSprGrpData[HUSPR_GRP_MAX];
+static SpriteOrder HuSprOrder[HUSPR_MAX*2];
 
-static short HuSprOrderNum;
-static short HuSprOrderNo;
+static s16 HuSprOrderNum;
+static s16 HuSprOrderNo;
 static BOOL HuSprPauseF;
 
-static void HuSprOrderEntry(short group, short sprite);
+static void HuSprOrderEntry(s16 group, s16 sprite);
 
-void mtxTransCat(Mtx matrix, float x, float y, int z); //Last argument should be a float
 
 void HuSprInit(void)
 {
-    short i;
-    SpriteData *sprite;
-    SpriteGroupData *group;
-    for(sprite = &HuSprData[1], i=1; i<SPRITE_MAX; i++, sprite++) {
+    s16 i;
+    HuSprite *sprite;
+    HuSprGrp *group;
+    for(sprite = &HuSprData[1], i=1; i<HUSPR_MAX; i++, sprite++) {
         sprite->data = NULL;
     }
-    for(group = HuSprGrpData, i=0; i<SPRITE_GROUP_MAX; i++, group++) {
+    for(group = HuSprGrpData, i=0; i<HUSPR_GRP_MAX; i++, group++) {
         group->capacity = 0;
     }
     sprite = &HuSprData[0];
@@ -46,16 +45,16 @@ void HuSprInit(void)
 
 void HuSprClose(void)
 {
-    short i;
-    SpriteGroupData *group;
-    SpriteData *sprite;
+    s16 i;
+    HuSprGrp *group;
+    HuSprite *sprite;
     
-    for(group = HuSprGrpData, i=0; i<SPRITE_GROUP_MAX; i++, group++) {
+    for(group = HuSprGrpData, i=0; i<HUSPR_GRP_MAX; i++, group++) {
         if(group->capacity != 0) {
             HuSprGrpKill(i);
         }
     }
-    for(sprite = &HuSprData[1], i=1; i<SPRITE_MAX; i++, sprite++) {
+    for(sprite = &HuSprData[1], i=1; i<HUSPR_MAX; i++, sprite++) {
         if(sprite->data) {
             HuSprKill(i);
         }
@@ -63,11 +62,11 @@ void HuSprClose(void)
     HuSprPauseF = FALSE;
 }
 
-void HuSprExec(short draw_no)
+void HuSprExec(s16 draw_no)
 {
-    SpriteData *sprite;
+    HuSprite *sprite;
     while(sprite = HuSprCall()) {
-        if(!(sprite->attr & SPRITE_ATTR_HIDDEN) && sprite->draw_no == draw_no) {
+        if(!(sprite->attr & HUSPR_ATTR_DISPOFF) && sprite->draw_no == draw_no) {
             HuSprDisp(sprite);
         }
     }
@@ -76,14 +75,14 @@ void HuSprExec(short draw_no)
 void HuSprBegin(void)
 {
     Mtx temp, rot;
-    short i, j;
+    s16 i, j;
     Vec axis = {0, 0, 1};
-    SpriteGroupData *group;
+    HuSprGrp *group;
     group = HuSprGrpData;
     HuSprOrderNum = 1;
     HuSprOrder[0].next = 0;
     HuSprOrder[0].prio = -1;
-    for(i=0; i<SPRITE_GROUP_MAX; i++, group++) {
+    for(i=0; i<HUSPR_GRP_MAX; i++, group++) {
         if(group->capacity != 0) {
             MTXTrans(temp, group->center_x*group->scale_x, group->center_y*group->scale_y, 0.0f);
             MTXRotAxisDeg(rot, &axis, group->z_rot);
@@ -101,12 +100,12 @@ void HuSprBegin(void)
     HuSprOrderNo = 0;
 }
 
-static void HuSprOrderEntry(short group, short sprite)
+static void HuSprOrderEntry(s16 group, s16 sprite)
 {
-    SpriteOrderData *order = &HuSprOrder[HuSprOrderNum];
-    short prio = HuSprData[sprite].prio;
-    short prev, next;
-    if(HuSprOrderNum >= SPRITE_MAX*2) {
+    SpriteOrder *order = &HuSprOrder[HuSprOrderNum];
+    s16 prio = HuSprData[sprite].prio;
+    s16 prev, next;
+    if(HuSprOrderNum >= HUSPR_MAX*2) {
         OSReport("Order Max Over!\n");
         return;
     }
@@ -124,14 +123,14 @@ static void HuSprOrderEntry(short group, short sprite)
     HuSprOrderNum++;
 }
 
-SpriteData *HuSprCall(void)
+HuSprite *HuSprCall(void)
 {
     HuSprOrderNo = HuSprOrder[HuSprOrderNo].next;
     if(HuSprOrderNo != 0) {
-        SpriteOrderData *order = &HuSprOrder[HuSprOrderNo];
-        SpriteData *sprite = &HuSprData[order->sprite];
+        SpriteOrder *order = &HuSprOrder[HuSprOrderNo];
+        HuSprite *sprite = &HuSprData[order->sprite];
         sprite->group_mtx = &HuSprGrpData[order->group].mtx;
-        if(sprite->attr & SPRITE_ATTR_FUNC) {
+        if(sprite->attr & HUSPR_ATTR_FUNC) {
             return sprite;
         }
         sprite->frame_data = &sprite->data->bank[sprite->bank].frame[sprite->frame];
@@ -142,7 +141,7 @@ SpriteData *HuSprCall(void)
     }
 }
 
-static inline void SpriteCalcFrame(SpriteData *sprite, AnimBankData *bank, AnimFrameData **frame, short loop)
+static inline void SpriteCalcFrame(HuSprite *sprite, AnimBankData *bank, AnimFrameData **frame, s16 loop)
 {
     if(sprite->time >= (*frame)->time) {
         sprite->frame++;
@@ -174,22 +173,22 @@ void HuSprFinish(void)
     AnimData *anim;
     AnimBankData *bank;
     AnimFrameData *frame;
-    SpriteData *sprite;
-    short i;
-    short j;
-    short loop;
-    short dir;
+    HuSprite *sprite;
+    s16 i;
+    s16 j;
+    s16 loop;
+    s16 dir;
     
-    for(sprite = &HuSprData[1], i=1; i<SPRITE_MAX; i++, sprite++) {
-        if(sprite->data && !(sprite->attr & SPRITE_ATTR_FUNC)) {
-            if(!HuSprPauseF || (sprite->attr & SPRITE_ATTR_NOPAUSE)) {
+    for(sprite = &HuSprData[1], i=1; i<HUSPR_MAX; i++, sprite++) {
+        if(sprite->data && !(sprite->attr & HUSPR_ATTR_FUNC)) {
+            if(!HuSprPauseF || (sprite->attr & HUSPR_ATTR_NOPAUSE)) {
                 anim = sprite->data;
                 bank = &anim->bank[sprite->bank];
                 frame = &bank->frame[sprite->frame];
-                loop = (sprite->attr & SPRITE_ATTR_LOOP) ? 0 : 1;
-                if(!(sprite->attr & SPRITE_ATTR_PAUSED)) {
-                    dir = (sprite->attr & SPRITE_ATTR_REVERSE) ? -1 : 1;
-                    for(j=0; j<(int)sprite->speed*minimumVcount; j++) {
+                loop = (sprite->attr & HUSPR_ATTR_LOOP) ? 0 : 1;
+                if(!(sprite->attr & HUSPR_ATTR_NOANIM)) {
+                    dir = (sprite->attr & HUSPR_ATTR_REVERSE) ? -1 : 1;
+                    for(j=0; j<(s32)sprite->speed*minimumVcount; j++) {
                         sprite->time += dir;
                         SpriteCalcFrame(sprite, bank, &frame, loop);
                     }
@@ -209,7 +208,7 @@ void HuSprPauseSet(BOOL value)
 
 AnimData *HuSprAnimRead(void *data)
 {
-    short i;
+    s16 i;
     AnimBmpData *bmp;
     AnimBankData *bank;
     AnimPatData *pat;
@@ -244,17 +243,17 @@ void HuSprAnimLock(AnimData *anim)
     anim->useNum++;
 }
 
-short HuSprCreate(AnimData *anim, short prio, short bank)
+s16 HuSprCreate(AnimData *anim, s16 prio, s16 bank)
 {
-    SpriteData *sprite;
-    short i;
-    for(sprite = &HuSprData[1], i=1; i<SPRITE_MAX; i++, sprite++) {
+    HuSprite *sprite;
+    s16 i;
+    for(sprite = &HuSprData[1], i=1; i<HUSPR_MAX; i++, sprite++) {
         if(!sprite->data) {
             break;
         }
     }
-    if(i == SPRITE_MAX) {
-        return SPRITE_INVALID;
+    if(i == HUSPR_MAX) {
+        return HUSPR_NONE;
     }
     sprite->data = anim;
     sprite->speed = 1.0f;
@@ -279,34 +278,34 @@ short HuSprCreate(AnimData *anim, short prio, short bank)
     return i;
 }
 
-short HuSprFuncCreate(void (*func)(SpriteData *sprite), short prio)
+s16 HuSprFuncCreate(HuSprFunc func, s16 prio)
 {
-    SpriteData *sprite;
-    short index = HuSprCreate(NULL, prio, 0);
-    if(index == SPRITE_INVALID) {
-        return SPRITE_INVALID;
+    HuSprite *sprite;
+    s16 index = HuSprCreate(NULL, prio, 0);
+    if(index == HUSPR_NONE) {
+        return HUSPR_NONE;
     }
     sprite = &HuSprData[index];
     sprite->func = func;
-    sprite->attr |= SPRITE_ATTR_FUNC;
+    sprite->attr |= HUSPR_ATTR_FUNC;
     return index;
 }
 
-short HuSprGrpCreate(short capacity)
+s16 HuSprGrpCreate(s16 capacity)
 {
-    SpriteGroupData *group;
-    short i, j;
-    for(group = HuSprGrpData, i=0; i<SPRITE_GROUP_MAX; i++, group++) {
+    HuSprGrp *group;
+    s16 i, j;
+    for(group = HuSprGrpData, i=0; i<HUSPR_GRP_MAX; i++, group++) {
         if(group->capacity == 0) {
             break;
         }
     }
-    if(i == SPRITE_GROUP_MAX) {
-        return SPRITE_GROUP_INVALID;
+    if(i == HUSPR_GRP_MAX) {
+        return HUSPR_GRP_NONE;
     }
-    group->members = HuMemDirectMalloc(HEAP_SYSTEM, sizeof(short)*capacity);
+    group->members = HuMemDirectMalloc(HEAP_SYSTEM, sizeof(s16)*capacity);
     for(j=0; j<capacity; j++) {
-        group->members[j] = SPRITE_INVALID;
+        group->members[j] = HUSPR_NONE;
     }
     group->capacity = capacity;
     group->x = group->y = group->z_rot = group->center_x = group->center_y = 0.0f;
@@ -314,14 +313,14 @@ short HuSprGrpCreate(short capacity)
     return i;
 }
 
-short HuSprGrpCopy(short group)
+s16 HuSprGrpCopy(s16 group)
 {
-    SpriteGroupData *new_group_ptr;
-    SpriteGroupData *group_ptr = &HuSprGrpData[group];
-    short new_group = HuSprGrpCreate(group_ptr->capacity);
-    short i;
-    if(new_group == SPRITE_GROUP_INVALID) {
-        return SPRITE_GROUP_INVALID;
+    HuSprGrp *new_group_ptr;
+    HuSprGrp *group_ptr = &HuSprGrpData[group];
+    s16 new_group = HuSprGrpCreate(group_ptr->capacity);
+    s16 i;
+    if(new_group == HUSPR_GRP_NONE) {
+        return HUSPR_GRP_NONE;
     }
     new_group_ptr = &HuSprGrpData[new_group];
     new_group_ptr->x = group_ptr->x;
@@ -332,9 +331,9 @@ short HuSprGrpCopy(short group)
     new_group_ptr->center_x = group_ptr->center_x;
     new_group_ptr->center_y = group_ptr->center_y;
     for(i=0; i<group_ptr->capacity; i++) {
-        if(group_ptr->members[i] != SPRITE_INVALID) {
-            SpriteData *old_sprite = &HuSprData[group_ptr->members[i]];
-            short new_sprite = HuSprCreate(old_sprite->data, old_sprite->prio, old_sprite->bank);
+        if(group_ptr->members[i] != HUSPR_NONE) {
+            HuSprite *old_sprite = &HuSprData[group_ptr->members[i]];
+            s16 new_sprite = HuSprCreate(old_sprite->data, old_sprite->prio, old_sprite->bank);
             HuSprData[new_sprite] = *old_sprite;
             HuSprGrpMemberSet(new_group, i, new_sprite);
         }
@@ -342,32 +341,32 @@ short HuSprGrpCopy(short group)
     return new_group;
 }
 
-void HuSprGrpMemberSet(short group, short member, short sprite)
+void HuSprGrpMemberSet(s16 group, s16 member, s16 sprite)
 {
-    SpriteGroupData *group_ptr = &HuSprGrpData[group];
-    SpriteData *sprite_ptr = &HuSprData[sprite];
-    if(group_ptr->capacity == 0 || group_ptr->capacity <= member || group_ptr->members[member] != SPRITE_INVALID) {
+    HuSprGrp *group_ptr = &HuSprGrpData[group];
+    HuSprite *sprite_ptr = &HuSprData[sprite];
+    if(group_ptr->capacity == 0 || group_ptr->capacity <= member || group_ptr->members[member] != HUSPR_NONE) {
         return;
     }
     group_ptr->members[member] = sprite;
 }
 
-void HuSprGrpMemberKill(short group, short member)
+void HuSprGrpMemberKill(s16 group, s16 member)
 {
-    SpriteGroupData *group_ptr = &HuSprGrpData[group];
-    if(group_ptr->capacity == 0 || group_ptr->capacity <= member || group_ptr->members[member] == SPRITE_INVALID) {
+    HuSprGrp *group_ptr = &HuSprGrpData[group];
+    if(group_ptr->capacity == 0 || group_ptr->capacity <= member || group_ptr->members[member] == HUSPR_NONE) {
         return;
     }
     HuSprKill(group_ptr->members[member]);
-    group_ptr->members[member] = SPRITE_INVALID;
+    group_ptr->members[member] = HUSPR_NONE;
 }
 
-void HuSprGrpKill(short group)
+void HuSprGrpKill(s16 group)
 {
-    SpriteGroupData *group_ptr = &HuSprGrpData[group];
-    short i;
+    HuSprGrp *group_ptr = &HuSprGrpData[group];
+    s16 i;
     for(i=0; i<group_ptr->capacity; i++) {
-        if(group_ptr->members[i] != SPRITE_INVALID) {
+        if(group_ptr->members[i] != HUSPR_NONE) {
             HuSprKill(group_ptr->members[i]);
         }
     }
@@ -375,13 +374,13 @@ void HuSprGrpKill(short group)
     HuMemDirectFree(group_ptr->members);
 }
 
-void HuSprKill(short sprite)
+void HuSprKill(s16 sprite)
 {
-    SpriteData *sprite_ptr = &HuSprData[sprite];
+    HuSprite *sprite_ptr = &HuSprData[sprite];
     if(!sprite_ptr->data) {
         return;
     }
-    if(!(sprite_ptr->attr & SPRITE_ATTR_FUNC)) {
+    if(!(sprite_ptr->attr & HUSPR_ATTR_FUNC)) {
         HuSprAnimKill(sprite_ptr->data);
         if(sprite_ptr->bg) {
             HuSprAnimKill(sprite_ptr->bg);
@@ -394,7 +393,7 @@ void HuSprKill(short sprite)
 void HuSprAnimKill(AnimData *anim)
 {
     if(--anim->useNum <= 0) {
-        if(anim->bmpNum & SPRITE_BMP_ALLOC) {
+        if(anim->bmpNum & ANIM_BMP_ALLOC) {
             if(anim->bmp->data) {
                 HuMemDirectFree(anim->bmp->data);
             }
@@ -406,11 +405,11 @@ void HuSprAnimKill(AnimData *anim)
     }
 }
 
-void HuSprAttrSet(short group, short member, int attr)
+void HuSprAttrSet(s16 group, s16 member, s32 attr)
 {
-    SpriteGroupData *group_ptr = &HuSprGrpData[group];
-    SpriteData *sprite_ptr;
-    if(group_ptr->capacity == 0 || group_ptr->capacity <= member || group_ptr->members[member] == SPRITE_INVALID) {
+    HuSprGrp *group_ptr = &HuSprGrpData[group];
+    HuSprite *sprite_ptr;
+    if(group_ptr->capacity == 0 || group_ptr->capacity <= member || group_ptr->members[member] == HUSPR_NONE) {
         return;
     }
     sprite_ptr = &HuSprData[group_ptr->members[member]];
@@ -418,11 +417,11 @@ void HuSprAttrSet(short group, short member, int attr)
     sprite_ptr->dirty_flag |= SPRITE_DIRTY_ATTR;
 }
 
-void HuSprAttrReset(short group, short member, int attr)
+void HuSprAttrReset(s16 group, s16 member, s32 attr)
 {
-    SpriteGroupData *group_ptr = &HuSprGrpData[group];
-    SpriteData *sprite_ptr;
-    if(group_ptr->capacity == 0 || group_ptr->capacity <= member || group_ptr->members[member] == SPRITE_INVALID) {
+    HuSprGrp *group_ptr = &HuSprGrpData[group];
+    HuSprite *sprite_ptr;
+    if(group_ptr->capacity == 0 || group_ptr->capacity <= member || group_ptr->members[member] == HUSPR_NONE) {
         return;
     }
     sprite_ptr = &HuSprData[group_ptr->members[member]];
@@ -430,59 +429,59 @@ void HuSprAttrReset(short group, short member, int attr)
     sprite_ptr->dirty_flag |= SPRITE_DIRTY_ATTR;
 }
 
-void HuSprPosSet(short group, short member, float x, float y)
+void HuSprPosSet(s16 group, s16 member, float x, float y)
 {
-    SpriteData *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
+    HuSprite *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
     sprite_ptr->x = x;
     sprite_ptr->y = y;
     sprite_ptr->dirty_flag |= SPRITE_DIRTY_XFORM;
 }
 
-void HuSprZRotSet(short group, short member, float z_rot)
+void HuSprZRotSet(s16 group, s16 member, float z_rot)
 {
-    SpriteData *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
+    HuSprite *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
     sprite_ptr->z_rot = z_rot;
     sprite_ptr->dirty_flag |= SPRITE_DIRTY_XFORM;
 }
 
-void HuSprScaleSet(short group, short member, float x, float y)
+void HuSprScaleSet(s16 group, s16 member, float x, float y)
 {
-    SpriteData *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
+    HuSprite *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
     sprite_ptr->scale_x = x;
     sprite_ptr->scale_y = y;
     sprite_ptr->dirty_flag |= SPRITE_DIRTY_XFORM;
 }
 
-void HuSprTPLvlSet(short group, short member, float tp_lvl)
+void HuSprTPLvlSet(s16 group, s16 member, float tp_lvl)
 {
-    SpriteData *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
+    HuSprite *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
     sprite_ptr->a = tp_lvl*255;
     sprite_ptr->dirty_flag |= SPRITE_DIRTY_COLOR;
 }
 
-void HuSprColorSet(short group, short member, u8 r, u8 g, u8 b)
+void HuSprColorSet(s16 group, s16 member, u8 r, u8 g, u8 b)
 {
-    SpriteData *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
+    HuSprite *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
     sprite_ptr->r = r;
     sprite_ptr->g = g;
     sprite_ptr->b = b;
     sprite_ptr->dirty_flag |= SPRITE_DIRTY_COLOR;
 }
 
-void HuSprSpeedSet(short group, short member, float speed)
+void HuSprSpeedSet(s16 group, s16 member, float speed)
 {
-    SpriteGroupData *group_ptr = &HuSprGrpData[group];
+    HuSprGrp *group_ptr = &HuSprGrpData[group];
     HuSprData[group_ptr->members[member]].speed = speed;
 }
 
-void HuSprBankSet(short group, short member, short bank)
+void HuSprBankSet(s16 group, s16 member, s16 bank)
 {
-    SpriteData *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
+    HuSprite *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
     AnimData *anim = sprite_ptr->data;
     AnimBankData *bank_ptr = &anim->bank[sprite_ptr->bank];
     AnimFrameData *frame_ptr = &bank_ptr->frame[sprite_ptr->frame];
     sprite_ptr->bank = bank;
-    if(sprite_ptr->attr & SPRITE_ATTR_REVERSE) {
+    if(sprite_ptr->attr & HUSPR_ATTR_REVERSE) {
         sprite_ptr->frame = bank_ptr->timeNum-1;
         frame_ptr = &bank_ptr->frame[sprite_ptr->frame];
         sprite_ptr->time = frame_ptr->time;
@@ -492,10 +491,10 @@ void HuSprBankSet(short group, short member, short bank)
     }
 }
 
-void HuSprGrpPosSet(short group, float x, float y)
+void HuSprGrpPosSet(s16 group, float x, float y)
 {
-    SpriteGroupData *group_ptr = &HuSprGrpData[group];
-    short i;
+    HuSprGrp *group_ptr = &HuSprGrpData[group];
+    s16 i;
     group_ptr->x = x;
     group_ptr->y = y;
     for(i=0; i<group_ptr->capacity; i++) {
@@ -505,102 +504,102 @@ void HuSprGrpPosSet(short group, float x, float y)
     }
 }
 
-void HuSprGrpCenterSet(short group, float x, float y)
+void HuSprGrpCenterSet(s16 group, float x, float y)
 {
-    SpriteGroupData *group_ptr = &HuSprGrpData[group];
-    short i;
+    HuSprGrp *group_ptr = &HuSprGrpData[group];
+    s16 i;
     group_ptr->center_x = x;
     group_ptr->center_y = y;
     for(i=0; i<group_ptr->capacity; i++) {
-        if(group_ptr->members[i] != SPRITE_INVALID) {
+        if(group_ptr->members[i] != HUSPR_NONE) {
             HuSprData[group_ptr->members[i]].dirty_flag |= SPRITE_DIRTY_XFORM;
         }
     }
 }
 
-void HuSprGrpZRotSet(short group, float z_rot)
+void HuSprGrpZRotSet(s16 group, float z_rot)
 {
-    SpriteGroupData *group_ptr = &HuSprGrpData[group];
-    short i;
+    HuSprGrp *group_ptr = &HuSprGrpData[group];
+    s16 i;
     group_ptr->z_rot = z_rot;
     for(i=0; i<group_ptr->capacity; i++) {
-        if(group_ptr->members[i] != SPRITE_INVALID) {
+        if(group_ptr->members[i] != HUSPR_NONE) {
             HuSprData[group_ptr->members[i]].dirty_flag |= SPRITE_DIRTY_XFORM;
         }
     }
 }
 
-void HuSprGrpScaleSet(short group, float x, float y)
+void HuSprGrpScaleSet(s16 group, float x, float y)
 {
-    SpriteGroupData *group_ptr = &HuSprGrpData[group];
-    short i;
+    HuSprGrp *group_ptr = &HuSprGrpData[group];
+    s16 i;
     group_ptr->scale_x = x;
     group_ptr->scale_y = y;
     for(i=0; i<group_ptr->capacity; i++) {
-        if(group_ptr->members[i] != SPRITE_INVALID) {
+        if(group_ptr->members[i] != HUSPR_NONE) {
             HuSprData[group_ptr->members[i]].dirty_flag |= SPRITE_DIRTY_XFORM;
         }
     }
 }
 
-void HuSprGrpTPLvlSet(short group, float tp_lvl)
+void HuSprGrpTPLvlSet(s16 group, float tp_lvl)
 {
-    SpriteGroupData *group_ptr = &HuSprGrpData[group];
-    short i;
+    HuSprGrp *group_ptr = &HuSprGrpData[group];
+    s16 i;
     for(i=0; i<group_ptr->capacity; i++) {
-        if(group_ptr->members[i] != SPRITE_INVALID) {
+        if(group_ptr->members[i] != HUSPR_NONE) {
             HuSprData[group_ptr->members[i]].a = tp_lvl*255;
             HuSprData[group_ptr->members[i]].dirty_flag |= SPRITE_DIRTY_COLOR;
         }
     }
 }
 
-s32 HuSprGrpDrawNoSet(short group, int draw_no)
+s32 HuSprGrpDrawNoSet(s16 group, s32 draw_no)
 {
-    SpriteGroupData *group_ptr = &HuSprGrpData[group];
-    short i;
+    HuSprGrp *group_ptr = &HuSprGrpData[group];
+    s16 i;
     for(i=0; i<group_ptr->capacity; i++) {
-        if(group_ptr->members[i] != SPRITE_INVALID) {
+        if(group_ptr->members[i] != HUSPR_NONE) {
             HuSprData[group_ptr->members[i]].draw_no = draw_no;
         }
     }
 }
 
-void HuSprDrawNoSet(short group, short member, int draw_no)
+void HuSprDrawNoSet(s16 group, s16 member, s32 draw_no)
 {
-    SpriteData *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
+    HuSprite *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
     sprite_ptr->draw_no = draw_no;
 }
 
-void HuSprPriSet(short group, short member, short prio)
+void HuSprPriSet(s16 group, s16 member, s16 prio)
 {
-    SpriteData *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
+    HuSprite *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
     sprite_ptr->prio = prio;
 }
 
-void HuSprGrpScissorSet(short group, short x, short y, short w, short h)
+void HuSprGrpScissorSet(s16 group, s16 x, s16 y, s16 w, s16 h)
 {
-    SpriteGroupData *group_ptr = &HuSprGrpData[group];
-    short i;
+    HuSprGrp *group_ptr = &HuSprGrpData[group];
+    s16 i;
     for(i=0; i<group_ptr->capacity; i++) {
-        if(group_ptr->members[i] != SPRITE_INVALID) {
+        if(group_ptr->members[i] != HUSPR_NONE) {
             HuSprScissorSet(group, i, x, y, w, h);
         }
     }
 }
 
-void HuSprScissorSet(short group, short member, short x, short y, short w, short h)
+void HuSprScissorSet(s16 group, s16 member, s16 x, s16 y, s16 w, s16 h)
 {
-    SpriteData *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
+    HuSprite *sprite_ptr = &HuSprData[HuSprGrpData[group].members[member]];
     sprite_ptr->scissor_x = x;
     sprite_ptr->scissor_y = y;
     sprite_ptr->scissor_w = w;
     sprite_ptr->scissor_h = h;
 }
 
-static short bitSizeTbl[11] = { 32, 24, 16, 8, 4, 16, 8, 8, 4, 8, 4 };
+static s16 bitSizeTbl[11] = { 32, 24, 16, 8, 4, 16, 8, 8, 4, 8, 4 };
 
-AnimData *HuSprAnimMake(short sizeX, short sizeY, short dataFmt)
+AnimData *HuSprAnimMake(s16 sizeX, s16 sizeY, s16 dataFmt)
 {
     AnimLayerData *layer;
     AnimBmpData *bmp;
@@ -627,7 +626,7 @@ AnimData *HuSprAnimMake(short sizeX, short sizeY, short dataFmt)
     anim->useNum = 0;
     anim->bankNum = 1;
     anim->patNum = 1;
-    anim->bmpNum = (1|SPRITE_BMP_ALLOC);
+    anim->bmpNum = (1|ANIM_BMP_ALLOC);
     bank->timeNum = 1;
     bank->unk = 10;
     frame->pat = 0;
@@ -663,19 +662,19 @@ AnimData *HuSprAnimMake(short sizeX, short sizeY, short dataFmt)
     return anim;
 }
 
-void HuSprBGSet(short group, short member,  AnimData *bg, short bg_bank)
+void HuSprBGSet(s16 group, s16 member,  AnimData *bg, s16 bg_bank)
 {
-    short sprite = HuSprGrpData[group].members[member];
+    s16 sprite = HuSprGrpData[group].members[member];
     HuSprSprBGSet(sprite, bg, bg_bank);
 }
 
-void HuSprSprBGSet(short sprite, AnimData *bg, short bg_bank)
+void HuSprSprBGSet(s16 sprite, AnimData *bg, s16 bg_bank)
 {
-    SpriteData *sprite_ptr = &HuSprData[sprite];
+    HuSprite *sprite_ptr = &HuSprData[sprite];
     sprite_ptr->bg = bg;
     sprite_ptr->bg_bank = bg_bank;
     sprite_ptr->wrap_t = sprite_ptr->wrap_s = GX_REPEAT;
-    sprite_ptr->attr &= ~SPRITE_ATTR_BILINEAR;
+    sprite_ptr->attr &= ~HUSPR_ATTR_LINEAR;
 }
 
 void AnimDebug(AnimData *anim)
@@ -688,7 +687,7 @@ void AnimDebug(AnimData *anim)
     AnimBankData *bank;
     AnimBmpData *bmp;
     
-    OSReport("patNum %d,bankNum %d,bmpNum %d\n", anim->patNum, anim->bankNum, anim->bmpNum & SPRITE_BMP_NUM_MASK);
+    OSReport("patNum %d,bankNum %d,bmpNum %d\n", anim->patNum, anim->bankNum, anim->bmpNum & ANIM_BMP_NUM_MASK);
     pat = anim->pat;
     for(i=0; i<anim->patNum; i++) {
         OSReport("PATTERN%d:\n", i);
@@ -716,7 +715,7 @@ void AnimDebug(AnimData *anim)
         bank++;
     }
     bmp = anim->bmp;
-    for(i=0; i<anim->bmpNum & SPRITE_BMP_NUM_MASK; i++) {
+    for(i=0; i<anim->bmpNum & ANIM_BMP_NUM_MASK; i++) {
         OSReport("BMP%d:\n", i);
         OSReport("\tpixSize %d,palNum %d,size (%d,%d)\n", bmp->pixSize, bmp->palNum, bmp->sizeX, bmp->sizeY);
         bmp++;
diff --git a/src/game/sprput.c b/src/game/sprput.c
index 5e1a923f..c3e50f2b 100644
--- a/src/game/sprput.c
+++ b/src/game/sprput.c
@@ -40,7 +40,7 @@ void HuSprDispInit(void)
     GXSetZMode(GX_FALSE, GX_ALWAYS, GX_FALSE);
 }
 
-void HuSprDisp(SpriteData *sprite)
+void HuSprDisp(HuSprite *sprite)
 {
     short i;
     AnimData *anim = sprite->data;
@@ -48,10 +48,10 @@ void HuSprDisp(SpriteData *sprite)
     Vec axis = {0, 0, 1};
     Mtx modelview, rot;
     short color_sum;
-    SpriteFunc func;
+    HuSprFunc func;
     
     GXSetScissor(sprite->scissor_x, sprite->scissor_y, sprite->scissor_w, sprite->scissor_h);
-    if(sprite->attr & SPRITE_ATTR_FUNC) {
+    if(sprite->attr & HUSPR_ATTR_FUNC) {
         if(sprite->func) {
             func = sprite->func;
             func(sprite);
@@ -80,9 +80,9 @@ void HuSprDisp(SpriteData *sprite)
         GXSetTevOp(GX_TEVSTAGE0, GX_MODULATE);
         GXSetNumChans(1);
         GXSetChanCtrl(GX_COLOR0A0, GX_FALSE, GX_SRC_REG, GX_SRC_REG, GX_LIGHT0, GX_DF_CLAMP, GX_AF_SPOT);
-        if(sprite->attr & SPRITE_ATTR_ADDITIVE) {
+        if(sprite->attr & HUSPR_ATTR_ADDCOL) {
             GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_ONE, GX_LO_NOOP);
-        } else if(sprite->attr & SPRITE_ATTR_INVERT) {
+        } else if(sprite->attr & HUSPR_ATTR_INVCOL) {
             GXSetBlendMode(GX_BM_BLEND, GX_BL_ZERO, GX_BL_INVDSTCLR, GX_LO_NOOP);
         } else {
             GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_NOOP);
@@ -123,7 +123,7 @@ void HuSprDisp(SpriteData *sprite)
                 continue;
             }
             GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR0A0);
-            HuSprTexLoad(anim, layer->bmpNo, 0, sprite->wrap_s, sprite->wrap_t, (sprite->attr & SPRITE_ATTR_BILINEAR) ? GX_LINEAR : GX_NEAR);
+            HuSprTexLoad(anim, layer->bmpNo, 0, sprite->wrap_s, sprite->wrap_t, (sprite->attr & HUSPR_ATTR_LINEAR) ? GX_LINEAR : GX_NEAR);
             if(layer->alpha != 255 || color_sum != 255*4) {
                 color.a = (u16)(sprite->a*layer->alpha) >> 8;
                 GXSetTevColor(GX_TEVSTAGE1, color);
@@ -140,14 +140,14 @@ void HuSprDisp(SpriteData *sprite)
                 pos[2][1] = layer->vtx[5]-pat->centerY;
                 pos[3][0] = layer->vtx[6]-pat->centerX;
                 pos[3][1] = layer->vtx[7]-pat->centerY;
-                if(layer->flip & SPRITE_LAYER_FLIPX) {
+                if(layer->flip & ANIM_LAYER_FLIPX) {
                     texcoord_x2 = layer->startX/(float)bmp->sizeX;
                     texcoord_x1 = (layer->startX+layer->sizeX)/(float)bmp->sizeX;
                 } else {
                     texcoord_x1 = layer->startX/(float)bmp->sizeX;
                     texcoord_x2 = (layer->startX+layer->sizeX)/(float)bmp->sizeX;
                 }
-                if(layer->flip & SPRITE_LAYER_FLIPY) {
+                if(layer->flip & ANIM_LAYER_FLIPY) {
                     texcoord_y2 = layer->startY/(float)bmp->sizeY;
                     texcoord_y1 = (layer->startY+layer->sizeY)/(float)bmp->sizeY;
                 } else {
@@ -188,49 +188,49 @@ void HuSprTexLoad(AnimData *anim, short bmp, short slot, GXTexWrapMode wrap_s, G
     AnimBmpData *bmp_ptr = &anim->bmp[bmp];
     short sizeX = bmp_ptr->sizeX;
     short sizeY = bmp_ptr->sizeY;
-    switch(bmp_ptr->dataFmt & SPRITE_BMP_FMTMASK) {
-        case SPRITE_BMP_RGBA8:
+    switch(bmp_ptr->dataFmt & ANIM_BMP_FMTMASK) {
+        case ANIM_BMP_RGBA8:
             GXInitTexObj(&tex_obj, bmp_ptr->data, sizeX, sizeY, GX_TF_RGBA8, wrap_s, wrap_t, GX_FALSE);
             break;
             
-        case SPRITE_BMP_RGB5A3:
-        case SPRITE_BMP_RGB5A3_DUPE:
+        case ANIM_BMP_RGB5A3:
+        case ANIM_BMP_RGB5A3_DUPE:
             GXInitTexObj(&tex_obj, bmp_ptr->data, sizeX, sizeY, GX_TF_RGB5A3, wrap_s, wrap_t, GX_FALSE);
             break;
             
-        case SPRITE_BMP_C8:
+        case ANIM_BMP_C8:
             GXInitTlutObj(&tlut_obj, bmp_ptr->palData, GX_TL_RGB5A3, bmp_ptr->palNum);
             GXLoadTlut(&tlut_obj, slot);
             GXInitTexObjCI(&tex_obj,bmp_ptr->data, sizeX, sizeY, GX_TF_C8, wrap_s, wrap_t, GX_FALSE, slot);
             break;
             
-        case SPRITE_BMP_C4:
+        case ANIM_BMP_C4:
             GXInitTlutObj(&tlut_obj, bmp_ptr->palData, GX_TL_RGB5A3, bmp_ptr->palNum);
             GXLoadTlut(&tlut_obj, slot);
             GXInitTexObjCI(&tex_obj,bmp_ptr->data, sizeX, sizeY, GX_TF_C4, wrap_s, wrap_t, GX_FALSE, slot);
             break;
             
-        case SPRITE_BMP_IA8:
+        case ANIM_BMP_IA8:
             GXInitTexObj(&tex_obj, bmp_ptr->data, sizeX, sizeY, GX_TF_IA8, wrap_s, wrap_t, GX_FALSE);
             break;
             
-        case SPRITE_BMP_IA4:
+        case ANIM_BMP_IA4:
             GXInitTexObj(&tex_obj, bmp_ptr->data, sizeX, sizeY, GX_TF_IA4, wrap_s, wrap_t, GX_FALSE);
             break;
             
-        case SPRITE_BMP_I8:
+        case ANIM_BMP_I8:
             GXInitTexObj(&tex_obj, bmp_ptr->data, sizeX, sizeY, GX_TF_I8, wrap_s, wrap_t, GX_FALSE);
             break;
         
-        case SPRITE_BMP_I4:
+        case ANIM_BMP_I4:
             GXInitTexObj(&tex_obj, bmp_ptr->data, sizeX, sizeY, GX_TF_I4, wrap_s, wrap_t, GX_FALSE);
             break;
             
-        case SPRITE_BMP_A8:
+        case ANIM_BMP_A8:
             GXInitTexObj(&tex_obj, bmp_ptr->data, sizeX, sizeY, GX_CTF_A8, wrap_s, wrap_t, GX_FALSE);
             break;
             
-        case SPRITE_BMP_CMPR:
+        case ANIM_BMP_CMPR:
             GXInitTexObj(&tex_obj, bmp_ptr->data, sizeX, sizeY, GX_TF_CMPR, wrap_s, wrap_t, GX_FALSE);
             break;
             
diff --git a/src/game/thpmain.c b/src/game/thpmain.c
index 1f8a68a9..babf6433 100755
--- a/src/game/thpmain.c
+++ b/src/game/thpmain.c
@@ -10,7 +10,7 @@
 
 static void THPTestProc(void);
 static void THPViewFunc(ModelData *arg0, Mtx arg1);
-static void THPViewSprFunc(SpriteData *arg0);
+static void THPViewSprFunc(HuSprite *arg0);
 static void THPDecodeFunc(void *param);
 
 static char THPFileName[64];
@@ -210,7 +210,7 @@ static void THPViewFunc(ModelData *arg0, Mtx arg1) {
     }
 }
 
-static void THPViewSprFunc(SpriteData *arg0) {
+static void THPViewSprFunc(HuSprite *arg0) {
     Vec spC = { 0.0f, 0.0f, 1.0f };
     GXColor sp8;
     s32 temp_r30;
diff --git a/src/game/window.c b/src/game/window.c
index 30d28f20..3a357f77 100644
--- a/src/game/window.c
+++ b/src/game/window.c
@@ -30,7 +30,7 @@ typedef struct {
     /* 0x04 */ u32 player[4];
 } keyBufData; // Size 0x14
 
-static void MesDispFunc(SpriteData *sprite);
+static void MesDispFunc(HuSprite *sprite);
 static u8 winBGMake(AnimData *bg, AnimData *frame);
 static void HuWinProc(void);
 static void HuWinDrawMes(s16 window);
@@ -252,7 +252,7 @@ void HuWinInit(s32 mess_data_no) {
 s16 HuWinCreate(float x, float y, s16 w, s16 h, s16 frame) {
     AnimData *bg_anim;
     WindowData *window;
-    SpriteData *sprite_ptr;
+    HuSprite *sprite_ptr;
     s16 group;
     s16 sprite;
     s16 window_id;
@@ -407,9 +407,9 @@ void HuWinAllKill(void) {
     HuDataDirClose(DATADIR_WIN);
 }
 
-static void MesDispFunc(SpriteData *sprite) {
+static void MesDispFunc(HuSprite *sprite) {
     WindowData *window = &winData[sprite->work[0]];
-    SpriteGroupData *group;
+    HuSprGrp *group;
     float uv_maxx;
     float uv_maxy;
     float uv_minx;
@@ -608,7 +608,7 @@ static inline void charEntry(s16 window, s16 x, s16 y, s16 char_idx, s16 color)
 
 static void HuWinDrawMes(s16 window) {
     WindowData *window_ptr = &winData[window];
-    SpriteGroupData *group = &HuSprGrpData[window_ptr->group];
+    HuSprGrp *group = &HuSprGrpData[window_ptr->group];
     s16 c;
     s16 i;
     s16 char_w;
@@ -888,7 +888,7 @@ static void HuWinKeyWait(s16 window) {
 }
 
 static s16 HuWinSpcFontEntry(WindowData *window, s16 entry, s16 x, s16 y) {
-    SpriteGroupData *group = &HuSprGrpData[window->group];
+    HuSprGrp *group = &HuSprGrpData[window->group];
     s16 sprite;
     s16 i;
     AnimData *anim;
@@ -906,7 +906,7 @@ static s16 HuWinSpcFontEntry(WindowData *window, s16 entry, s16 x, s16 y) {
 }
 
 static void HuWinSpcFontPosSet(WindowData *window, s16 index, s16 x, s16 y) {
-    SpriteGroupData *group = &HuSprGrpData[window->group];
+    HuSprGrp *group = &HuSprGrpData[window->group];
 
     HuSprPosSet(window->group, index, x - window->w / 2, y - window->h / 2);
 }
@@ -1372,7 +1372,7 @@ void HuWinAnimSet(s16 window, AnimData *anim, s16 bank, float x, float y) {
 
 s16 HuWinSprSet(s16 window, s16 sprite, float x, float y) {
     WindowData *window_ptr = &winData[window];
-    SpriteGroupData *group = &HuSprGrpData[window_ptr->group];
+    HuSprGrp *group = &HuSprGrpData[window_ptr->group];
     s16 i;
 
     for (i=2; i<=9; i++) {
@@ -1388,14 +1388,14 @@ s16 HuWinSprSet(s16 window, s16 sprite, float x, float y) {
 
 void HuWinSprPosSet(s16 window, s16 index, float x, float y) {
     WindowData *window_ptr = &winData[window];
-    SpriteGroupData *group = &HuSprGrpData[window_ptr->group];
+    HuSprGrp *group = &HuSprGrpData[window_ptr->group];
 
     HuSprPosSet(window_ptr->group, index, x - group->center_x, y - group->center_y);
 }
 
 void HuWinSprPriSet(s16 window, s16 index, s16 prio) {
     WindowData *window_ptr = &winData[window];
-    SpriteGroupData *group = &HuSprGrpData[window_ptr->group];
+    HuSprGrp *group = &HuSprGrpData[window_ptr->group];
 
     HuSprPriSet(window_ptr->group, index, prio);
 }
@@ -1419,7 +1419,7 @@ void HuWinDispOff(s16 window) {
 
     for(i=0; i<30; i++) {
         if (window_ptr->sprite_id[i] != -1) {
-            HuSprAttrSet(window_ptr->group, i, SPRITE_ATTR_HIDDEN);
+            HuSprAttrSet(window_ptr->group, i, HUSPR_ATTR_DISPOFF);
         }
     }
     window_ptr->attr |= 8;
@@ -1431,7 +1431,7 @@ void HuWinDispOn(s16 window) {
 
     for (i=0; i<30; i++) {
         if (window_ptr->sprite_id[i] != -1) {
-            HuSprAttrReset(window_ptr->group, i, SPRITE_ATTR_HIDDEN);
+            HuSprAttrReset(window_ptr->group, i, HUSPR_ATTR_DISPOFF);
         }
     }
     window_ptr->attr = window_ptr->attr & ~8;

From acb81924604f28292bf33431cefc2a67fc2993c5 Mon Sep 17 00:00:00 2001
From: gamemasterplc <gamemasterplc@gmail.com>
Date: Sun, 10 Mar 2024 22:39:25 -0500
Subject: [PATCH 5/7] Remove Duplicate SpriteFunc

---
 include/game/animdata.h | 2 --
 1 file changed, 2 deletions(-)

diff --git a/include/game/animdata.h b/include/game/animdata.h
index 815367f0..88b42cc4 100644
--- a/include/game/animdata.h
+++ b/include/game/animdata.h
@@ -22,8 +22,6 @@
 #define ANIM_LAYER_FLIPX 0x1
 #define ANIM_LAYER_FLIPY 0x2
 
-typedef void (*SpriteFunc)(struct sprite_data *);
-
 typedef struct anim_frame_data {
     s16 pat;
     s16 time;

From 31143de4ee106ec62971a328a1d0a81431a5600a Mon Sep 17 00:00:00 2001
From: gamemasterplc <gamemasterplc@gmail.com>
Date: Mon, 11 Mar 2024 10:50:14 -0500
Subject: [PATCH 6/7] Start decompiling board/last5.c

---
 config/GMPE01_00/symbols.txt |   4 +-
 include/game/board/player.h  |   1 -
 include/game/board/window.h  |   1 -
 include/game/process.h       |   2 +-
 src/game/board/last5.c       | 742 +++++++++++++++++++++++++++++++++++
 5 files changed, 745 insertions(+), 5 deletions(-)
 create mode 100644 src/game/board/last5.c

diff --git a/config/GMPE01_00/symbols.txt b/config/GMPE01_00/symbols.txt
index 6315e23d..193d486e 100644
--- a/config/GMPE01_00/symbols.txt
+++ b/config/GMPE01_00/symbols.txt
@@ -1925,9 +1925,9 @@ CreateBlock = .text:0x800AAC6C; // type:function size:0xD4 scope:local
 UpdateLotteryDraw = .text:0x800AAD40; // type:function size:0x170 scope:local
 SetLotteryDrawState = .text:0x800AAEB0; // type:function size:0x88 scope:local
 GetLotteryDrawState = .text:0x800AAF38; // type:function size:0x20 scope:local
-KillLotteryWheel = .text:0x800AAF58; // type:function size:0x24 scope:local
+KillLotteryDrawWheel = .text:0x800AAF58; // type:function size:0x24 scope:local
 UpdateLotteryDrawWheel = .text:0x800AAF7C; // type:function size:0x2D0 scope:local
-SetLotteryWheelState = .text:0x800AB24C; // type:function size:0x1D8 scope:local
+SetLotteryDrawWheelState = .text:0x800AB24C; // type:function size:0x1D8 scope:local
 ExecLotteryDraw = .text:0x800AB424; // type:function size:0x950 scope:local
 KillLotteryTicket = .text:0x800ABD74; // type:function size:0x4C scope:local
 InitLotteryTicket = .text:0x800ABDC0; // type:function size:0x488 scope:local
diff --git a/include/game/board/player.h b/include/game/board/player.h
index 229e5bdd..b7f983e1 100644
--- a/include/game/board/player.h
+++ b/include/game/board/player.h
@@ -8,7 +8,6 @@
 #include "game/gamework.h"
 #include "game/window.h"
 #include "game/object.h"
-#include "game/process.h"
 #include "game/hsfman.h"
 #include "game/hsfmotion.h"
 #include "game/gamework_data.h"
diff --git a/include/game/board/window.h b/include/game/board/window.h
index 2792395a..bf594796 100644
--- a/include/game/board/window.h
+++ b/include/game/board/window.h
@@ -2,7 +2,6 @@
 #define _BOARD_WINDOW_H
 
 #include "game/window.h"
-#include "game/process.h"
 
 typedef void (*BoardWinComKeyFunc)();
 
diff --git a/include/game/process.h b/include/game/process.h
index aad4d97a..c83b9cf2 100644
--- a/include/game/process.h
+++ b/include/game/process.h
@@ -38,7 +38,7 @@ Process *HuPrcCurrentGet(void);
 int HuPrcKill(Process *process);
 void HuPrcChildKill(Process *process);
 void HuPrcSleep(int time);
-void HuPrcVSleep(void);
+void HuPrcVSleep();
 void HuPrcWakeup(Process *process);
 void HuPrcDestructorSet2(Process *process, void (*func)(void));
 void HuPrcDestructorSet(void (*func)(void));
diff --git a/src/game/board/last5.c b/src/game/board/last5.c
new file mode 100644
index 00000000..f1141878
--- /dev/null
+++ b/src/game/board/last5.c
@@ -0,0 +1,742 @@
+#include "game/board/main.h"
+#include "game/board/model.h"
+#include "game/board/player.h"
+#include "game/board/audio.h"
+#include "game/board/window.h"
+#include "game/board/ui.h"
+#include "game/board/space.h"
+#include "game/board/star.h"
+#include "game/audio.h"
+#include "game/objsub.h"
+#include "game/pad.h"
+
+#include "game/data.h"
+#include "game/wipe.h"
+
+static s16 stopWin = -1;
+static s16 wheelMdl = -1;
+s16 lbl_801D3854 = -1;
+static s16 focusMdl = -1;
+static s32 messBase = -1;
+
+static s32 hostMotTbl[][8] = {
+	{ 
+		DATA_MAKE_NUM(DATADIR_BLAST5, 23),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 24),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 25),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 26),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 27),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 28),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 29),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 30)
+	},
+	{ 
+		DATA_MAKE_NUM(DATADIR_BLAST5, 31),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 32),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 33),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 34),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 35),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 36),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 37),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 38)
+	},
+	{ 
+		DATA_MAKE_NUM(DATADIR_BLAST5, 39),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 40),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 41),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 42),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 43),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 44),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 45),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 46)
+	},
+	{ 
+		DATA_MAKE_NUM(DATADIR_BLAST5, 47),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 48),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 49),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 50),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 51),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 52),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 53),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 54)
+	},
+	{ 
+		DATA_MAKE_NUM(DATADIR_BLAST5, 55),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 56),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 57),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 58),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 59),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 60),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 61),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 62)
+	},
+	{ 
+		DATA_MAKE_NUM(DATADIR_BLAST5, 63),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 64),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 65),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 66),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 67),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 68),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 69),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 70)
+	},
+	{ 
+		-1,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+	},
+	{ 
+		-1,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+	},
+	{ 
+		-1,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+	},
+};
+
+static s32 messBaseTbl[] = {
+	0xE0000,
+	0xE0018,
+	0xE0030,
+	0xE0048,
+	0xE0060,
+	0xE0078,
+	0,
+	0,
+	0,
+};
+
+static float playerOfsTbl[][2] = {
+	{ -94, 0 },
+	{ 0, 0 },
+	{ 94, 0 }
+};
+
+static char *plateObjNameTbl[] = {
+	"plate",
+	"plate1",
+	"plate2",
+	"plate3"
+};
+
+static char *hiliteObjNameTbl[] = {
+	"lite",
+	"lite1",
+	"lite2",
+	"lite3",
+	"kao",
+	"kao1",
+	"kao2",
+	"kao3",
+};
+
+static s32 resultRankFX12Tbl[] = {
+	0x122,
+	0x162,
+	0x1A2,
+	0x1E2,
+	0x222,
+	0x262,
+	0x2A2,
+	0x2E2
+};
+
+static s32 resultRankFX3Tbl[] = {
+	0x12A,
+	0x16A,
+	0x1AA,
+	0x1EA,
+	0x22A,
+	0x26A,
+	0x2AA,
+	0x2EA
+};
+
+static s32 resultRankFX4Tbl[] = {
+	0x12E,
+	0x16E,
+	0x1AE,
+	0x1EE,
+	0x22E,
+	0x26E,
+	0x2AE,
+	0x2EE
+};
+
+static s32 impactFXTbl[] = {
+	0x119,
+	0x159,
+	0x199,
+	0x1D9,
+	0x219,
+	0x259,
+	0x299,
+	0x2D9
+};
+
+static s32 lotteryWheelMdlTbl[] = {
+	DATA_MAKE_NUM(DATADIR_BLAST5, 13),
+	DATA_MAKE_NUM(DATADIR_BLAST5, 14),
+	DATA_MAKE_NUM(DATADIR_BLAST5, 15),
+	DATA_MAKE_NUM(DATADIR_BLAST5, 16),
+	DATA_MAKE_NUM(DATADIR_BLAST5, 17),
+	DATA_MAKE_NUM(DATADIR_BLAST5, 18),
+	DATA_MAKE_NUM(DATADIR_BLAST5, 19),
+	DATA_MAKE_NUM(DATADIR_BLAST5, 20),
+};
+
+static s16 lotterySprPrioTbl[] = {
+	1520,
+	1510,
+	1500,
+	1500,
+	1500,
+	1500,
+	1500,
+	1500,
+	1500,
+	1500,
+	1500,
+	1490,
+	1490,
+	1500,
+	1500
+};
+
+static s32 lotterySprTbl[] = {
+	DATA_MAKE_NUM(DATADIR_BOARD, 39),
+	DATA_MAKE_NUM(DATADIR_BOARD, 38),
+	DATA_MAKE_NUM(DATADIR_BOARD, 41),
+	DATA_MAKE_NUM(DATADIR_BOARD, 40),
+	DATA_MAKE_NUM(DATADIR_BOARD, 40),
+	DATA_MAKE_NUM(DATADIR_BOARD, 40),
+	DATA_MAKE_NUM(DATADIR_BOARD, 45),
+	DATA_MAKE_NUM(DATADIR_BOARD, 40),
+	DATA_MAKE_NUM(DATADIR_BOARD, 40),
+	DATA_MAKE_NUM(DATADIR_BOARD, 40),
+	DATA_MAKE_NUM(DATADIR_BOARD, 44),
+	DATA_MAKE_NUM(DATADIR_BOARD, 42),
+	DATA_MAKE_NUM(DATADIR_BOARD, 42),
+};
+
+static float lotterySprPosTbl[][2] = {
+	{ 0, -35 },
+	{ 0, 0 },
+	{ -68, -38 },
+	{ 80, -22 },
+	{ 64, -22 },
+	{ 48, -22 },
+	{ 26, -22 },
+	{ 80, -48 },
+	{ 64, -48 },
+	{ 48, -48 },
+	{ 26, -48 },
+	{ -18, -40 },
+	{ -18, 32 },
+	{ -16, -72 },
+	{ -16, 0 }
+};
+
+static s32 teamCharSprTbl[] = {
+	DATA_MAKE_NUM(DATADIR_BOARD, 46),
+	DATA_MAKE_NUM(DATADIR_BOARD, 47),
+	DATA_MAKE_NUM(DATADIR_BOARD, 48),
+	DATA_MAKE_NUM(DATADIR_BOARD, 49),
+	DATA_MAKE_NUM(DATADIR_BOARD, 50),
+	DATA_MAKE_NUM(DATADIR_BOARD, 51),
+	DATA_MAKE_NUM(DATADIR_BOARD, 52),
+	DATA_MAKE_NUM(DATADIR_BOARD, 53),
+};
+
+static s8 currTicket;
+static s8 numTickets;
+static s8 last5Player;
+static s16 last5Space;
+static s16 hostMdl;
+static omObjData *last5RouletteObj;
+static Process *last5Proc;
+static omObjData *teamResultObj;
+static omObjData *hostMoveObj;
+static omObjData *lotteryDrawObj;
+static omObjData *lotteryDrawWheelObj;
+
+static Vec spacePos;
+static Vec focusPos;
+static Vec hostPos;
+static s16 hostMot[8];
+static omObjData *lotteryTicketObj[4];
+
+static void DestroyLast5(void);
+
+static void ExecLast5(void);
+static void CreateLast5(void);
+static void KillLast5(void);
+
+static void InitHost(void);
+static void KillHost(void);
+
+static void Last5Main(void);
+
+static s32 CheckJump(s32 player);
+
+static void CreateBlock(Vec *pos);
+
+static void CreateLotteryDrawWheel(void);
+
+static void SetLotteryDrawState(s32 state);
+static s32 GetLotteryDrawState();
+
+static void KillLotteryDrawWheel(void);
+
+static void ExecLotteryDraw(void);
+
+static void InitLotteryTicket(void);
+static void KillLotteryTicket(void);
+
+static void StartHostMove(Vec *from, Vec *to, s32 time);
+static s32 CheckHostMove(void);
+
+
+static void CreateStopWin(void);
+static void CreateLast5Roulette(void);
+static void SetLast5RouletteFade(s32 flag);
+static void SetLast5RouletteState(s32 state);
+static s32 GetLast5RouletteState();
+static s32 GetLast5RouletteResult();
+
+static void CreateTeamResult(void);
+static void GetTeamResultTaget(s32 team, Vec *pos);
+static void SetTeamResultTaget(s32 team, Vec *pos);
+static void KillTeamResult(void);
+
+void BoardLast5Exec()
+{
+	GWSystem.player_curr = -1;
+	last5Proc = HuPrcChildCreate(ExecLast5, 8200, 14336, 0, boardMainProc);
+	HuPrcDestructorSet2(last5Proc, DestroyLast5);
+	while(last5Proc != NULL) {
+		HuPrcVSleep();
+	}
+	GWSystem.player_curr = 0;
+}
+
+static void DestroyLast5(void)
+{
+	KillLast5();
+	HuDataDirClose(DATADIR_BLAST5);
+	last5Proc = NULL;
+}
+
+static void ExecLast5(void)
+{
+	s32 i;
+	messBase = messBaseTbl[GWBoardGet()];
+	CreateLast5();
+	WipeCreate(WIPE_MODE_IN, WIPE_TYPE_NORMAL, -1);
+	while(WipeStatGet()) {
+		HuPrcVSleep();
+	}
+	_ClearFlag(0x1001C);
+	BoardLast5GfxInit();
+	BoardAudSeqFadeOut(0, 1000);
+	BoardMusStart(1, 8, 127, 0);
+	BoardWinCreate(2, messBase, BoardWinPortraitGetStar());
+	BoardWinWait();
+	BoardWinKill();
+	ExecLotteryDraw();
+	Last5Main();
+	BoardAudSeqFadeOut(1, 1000);
+	_SetFlag(0x1001C);
+	_SetFlag(0x1000E);
+	WipeColorSet(255, 255, 255);
+	WipeCreate(WIPE_MODE_OUT, WIPE_TYPE_NORMAL, -1);
+	while(WipeStatGet()) {
+		HuPrcVSleep();
+	}
+	BoardModelMotionStart(hostMdl, 1, 0x40000001);
+	BoardCameraMoveSet(0);
+	BoardCameraViewSet(2);
+	BoardCameraMotionWait();
+	BoardCameraMoveSet(1);
+	for(i=0; i<4; i++) {
+		BoardModelVisibilitySet(BoardPlayerModelGet(i), 1);
+		BoardPlayerCornerPosSet(i);
+		BoardPlayerRotYSet(i, 0.0f);
+	}
+	BoardStatusItemSet(0);
+	HuPrcSleep(60);
+	HuPrcEnd();
+}
+
+static void CreateLast5(void)
+{
+	Vec rot;
+	s32 i;
+	last5Space = BoardSpaceFlagPosGet(0, 0x80000000, &spacePos);
+	for(i=0; i<4; i++) {
+		BoardModelVisibilitySet(BoardPlayerModelGet(i), 0);
+	}
+	BoardStatusItemSet(0);
+	focusPos.x = 150.0f+spacePos.x;
+	focusPos.y = 100.0f+spacePos.y;
+	focusPos.z = -150.0f+spacePos.z;
+	focusMdl = BoardModelCreate(DATA_MAKE_NUM(DATADIR_BOARD, 10), NULL, 0);
+	BoardModelVisibilitySet(focusMdl, 0);
+	BoardModelPosSetV(focusMdl, &focusPos);
+	rot.x = -10.0f;
+	rot.y = 0.0f;
+	rot.z = 0.0f;
+	BoardCameraMoveSet(0);
+	BoardCameraMotionStartEx(focusMdl, &rot, NULL, 1480.0f, 25.0f, 1);
+	BoardCameraMotionWait();
+	BoardCameraMoveSet(1);
+	InitHost();
+	CreateLotteryDrawWheel();
+	InitLotteryTicket();
+}
+
+static void KillLast5(void)
+{
+	if(stopWin != -1) {
+		HuWinKill(stopWin);
+		stopWin = -1;
+	}
+	BoardConfettiKill();
+	KillHost();
+	KillLotteryDrawWheel();
+	KillLotteryTicket();
+}
+
+static void InitHost(void)
+{
+	Vec pos;
+	s32 i;
+	s32 board = GWBoardGet();
+	hostMdl = BoardStarHostMdlGet();
+	BoardModelPosGet(hostMdl, &hostPos);
+	for(i=0; i<8; i++) {
+		hostMot[i] = BoardModelMotionCreate(hostMdl, hostMotTbl[board][i]);
+	}
+	BoardModelMotionStart(hostMdl, 1, 0x40000001);
+	pos.x = 150.0f+spacePos.x;
+	pos.y = spacePos.y;
+	pos.z = (150.0f+spacePos.z)-50.0f;
+	BoardModelPosSetV(hostMdl, &pos);
+}
+
+static void KillHost(void)
+{
+	s32 i;
+	for(i=0; i<8; i++) {
+		if(hostMot[i] != -1) {
+			BoardModelMotionKill(hostMdl, hostMot[i]);
+			hostMot[i] = -1;
+		}
+	}
+	BoardModelRotYSet(hostMdl, 0.0f);
+	BoardModelPosSetV(hostMdl, &hostPos);
+}
+
+static void Last5Main(void)
+{
+	float temp_f31;
+	s32 temp_r31;
+	s32 temp_r30;
+	s32 temp_r29;
+	s32 temp_r27;
+	s32 temp_r26;
+	s32 temp_r25;
+	s32 temp_r24;
+	s32 temp_r23;
+	s32 temp_r22;
+	s32 temp_r21;
+	s32 temp_r20;
+	s32 temp_r19;
+	s32 temp_r18;
+	Vec sp6C[4];
+	Vec sp60;
+	Vec sp54;
+	Vec sp48;
+	Vec sp3C;
+	float sp2C[4];
+	s8 sp28[4];
+	s8 sp24[4];
+	s8 sp20[4];
+	
+	
+	
+	temp_r18 = -1;
+	for(temp_r26=temp_r27=0; temp_r27<=3; temp_r27++) {
+		for(temp_r25=temp_r31=0; temp_r31<4; temp_r31++) {
+			if(GWPlayer[temp_r31].rank == temp_r27) {
+				sp28[temp_r26] = temp_r31;
+				sp24[temp_r26] = temp_r27;
+				temp_r26++;
+				if(temp_r27 > temp_r18) {
+					sp20[temp_r25] = temp_r31;
+					temp_r25++;
+				}
+			}
+		}
+		if(temp_r25 != 0) {
+			temp_r21 = temp_r25;
+		}
+	}
+	BoardWinCreate(2, messBase+10, BoardWinPortraitGetStar());
+	BoardWinWait();
+	BoardModelMotionShiftSet(hostMdl, hostMot[5], 0.0f, 4.0f, 0);
+	HuPrcVSleep(8);
+	BoardModelMotionShiftSet(hostMdl, hostMot[6], 0.0f, 8.0f, 0x40000001);
+	for(temp_r31=0; temp_r31<4; temp_r31++) {
+		temp_r30 = sp28[temp_r31];
+		temp_r27 = sp24[temp_r31];
+		temp_r23 = GWPlayer[temp_r30].character;
+		sp6C[temp_r31].x = -122.0f;
+		sp6C[temp_r31].y = (temp_r31*74)+80;
+		sp6C[temp_r31].z = 0.0f;
+		BoardStatusPosSet(temp_r30, &sp6C[temp_r31]);
+		HuPrcVSleep();
+		BoardStatusShowSet(temp_r30, 1);
+		sp2C[temp_r31] = (122.0f-sp6C[temp_r31].x)/15.0f;
+		for(temp_r29=0; temp_r29<15; temp_r29++) {
+			sp6C[temp_r31].x += sp2C[temp_r31];
+			BoardStatusPosSet(temp_r30, &sp6C[temp_r31]);
+			HuPrcVSleep();
+		}
+		switch(temp_r27) {
+			case 0:
+			case 1:
+				temp_r22 = resultRankFX12Tbl[temp_r23];
+				break;
+				
+			case 2:
+				temp_r22 = resultRankFX3Tbl[temp_r23];
+				break;
+				
+			case 3:
+				temp_r22 = resultRankFX4Tbl[temp_r23];
+				break;
+		}
+		HuAudFXPlay(temp_r22);
+		temp_r24 = 11+messBase+temp_r27;
+		BoardWinCreate(2, temp_r24, BoardWinPortraitGetStar());
+		BoardWinInsertMesSet(BoardPlayerGetCharMess(temp_r30), temp_r27);
+		BoardWinWait();
+	}
+	if((s32)GWSystem.team != 0) {
+		CreateTeamResult();
+		for(temp_r31=0; temp_r31<4; temp_r31++) {
+			sp2C[temp_r31] = (-122.0f-sp6C[temp_r31].x)/15.0f;
+		}
+		for(temp_r29=0; temp_r29<15; temp_r29++) {
+			for(temp_r31=0; temp_r31<4; temp_r31++) {
+				temp_r30 = sp28[temp_r31];
+				sp6C[temp_r31].x += sp2C[temp_r31];
+				BoardStatusPosSet(temp_r30, &sp6C[temp_r31]);
+			}
+			HuPrcVSleep();
+		}
+		BoardStatusItemSet(0);
+		temp_r24 = 0xE0090+GWBoardGet();
+		BoardWinCreate(2, temp_r24, BoardWinPortraitGetStar());
+		BoardWinWait();
+		for(temp_r31=0; temp_r31<2; temp_r31++) {
+			GetTeamResultTaget(temp_r31, &sp6C[temp_r31]);
+			sp2C[temp_r31] = (122.0f-sp6C[temp_r31].x)/15.0f;
+			for(temp_r29=0; temp_r29<15; temp_r29++) {
+				sp6C[temp_r31].x += sp2C[temp_r31];
+				SetTeamResultTaget(temp_r31, &sp6C[temp_r31]);
+				HuPrcVSleep();
+			}
+		}
+	}
+	BoardModelMotionStart(hostMdl, hostMot[5], 0x40000004);
+	HuPrcVSleep(8);
+	BoardModelMotionShiftSet(hostMdl, 1, 0.0f, 8.0f, 0x40000001);
+	BoardWinCreate(2, messBase+15, BoardWinPortraitGetStar());
+	BoardWinWait();
+	if((s32)GWSystem.team != 0) {
+		for(temp_r31=0; temp_r31<2; temp_r31++) {
+			sp2C[temp_r31] = (-122.0f-sp6C[temp_r31].x)/15.0f;
+		}
+		for(temp_r29=0; temp_r29<15; temp_r29++) {
+			for(temp_r31=0; temp_r31<2; temp_r31++) {
+				GetTeamResultTaget(temp_r31, &sp6C[temp_r31]);
+				sp6C[temp_r31].x += sp2C[temp_r31];
+				SetTeamResultTaget(temp_r31, &sp6C[temp_r31]);
+			}
+			HuPrcVSleep();
+		}
+		KillTeamResult();
+	} else {
+		for(temp_r31=0; temp_r31<4; temp_r31++) {
+			sp2C[temp_r31] = (-122.0f-sp6C[temp_r31].x)/15.0f;
+		}
+		for(temp_r29=0; temp_r29<15; temp_r29++) {
+			for(temp_r31=0; temp_r31<4; temp_r31++) {
+				temp_r30 = sp28[temp_r31];
+				sp6C[temp_r31].x += sp2C[temp_r31];
+				BoardStatusPosSet(temp_r30, &sp6C[temp_r31]);
+			}
+			HuPrcVSleep();
+		}
+		BoardStatusItemSet(0);
+	}
+	BoardModelPosGet(hostMdl, &sp60);
+	sp54.x = sp60.x+100.0f;
+	sp54.y = sp60.y;
+	sp54.z = sp60.z;
+	StartHostMove(&sp60, &sp54, 25);
+	while(!CheckHostMove()) {
+		HuPrcVSleep();
+	}
+	BoardModelMotionShiftSet(hostMdl, 1, 0.0f, 8.0f, 0x40000001);
+	HuPrcSleep(8);
+	if((s32)GWSystem.team != 0) {
+		temp_r30 = last5Player;
+	} else {
+		if(temp_r21 == 1) {
+			temp_r30 = sp20[0];
+		} else {
+			temp_r30 = sp20[BoardRandMod(temp_r21)];
+		}
+	}
+	sp48.x = sp60.x-100.0f;
+	sp48.y = sp60.y;
+	sp48.z = sp60.z;
+	sp48.y += 700.0f;
+	BoardPlayerPosSetV(temp_r30, &sp48);
+	BoardPlayerMotionStart(temp_r30, 6, 0x40000001);
+	BoardPlayerVoiceEnableSet(temp_r30, 6, 0);
+	BoardPlayerRotYSet(temp_r30, 0);
+	BoardModelVisibilitySet(BoardPlayerModelGet(temp_r30), 1);
+	BoardWinCreate(2, messBase+16, BoardWinPortraitGetStar());
+	BoardWinInsertMesSet(BoardPlayerGetCharMess(temp_r30), 3);
+	BoardWinWait();
+	BoardModelMotionShiftSet(hostMdl, hostMot[5], 0.0f, 4.0f, 0);
+	HuPrcVSleep(8);
+	BoardModelMotionShiftSet(hostMdl, hostMot[6], 0.0f, 8.0f, 0x40000001);
+	temp_r19 = 0;
+	temp_r29 = 3;
+	for(temp_f31=0; temp_r29>0; temp_f31++) {
+		sp48.y += (float)(5.0+((9.8/120)*temp_f31*temp_f31));
+		if(sp60.y > sp48.y) {
+			omVibrate(temp_r30, 12, 6, 6);
+			if(!temp_r19) {
+				HuAudFXPlay(impactFXTbl[GWPlayer[temp_r30].character]);
+				temp_r19 = 1;
+			}
+			sp48.y = sp60.y;
+			sp48.y += temp_r29*10;
+			temp_r29--;
+			temp_f31 = 0.0f;
+		}
+		BoardPlayerPosSetV(temp_r30, &sp48);
+		HuPrcVSleep();
+	}
+	HuPrcSleep(20);
+	BoardPlayerIdleSet(temp_r30);
+	sp3C = sp48;
+	BoardModelMotionStart(hostMdl, hostMot[5], 0x40000004);
+	HuPrcVSleep(8);
+	BoardModelMotionShiftSet(hostMdl, 1, 0.0f, 8.0f, 0x40000001);
+	CreateLast5Roulette();
+	SetLast5RouletteFade(1);
+	SetLast5RouletteState(2);
+	CreateStopWin();
+	sp48.x = sp60.x-100.0f;
+	sp48.y = sp60.y;
+	sp48.z = sp60.z;
+	CreateBlock(&sp48);
+	SetLotteryDrawState(2);
+	while(GetLotteryDrawState() != 0) {
+		HuPrcVSleep();
+	}
+	while(!CheckJump(temp_r30)) {
+		HuPrcVSleep();
+	}
+	BoardPlayerDiceJumpStart(temp_r30);
+	while(!BoardPlayerDiceJumpCheck(temp_r30)) {
+		HuPrcVSleep();
+	}
+	SetLotteryDrawState(1);
+	SetLast5RouletteState(3);
+	while(GWPlayer[temp_r30].field08_bit3) {
+		HuPrcVSleep();
+	}
+	while(GetLast5RouletteState() != 0) {
+		HuPrcVSleep();
+	}
+	HuWinDispOff(stopWin);
+	SetLotteryDrawState(3);
+	temp_r20 = GetLast5RouletteResult();
+	GWSystem.last5_effect = temp_r20;
+	if(GWSystem.last5_effect == 2) {
+		BoardSpaceTypeForce(2, 3);
+	}
+	if(GWSystem.last5_effect == 3) {
+		BoardSpaceTypeForce(2, 7);
+	}
+	temp_r24 = 18+messBase+temp_r20;
+	BoardWinCreate(2, temp_r24, BoardWinPortraitGetStar());
+	BoardWinWait();
+	StartHostMove(&sp54, &sp60, 25);
+	BoardPlayerPosGet(temp_r30, &sp48);
+	sp48 = sp3C;
+	sp3C.x = sp48.x-300.0f;
+	sp3C.y = sp48.y;
+	sp3C.z = sp48.z;
+	BoardPlayerPosLerpStart(temp_r30, &sp48, &sp3C, 25);
+	while(GWPlayer[temp_r30].moving) {
+		HuPrcVSleep();
+	}
+	BoardPlayerIdleSet(temp_r30);
+	BoardModelVisibilitySet(BoardPlayerModelGet(temp_r30), 0);
+	SetLast5RouletteFade(0);
+	BoardModelMotionShiftSet(hostMdl, 1, 0.0f, 8.0f, 0x40000001);
+	BoardWinCreate(2, messBase+23, BoardWinPortraitGetStar());
+	BoardWinWait();
+	BoardModelMotionShiftSet(hostMdl, hostMot[4], 0.0f, 8.0f, 0);
+	HuPrcSleep(8);
+	while(!BoardModelMotionEndCheck(hostMdl)) {
+		HuPrcVSleep();
+	}
+	BoardModelMotionShiftSet(hostMdl, hostMot[2], 0.0f, 8.0f, 0x40000001);
+	SetLotteryDrawState(4);
+}
+
+static s32 CheckJump(s32 player)
+{
+	s32 sp8 = 0;
+	if(GWPlayer[player].com) {
+		if(BoardRandMod(100) >= 90) {
+			return 1;
+		} else {
+			goto return0;
+		}
+	}
+	if(HuPadBtnDown[GWPlayer[player].port] == PAD_BUTTON_A) {
+		return 1;
+	} else {
+		return0:
+		return 0;
+	}
+}
\ No newline at end of file

From 5ab4952bc7382705b7b10d62c81cff7ce8641584 Mon Sep 17 00:00:00 2001
From: gamemasterplc <gamemasterplc@gmail.com>
Date: Mon, 11 Mar 2024 17:11:48 -0500
Subject: [PATCH 7/7] Match board/last5.c

---
 config/GMPE01_00/symbols.txt |   13 +-
 configure.py                 |    2 +-
 src/game/board/last5.c       | 1303 +++++++++++++++++++++++++++++++++-
 3 files changed, 1283 insertions(+), 35 deletions(-)

diff --git a/config/GMPE01_00/symbols.txt b/config/GMPE01_00/symbols.txt
index 193d486e..d2efc523 100644
--- a/config/GMPE01_00/symbols.txt
+++ b/config/GMPE01_00/symbols.txt
@@ -1921,7 +1921,7 @@ KillHost = .text:0x800A9C68; // type:function size:0xA4 scope:local
 Last5Main = .text:0x800A9D0C; // type:function size:0xCC0 scope:local
 CheckJump = .text:0x800AA9CC; // type:function size:0xA4 scope:local
 CreateLotteryDrawWheel = .text:0x800AAA70; // type:function size:0x1FC scope:local
-CreateBlock = .text:0x800AAC6C; // type:function size:0xD4 scope:local
+CreateLotteryDraw = .text:0x800AAC6C; // type:function size:0xD4 scope:local
 UpdateLotteryDraw = .text:0x800AAD40; // type:function size:0x170 scope:local
 SetLotteryDrawState = .text:0x800AAEB0; // type:function size:0x88 scope:local
 GetLotteryDrawState = .text:0x800AAF38; // type:function size:0x20 scope:local
@@ -1947,7 +1947,7 @@ SetLast5RouletteState = .text:0x800AD194; // type:function size:0x38 scope:local
 GetLast5RouletteState = .text:0x800AD1CC; // type:function size:0x38 scope:local
 GetLast5RouletteResult = .text:0x800AD204; // type:function size:0x44 scope:local
 CreateTeamResult = .text:0x800AD248; // type:function size:0x2B4 scope:local
-CreateTeamResultSprite = .text:0x800AD4FC; // type:function size:0x340 scope:local
+CreateTeamResultWork = .text:0x800AD4FC; // type:function size:0x340 scope:local
 SetTeamResultTarget = .text:0x800AD83C; // type:function size:0x58 scope:local
 GetTeamResultTarget = .text:0x800AD894; // type:function size:0x58 scope:local
 KillTeamResult = .text:0x800AD8EC; // type:function size:0x38 scope:local
@@ -5322,15 +5322,16 @@ hostMotTbl = .data:0x8013B0D8; // type:object size:0x120 scope:local
 messBaseTbl = .data:0x8013B1F8; // type:object size:0x24 scope:local
 playerOfsTbl = .data:0x8013B21C; // type:object size:0x18 scope:local
 plateObjNameTbl = .data:0x8013B234; // type:object size:0x10 scope:local
-hiliteObjNameTbl = .data:0x8013B244; // type:object size:0x20 scope:local
+hiliteObjNameTbl = .data:0x8013B244; // type:object size:0x10 scope:local
+faceObjNameTbl = .data:0x8013B254; // type:object size:0x10 scope:local
 resultRankFX12Tbl = .data:0x8013B264; // type:object size:0x20 scope:local
 resultRankFX3Tbl = .data:0x8013B284; // type:object size:0x20 scope:local
 resultRankFX4Tbl = .data:0x8013B2A4; // type:object size:0x20 scope:local
 impactFXTbl = .data:0x8013B2C4; // type:object size:0x20 scope:local
 lotteryWheelMdlTbl = .data:0x8013B2E4; // type:object size:0x20 scope:local
-lotterySprPrioTbl = .data:0x8013B304; // type:object size:0x1E scope:local
-lotterySprTbl = .data:0x8013B324; // type:object size:0x34 scope:local
-lotterySprPosTbl = .data:0x8013B358; // type:object size:0x78 scope:local
+teamSprPrioTbl = .data:0x8013B304; // type:object size:0x1E scope:local
+teamSprTbl = .data:0x8013B324; // type:object size:0x34 scope:local
+teamSprPosTbl = .data:0x8013B358; // type:object size:0x78 scope:local
 teamCharSprTbl = .data:0x8013B3D0; // type:object size:0x20 scope:local
 boxModelID = .data:0x8013B3F0; // type:object size:0x10 scope:local data:2byte
 boxPosTbl = .data:0x8013B400; // type:object size:0x40 scope:local data:float
diff --git a/configure.py b/configure.py
index 2296aa50..2f8e79c6 100644
--- a/configure.py
+++ b/configure.py
@@ -393,7 +393,7 @@ config.libs = [
             Object(NonMatching, "game/board/mg_setup.c"),
             Object(NonMatching, "game/board/boo_house.c"),
             Object(NonMatching, "game/board/start.c"),
-            Object(NonMatching, "game/board/last5.c"),
+            Object(Matching, "game/board/last5.c"),
             Object(Matching, "game/board/pause.c"),
             Object(Matching, "game/board/com_path.c"),
             Object(Matching, "game/board/tutorial.c"),
diff --git a/src/game/board/last5.c b/src/game/board/last5.c
index f1141878..ccf070e6 100644
--- a/src/game/board/last5.c
+++ b/src/game/board/last5.c
@@ -141,11 +141,14 @@ static char *hiliteObjNameTbl[] = {
 	"lite",
 	"lite1",
 	"lite2",
-	"lite3",
+	"lite3"
+};
+
+static char *faceObjNameTbl[] = {
 	"kao",
 	"kao1",
 	"kao2",
-	"kao3",
+	"kao3"
 };
 
 static s32 resultRankFX12Tbl[] = {
@@ -203,7 +206,7 @@ static s32 lotteryWheelMdlTbl[] = {
 	DATA_MAKE_NUM(DATADIR_BLAST5, 20),
 };
 
-static s16 lotterySprPrioTbl[] = {
+static s16 teamSprPrioTbl[] = {
 	1520,
 	1510,
 	1500,
@@ -221,7 +224,7 @@ static s16 lotterySprPrioTbl[] = {
 	1500
 };
 
-static s32 lotterySprTbl[] = {
+static s32 teamSprTbl[] = {
 	DATA_MAKE_NUM(DATADIR_BOARD, 39),
 	DATA_MAKE_NUM(DATADIR_BOARD, 38),
 	DATA_MAKE_NUM(DATADIR_BOARD, 41),
@@ -237,7 +240,7 @@ static s32 lotterySprTbl[] = {
 	DATA_MAKE_NUM(DATADIR_BOARD, 42),
 };
 
-static float lotterySprPosTbl[][2] = {
+static float teamSprPosTbl[][2] = {
 	{ 0, -35 },
 	{ 0, 0 },
 	{ -68, -38 },
@@ -297,35 +300,43 @@ static void Last5Main(void);
 
 static s32 CheckJump(s32 player);
 
-static void CreateBlock(Vec *pos);
-
 static void CreateLotteryDrawWheel(void);
-
+static void CreateLotteryDraw(Vec *pos);
+static void UpdateLotteryDraw(omObjData *object);
 static void SetLotteryDrawState(s32 state);
 static s32 GetLotteryDrawState();
-
 static void KillLotteryDrawWheel(void);
-
+static void UpdateLotteryDrawWheel(omObjData *object);
+static void SetLotteryDrawWheelState(s32 state);
 static void ExecLotteryDraw(void);
 
-static void InitLotteryTicket(void);
 static void KillLotteryTicket(void);
+static void InitLotteryTicket(void);
+static void UpdateLotteryTicket(omObjData *object);
+static void SetLotteryTicketState(s32 player, s32 state);
+static s32 GetLotteryTicketPlayer(void);
+static s32 CheckLotteryTicket(void);
+static void UpdateLotteryTicketMatch(s32 progress, s32 character);
 
-static void StartHostMove(Vec *from, Vec *to, s32 time);
+static void StartHostMove(Vec *from, Vec *to, s16 time);
+static void ExecHostMove(omObjData *object);
 static s32 CheckHostMove(void);
 
-
 static void CreateStopWin(void);
+
 static void CreateLast5Roulette(void);
+static void UpdateLast5Roulette(omObjData *object);
+
 static void SetLast5RouletteFade(s32 flag);
 static void SetLast5RouletteState(s32 state);
-static s32 GetLast5RouletteState();
-static s32 GetLast5RouletteResult();
+static s32 GetLast5RouletteState(void);
+static s32 GetLast5RouletteResult(void);
 
 static void CreateTeamResult(void);
-static void GetTeamResultTaget(s32 team, Vec *pos);
-static void SetTeamResultTaget(s32 team, Vec *pos);
+static void GetTeamResultTarget(s32 team, Vec *pos);
+static void SetTeamResultTarget(s32 team, Vec *pos);
 static void KillTeamResult(void);
+static void UpdateTeamResult(omObjData *object);
 
 void BoardLast5Exec()
 {
@@ -559,11 +570,11 @@ static void Last5Main(void)
 		BoardWinCreate(2, temp_r24, BoardWinPortraitGetStar());
 		BoardWinWait();
 		for(temp_r31=0; temp_r31<2; temp_r31++) {
-			GetTeamResultTaget(temp_r31, &sp6C[temp_r31]);
+			GetTeamResultTarget(temp_r31, &sp6C[temp_r31]);
 			sp2C[temp_r31] = (122.0f-sp6C[temp_r31].x)/15.0f;
 			for(temp_r29=0; temp_r29<15; temp_r29++) {
 				sp6C[temp_r31].x += sp2C[temp_r31];
-				SetTeamResultTaget(temp_r31, &sp6C[temp_r31]);
+				SetTeamResultTarget(temp_r31, &sp6C[temp_r31]);
 				HuPrcVSleep();
 			}
 		}
@@ -579,9 +590,9 @@ static void Last5Main(void)
 		}
 		for(temp_r29=0; temp_r29<15; temp_r29++) {
 			for(temp_r31=0; temp_r31<2; temp_r31++) {
-				GetTeamResultTaget(temp_r31, &sp6C[temp_r31]);
+				GetTeamResultTarget(temp_r31, &sp6C[temp_r31]);
 				sp6C[temp_r31].x += sp2C[temp_r31];
-				SetTeamResultTaget(temp_r31, &sp6C[temp_r31]);
+				SetTeamResultTarget(temp_r31, &sp6C[temp_r31]);
 			}
 			HuPrcVSleep();
 		}
@@ -637,7 +648,7 @@ static void Last5Main(void)
 	temp_r19 = 0;
 	temp_r29 = 3;
 	for(temp_f31=0; temp_r29>0; temp_f31++) {
-		sp48.y += (float)(5.0+((9.8/120)*temp_f31*temp_f31));
+		sp48.y += (float)(5.0+((-9.8/120)*temp_f31*temp_f31));
 		if(sp60.y > sp48.y) {
 			omVibrate(temp_r30, 12, 6, 6);
 			if(!temp_r19) {
@@ -665,7 +676,7 @@ static void Last5Main(void)
 	sp48.x = sp60.x-100.0f;
 	sp48.y = sp60.y;
 	sp48.z = sp60.z;
-	CreateBlock(&sp48);
+	CreateLotteryDraw(&sp48);
 	SetLotteryDrawState(2);
 	while(GetLotteryDrawState() != 0) {
 		HuPrcVSleep();
@@ -729,14 +740,1250 @@ static s32 CheckJump(s32 player)
 	if(GWPlayer[player].com) {
 		if(BoardRandMod(100) >= 90) {
 			return 1;
+		}
+	} else if(HuPadBtnDown[GWPlayer[player].port] == PAD_BUTTON_A) {
+		return 1;
+	}
+	return 0;
+}
+
+typedef struct draw_wheel_mdl {
+	s16 plate[4];
+	s16 face[4];
+	s16 center;
+} DrawWheelMdl;
+
+typedef struct draw_wheel_work {
+	struct {
+		u8 kill : 1;
+	};
+	s8 state;
+	s8 hilite;
+	u16 timer;
+	u8 hilite_vel;
+	u8 hilite_accel;
+	DrawWheelMdl *mdl;
+} DrawWheelWork;
+
+typedef struct lottery_draw_work {
+	struct {
+		u8 kill : 1;
+	};
+	u8 state;
+	s16 block_mdl;
+	float min_y;
+} LotteryDrawWork;
+
+static void CreateLotteryDrawWheel(void)
+{
+	omObjData *object;
+	DrawWheelWork *work;
+	DrawWheelMdl *mdl;
+	s32 i;
+	object = omAddObjEx(boardObjMan, 257, 0, 0, -1, UpdateLotteryDrawWheel);
+	lotteryDrawWheelObj = object;
+	work = OM_GET_WORK_PTR(object, DrawWheelWork);
+	work->kill = 0;
+	work->state = 0;
+	work->mdl = HuMemDirectMallocNum(HEAP_SYSTEM, sizeof(DrawWheelMdl), MEMORY_DEFAULT_NUM);
+	work->hilite = 0;
+	work->hilite_vel = 2;
+	work->hilite_accel = 5;
+	mdl = work->mdl;
+	object->trans.x = spacePos.x + -300.0f;
+	object->trans.y = spacePos.y;
+	object->trans.z = spacePos.z + -50.0f;
+	wheelMdl = BoardModelCreate(DATA_MAKE_NUM(DATADIR_BLAST5, 12), NULL, 0);
+	BoardModelPosSet(wheelMdl, object->trans.x, object->trans.y, object->trans.z);
+	mdl->center = BoardModelCreate(DATA_MAKE_NUM(DATADIR_BLAST5, 22), NULL, 0);
+	BoardModelVisibilitySet(mdl->center, 0);
+	for(i=0; i<4; i++) {
+		s32 character = GWPlayer[i].character;
+		mdl->face[i] = BoardModelCreate(lotteryWheelMdlTbl[character], NULL, 0);
+		BoardModelPosSet(mdl->face[i], 0, 0, -10);
+		mdl->plate[i] = BoardModelCreate(DATA_MAKE_NUM(DATADIR_BLAST5, 21), NULL, 1);
+		BoardModelHookSet(wheelMdl, faceObjNameTbl[i], mdl->face[i]);
+		BoardModelHookSet(wheelMdl, plateObjNameTbl[i], mdl->plate[i]);
+	}
+}
+
+static void CreateLotteryDraw(Vec *pos)
+{
+	omObjData *object;
+	LotteryDrawWork *work;
+	object = omAddObjEx(boardObjMan, 257, 0, 0, -1, UpdateLotteryDraw);
+	lotteryDrawObj = object;
+	work = OM_GET_WORK_PTR(object, LotteryDrawWork);
+	work->kill = 0;
+	work->state = 0;
+	work->block_mdl = BoardModelCreate(DATA_MAKE_NUM(DATADIR_BLAST5, 11), NULL, 0);
+	work->min_y = pos->y+300.0f;
+	pos->y += 700.0f;
+	BoardModelPosSetV(work->block_mdl, pos);
+	object->trans.x = 1.0f;
+	BoardModelAlphaSet(work->block_mdl, 255);
+}
+
+static void UpdateLotteryDraw(omObjData *object)
+{
+	LotteryDrawWork *work = OM_GET_WORK_PTR(object, LotteryDrawWork);
+	Vec pos;
+	if(work->kill || BoardIsKill()) {
+		BoardModelKill(work->block_mdl);
+		lotteryDrawObj = NULL;
+		omDelObjEx(HuPrcCurrentGet(), object);
+		return;
+	}
+	switch(work->state) {
+		case 1:
+			BoardModelPosGet(work->block_mdl, &pos);
+			pos.y += 50.0f;
+			BoardModelPosSetV(work->block_mdl, &pos);
+			SetLotteryDrawState(2);
+			break;
+			
+		case 2:
+			BoardModelPosGet(work->block_mdl, &pos);
+			if(pos.y < work->min_y) {
+				pos.y = work->min_y;
+				SetLotteryDrawState(0);
+			}
+			pos.y -= 20.0f;
+			BoardModelPosSetV(work->block_mdl, &pos);
+			break;
+			
+		case 3:
+			object->trans.x -= 0.1f;
+			if(object->trans.x < 0.0f) {
+				object->trans.x = 0;
+				SetLotteryDrawState(0);
+			}
+			BoardModelAlphaSet(work->block_mdl, 255.0f*object->trans.x);
+			break;
+			
+		case 0:
+			break;
+			
+		default:
+			break;
+	}
+}
+
+static void SetLotteryDrawState(s32 state)
+{
+	LotteryDrawWork *work;
+	if(!lotteryDrawObj) {
+		return;
+	}
+	work = OM_GET_WORK_PTR(lotteryDrawObj, LotteryDrawWork);
+	work->state = state;
+	if(state == 4) {
+		work->kill = 1;
+	}
+	if(state == 3) {
+		lotteryDrawObj->trans.x = 1.0f;
+	}
+	if(state == 1) {
+		HuAudFXPlay(780);
+	}
+}
+
+static s32 GetLotteryDrawState(void)
+{
+	LotteryDrawWork *work = OM_GET_WORK_PTR(lotteryDrawObj, LotteryDrawWork);
+	return work->state;
+}
+
+static void KillLotteryDrawWheel(void)
+{
+	SetLotteryDrawWheelState(5);
+}
+
+static void UpdateLotteryDrawWheel(omObjData *object)
+{
+	DrawWheelWork *work = OM_GET_WORK_PTR(object, DrawWheelWork);
+	DrawWheelMdl *mdl = work->mdl;
+	s32 i;
+	if(work->kill || BoardIsKill()) {
+		BoardModelHookReset(wheelMdl);
+		for(i=0; i<4; i++) {
+			if(mdl->face[i] != -1) {
+				BoardModelKill(mdl->face[i]);
+			}
+			if(mdl->plate[i] != -1) {
+				BoardModelKill(mdl->plate[i]);
+			}
+		}
+		if(wheelMdl != -1) {
+			BoardModelKill(wheelMdl);
+			wheelMdl = -1;
+		}
+		if(lbl_801D3854 != -1) {
+			BoardModelKill(lbl_801D3854);
+			lbl_801D3854 = -1;
+		}
+		if(mdl->center != -1) {
+			BoardModelKill(mdl->center);
+		}
+		HuMemDirectFree(work->mdl);
+		lotteryDrawWheelObj = NULL;
+		omDelObjEx(HuPrcCurrentGet(), object);
+		return;
+	}
+	switch(work->state) {
+		case 4:
+			if(work->timer == 0) {
+				work->hilite_vel += work->hilite_accel;
+				work->hilite_accel++;
+				if(work->hilite_vel > 60 || (work->hilite_vel > 40 && BoardRandMod(100) > 80)) {
+					BoardModelMotionStart(mdl->center, 0, 0x40000001);
+					HuAudFXPlay(870);
+					SetLotteryDrawWheelState(0);
+					break;
+				}
+			}
+			
+		case 3:
+			if(work->timer < work->hilite_vel) {
+				work->timer++;
+			} else {
+				BoardModelHookObjReset(wheelMdl, hiliteObjNameTbl[work->hilite]);
+				work->hilite = (work->hilite+1)  & 0x3;
+				HuAudFXPlay(855);
+				BoardModelHookSet(wheelMdl, hiliteObjNameTbl[work->hilite], mdl->center);
+				work->timer = 0;
+			}
+			break;
+		
+		case 1:
+		case 2:
+			if(work->timer != 0) {
+				object->trans.x += object->rot.x;
+				object->trans.z += object->rot.z;
+				work->timer--;
+			} else {
+				BoardModelMotionSpeedSet(wheelMdl, 0);
+				work->state = 0;
+			}
+			break;
+			
+		case 0:
+			break;
+			
+		default:
+			break;
+	}
+	BoardModelPosSet(wheelMdl, object->trans.x, object->trans.y, object->trans.z);
+}
+
+static void SetLotteryDrawWheelState(s32 state)
+{
+	DrawWheelWork *work;
+	DrawWheelMdl *mdl;
+	Vec pos_wheel, pos_space, dist;
+	if(!lotteryDrawWheelObj) {
+		return;
+	}
+	work = OM_GET_WORK_PTR(lotteryDrawWheelObj, DrawWheelWork);
+	
+	work->state = state;
+	mdl = work->mdl;
+	switch(state) {
+		case 5:
+			work->kill = 1;
+			break;
+		
+		case 3:
+			work->timer = 0;
+			work->hilite = 0;
+			work->hilite_vel = 2;
+			BoardModelVisibilitySet(mdl->center, 1);
+			BoardModelMotionStart(mdl->center, 0, 0);
+			BoardModelMotionSpeedSet(mdl->center, 0.0f);
+			BoardModelMotionTimeSet(mdl->center, 3.0f);
+			BoardModelHookSet(wheelMdl, hiliteObjNameTbl[work->hilite], mdl->center);
+			break;
+			
+		default:
+			if(state == 2 || state == 1) {
+				BoardModelPosGet(wheelMdl, &pos_wheel);
+				if(state == 2) {
+					pos_space = spacePos;
+				} else {
+					pos_space.x = -300.0f+pos_wheel.x;
+					pos_space.y = pos_wheel.y;
+					pos_space.z = -50.0f+pos_wheel.z;
+				}
+				VECSubtract(&pos_space, &pos_wheel, &dist);
+				lotteryDrawWheelObj->rot.x = dist.x/26.0f;
+				lotteryDrawWheelObj->rot.z = dist.z/26.0f;
+				BoardModelMotionStart(wheelMdl, 0, 0x40000001);
+				BoardModelMotionSpeedSet(wheelMdl, 3.0f);
+				work->timer = 26;
+			}
+			break;
+	}
+}
+
+static s32 GetLotteryDrawWheelState()
+{
+	DrawWheelWork *work;
+	if(!lotteryDrawWheelObj) {
+		return -1;
+	}
+	work = OM_GET_WORK_PTR(lotteryDrawWheelObj, DrawWheelWork);
+	return work->state;
+}
+
+static s32 GetLotteryDrawWheelResult()
+{
+	DrawWheelWork *work;
+	if(!lotteryDrawWheelObj) {
+		return -1;
+	}
+	work = OM_GET_WORK_PTR(lotteryDrawWheelObj, DrawWheelWork);
+	return GWPlayer[work->hilite].character;
+}
+
+static void ExecLotteryDraw(void)
+{
+	s32 ticket;
+	s32 valid;
+	s32 character;
+	s32 stream;
+	s32 player;
+	Vec rot;
+	Vec offset;
+	Vec confetti_pos;
+	Vec pos;
+	Vec star_pos;
+	Vec host_end;
+	Vec host_start;
+	Vec player_end;
+	Vec player_start;
+
+	if(GWPlayer[0].field00_bit9 || GWPlayer[1].field00_bit9 || GWPlayer[2].field00_bit9 || GWPlayer[3].field00_bit9) {
+		BoardWinCreate(2, messBase+1, BoardWinPortraitGetStar());
+		BoardWinWait();
+		BoardModelPosGet(hostMdl, &host_end);
+		250.0f+host_end.y;
+		CreateLotteryDraw(&host_end);
+		SetLotteryDrawState(2);
+		SetLotteryDrawWheelState(2);
+		for(ticket=0; ticket<4; ticket++) {
+			SetLotteryTicketState(ticket, 3);
+		}
+		HuPrcSleep(15);
+		while(GetLotteryDrawWheelState() != 0) {
+			HuPrcVSleep();
+		}
+		offset.x = 50.0f;
+		offset.z = 0.0f;
+		offset.y = 100.0f;
+		valid = 0;
+		for(currTicket=ticket=0; ticket<3; ticket++, currTicket++) {
+			BoardCameraBackup();
+			SetLotteryDrawWheelState(3);
+			BoardWinCreate(2, 2+messBase+ticket, BoardWinPortraitGetStar());
+			BoardWinWait();
+			BoardModelMotionShiftSet(hostMdl, hostMot[7], 0, 8, 0);
+			HuPrcSleep(8);
+			while(BoardModelMotionTimeGet(hostMdl) < 26.0f) {
+				HuPrcVSleep();
+			}
+			SetLotteryDrawState(1);
+			HuPrcSleep(BoardRandMod(20));
+			SetLotteryDrawWheelState(4);
+			BoardCameraMotionStartEx(wheelMdl, NULL, &offset, 700, -1, 21);
+			while(!BoardModelMotionEndCheck(hostMdl)) {
+				HuPrcVSleep();
+			}
+			BoardModelMotionShiftSet(hostMdl, 1, 0, 8, 0x40000001);
+			while(GetLotteryDrawWheelState() != 0) {
+				HuPrcVSleep();
+			}
+			character = GetLotteryDrawWheelResult();
+			UpdateLotteryTicketMatch(ticket, character);
+			HuPrcSleep(120);
+			if(CheckLotteryTicket()) {
+				valid = 1;
+				break;
+			}
+			if(ticket == 2) {
+				player = GetLotteryTicketPlayer();
+				BoardModelPosGet(hostMdl, &confetti_pos);
+				confetti_pos.y += 400.0f;
+				BoardConfettiCreate(&confetti_pos, 100, 200.0f);
+				break;
+			}
+			BoardCameraRestore();
+			BoardCameraMotionWait();
+		}
+		rot.x = -10.0f;
+		rot.y = 0.0f;
+		rot.z = 0.0f;
+		BoardCameraMotionStartEx(focusMdl, &rot, NULL, 1480.0f, 25.0f, 20);
+		if(valid) {
+			BoardWinCreate(2, 9+messBase, BoardWinPortraitGetStar());
+			BoardWinWait();
+			SetLotteryDrawState(3);
+			SetLotteryDrawWheelState(1);
+			for(ticket=0; ticket<4; ticket++) {
+				SetLotteryTicketState(ticket, 4);
+			}
 		} else {
-			goto return0;
+			BoardAudSeqPause(1, 1, 1000);
+			BoardModelMotionShiftSet(hostMdl, hostMot[3], 0, 8, 0x40000001);
+			stream = HuAudSStreamPlay(10);
+			while(HuAudSStreamStatGet(stream)) {
+				HuPrcVSleep();
+			}
+			BoardAudSeqPause(1, 0, 1000);
+			BoardWinCreate(2, 5+messBase, BoardWinPortraitGetStar());
+			BoardWinWait();
+			BoardCameraRestore();
+			BoardCameraMotionWait();
+			SetLotteryDrawState(3);
+			SetLotteryDrawWheelState(1);
+			for(ticket=0; ticket<4; ticket++) {
+				SetLotteryTicketState(ticket, 4);
+			}
+			player_end.x = spacePos.x + -300.0f;
+			player_end.y = spacePos.y;
+			player_end.z = spacePos.z + -50.0f;
+			BoardPlayerPosSetV(player, &player_end);
+			BoardModelVisibilitySet(BoardPlayerModelGet(player), 1);
+			BoardModelPosGet(hostMdl, &host_end);
+			player_start = host_end;
+			host_start.x = host_end.x+200.0f;
+			host_start.y = host_end.y;
+			host_start.z = host_end.z;
+			StartHostMove(&host_end, &host_start, 25);
+			BoardPlayerPosLerpStart(player, &player_end, &player_start, 25);
+			while(GWPlayer[player].moving) {
+				HuPrcVSleep();
+			}
+			BoardPlayerIdleSet(player);
+			BoardModelMotionShiftSet(hostMdl, hostMot[0], 0, 8, 0x40000001);
+			while(!CheckHostMove()) {
+				HuPrcVSleep();
+			}
+			BoardModelMotionShiftSet(hostMdl, 1, 0, 8, 0x40000001);
+			BoardStatusShowSetForce(player);
+			BoardStatusShowSet(player, 1);
+			BoardPlayerMotBlendSet(player, 0, 7);
+			while(!BoardPlayerMotBlendCheck(player)) {
+				HuPrcVSleep();
+			}
+			BoardWinCreate(2, 6+messBase, BoardWinPortraitGetStar());
+			BoardWinWait();
+			BoardAudSeqPause(1, 1, 1000);
+			BoardModelMotionShiftSet(hostMdl, hostMot[1], 0, 8, 0);
+			star_pos.x = host_start.x;
+			star_pos.y = 60.0f+host_start.y;
+			star_pos.z = host_start.z;
+			HuPrcSleep(30);
+			BoardStarGive(player, &star_pos);
+			BoardAudSeqPause(1, 0, 1000);
+			BoardStatusShowSet(player, 0);
+			StartHostMove(&host_start, &host_end, 25);
+			BoardPlayerPosLerpStart(player, &player_start, &player_end, 25);
+			BoardModelMotionShiftSet(hostMdl, hostMot[0], 0, 8, 0x40000001);
+			while(!CheckHostMove()) {
+				HuPrcVSleep();
+			}
+			BoardModelMotionShiftSet(hostMdl, 1, 0, 8, 0x40000001);
+			while(GWPlayer[player].moving) {
+				HuPrcVSleep();
+			}
+			BoardPlayerIdleSet(player);
+			BoardModelVisibilitySet(BoardPlayerModelGet(player), 0);
+			BoardConfettiStop();
+			BoardModelVisibilitySet(wheelMdl, 0);
+		}
+		SetLotteryDrawState(4);
+		BoardWinCreate(2, 7+messBase, BoardWinPortraitGetStar());
+		BoardWinWait();
+		BoardWinKill();
+	}
+}
+
+static void KillLotteryTicket(void)
+{
+	s32 i;
+	for(i=0; i<numTickets; i++) {
+		SetLotteryTicketState(i, 5);
+	}
+}
+
+typedef struct ticket_work {
+	struct {
+		u8 kill : 1;
+		u8 player : 2;
+		u8 done : 1;
+		u8 index : 2;
+	};
+	s8 state;
+	u8 unk02;
+	s8 character[3];
+	u16 angle;
+	s16 group;
+} TicketWork;
+
+static void InitLotteryTicket(void)
+{
+	s32 i;
+	s32 j;
+	s32 playerSprTbl[] = {
+		DATA_MAKE_NUM(DATADIR_BLAST5, 0),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 1),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 2),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 3),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 4),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 5),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 6),
+		DATA_MAKE_NUM(DATADIR_BLAST5, 7),
+	};
+	s32 ownerSprTbl[] = {
+		DATA_MAKE_NUM(DATADIR_BOARD, 46),
+		DATA_MAKE_NUM(DATADIR_BOARD, 47),
+		DATA_MAKE_NUM(DATADIR_BOARD, 48),
+		DATA_MAKE_NUM(DATADIR_BOARD, 49),
+		DATA_MAKE_NUM(DATADIR_BOARD, 50),
+		DATA_MAKE_NUM(DATADIR_BOARD, 51),
+		DATA_MAKE_NUM(DATADIR_BOARD, 52),
+		DATA_MAKE_NUM(DATADIR_BOARD, 53),
+	};
+	s32 character;
+	s16 sprite;
+	s32 member;
+	u8 ticket_mask;
+	omObjData *object;
+	TicketWork *work;
+	currTicket = 0;
+	lotteryTicketObj[0] = lotteryTicketObj[1] = lotteryTicketObj[2] = lotteryTicketObj[3] = NULL;
+	for(numTickets=i=0; i<4; i++) {
+		if(!GWPlayer[i].field00_bit9) {
+			continue;
+		}
+		object = omAddObjEx(boardObjMan, 257, 0, 0, -1, UpdateLotteryTicket);
+		lotteryTicketObj[numTickets] = object;
+		work = OM_GET_WORK_PTR(object, TicketWork);
+		work->kill = 0;
+		work->player = i;
+		work->index = numTickets;
+		work->angle = 0;
+		work->unk02 = 0;
+		work->done = 0;
+		work->group = HuSprGrpCreate(6);
+		object->trans.x = 680.0f;
+		object->trans.y = 64.0f+(82.0f*numTickets);
+		object->rot.x = 0.0f;
+		object->rot.y = 0.0f;
+		HuSprGrpPosSet(work->group, object->trans.x, object->trans.y);
+		HuSprGrpScaleSet(work->group, 0.4f, 0.4f);
+		BoardSpriteCreate(DATA_MAKE_NUM(DATADIR_BLAST5, 9), 2000, NULL, &sprite);
+		HuSprGrpMemberSet(work->group, 0, sprite);
+		HuSprAttrSet(work->group, 0, HUSPR_ATTR_LINEAR);
+		HuSprScaleSet(work->group, 0, 2.5f, 2.5f);
+		character = GWPlayer[i].character;
+		BoardSpriteCreate(ownerSprTbl[character], 1200, NULL, &sprite);
+		HuSprGrpMemberSet(work->group, 5, sprite);
+		HuSprAttrSet(work->group, 5, HUSPR_ATTR_LINEAR);
+		HuSprScaleSet(work->group, 5, 2.5f, 2.5f);
+		HuSprPosSet(work->group, 5, -200, -32);
+		HuSprScaleSet(work->group, 5, 1.75f, 1.75f);
+		BoardSpriteCreate(DATA_MAKE_NUM(DATADIR_BLAST5, 8), 1200, NULL, &sprite);
+		HuSprGrpMemberSet(work->group, 4, sprite);
+		HuSprAttrSet(work->group, 4, HUSPR_ATTR_LINEAR);
+		HuSprAttrSet(work->group, 4, HUSPR_ATTR_DISPOFF);
+		HuSprAttrSet(work->group, 4, HUSPR_ATTR_ADDCOL);
+		HuSprScaleSet(work->group, 4, 1.3f, 1.3f);
+		ticket_mask = GWPlayer[i].field00_bitA;
+		j=3;
+		while(j>=0) {
+			s32 player_spr;
+			
+			j--;
+			work->character[j] = GWPlayer[ticket_mask & 0x3].character;
+			player_spr = playerSprTbl[work->character[j]];
+			member = j+1;
+			BoardSpriteCreate(player_spr, 1500, NULL, &sprite);
+			HuSprGrpMemberSet(work->group, member, sprite);
+			HuSprAttrSet(work->group, member, HUSPR_ATTR_LINEAR);
+			HuSprPosSet(work->group, member, playerOfsTbl[j][0], playerOfsTbl[j][1]);
+			ticket_mask >>= 2;
+		}
+		numTickets++;
+	}
+}
+
+static void UpdateLotteryTicket(omObjData *object)
+{
+	TicketWork *work = OM_GET_WORK_PTR(object, TicketWork);
+	if(work->kill || BoardIsKill()) {
+		HuSprGrpKill(work->group);
+		omDelObjEx(HuPrcCurrentGet(), object);
+		lotteryTicketObj[work->index] = NULL;
+		return;
+	}
+	switch(work->state) {
+		case 2:
+			if(work->angle < 540) {
+				float scale = 0.4f+(0.1f*sin(M_PI*(float)(work->angle%180)/180.0));
+				HuSprGrpScaleSet(work->group, scale, scale);
+				work->angle += 9;
+			} else {
+				work->angle = 0;
+				work->state = 0;
+				HuSprGrpScaleSet(work->group, 0.4f, 0.4f);
+			}
+			break;
+			
+		case 1:
+			if(work->angle > 96) {
+				u16 color = work->angle;
+				HuSprColorSet(work->group, 0, color, color, color);
+				HuSprColorSet(work->group, 1, color, color, color);
+				HuSprColorSet(work->group, 2, color, color, color);
+				HuSprColorSet(work->group, 3, color, color, color);
+				HuSprColorSet(work->group, 5, color, color, color);
+				work->angle -= 3;
+			} else {
+				work->angle = 0;
+				work->state = 0;
+			}
+			break;
+			
+		case 3:
+		case 4:
+			if(work->angle != 0) {
+				object->trans.x += object->rot.x;
+				
+				HuSprGrpPosSet(work->group, object->trans.x, object->trans.y);
+				work->angle--;
+			} else {
+				if(work->state == 4) {
+					BoardModelVisibilitySet(wheelMdl, 0);
+				}
+				SetLotteryTicketState(work->player, 0);
+			}
+			break;
+			
+		case 0:
+			break;
+		
+		default:
+			break;
+			
+			
+	}
+}
+
+static void SetLotteryTicketState(s32 player, s32 state)
+{
+	TicketWork *work;
+	omObjData *object;
+	s32 i;
+	for(i=0; i<numTickets; i++) {
+		object = lotteryTicketObj[i];
+		if(!object) {
+			continue;
+		}
+		work = OM_GET_WORK_PTR(object, TicketWork);
+		if(work->player == player) {
+			work->state = state;
+			work->angle = 0;
+			switch(state) {
+				case 2:
+					HuSprAttrReset(work->group, 4, HUSPR_ATTR_DISPOFF);
+					HuSprPosSet(work->group, 4, playerOfsTbl[currTicket][0], playerOfsTbl[currTicket][1]);
+					break;
+					
+				case 1:
+					work->angle = 255;
+					work->done = 1;
+					HuSprAttrSet(work->group, 4, HUSPR_ATTR_DISPOFF);
+					break;
+					
+				case 3:
+					object->rot.x = 472.0f-object->trans.x;
+					object->rot.x /= 15.0f;
+					work->angle = 15;
+					break;
+					
+				case 4:
+					object->rot.x = 680.0f-object->trans.x;
+					object->rot.x /= 15.0f;
+					work->angle = 15;
+					break;
+					
+				case 5:
+					work->kill = 1;
+					
+				default:
+					break;
+			}
+			return;
+		}
+		
+	}
+}
+
+static s32 GetLotteryTicketPlayer(void)
+{
+	s32 i;
+	for(i=0; i<numTickets; i++) {
+		omObjData *object = lotteryTicketObj[i];
+		TicketWork *work = OM_GET_WORK_PTR(object, TicketWork);
+		if(!work->done) {
+			return work->player;
 		}
 	}
-	if(HuPadBtnDown[GWPlayer[player].port] == PAD_BUTTON_A) {
-		return 1;
-	} else {
-		return0:
+	return -1;
+}
+
+static s32 CheckLotteryTicket(void)
+{
+	TicketWork *work;
+	omObjData *object;
+	
+	s32 i;
+	for(i=0; i<numTickets; i++) {
+		object = lotteryTicketObj[i];
+		work = OM_GET_WORK_PTR(object, TicketWork);
+		if(!work->done) {
+			return 0;
+		}
+	}
+	return 1;
+}
+
+static void UpdateLotteryTicketMatch(s32 progress, s32 character)
+{
+	s32 i;
+	TicketWork *work;
+	omObjData *object;
+	s32 match_state;
+	
+	for(i=0; i<numTickets; i++) {
+		object = lotteryTicketObj[i];
+		work = OM_GET_WORK_PTR(object, TicketWork);
+		if(!work->done) {
+			if(work->character[progress] == character) {
+				match_state = 2;
+			} else {
+				match_state = 1;
+			}
+			SetLotteryTicketState(work->player, match_state);
+		}
+	}
+}
+
+typedef struct host_move_work {
+	struct {
+		u8 kill : 1;
+		u8 finish : 1;
+	};
+	u8 state;
+	s16 time;
+	s16 angle;
+	s16 angle_end;
+} HostMoveWork;
+
+static void StartHostMove(Vec *from, Vec *to, s16 time)
+{
+	HostMoveWork *work;
+	omObjData *object;
+	float duration;
+	float angle;
+	if(time <= 0) {
+		time = 1;
+	}
+	object = omAddObjEx(boardObjMan, 257, 0, 0, -1, ExecHostMove);
+	hostMoveObj = object;
+	work = OM_GET_WORK_PTR(object, HostMoveWork);
+	work->kill = 0;
+	work->finish = 0;
+	work->time = time;
+	work->state = 0;
+	OSs16tof32(&time, &duration);
+	omSetTra(object, from->x, from->y, from->z);
+	omSetRot(object, (to->x-from->x)/duration, 0.0f, (to->z-from->z)/duration);
+	omSetSca(object, to->x, to->y, to->z);
+	angle = 180.0*(atan2(object->rot.x, object->rot.z)/M_PI);
+	work->angle = 0;
+	OSf32tos16(&angle, &work->angle_end);
+	BoardModelMotionShiftSet(hostMdl, hostMot[0], 0, 8, 0x40000001);
+	BoardModelMotionSpeedSet(hostMdl, 3.0f);
+}
+
+static void ExecHostMove(omObjData *object)
+{
+	HostMoveWork *work = OM_GET_WORK_PTR(object, HostMoveWork);
+	float angle;
+	float angle_end;
+	if(work->kill || BoardIsKill()) {
+		hostMoveObj = NULL;
+		omDelObjEx(HuPrcCurrentGet(), object);
+		return;
+	}
+	OSs16tof32(&work->angle, &angle);
+	OSs16tof32(&work->angle_end, &angle_end);
+	switch(work->state) {
+		case 0:
+			if(BoardDAngleCalcRange(&angle, angle_end, 10.0f)) {
+				if(work->finish) {
+					work->kill = 1;
+				} else {
+					work->state = 1;
+				}
+				BoardModelMotionSpeedSet(hostMdl, 1.0f);
+			}
+			OSf32tos16(&angle, &work->angle);
+			BoardModelRotYSet(hostMdl, angle);
+			break;
+			
+		case 1:
+			if(work->time) {
+				work->time--;
+				object->trans.x += object->rot.x;
+				object->trans.y += object->rot.y;
+				object->trans.z += object->rot.z;
+			} else {
+				object->trans.x = object->scale.x;
+				object->trans.y = object->scale.y;
+				object->trans.z = object->scale.z;
+				work->angle_end = 0;
+				work->finish = 1;
+				work->state = 0;
+				BoardModelMotionSpeedSet(hostMdl, 3.0f);
+			}
+			break;
+			
+		default:
+			break;
+	}
+	BoardModelPosSet(hostMdl, object->trans.x, object->trans.y, object->trans.z);
+}
+
+static s32 CheckHostMove(void)
+{
+	if(hostMoveObj) {
 		return 0;
+	} else {
+		return 1;
+	}
+}
+
+static void CreateStopWin(void)
+{
+	s32 mess = 0x120011;
+	float size[2];
+	float pos_x, pos_y;
+	HuWinMesMaxSizeGet(1, size, mess);
+	pos_x = -10000;
+	pos_y = 352;
+	stopWin = HuWinCreate(pos_x, pos_y, size[0], size[1], 0);
+	HuWinBGTPLvlSet(stopWin, 0.0f);
+	HuWinMesSpeedSet(stopWin, 0);
+	HuWinMesSet(stopWin, mess);
+}
+
+typedef struct last5_roulette_work {
+	struct {
+		u8 kill : 1;
+		u8 state : 3;
+	};
+	s8 choice;
+	s8 fade_speed;
+	s8 choices[4];
+	s16 alpha;
+	u16 switch_timer;
+	u8 switch_vel;
+	u8 switch_accel;
+	s16 model;
+} Last5RouletteWork;
+
+static void CreateLast5Roulette(void)
+{
+	Last5RouletteWork *work;
+	omObjData *object;
+	s32 choice1, choice2;
+	Vec pos;
+	object = omAddObjEx(boardObjMan, 257, 0, 0, -1, UpdateLast5Roulette);
+	last5RouletteObj = object;
+	work = OM_GET_WORK_PTR(object, Last5RouletteWork);
+	work->kill = 0;
+	work->choice = 0;
+	work->switch_timer = 0;
+	work->switch_vel = 4;
+	work->state = 2;
+	work->alpha = 0;
+	work->fade_speed = 0;
+	work->switch_accel = 5;
+	choice1 = BoardRandMod(3)+2;
+	do {
+		choice2 = BoardRandMod(3)+2;
+	} while(choice1 == choice2);
+	work->choices[0] = 1;
+	work->choices[1] = 1;
+	work->choices[2] = choice1;
+	work->choices[3] = choice2;
+	work->model = BoardModelCreate(DATA_MAKE_NUM(DATADIR_BLAST5, 10), NULL, 0);
+	pos.x = 150.0f+spacePos.x;
+	pos.y = 177.0f+spacePos.y;
+	pos.z = -135.0f+spacePos.z;
+	BoardModelPosSetV(work->model, &pos);
+	BoardModelMotionStart(work->model, 0, 0);
+	BoardModelMotionSpeedSet(work->model, 0);
+}
+
+static void UpdateLast5Roulette(omObjData *object)
+{
+	Last5RouletteWork *work = OM_GET_WORK_PTR(object, Last5RouletteWork);
+	if(work->kill || BoardIsKill()) {
+		BoardModelHookReset(wheelMdl);
+		if(work->model != -1) {
+			BoardModelKill(work->model);
+		}
+		last5RouletteObj = NULL;
+		omDelObjEx(HuPrcCurrentGet(), object);
+		return;
+	}
+	
+	switch(work->state) {
+		case 3:
+			if(work->switch_timer == 0) {
+				work->switch_vel += work->switch_accel;
+				work->switch_accel++;
+				if(work->switch_vel > 60 || (work->switch_vel > 40 && BoardRandMod(100) > 80)) {
+					if((GWBoardGet() == 0 || GWBoardGet() == 2) && work->choices[work->choice] == 2) {
+						work->switch_timer++;
+						return;
+					} else {
+						HuAudFXPlay(870);
+						SetLast5RouletteState(0);
+						break;
+					}
+				}
+			}
+			
+		case 2:
+			if(work->switch_timer < work->switch_vel) {
+				work->switch_timer++;
+			} else {
+				s32 choice = work->choices[work->choice];
+				float time;
+				do {
+					work->choice = BoardRandMod(4);
+				} while(work->choices[work->choice] == choice);
+				OSs8tof32(&work->choices[work->choice], &time);
+				HuAudFXPlay(855);
+				BoardModelMotionTimeSet(work->model, 0.1f+time);
+				work->switch_timer = 0;
+			}
+			break;
+			
+		case 0:
+			break;
+			
+		default:
+			break;
+	}
+	if(work->fade_speed) {
+		work->alpha += work->fade_speed;
+		if(work->alpha >= 255) {
+			work->alpha = 255;
+			work->fade_speed = 0;
+		}
+		if(work->alpha < 0) {
+			work->alpha = 0;
+			work->fade_speed = 0;
+		}
+		BoardModelAlphaSet(work->model, work->alpha);
+	}
+}
+
+static void SetLast5RouletteFade(s32 flag)
+{
+	Last5RouletteWork *work;
+	if(!last5RouletteObj) {
+		return;
+	}
+	work = OM_GET_WORK_PTR(last5RouletteObj, Last5RouletteWork);
+	if(flag) {
+		work->fade_speed = 4;
+	} else {
+		work->fade_speed = -4;
+	}
+}
+
+static void SetLast5RouletteState(s32 state)
+{
+	Last5RouletteWork *work;
+	if(!last5RouletteObj) {
+		return;
+	}
+	work = OM_GET_WORK_PTR(last5RouletteObj, Last5RouletteWork);
+	work->state = state;
+}
+
+static s32 GetLast5RouletteState(void)
+{
+	Last5RouletteWork *work;
+	if(!last5RouletteObj) {
+		return -1;
+	}
+	work = OM_GET_WORK_PTR(last5RouletteObj, Last5RouletteWork);
+	return work->state;
+}
+
+static s32 GetLast5RouletteResult(void)
+{
+	Last5RouletteWork *work;
+	if(!last5RouletteObj) {
+		return -1;
+	}
+	work = OM_GET_WORK_PTR(last5RouletteObj, Last5RouletteWork);
+	return work->choices[work->choice];
+}
+
+typedef struct team_result_work {
+	struct {
+		u8 kill : 1;
+	};
+	u8 delay;
+	u8 player[2][2];
+	s16 group[2];
+} TeamResultWork;
+
+static void CreateTeamResultWork(TeamResultWork *work);
+
+static void CreateTeamResult(void)
+{
+	TeamResultWork *work;
+	omObjData *object;
+	s32 i;
+	s32 j;
+	s32 coins[2];
+	s32 stars[2];
+	u32 score[2];
+	s32 team, player;
+	s32 rank1, rank2;
+	object = omAddObjEx(boardObjMan, 268, 0, 0, -1, UpdateTeamResult);
+	teamResultObj = object;
+	work = OM_GET_WORK_PTR(object, TeamResultWork);
+	CreateTeamResultWork(work);
+	coins[0] = coins[1] = stars[0] = stars[1] = 0;
+	for(i=0; i<2; i++) {
+		for(j=0; j<2; j++) {
+			coins[i] += BoardPlayerCoinsGet(work->player[i][j]);
+			stars[i] += GWStarsGet(work->player[i][j]);
+		}
+	}
+	for(i=0; i<2; i++) {
+		score[i] = coins[i]+(stars[i] << 11);
+	}
+	team = BoardRandMod(2);
+	player = BoardRandMod(2);
+	if(score[0] >= score[1]) {
+		object->trans.x = -108.0f;
+		object->trans.y = 152.0f;
+		object->rot.x = -108.0f;
+		object->rot.y = 302.0f;
+		if(score[0] == score[1]) {
+			last5Player = work->player[team][player];
+		} else {
+			rank1 = GWPlayer[work->player[1][0]].rank;
+			rank2 = GWPlayer[work->player[1][1]].rank;
+			if(rank1 == rank2) {
+				last5Player = work->player[1][player];
+			} else {
+				if(rank1 < rank2) {
+					last5Player = work->player[1][1];
+				} else {
+					last5Player = work->player[1][0];
+				}
+			}
+		}
+	} else {
+		object->rot.x = -108.0f;
+		object->rot.y = 152.0f;
+		object->trans.x = -108.0f;
+		object->trans.y = 302.0f;
+		rank1 = GWPlayer[work->player[0][0]].rank;
+		rank2 = GWPlayer[work->player[0][1]].rank;
+		if(rank1 == rank2) {
+			last5Player = work->player[0][player];
+		} else {
+			if(rank1 < rank2) {
+				last5Player = work->player[0][1];
+			} else {
+				last5Player = work->player[0][0];
+			}
+		}
+	}
+}
+
+static void CreateTeamResultWork(TeamResultWork *work)
+{
+	GXColor color = { 128, 128, 128, 0 };
+	s32 i;
+	s32 character;
+	s16 group;
+	s32 j;
+	s32 team1_idx, team2_idx;
+	s16 sprite;
+	s32 spr_file;
+	s16 prio;
+	float x, y;
+	for(team1_idx=team2_idx=i=0; i<4; i++) {
+		s32 team = GWPlayer[i].team;
+		if(team == 0) {
+			work->player[0][team1_idx] = i;
+			team1_idx++;
+		} else {
+			work->player[1][team2_idx] = i;
+			team2_idx++;
+		}
+	}
+	for(j=0; j<2; j++) {
+		group = HuSprGrpCreate(15);
+		work->group[j] = group;
+		for(i=0; i<13; i++) {
+			spr_file = teamSprTbl[i];
+			prio = teamSprPrioTbl[i];
+			
+			BoardSpriteCreate(spr_file, prio, NULL, &sprite);
+			HuSprGrpMemberSet(group, i, sprite);
+			HuSprAttrSet(group, i, HUSPR_ATTR_NOANIM);
+			HuSprAttrSet(group, i, HUSPR_ATTR_LINEAR);
+			HuSprPosSet(group, i, teamSprPosTbl[i][0], teamSprPosTbl[i][1]);
+		}
+		HuSprTPLvlSet(group, 0, 0.7f);
+		HuSprScaleSet(group, 0, 1.0f, 2.5f);
+		HuSprColorSet(group, 0, color.r, color.g, color.b);
+		if(!GWPlayer[work->player[j][0]].com) {
+			HuSprAttrSet(group, 11, HUSPR_ATTR_DISPOFF);
+		}
+		if(!GWPlayer[work->player[j][1]].com) {
+			HuSprAttrSet(group, 12, HUSPR_ATTR_DISPOFF);
+		}
+		if(j == 0) {
+			HuSprBankSet(group, 1, 2);
+		} else {
+			HuSprBankSet(group, 1, 1);
+		}
+		for(i=0; i<2; i++) {
+			character = GWPlayer[work->player[j][i]].character;
+			BoardSpriteCreate(teamCharSprTbl[character], 1500, NULL, &sprite);
+			HuSprGrpMemberSet(group, i+13, sprite);
+			HuSprAttrSet(group, i+13, HUSPR_ATTR_LINEAR);
+			x = teamSprPosTbl[i+13][0];
+			y = teamSprPosTbl[i+13][1];
+			HuSprPosSet(group, i+13, x, y);
+		}
+	}
+}
+
+static void SetTeamResultTarget(s32 team, Vec *pos)
+{
+	if(!teamResultObj || !pos) {
+		return;
+	}
+	if(team) {
+		teamResultObj->rot.x = pos->x;
+		teamResultObj->rot.y = pos->y;
+	} else {
+		teamResultObj->trans.x = pos->x;
+		teamResultObj->trans.y = pos->y;
+	}
+}
+
+static void GetTeamResultTarget(s32 team, Vec *pos)
+{
+	if(!teamResultObj || !pos) {
+		return;
+	}
+	if(team) {
+		pos->x = teamResultObj->rot.x;
+		pos->y = teamResultObj->rot.y;
+	} else {
+		pos->x = teamResultObj->trans.x;
+		pos->y = teamResultObj->trans.y;
+	}
+}
+
+static void KillTeamResult(void)
+{
+	TeamResultWork *work;
+	if(!teamResultObj) {
+		return;
+	}
+	work = OM_GET_WORK_PTR(teamResultObj, TeamResultWork);
+	work->kill = 1;
+}
+
+static void UpdateTeamResult(omObjData *object)
+{
+	TeamResultWork *work;
+	s32 i, j;
+	work = OM_GET_WORK_PTR(object, TeamResultWork);
+	if(work->kill || BoardIsKill()) {
+		HuSprGrpKill(work->group[0]);
+		HuSprGrpKill(work->group[1]);
+		teamResultObj = NULL;
+		omDelObjEx(HuPrcCurrentGet(), object);
+		return;
+	}
+	if(work->delay) {
+		work->delay--;
+		return;
+	}
+	{
+		s8 rank[2];
+		u32 score[2];
+		s32 coins[2];
+		s32 stars[2];
+		
+		
+		
+		coins[0] = coins[1] = stars[0] = stars[1] = 0;
+		for(i=0; i<2; i++) {
+			for(j=0; j<2; j++) {
+				coins[i] += BoardPlayerCoinsGet(work->player[i][j]);
+				stars[i] += GWStarsGet(work->player[i][j]);
+			}
+		}
+		for(i=0; i<2; i++) {
+			s32 star_val;
+			s32 coin_val;
+			
+			score[i] = coins[i]+(stars[i] << 11);
+			coin_val = coins[i];
+			if(coin_val > 999) {
+				coin_val = 999;
+			}
+			star_val = stars[i];
+			if(star_val > 999) {
+				star_val = 999;
+			}
+			BoardSpriteDigitUpdate(work->group[i], 3, coin_val);
+			BoardSpriteDigitUpdate(work->group[i], 7, star_val);
+		}
+		if(score[0] == score[1]) {
+			rank[0] = rank[1] = 0;
+		} else if(score[0] > score[1]) {
+			rank[0] = 0;
+			rank[1] = 1;
+		} else {
+			rank[1] = 0;
+			rank[0] = 1;
+		}
+		HuSprBankSet(work->group[0], 2, rank[0]);
+		HuSprBankSet(work->group[1], 2, rank[1]);
+		HuSprGrpPosSet(work->group[0], object->trans.x, object->trans.y);
+		HuSprGrpPosSet(work->group[1], object->rot.x, object->rot.y);
 	}
 }
\ No newline at end of file