kobayashi90/marioparty4
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

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

Browse source
This commit is contained in:
CreateSource 2024-03-11 22:15:25 -04:00
commit 8564cca7b4
38 changed files with 3669 additions and 573 deletions
Download patch file Download diff file Expand all files Collapse all files

6
src/game/board/basic_space.c
View file

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

2
src/game/board/battle.c
View file

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

6
src/game/board/block.c
View file

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

532
src/game/board/char_wheel.c Executable file
View file

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

18
src/game/board/item.c
View file

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

1989
src/game/board/last5.c Normal file
View file

File diff suppressed because it is too large Load diff

8
src/game/board/lottery.c
View file

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

17
src/game/board/main.c
View file

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

676
src/game/board/player.c
View file

@ -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,
0x70098, 0x70099, 0x7009A, 0x7009B,
0x7009C,
0x4001F
};
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);
if (playerMot[temp_r27->player_idx] != 1) {
var_r29 = BoardModelMotionShiftSet(BoardPlayerModelGet(arg0), 1, 0.0f, 8.0f, 0x40000001);
if (var_r29 == 0) {
playerMot[temp_r27->player_idx] = 1;
}
}
BoardPlayerMotionShiftSet(arg0, 1, 0.0f, 8.0f, 0x40000001);
}
void BoardPlayerMotBlendSet(s32 arg0, s16 arg1, s16 arg2) {
@ -2029,12 +2049,13 @@ void BoardPlayerAutoSizeSet(s32 player, s32 value) {
}
s32 BoardPlayerAutoSizeGet(s32 arg0) {
PlayerState* temp_r30 = BoardPlayerGet(arg0);
if (temp_r30 != 0 ) {
arg0 = temp_r30->auto_size;
PlayerState* player;
player = BoardPlayerGet(arg0);
if(!player) {
return;
}
return arg0;
return player->auto_size;
}
u32 BoardPlayerMoveAwayIsDone(void) {
@ -2239,10 +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) {
return BoardModelIDGet(BoardPlayerModelGet(arg0));
static void RemoveSparkSpace(s32 player)
{
if(GWPlayer[player].field02_bit1) {
BoardWinCreate(0, 0x12001C, -1);
BoardWinWait();
BoardWinKill();
GWPlayer[player].field02_bit1 = 0;
GWPlayer[player].space_shock = 0;
}
}
static void SetRollPlayerSize(s32 player)
{
s32 auto_size = BoardPlayerAutoSizeGet(player);
if(auto_size != 0) {
BoardStatusHammerKill(player);
BoardPlayerAutoSizeSet(player, 0);
HuPrcSleep(30);
omVibrate(player, 90, 6, 6);
if(auto_size == 1) {
HuAudFXPlay(788);
HuAudFXPlay(787);
} else if(auto_size == 2) {
HuAudFXPlay(786);
HuAudFXPlay(785);
}
BoardPlayerResizeAnimExec(player, auto_size);
BoardPlayerSizeSet(player, auto_size);
HuPrcSleep(30);
rollResized = 1;
}
}
s32 BoardRollResizeCheck(void)
{
return rollResized;
}
void BoardPlayerResizeAnimExec(s32 player, s32 size)
{
s32 j;
s32 i;
s16 modelid;
s32 frame;
s16 model;
float mdl_size;
float frame_data[9];
float steps[4];
float player_sizes[] = { 1, 0.3, 2.5 };
mdl_size = player_sizes[BoardPlayerSizeGet(player)];
steps[0] = mdl_size;
steps[1] = mdl_size+((player_sizes[size]-mdl_size)/3);
steps[2] = mdl_size+((player_sizes[size]-mdl_size)/1.5f);
steps[3] = player_sizes[size];
frame_data[0] = steps[1];
frame_data[1] = steps[0];
frame_data[2] = steps[1];
frame_data[3] = steps[2];
frame_data[4] = steps[1];
frame_data[5] = steps[2];
frame_data[6] = steps[3];
frame_data[7] = steps[2];
frame_data[8] = steps[3];
model = BoardPlayerModelGet(player);
modelid = BoardModelIDGet(model);
Hu3DModelAttrSet(modelid, 0x40000002);
frame = 0;
for(j=0; j<9; j++) {
float size_vel;
size_vel = (frame_data[frame++]-mdl_size)/10.0f;
for(i=0; i<10; i++) {
BoardPlayerScaleSet(player, mdl_size, mdl_size, mdl_size);
mdl_size += size_vel;
HuPrcVSleep();
}
}
Hu3DModelAttrReset(modelid, 0x40000002);
BoardPlayerSizeSet(player, size);
}
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);

14
src/game/board/space.c
View file

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

5
src/game/board/star.c
View file

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

2
src/game/board/ui.c
View file

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

14
src/game/board/warp.c
View file

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

2
src/game/chrman.c
View file

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

84
src/game/minigame_seq.c
View file

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

327
src/game/sprman.c
View file

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

40
src/game/sprput.c
View file

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

4
src/game/thpmain.c
View file

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

24
src/game/window.c
View file

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