Merge branch 'main' of https://github.com/abnormalhare/mp4-dtk

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
@@ -1921,13 +1921,13 @@ 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
-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
@@ -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
@@ -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
@@ -5231,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
+wheelSprPrio = .data:0x8013A270; // type:object size:0xE scope:local data:byte
-wheelCharIconPrioTbl = .data:0x8013A27A; // type:object size:0x4 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
@@ -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
+teamSprPrioTbl = .data:0x8013B304; // type:object size:0x1E scope:local
-lotterySprTbl = .data:0x8013B324; // type:object size:0x34 scope:local
+teamSprTbl = .data:0x8013B324; // type:object size:0x34 scope:local
-lotterySprPosTbl = .data:0x8013B358; // type:object size:0x78 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

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"),
@@ -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"),

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*);

include/game/animdata.h

@@ -0,0 +1,83 @@
+#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 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

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

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

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"
@@ -115,32 +114,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 BoardPlayerIdleSet(s32);
-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,22 +139,16 @@ 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);
+void BoardPlayerResizeAnimExec(s32 player, s32 size);
-s32 MegaPlayerPassFunc(s32, s16);
 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*);
 
 #endif

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;

include/game/board/window.h

@@ -2,7 +2,6 @@
 #define _BOARD_WINDOW_H
 
 #include "game/window.h"
-#include "game/process.h"
 
 typedef void (*BoardWinComKeyFunc)();
 

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

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));

include/game/sprite.h

@@ -5,111 +5,36 @@
 #include "game/data.h"
 #include "game/memory.h"
 
-#define SPRITE_MAX 384
+#define HUSPR_MAX 384
-#define SPRITE_GROUP_MAX 256
+#define HUSPR_GRP_MAX 256
 
-#define SPRITE_INVALID -1
+#define HUSPR_NONE -1
-#define SPRITE_GROUP_INVALID -1
+#define HUSPR_GRP_NONE -1
 
-#define SPRITE_ATTR_PAUSED 0x1
+#define HUSPR_ATTR_NOANIM 0x1
-#define SPRITE_ATTR_LOOP 0x2
+#define HUSPR_ATTR_LOOP 0x2
-#define SPRITE_ATTR_HIDDEN 0x4
+#define HUSPR_ATTR_DISPOFF 0x4
-#define SPRITE_ATTR_BILINEAR 0x8
+#define HUSPR_ATTR_LINEAR 0x8
-#define SPRITE_ATTR_FUNC 0x10
+#define HUSPR_ATTR_FUNC 0x10
-#define SPRITE_ATTR_NOPAUSE 0x20
+#define HUSPR_ATTR_NOPAUSE 0x20
-#define SPRITE_ATTR_REVERSE 0x40
+#define HUSPR_ATTR_REVERSE 0x40
-#define SPRITE_ATTR_ADDITIVE 0x80
+#define HUSPR_ATTR_ADDCOL 0x80
-#define SPRITE_ATTR_INVERT 0x100
+#define HUSPR_ATTR_INVCOL 0x100
 
-#define SPRITE_BMP_RGBA8 0
+#include "game/animdata.h"
-#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
 
-#define SPRITE_BMP_FMTMASK 0xF
+typedef void (*HuSprFunc)(struct hu_sprite *);
-#define SPRITE_BMP_ALLOC 0x8000
-#define SPRITE_BMP_NUM_MASK 0x7FFF
 
-#define SPRITE_LAYER_FLIPX 0x1
+typedef struct hu_sprite {
-#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 {
     u8 r;
     u8 g;
     u8 b;
-    char draw_no;
+    u8 draw_no;
-    short frame;
+    s16 frame;
-    short bank;
+    s16 bank;
-    short attr;
+    s16 attr;
-    short dirty_flag;
+    s16 dirty_flag;
-    short prio;
+    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;
+    s16 tex_scale_x;
-    short tex_scale_y;
+    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;
+    u16 bg_bank;
-    short scissor_x;
+    s16 scissor_x;
-    short scissor_y;
+    s16 scissor_y;
-    short scissor_w;
+    s16 scissor_w;
-    short scissor_h;
+    s16 scissor_h;
-} SpriteData;
+} HuSprite;
 
-typedef struct sprite_group_data {
+typedef struct hu_spr_grp {
-    short capacity;
+    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 HuSprite HuSprData[HUSPR_MAX];
-extern SpriteGroupData HuSprGrpData[SPRITE_GROUP_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);
+s16 HuSprCreate(AnimData *anim, s16 prio, s16 bank);
-short HuSprFuncCreate(SpriteFunc func, short prio);
+s16 HuSprFuncCreate(HuSprFunc func, s16 prio);
-short HuSprGrpCreate(short capacity);
+s16 HuSprGrpCreate(s16 capacity);
-short HuSprGrpCopy(short group);
+s16 HuSprGrpCopy(s16 group);
-void HuSprGrpMemberSet(short group, short member, short sprite);
+void HuSprGrpMemberSet(s16 group, s16 member, s16 sprite);
-void HuSprGrpMemberKill(short group, short member);
+void HuSprGrpMemberKill(s16 group, s16 member);
-void HuSprGrpKill(short group);
+void HuSprGrpKill(s16 group);
-void HuSprKill(short sprite);
+void HuSprKill(s16 sprite);
 void HuSprAnimKill(AnimData *anim);
-void HuSprAttrSet(short group, short member, int attr);
+void HuSprAttrSet(s16 group, s16 member, s32 attr);
-void HuSprAttrReset(short group, short member, int attr);
+void HuSprAttrReset(s16 group, s16 member, s32 attr);
-void HuSprPosSet(short group, short member, float x, float y);
+void HuSprPosSet(s16 group, s16 member, float x, float y);
-void HuSprZRotSet(short group, short member, float z_rot);
+void HuSprZRotSet(s16 group, s16 member, float z_rot);
-void HuSprScaleSet(short group, short member, float x, float y);
+void HuSprScaleSet(s16 group, s16 member, float x, float y);
-void HuSprTPLvlSet(short group, short member, float tp_lvl);
+void HuSprTPLvlSet(s16 group, s16 member, float tp_lvl);
-void HuSprColorSet(short group, short member, u8 r, u8 g, u8 b);
+void HuSprColorSet(s16 group, s16 member, u8 r, u8 g, u8 b);
-void HuSprSpeedSet(short group, short member, float speed);
+void HuSprSpeedSet(s16 group, s16 member, float speed);
-void HuSprBankSet(short group, short member, short bank);
+void HuSprBankSet(s16 group, s16 member, s16 bank);
-void HuSprGrpPosSet(short group, float x, float y);
+void HuSprGrpPosSet(s16 group, float x, float y);
-void HuSprGrpCenterSet(short group, float x, float y);
+void HuSprGrpCenterSet(s16 group, float x, float y);
-void HuSprGrpZRotSet(short group, float z_rot);
+void HuSprGrpZRotSet(s16 group, float z_rot);
-void HuSprGrpScaleSet(short group, float x, float y);
+void HuSprGrpScaleSet(s16 group, float x, float y);
-void HuSprGrpTPLvlSet(short group, float tp_lvl);
+void HuSprGrpTPLvlSet(s16 group, float tp_lvl);
-s32 HuSprGrpDrawNoSet(short group, int draw_no);
+s32 HuSprGrpDrawNoSet(s16 group, s32 draw_no);
-void HuSprDrawNoSet(short group, short member, int draw_no);
+void HuSprDrawNoSet(s16 group, s16 member, s32 draw_no);
-void HuSprPriSet(short group, short member, short prio);
+void HuSprPriSet(s16 group, s16 member, s16 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);
-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);
-AnimData *HuSprAnimMake(short sizeX, short sizeY, short dataFmt);
+AnimData *HuSprAnimMake(s16 sizeX, s16 sizeY, s16 dataFmt);
-void HuSprBGSet(short group, short member,  AnimData *bg, short bg_bank);
+void HuSprBGSet(s16 group, s16 member,  AnimData *bg, s16 bg_bank);
-void HuSprSprBGSet(short sprite, AnimData *bg, short bg_bank);
+void HuSprSprBGSet(s16 sprite, AnimData *bg, s16 bg_bank);
 void AnimDebug(AnimData *anim);
 
 void HuSprDispInit(void);
-void HuSprDisp(SpriteData *sprite);
+void HuSprDisp(HuSprite *sprite);
-void HuSprTexLoad(AnimData *anim, short bmp, short slot, GXTexWrapMode wrap_s, GXTexWrapMode wrap_t, GXTexFilter filter);
+void HuSprTexLoad(AnimData *anim, s16 bmp, s16 slot, GXTexWrapMode wrap_s, GXTexWrapMode wrap_t, GXTexFilter filter);
-void HuSprExecLayerSet(short draw_no, short layer);
+void HuSprExecLayerSet(s16 draw_no, s16 layer);
 
 #endif

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);
+		HuSprAttrSet(group, 0, HUSPR_ATTR_DISPOFF);
-		HuSprAttrReset(group, 1, SPRITE_ATTR_HIDDEN);
+		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, 0, HUSPR_ATTR_DISPOFF);
-		HuSprAttrSet(group, 1, SPRITE_ATTR_HIDDEN);
+		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, 0, HUSPR_ATTR_DISPOFF);
-	HuSprAttrReset(titleGroup, 1, SPRITE_ATTR_HIDDEN);
+	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, 0, HUSPR_ATTR_DISPOFF);
-	HuSprAttrSet(titleGroup, 1, SPRITE_ATTR_HIDDEN);
+	HuSprAttrSet(titleGroup, 1, HUSPR_ATTR_DISPOFF);
-	HuSprAttrSet(titleGroup, 2, SPRITE_ATTR_HIDDEN);
+	HuSprAttrSet(titleGroup, 2, HUSPR_ATTR_DISPOFF);
-	HuSprAttrSet(titleGroup, 3, SPRITE_ATTR_HIDDEN);
+	HuSprAttrSet(titleGroup, 3, HUSPR_ATTR_DISPOFF);
 	return 0;
 }
 

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];
@@ -541,7 +542,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;
             }

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;

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);

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) {

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"

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"

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) {

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);

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) {

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;
+    }
+}

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);
@@ -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]);

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) {

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);
 
@@ -2019,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);
@@ -2106,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);
 		}
 	}
 }

src/game/board/player.c

@@ -6,12 +6,44 @@
 #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"
 #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 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 player, s32 space);
+static s32 MegaExecJump(s32 player, s32 space);
+
 //TODO: Give better name
 typedef struct bitcopy {
     struct {
@@ -89,9 +121,12 @@ static s32 bowserSuitCharMdlTbl[] = {
 
 static s32 bowserSuitMotTbl[] = {
     0x40019, 0x4001A, 0x4001B, 0x4001E,
-    0x4001F, 0x70095, 0x70096, 0x70097,
+    0x4001F
-    0x70098, 0x70099, 0x7009A, 0x7009B,
+};
-    0x7009C,
+
+static s32 sparkMotTbl[] = {
+	0x70095, 0x70096, 0x70097, 0x70098,
+	0x70099, 0x7009A, 0x7009B, 0x7009C,
 };
 
 static s32 boardSparkSfxTbl[] = {
@@ -104,7 +139,7 @@ static s32 boardSparkSfxTblAlt[] = {
     0x223, 0x263, 0x2A3, 0x2E3,
 };
 
-static s32 megaSquishObj[] = {
+static omObjData *megaSquishObj[] = {
     0, 0, 0, 0,
 };
 
@@ -113,15 +148,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 +537,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 +619,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) {
@@ -804,7 +831,7 @@ block_14:
     } while (1);
     BoardPauseDisableSet(1);
     BoardDiceDigit2DUpdateEnable(arg0);
-    BoardRotateDiceNumbers(arg0);
+    BoardPlayerIdleSet(arg0);
     if (GWPlayer[arg0].bowser_suit != 0) {
         BoardCameraTargetPlayerSet(arg0);
     }
@@ -889,7 +916,7 @@ void BoardPlayerZoomRestore(s32 arg0) {
     while (BoardPlayerMotBlendCheck(arg0) == 0) {
         HuPrcVSleep();
     }
-    BoardRotateDiceNumbers(arg0);
+    BoardPlayerIdleSet(arg0);
 }
 
 void BoardJunctionMaskSet(s32 arg0) {
@@ -1221,7 +1248,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);
@@ -1261,7 +1288,7 @@ static s32 DoDebugMove(s32 arg0, s16* arg1) {
                     }
                 } else {
                     if (BoardPlayerMotGet(arg0) != 1) {
-                        BoardRotateDiceNumbers(arg0);
+                        BoardPlayerIdleSet(arg0);
                     }
                     if (GWPlayer[arg0].bowser_suit != 0) {
                         BoardBowserSuitMotionSetWait();
@@ -1375,7 +1402,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) {
         
@@ -1418,7 +1445,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);
@@ -1453,7 +1480,7 @@ static s32 ExecJunction(s32 arg0, s16* arg1) {
                 }
             } else {
                 if (BoardPlayerMotGet(arg0) != 1) {
-                    BoardRotateDiceNumbers(arg0);
+                    BoardPlayerIdleSet(arg0);
                 }
                 if (GWPlayer[arg0].bowser_suit != 0) {
                     BoardBowserSuitMotionSetWait();
@@ -1684,7 +1711,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;
@@ -1725,21 +1752,14 @@ static void DiceJumpFunc(omObjData* arg0) {
     }
 }
 
-void BoardRotateDiceNumbers(s32 arg0) {
-    PlayerState* temp_r27;
-    s32 var_r29;
 
-    if (GWPlayer[arg0].bowser_suit != 0) {
+void BoardPlayerIdleSet(s32 arg0)
+{
+    if (GWPlayer[arg0].bowser_suit) {
         BoardBowserSuitMotionSetWait();
         BoardBowserSuitPlayerModelKill();
     }
-    temp_r27 = BoardPlayerGet(arg0);
+	BoardPlayerMotionShiftSet(arg0, 1, 0.0f, 8.0f, 0x40000001);
-    if (playerMot[temp_r27->player_idx] != 1) {
-        var_r29 = BoardModelMotionShiftSet(BoardPlayerModelGet(arg0), 1, 0.0f, 8.0f, 0x40000001);
-        if (var_r29 == 0) {
-            playerMot[temp_r27->player_idx] = 1;
-        }
-    }
 }
 
 void BoardPlayerMotBlendSet(s32 arg0, s16 arg1, s16 arg2) {
@@ -2029,12 +2049,13 @@ void BoardPlayerAutoSizeSet(s32 player, s32 value) {
 }
 
 s32 BoardPlayerAutoSizeGet(s32 arg0) {
-    PlayerState* temp_r30 = BoardPlayerGet(arg0);
+    PlayerState* player;
-    
+
-    if (temp_r30 != 0 ) {
+    player = BoardPlayerGet(arg0);
-        arg0 = temp_r30->auto_size;
+    if(!player) {
+        return;
     }
-    return arg0;
+    return player->auto_size;
 }
 
 u32 BoardPlayerMoveAwayIsDone(void) {
@@ -2239,10 +2260,578 @@ 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);
+	BoardPlayerIdleSet(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);
+		BoardPlayerIdleSet(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++) {
+		BoardPlayerIdleSet(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) {
+static void RemoveSparkSpace(s32 player)
-    return BoardModelIDGet(BoardPlayerModelGet(arg0));
+{
+	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);
+}
+
+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) {
@@ -2290,14 +2879,13 @@ void BoardPlayerCopyEyeMat(s32 arg0, s32 arg1) {
     DCStoreRange(hsfData->material, hsfData->materialCnt * 0x3C);
 }
 
-
 void BoardPlayerCopyMat(s32 arg0) {
     s16 modelID;
     ModelData *model;
     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);

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;
@@ -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;
 		}

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"
@@ -211,7 +212,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 +690,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;

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;

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;
@@ -66,7 +62,7 @@ void WarpProcess(void) {
         HuPrcVSleep();
     }
     
-    BoardRotateDiceNumbers(curr_player);
+    BoardPlayerIdleSet(curr_player);
     if (_CheckFlag(0x1000B) != 0) {
         BoardTutorialHookExec(18, 0);
         boardTutorialData[0] = 0;
@@ -144,7 +140,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 +241,7 @@ static void WarpImpact(s32 player) {
     HuPrcSleep(60);
     
     for (i = 0; i < warpImpactCnt; i++) {
-        BoardRotateDiceNumbers(warpImpactPlayer[i]);
+        BoardPlayerIdleSet(warpImpactPlayer[i]);
     }
     warpState = 6;
 }

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;

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);
+		HuSprAttrSet(work->spr_grp[word_grp], i, HUSPR_ATTR_LINEAR);
-		HuSprAttrReset(work->spr_grp[word_grp], i, SPRITE_ATTR_HIDDEN);
+		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);
+		HuSprAttrSet(work->spr_grp[word_grp], i, HUSPR_ATTR_LINEAR);
-		HuSprAttrReset(work->spr_grp[word_grp], i, SPRITE_ATTR_HIDDEN);
+		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;;

src/game/sprman.c

@@ -8,34 +8,33 @@
 #define SPRITE_DIRTY_XFORM 0x2
 #define SPRITE_DIRTY_COLOR 0x4
 
-typedef struct sprite_order_data {
+typedef struct sprite_order {
-    unsigned short group;
+    u16 group;
-    unsigned short sprite;
+    u16 sprite;
-    unsigned short prio;
+    u16 prio;
-    unsigned short next;
+    u16 next;
-} SpriteOrderData;
+} SpriteOrder;
 
-SpriteData HuSprData[SPRITE_MAX];
+HuSprite HuSprData[HUSPR_MAX];
-SpriteGroupData HuSprGrpData[SPRITE_GROUP_MAX];
+HuSprGrp HuSprGrpData[HUSPR_GRP_MAX];
-static SpriteOrderData HuSprOrder[SPRITE_MAX*2];
+static SpriteOrder HuSprOrder[HUSPR_MAX*2];
 
-static short HuSprOrderNum;
+static s16 HuSprOrderNum;
-static short HuSprOrderNo;
+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;
+    s16 i;
-    SpriteData *sprite;
+    HuSprite *sprite;
-    SpriteGroupData *group;
+    HuSprGrp *group;
-    for(sprite = &HuSprData[1], i=1; i<SPRITE_MAX; i++, sprite++) {
+    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;
+    s16 i;
-    SpriteGroupData *group;
+    HuSprGrp *group;
-    SpriteData *sprite;
+    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];
+    SpriteOrder *order = &HuSprOrder[HuSprOrderNum];
-    short prio = HuSprData[sprite].prio;
+    s16 prio = HuSprData[sprite].prio;
-    short prev, next;
+    s16 prev, next;
-    if(HuSprOrderNum >= SPRITE_MAX*2) {
+    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];
+        SpriteOrder *order = &HuSprOrder[HuSprOrderNo];
-        SpriteData *sprite = &HuSprData[order->sprite];
+        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;
+    HuSprite *sprite;
-    short i;
+    s16 i;
-    short j;
+    s16 j;
-    short loop;
+    s16 loop;
-    short dir;
+    s16 dir;
     
-    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 && !(sprite->attr & SPRITE_ATTR_FUNC)) {
+        if(sprite->data && !(sprite->attr & HUSPR_ATTR_FUNC)) {
-            if(!HuSprPauseF || (sprite->attr & SPRITE_ATTR_NOPAUSE)) {
+            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;
+                loop = (sprite->attr & HUSPR_ATTR_LOOP) ? 0 : 1;
-                if(!(sprite->attr & SPRITE_ATTR_PAUSED)) {
+                if(!(sprite->attr & HUSPR_ATTR_NOANIM)) {
-                    dir = (sprite->attr & SPRITE_ATTR_REVERSE) ? -1 : 1;
+                    dir = (sprite->attr & HUSPR_ATTR_REVERSE) ? -1 : 1;
-                    for(j=0; j<(int)sprite->speed*minimumVcount; j++) {
+                    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;
+    HuSprite *sprite;
-    short i;
+    s16 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) {
             break;
         }
     }
-    if(i == SPRITE_MAX) {
+    if(i == HUSPR_MAX) {
-        return SPRITE_INVALID;
+        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;
+    HuSprite *sprite;
-    short index = HuSprCreate(NULL, prio, 0);
+    s16 index = HuSprCreate(NULL, prio, 0);
-    if(index == SPRITE_INVALID) {
+    if(index == HUSPR_NONE) {
-        return SPRITE_INVALID;
+        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;
+    HuSprGrp *group;
-    short i, j;
+    s16 i, j;
-    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) {
             break;
         }
     }
-    if(i == SPRITE_GROUP_MAX) {
+    if(i == HUSPR_GRP_MAX) {
-        return SPRITE_GROUP_INVALID;
+        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;
+    HuSprGrp *new_group_ptr;
-    SpriteGroupData *group_ptr = &HuSprGrpData[group];
+    HuSprGrp *group_ptr = &HuSprGrpData[group];
-    short new_group = HuSprGrpCreate(group_ptr->capacity);
+    s16 new_group = HuSprGrpCreate(group_ptr->capacity);
-    short i;
+    s16 i;
-    if(new_group == SPRITE_GROUP_INVALID) {
+    if(new_group == HUSPR_GRP_NONE) {
-        return SPRITE_GROUP_INVALID;
+        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) {
+        if(group_ptr->members[i] != HUSPR_NONE) {
-            SpriteData *old_sprite = &HuSprData[group_ptr->members[i]];
+            HuSprite *old_sprite = &HuSprData[group_ptr->members[i]];
-            short new_sprite = HuSprCreate(old_sprite->data, old_sprite->prio, old_sprite->bank);
+            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];
+    HuSprGrp *group_ptr = &HuSprGrpData[group];
-    SpriteData *sprite_ptr = &HuSprData[sprite];
+    HuSprite *sprite_ptr = &HuSprData[sprite];
-    if(group_ptr->capacity == 0 || group_ptr->capacity <= member || group_ptr->members[member] != SPRITE_INVALID) {
+    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];
+    HuSprGrp *group_ptr = &HuSprGrpData[group];
-    if(group_ptr->capacity == 0 || group_ptr->capacity <= member || group_ptr->members[member] == SPRITE_INVALID) {
+    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];
+    HuSprGrp *group_ptr = &HuSprGrpData[group];
-    short i;
+    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];
+    HuSprGrp *group_ptr = &HuSprGrpData[group];
-    SpriteData *sprite_ptr;
+    HuSprite *sprite_ptr;
-    if(group_ptr->capacity == 0 || group_ptr->capacity <= member || group_ptr->members[member] == SPRITE_INVALID) {
+    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];
+    HuSprGrp *group_ptr = &HuSprGrpData[group];
-    SpriteData *sprite_ptr;
+    HuSprite *sprite_ptr;
-    if(group_ptr->capacity == 0 || group_ptr->capacity <= member || group_ptr->members[member] == SPRITE_INVALID) {
+    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];
+    HuSprGrp *group_ptr = &HuSprGrpData[group];
-    short i;
+    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];
+    HuSprGrp *group_ptr = &HuSprGrpData[group];
-    short i;
+    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];
+    HuSprGrp *group_ptr = &HuSprGrpData[group];
-    short i;
+    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];
+    HuSprGrp *group_ptr = &HuSprGrpData[group];
-    short i;
+    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];
+    HuSprGrp *group_ptr = &HuSprGrpData[group];
-    short i;
+    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];
+    HuSprGrp *group_ptr = &HuSprGrpData[group];
-    short i;
+    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];
+    HuSprGrp *group_ptr = &HuSprGrpData[group];
-    short i;
+    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++;

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) {
+    switch(bmp_ptr->dataFmt & ANIM_BMP_FMTMASK) {
-        case SPRITE_BMP_RGBA8:
+        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 ANIM_BMP_RGB5A3:
-        case SPRITE_BMP_RGB5A3_DUPE:
+        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;
             

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;

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;