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