3644 lines
123 KiB
C
3644 lines
123 KiB
C
#include "game/armem.h"
|
|
#include "game/disp.h"
|
|
#include "game/gamework_data.h"
|
|
#include "game/hsfman.h"
|
|
#include "game/object.h"
|
|
#include "game/objsub.h"
|
|
#include "game/pad.h"
|
|
#include "game/process.h"
|
|
#include "game/sprite.h"
|
|
#include "game/window.h"
|
|
#include "game/wipe.h"
|
|
|
|
#include "game/minigame_seq.h"
|
|
|
|
#include "math.h"
|
|
|
|
#include "stdarg.h"
|
|
#include "version.h"
|
|
|
|
#undef abs
|
|
|
|
#define ABS(x) (((x) < 0) ? -(x) : (x))
|
|
|
|
extern s16 HuSysVWaitGet(s16 param);
|
|
|
|
typedef struct seq_info {
|
|
SeqInitFunc init;
|
|
SeqUpdateFunc update;
|
|
float x;
|
|
float y;
|
|
float scale_x;
|
|
float scale_y;
|
|
s32 time_max;
|
|
} SeqInfo;
|
|
|
|
OverlayID mgSeqOvlPrev = OVL_INVALID;
|
|
|
|
static SeqInfo seqInfoTbl[] = {
|
|
{ NULL, NULL, HU_DISP_CENTERX + 4, HU_DISP_CENTERY, 1.0f, 1.0f, 60 },
|
|
{ MGSeqInitTimer, MGSeqUpdateTimer, HU_DISP_CENTERX + 4, 64.0f, 1.0f, 1.0f, 60 },
|
|
{ MGSeqInitType2, MGSeqUpdateType2, HU_DISP_CENTERX + 4, HU_DISP_CENTERY, 0.5f, 0.5f, 60 },
|
|
{ MGSeqInitMGBasic, MGSeqUpdateMGBasic, HU_DISP_CENTERX + 4, HU_DISP_CENTERY, 1.0f, 1.0f, 180 },
|
|
{ MGSeqInitMGCommon, MGSeqUpdateMG1vs3, HU_DISP_CENTERX + 4, HU_DISP_CENTERY, 1.0f, 1.0f, 180 },
|
|
{ MGSeqInitWin, MGSeqUpdateWin, HU_DISP_CENTERX + 4, HU_DISP_CENTERY, 1.0f, 1.0f, 180 },
|
|
{ MGSeqInitMGCommon, MGSeqUpdateMGBattle, HU_DISP_CENTERX + 4, HU_DISP_CENTERY, 1.0f, 1.0f, 180 },
|
|
{ MGSeqInitMGCommon, MGSeqUpdateMGStory, HU_DISP_CENTERX + 4, HU_DISP_CENTERY, 1.0f, 1.0f, 180 },
|
|
{ MGSeqInitMGBasic, MGSeqUpdateMGBasic, HU_DISP_CENTERX + 4, HU_DISP_CENTERY, 1.0f, 1.0f, 180 },
|
|
{ MGSeqInitMGCommon, MGSeqUpdateMG2vs2, HU_DISP_CENTERX + 4, HU_DISP_CENTERY, 1.0f, 1.0f, 180 },
|
|
{ MGSeqInitFlip, MGSeqUpdateFlip, HU_DISP_CENTERX + 4, HU_DISP_CENTERY, 1.0f, 1.0f, 180 },
|
|
{ MGSeqInitMGCommon, MGSeqUpdateMGBowser, HU_DISP_CENTERX + 4, HU_DISP_CENTERY, 1.0f, 1.0f, 180 },
|
|
{ MGSeqInitWin, MGSeqUpdateWin, HU_DISP_CENTERX + 4, HU_DISP_CENTERY, 1.0f, 1.0f, 180 },
|
|
{ MGSeqInitDraw, MGSeqUpdateDraw, HU_DISP_CENTERX + 4, HU_DISP_CENTERY, 1.0f, 1.0f, 60 },
|
|
{ MGSeqInitRecord, MGSeqUpdateRecord, HU_DISP_CENTERX + 4, HU_DISP_CENTERY, 1.0f, 1.0f, 180 },
|
|
{ NULL, NULL, HU_DISP_CENTERX + 4, HU_DISP_CENTERY, 1.0f, 1.0f, 60 },
|
|
{ NULL, NULL, HU_DISP_CENTERX + 4, HU_DISP_CENTERY, 1.0f, 1.0f, 60 },
|
|
};
|
|
|
|
static s32 seqType2SprTbl[6] = { 0, 0, 0, 0, 0, 0 };
|
|
|
|
static s16 mgSeqTypeTbl[9] = {
|
|
MG_SEQ_TYPE_4P,
|
|
MG_SEQ_TYPE_1VS3,
|
|
MG_SEQ_TYPE_2VS2,
|
|
MG_SEQ_TYPE_BOWSER,
|
|
MG_SEQ_TYPE_BATTLE,
|
|
MG_SEQ_TYPE_PINBALL,
|
|
MG_SEQ_TYPE_STORY,
|
|
MG_SEQ_TYPE_BOWSER,
|
|
MG_SEQ_TYPE_STORY,
|
|
};
|
|
|
|
static char lbl_8012F336[] = {
|
|
"ｱｲｳｴｵｶｷｸ"
|
|
"ｹｺｻｼｽｾｿﾀ"
|
|
"ﾁﾂﾃﾄﾅﾆﾇﾈ"
|
|
"ﾉﾊﾋﾌﾍﾎﾏﾐ"
|
|
"ﾑﾒﾓﾔﾕﾖﾗﾘ"
|
|
"ﾙﾚﾛﾜｦﾝｧｨ"
|
|
"ｩｪｫｬｭｮｯｶ"
|
|
"ｷｸｺｻｼｽｾｿ"
|
|
"ﾀﾁﾂﾃﾄﾊﾋﾌ"
|
|
"ﾍﾎﾊﾋﾌﾍﾎ"
|
|
"!?ｰ",
|
|
};
|
|
|
|
static char lbl_8012F389[] = "x first\n";
|
|
static char lbl_8012F392[] = "y first\n";
|
|
|
|
static SeqWork seqWorkData[8];
|
|
|
|
static s16 seqTimer;
|
|
static u8 seqDoneF;
|
|
u8 lbl_801D3D94;
|
|
static s16 seqSpeed;
|
|
static s16 seqPauseF;
|
|
static int seqRecordVal;
|
|
static s32 pauseWaitF;
|
|
static s32 pauseExitF;
|
|
static s32 pauseActiveF;
|
|
static Process *pauseProcess;
|
|
static s32 seqLanguage;
|
|
|
|
void fn_80036BC8(void);
|
|
|
|
void MGSeqInit(void)
|
|
{
|
|
s32 i;
|
|
SeqWork *work;
|
|
work = &seqWorkData[0];
|
|
for (i = 8; i != 0; i--, work++) {
|
|
work->seq_no = 0;
|
|
work->data = NULL;
|
|
}
|
|
seqPauseF = 0;
|
|
seqDoneF = 0;
|
|
lbl_801D3D94 = 0;
|
|
seqTimer = 30;
|
|
HuAR_DVDtoARAM(DATADIR_GAMEMES);
|
|
HuAR_DVDtoARAM(DATADIR_MGCONST);
|
|
while (HuARDMACheck())
|
|
;
|
|
fn_80036BC8();
|
|
mgSeqOvlPrev = -1;
|
|
seqLanguage = GWLanguageGet();
|
|
}
|
|
|
|
void MGSeqMain(void)
|
|
{
|
|
SeqInfo *info;
|
|
s32 i;
|
|
s32 j;
|
|
s32 alive_flag;
|
|
u8 stat;
|
|
SeqWork *work;
|
|
|
|
seqSpeed = HuSysVWaitGet(seqSpeed);
|
|
if (Hu3DPauseF) {
|
|
return;
|
|
}
|
|
alive_flag = 0;
|
|
stat = 0;
|
|
work = &seqWorkData[0];
|
|
for (i = 0; i < 8; i++, work++) {
|
|
if (work->stat == 0) {
|
|
continue;
|
|
}
|
|
if (work->update) {
|
|
alive_flag = work->update(work);
|
|
}
|
|
else {
|
|
info = &seqInfoTbl[work->seq_no];
|
|
if (work->seq_no != 0 && NULL != info->update) {
|
|
alive_flag = info->update(work);
|
|
}
|
|
}
|
|
if (!alive_flag) {
|
|
work->stat = 0;
|
|
if (!lbl_801D3D94) {
|
|
for (j = 0; j < 8; j++) {
|
|
if (seqWorkData[j].stat) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!work->data) {
|
|
HuMemDirectFree(work->data);
|
|
work->data = NULL;
|
|
}
|
|
}
|
|
stat |= work->stat;
|
|
}
|
|
if (!stat || stat & 0x4) {
|
|
if (seqTimer > 0) {
|
|
seqTimer -= seqSpeed;
|
|
}
|
|
}
|
|
}
|
|
|
|
static s16 CreateSeq(s16 seq_no, va_list params)
|
|
{
|
|
SeqWork *work;
|
|
SeqInfo *info;
|
|
s32 i;
|
|
s32 temp;
|
|
work = seqWorkData;
|
|
info = &seqInfoTbl[(u8)seq_no];
|
|
for (i = 0; i < 8; i++, work++) {
|
|
if (work->stat == 0) {
|
|
break;
|
|
}
|
|
}
|
|
if (i >= 8) {
|
|
return -1;
|
|
}
|
|
work->stat |= 0x1;
|
|
if (work->data) {
|
|
HuMemDirectFree(work->data);
|
|
}
|
|
work->data = NULL;
|
|
work->seq_no = (u8)seq_no;
|
|
work->time = 0;
|
|
work->x = info->x;
|
|
work->y = info->y;
|
|
work->scale_x = info->scale_x;
|
|
work->scale_y = info->scale_y;
|
|
work->unk_18 = 0.0f;
|
|
work->unk_7D = 255;
|
|
work->time_max = info->time_max;
|
|
work->timer_val = work->state = work->alt_word_len = work->word_len = 0;
|
|
work->angle = work->win_scale = 0.0f;
|
|
work->param[0] = work->param[1] = 0;
|
|
for (temp = 0; temp < 16; temp++) {
|
|
work->sprite[temp] = work->spr_grp[temp] = -1;
|
|
}
|
|
if (NULL != info->init) {
|
|
temp = info->init(work, params);
|
|
if (temp == 0) {
|
|
work->stat = 0;
|
|
return -1;
|
|
}
|
|
}
|
|
seqTimer = 30;
|
|
return i;
|
|
}
|
|
|
|
s16 MGSeqCreate(s16 type, ...)
|
|
{
|
|
s16 ret;
|
|
va_list params;
|
|
va_start(params, type);
|
|
if (type == MG_SEQ_TYPE_AUTO) {
|
|
if (GWSystem.mg_next == 0xFFFF) {
|
|
type = MG_SEQ_TYPE_4P;
|
|
}
|
|
else {
|
|
type = mgSeqTypeTbl[mgInfoTbl[GWSystem.mg_next].type];
|
|
}
|
|
}
|
|
ret = CreateSeq(type, params);
|
|
va_end(params);
|
|
return ret;
|
|
}
|
|
|
|
u8 MGSeqStatGet(s16 id)
|
|
{
|
|
SeqWork *work;
|
|
u8 ret = 0;
|
|
if (id < 0) {
|
|
s32 i;
|
|
work = seqWorkData;
|
|
for (i = 8; i != 0; i--, work++) {
|
|
ret |= work->stat;
|
|
}
|
|
}
|
|
else {
|
|
if (id < 8) {
|
|
ret = seqWorkData[id].stat;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
void MGSeqPosSet(s16 id, float x, float y)
|
|
{
|
|
if (id >= 0 && id < 8) {
|
|
seqWorkData[id].x = x;
|
|
seqWorkData[id].y = y;
|
|
}
|
|
}
|
|
|
|
void MGSeqParamSet(s16 id, s16 param1, s16 param2)
|
|
{
|
|
if (id >= 0 && id < 8) {
|
|
seqWorkData[id].param[0] = param1;
|
|
seqWorkData[id].param[1] = param2;
|
|
}
|
|
}
|
|
|
|
void MGSeqKill(s16 id)
|
|
{
|
|
if (id >= 0 && id < 8) {
|
|
if (seqWorkData[id].stat != 0) {
|
|
seqWorkData[id].stat = 8;
|
|
}
|
|
}
|
|
}
|
|
|
|
void MGSeqKillAll(void)
|
|
{
|
|
seqDoneF = 1;
|
|
MGSeqMain();
|
|
seqDoneF = 0;
|
|
MGSeqStub();
|
|
lbl_801D3D94 = 0;
|
|
}
|
|
|
|
s32 MGSeqDoneCheck(void)
|
|
{
|
|
u8 stat = MGSeqStatGet(-1);
|
|
if (stat == 0 || (stat & 0xC)) {
|
|
if (seqTimer <= 0 || (stat & 0x8)) {
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void MGSeqStub(void) { }
|
|
|
|
void MGSeqSprKill(SeqWork *work)
|
|
{
|
|
s32 i;
|
|
for (i = 0; i < 16; i++) {
|
|
if (work->spr_grp[i] >= 0) {
|
|
HuSprGrpKill(work->spr_grp[i]);
|
|
}
|
|
if (work->sprite[i] >= 0) {
|
|
HuSprKill(work->sprite[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void *SeqReadFile(s32 file)
|
|
{
|
|
return HuAR_ARAMtoMRAMFileRead(file, MEMORY_DEFAULT_NUM, HEAP_DATA);
|
|
}
|
|
|
|
s32 MGSeqInitTimer(SeqWork *work, va_list params)
|
|
{
|
|
AnimData *spr_anim;
|
|
s16 sprite;
|
|
s16 spr_grp;
|
|
int duration, x, y;
|
|
s16 i;
|
|
|
|
duration = va_arg(params, int);
|
|
x = va_arg(params, int);
|
|
y = va_arg(params, int);
|
|
if (duration <= 0 && duration > 99) {
|
|
duration = 99;
|
|
}
|
|
work->timer_val = duration;
|
|
if (x >= 0) {
|
|
work->x = x;
|
|
}
|
|
if (y >= 0) {
|
|
work->y = y;
|
|
}
|
|
work->alt_word_len = 0;
|
|
work->state = 2;
|
|
work->angle = 0;
|
|
work->spr_grp[0] = spr_grp = HuSprGrpCreate(4);
|
|
HuSprGrpScaleSet(spr_grp, work->scale_x, work->scale_y);
|
|
spr_anim = HuSprAnimRead(SeqReadFile(DATA_MAKE_NUM(DATADIR_GAMEMES, 2)));
|
|
x = 12;
|
|
for (i = 0; i < 2; i++) {
|
|
sprite = HuSprCreate(spr_anim, 5, 0);
|
|
HuSprGrpMemberSet(spr_grp, i, sprite);
|
|
HuSprSpeedSet(spr_grp, i, 0);
|
|
HuSprPosSet(spr_grp, i, x, 0);
|
|
HuSprColorSet(spr_grp, i, 112, 233, 255);
|
|
x -= 24;
|
|
(void)i; // Hack for Matching
|
|
}
|
|
spr_anim = HuSprAnimRead(SeqReadFile(DATA_MAKE_NUM(DATADIR_GAMEMES, 1)));
|
|
sprite = HuSprCreate(spr_anim, 7, 0);
|
|
HuSprGrpMemberSet(spr_grp, 2, sprite);
|
|
HuSprPosSet(spr_grp, 2, 0, 0);
|
|
HuSprTPLvlSet(spr_grp, 2, 0.5f);
|
|
HuSprColorSet(spr_grp, 2, 0, 0, 0);
|
|
spr_anim = HuSprAnimRead(SeqReadFile(DATA_MAKE_NUM(DATADIR_GAMEMES, 0)));
|
|
sprite = HuSprCreate(spr_anim, 6, 0);
|
|
HuSprGrpMemberSet(spr_grp, 3, sprite);
|
|
HuSprPosSet(spr_grp, 3, 0, 0);
|
|
if (seqPauseF) {
|
|
work->state = 1;
|
|
for (i = 0; i < 2; i++) {
|
|
HuSprAttrSet(spr_grp, i, HUSPR_ATTR_DISPOFF);
|
|
#if VERSION_NTSC
|
|
//(void)i; //Hack for Matching
|
|
#endif
|
|
}
|
|
}
|
|
#if VERSION_PAL
|
|
HuSprGrpPosSet(spr_grp, -1000.0f, 0.0f);
|
|
#endif
|
|
return 1;
|
|
}
|
|
|
|
s32 MGSeqUpdateTimer(SeqWork *work)
|
|
{
|
|
float scale;
|
|
float tp_lvl;
|
|
u8 digits[2];
|
|
s16 i;
|
|
s16 spr_grp = work->spr_grp[0];
|
|
if (work->param[0] != 0 && work->state != -1) {
|
|
switch (work->param[0]) {
|
|
case 2:
|
|
switch (work->param[1]) {
|
|
case -1:
|
|
work->stat |= 0x4;
|
|
work->state = -1;
|
|
work->angle = 0.0f;
|
|
break;
|
|
|
|
case 0:
|
|
work->state = 2;
|
|
work->angle = 0.0f;
|
|
break;
|
|
|
|
case 1:
|
|
work->state = 3;
|
|
work->angle = 0.0f;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
work->param[0] = 0;
|
|
break;
|
|
|
|
case 1:
|
|
if (work->param[1] < 0 && !(work->stat & 0x4)) {
|
|
work->stat |= 0x4;
|
|
work->state = -1;
|
|
work->angle = 0.0f;
|
|
}
|
|
else {
|
|
if (work->param[1] > 99) {
|
|
work->timer_val = 99;
|
|
}
|
|
else {
|
|
if (work->timer_val != work->param[1]) {
|
|
work->timer_val = work->param[1];
|
|
if (work->param[1] <= 5) {
|
|
HuAudFXPlay(6);
|
|
work->state = 3;
|
|
work->angle = 0.0f;
|
|
HuSprColorSet(spr_grp, 0, 255, 112, 160);
|
|
HuSprColorSet(spr_grp, 1, 255, 112, 160);
|
|
}
|
|
else {
|
|
HuSprColorSet(spr_grp, 0, 112, 233, 255);
|
|
HuSprColorSet(spr_grp, 1, 112, 233, 255);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
work->param[0] = 0;
|
|
break;
|
|
|
|
case 3:
|
|
for (i = 0; i < 2; i++) {
|
|
HuSprAttrReset(spr_grp, i, HUSPR_ATTR_DISPOFF);
|
|
}
|
|
work->state = 3;
|
|
work->param[0] = 0;
|
|
break;
|
|
|
|
default:
|
|
work->param[0] = 0;
|
|
break;
|
|
}
|
|
}
|
|
if (work->state == 1) {
|
|
return 1;
|
|
}
|
|
if (work->timer_val > 99) {
|
|
digits[0] = digits[1] = 9;
|
|
}
|
|
else {
|
|
s32 value;
|
|
value = work->timer_val / 10;
|
|
digits[1] = value;
|
|
digits[0] = work->timer_val - (value * 10);
|
|
}
|
|
HuSprGrpPosSet(spr_grp, work->x, work->y);
|
|
HuSprGrpScaleSet(spr_grp, work->scale_x, work->scale_y);
|
|
for (i = 0; i < 2; i++) {
|
|
HuSprBankSet(spr_grp, i, digits[i]);
|
|
}
|
|
if (work->state != 0) {
|
|
switch (work->state) {
|
|
case 2: {
|
|
float scale_x, scale_y;
|
|
scale = fabs(((sin((work->angle * M_PI) / 180) * 5.0f) + 1.0f) - (sin((130 * M_PI) / 180) * 5.0f));
|
|
scale_x = work->scale_x * scale;
|
|
scale_y = work->scale_y * scale;
|
|
work->angle += seqSpeed * 5.0f;
|
|
if (work->angle > 130.0f) {
|
|
work->state = 0;
|
|
break;
|
|
}
|
|
HuSprGrpScaleSet(spr_grp, scale_x, scale_y);
|
|
} break;
|
|
|
|
case 3: {
|
|
scale = sin((work->angle * M_PI) / 180) + 1.0;
|
|
tp_lvl = 1.0 - (sin((work->angle * M_PI) / 180) * 0.5);
|
|
work->angle += seqSpeed * 18.0f;
|
|
if (work->angle > 180.0f) {
|
|
work->state = 0;
|
|
scale = 1.0f;
|
|
tp_lvl = 1.0f;
|
|
}
|
|
for (i = 0; i < 2; i++) {
|
|
HuSprScaleSet(spr_grp, i, scale, scale);
|
|
HuSprTPLvlSet(spr_grp, i, tp_lvl);
|
|
}
|
|
} break;
|
|
|
|
case -1:
|
|
HuSprGrpScaleSet(spr_grp, work->scale_x, work->scale_y);
|
|
for (i = 0; i < 2; i++) {
|
|
HuSprScaleSet(spr_grp, i, 1.0f, 1.0f);
|
|
}
|
|
work->angle += 1.0f;
|
|
if (work->angle < 60.0f) {
|
|
break;
|
|
}
|
|
tp_lvl = 1.0 - ((work->angle - 60.0f) / 20.0f);
|
|
if (tp_lvl <= 0.0f) {
|
|
tp_lvl = 0.0f;
|
|
work->state = 0;
|
|
work->stat |= 0x8;
|
|
}
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
HuSprTPLvlSet(spr_grp, i, tp_lvl);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
if (seqDoneF || (work->stat & 0x8)) {
|
|
MGSeqSprKill(work);
|
|
return 0;
|
|
}
|
|
else {
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
s32 MGSeqInitType2(SeqWork *work, va_list params)
|
|
{
|
|
s16 spr_idx;
|
|
s16 spr_grp;
|
|
AnimData *anim_tbl[6];
|
|
s32 i;
|
|
s16 len;
|
|
char *str;
|
|
char c;
|
|
int time_max;
|
|
int x, y;
|
|
work->data = va_arg(params, void *);
|
|
time_max = va_arg(params, int);
|
|
x = va_arg(params, int);
|
|
y = va_arg(params, int);
|
|
if (time_max < 0) {
|
|
time_max = -1;
|
|
}
|
|
work->time_max = time_max;
|
|
if (x >= 0) {
|
|
work->x = x;
|
|
}
|
|
if (y >= 0) {
|
|
work->y = y;
|
|
}
|
|
work->state = 0;
|
|
work->angle = 0.0f;
|
|
x = 0;
|
|
len = 0;
|
|
str = work->data;
|
|
while (c = *str++) {
|
|
if (c >= '0' && c <= '9') {
|
|
x |= 1;
|
|
len++;
|
|
}
|
|
else if (c >= 'A' && c <= 'Z') {
|
|
x |= 2;
|
|
len++;
|
|
}
|
|
else if (c >= 'a' && c <= 'z') {
|
|
x |= 4;
|
|
len++;
|
|
}
|
|
else if (c == '!' || c == '?') {
|
|
x |= 8;
|
|
len++;
|
|
}
|
|
}
|
|
work->word_len = len;
|
|
for (i = 0; i < 6; i++) {
|
|
if (x & (1 << i)) {
|
|
anim_tbl[i] = HuSprAnimRead(SeqReadFile(seqType2SprTbl[i]));
|
|
}
|
|
else {
|
|
anim_tbl[i] = NULL;
|
|
}
|
|
}
|
|
work->spr_grp[0] = spr_grp = HuSprGrpCreate(len);
|
|
x = 0;
|
|
spr_idx = 0;
|
|
str = work->data;
|
|
while (c = *str++) {
|
|
i = -2;
|
|
if (c >= '0' && c <= '9') {
|
|
c -= '0';
|
|
i = 0;
|
|
}
|
|
else if (c >= 'A' && c <= 'Z') {
|
|
c -= 'A';
|
|
i = 1;
|
|
}
|
|
else if (c >= 'a' && c <= 'z') {
|
|
c -= 'a';
|
|
i = 2;
|
|
}
|
|
else if (c == '!' || c == '?') {
|
|
if (c == '!') {
|
|
c = 0;
|
|
}
|
|
else {
|
|
c = 1;
|
|
}
|
|
i = 3;
|
|
}
|
|
else if (c == ' ') {
|
|
i = -1;
|
|
}
|
|
work->alt_word_len = x;
|
|
if (i == -1) {
|
|
x += 32;
|
|
}
|
|
else if (i >= 0) {
|
|
s16 sprite = HuSprCreate(anim_tbl[i], 5, c);
|
|
HuSprGrpMemberSet(spr_grp, spr_idx, sprite);
|
|
HuSprSpeedSet(spr_grp, spr_idx, 0.0f);
|
|
HuSprPosSet(spr_grp, spr_idx, x, 0.0f);
|
|
spr_idx++;
|
|
x += 64;
|
|
}
|
|
}
|
|
if (seqPauseF) {
|
|
work->state = 1;
|
|
for (i = 0; i < work->word_len; i++) {
|
|
HuSprAttrSet(spr_grp, i, HUSPR_ATTR_DISPOFF);
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
s32 MGSeqUpdateType2(SeqWork *work)
|
|
{
|
|
float tp_lvl;
|
|
s16 spr_grp;
|
|
spr_grp = work->spr_grp[0];
|
|
HuSprGrpPosSet(spr_grp, work->x - ((0.5f * work->scale_x) * work->alt_word_len), work->y);
|
|
HuSprGrpScaleSet(spr_grp, work->scale_x, work->scale_y);
|
|
if (work->param[0] != 0 && work->state != -1) {
|
|
switch (work->param[0]) {
|
|
case 2:
|
|
if (work->param[1] != -1) {
|
|
(void)work; // HACK: to introduce extra branch
|
|
}
|
|
else {
|
|
work->state = -1;
|
|
work->angle = 0.0f;
|
|
}
|
|
work->param[0] = 0;
|
|
break;
|
|
|
|
case 1:
|
|
work->time_max = work->param[1];
|
|
work->param[0] = 0;
|
|
break;
|
|
|
|
case 3: {
|
|
s32 i;
|
|
for (i = 0; i < work->word_len; i++) {
|
|
HuSprAttrReset(spr_grp, i, HUSPR_ATTR_DISPOFF);
|
|
(void)i;
|
|
}
|
|
work->state = 0;
|
|
work->param[0] = 0;
|
|
} break;
|
|
|
|
default:
|
|
work->param[0] = 0;
|
|
break;
|
|
}
|
|
}
|
|
if (work->state == 1) {
|
|
return 1;
|
|
}
|
|
work->time += seqSpeed;
|
|
if (work->time >= work->time_max && work->state != -1) {
|
|
work->stat |= 0x4;
|
|
work->state = -1;
|
|
work->angle = 0.0f;
|
|
}
|
|
if (work->state != 0) {
|
|
if (work->state != -1) {
|
|
(void)work; // HACK: to introduce extra branch
|
|
}
|
|
else {
|
|
s16 i;
|
|
work->angle += seqSpeed * 0.1f;
|
|
tp_lvl = 1.0f - work->angle;
|
|
if (tp_lvl <= 0.0f) {
|
|
tp_lvl = 0.0f;
|
|
work->state = 0;
|
|
work->stat |= 0x8;
|
|
}
|
|
for (i = 0; i < work->word_len; i++) {
|
|
HuSprTPLvlSet(spr_grp, i, tp_lvl);
|
|
(void)i;
|
|
}
|
|
}
|
|
}
|
|
if (seqDoneF || (work->stat & 0x8)) {
|
|
MGSeqSprKill(work);
|
|
return 0;
|
|
}
|
|
else {
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
static char seqFontAlphaTbl[] = { "ABCDEFGH"
|
|
"IJKLMNOP"
|
|
"QRSTUVWX"
|
|
"YZabcdef"
|
|
"ghijklmn"
|
|
"opqrstuv"
|
|
"wxyz" };
|
|
|
|
static char seqFontKanaTbl[] = { "ｱｲｳｴｵｶｷｸ"
|
|
"ｹｺｻｼｽｾｿﾀ"
|
|
"ﾁﾂﾃﾄﾅﾆﾇﾈ"
|
|
"ﾉﾊﾋﾌﾍﾎﾏﾐ"
|
|
"ﾑﾒﾓﾔﾕﾖﾗﾘ"
|
|
"ﾙﾚﾛﾜｦﾝｧｨ"
|
|
"ｩｪｫｬｭｮｯｶ"
|
|
"ｷｸｹｺｻｼｽｾ"
|
|
"ｿﾀﾁﾂﾃﾄﾊﾋ"
|
|
"ﾌﾍﾎﾊﾋﾌﾍﾎ"
|
|
"ｰ" };
|
|
|
|
static char seqFontNumTbl[] = "0123456789";
|
|
|
|
static s32 *letterBufTbl[5] = {};
|
|
|
|
static char wordStartE[] = "START!";
|
|
|
|
static char seqPunctTbl[] = "!?";
|
|
|
|
static char wordStartJ[] = "ｽﾀｰﾄ!";
|
|
|
|
static char wordFinishJ[] = "ﾌｨﾆｯｼｭ!";
|
|
|
|
static char wordDrawJ[] = "ﾋｷﾜｹ!";
|
|
|
|
static char wordFinishE[] = "FINISH!";
|
|
static char wordDrawE[] = "DRAW!";
|
|
|
|
static char *wordMgTbl[6] = {
|
|
wordStartJ,
|
|
wordFinishJ,
|
|
wordDrawJ,
|
|
wordStartE,
|
|
wordFinishE,
|
|
wordDrawE,
|
|
};
|
|
|
|
void fn_80036BC8(void)
|
|
{
|
|
if (!letterBufTbl[0]) {
|
|
letterBufTbl[0] = HuMemDirectMalloc(HEAP_SYSTEM, sizeof(s32) * strlen(seqFontAlphaTbl));
|
|
memset(letterBufTbl[0], 0, sizeof(s32) * strlen(seqFontAlphaTbl));
|
|
}
|
|
if (!letterBufTbl[1]) {
|
|
letterBufTbl[1] = HuMemDirectMalloc(HEAP_SYSTEM, sizeof(s32) * strlen(seqFontKanaTbl));
|
|
memset(letterBufTbl[1], 0, sizeof(s32) * strlen(seqFontKanaTbl));
|
|
}
|
|
if (!letterBufTbl[2]) {
|
|
letterBufTbl[2] = HuMemDirectMalloc(HEAP_SYSTEM, sizeof(s32) * strlen(seqFontKanaTbl));
|
|
memset(letterBufTbl[2], 0, sizeof(s32) * strlen(seqFontKanaTbl));
|
|
}
|
|
if (!letterBufTbl[3]) {
|
|
letterBufTbl[3] = HuMemDirectMalloc(HEAP_SYSTEM, sizeof(s32) * strlen(seqFontNumTbl));
|
|
memset(letterBufTbl[3], 0, sizeof(s32) * strlen(seqFontNumTbl));
|
|
}
|
|
if (!letterBufTbl[4]) {
|
|
letterBufTbl[4] = HuMemDirectMalloc(HEAP_SYSTEM, sizeof(s32) * strlen(seqPunctTbl));
|
|
memset(letterBufTbl[4], 0, sizeof(s32) * strlen(seqPunctTbl));
|
|
}
|
|
}
|
|
|
|
static AnimData *SeqLoadFontChar(char *str, s16 flags);
|
|
|
|
static s32 SeqMakeWord(SeqWork *work, char *str, s16 flags)
|
|
{
|
|
s16 len;
|
|
s16 x;
|
|
s16 i;
|
|
s16 grp_idx;
|
|
#if VERSION_JPN
|
|
char *str_ptr;
|
|
AnimData **char_anim;
|
|
s16 *char_pos;
|
|
#else
|
|
AnimData **char_anim;
|
|
s16 *char_pos;
|
|
char *str_ptr;
|
|
#endif
|
|
s16 spr_grp;
|
|
for (grp_idx = 0; grp_idx < 16; grp_idx++) {
|
|
if (work->spr_grp[grp_idx] == -1) {
|
|
break;
|
|
}
|
|
}
|
|
if (grp_idx == 16) {
|
|
return -1;
|
|
}
|
|
char_anim = HuMemDirectMalloc(HEAP_SYSTEM, sizeof(AnimData *) * 100);
|
|
char_pos = HuMemDirectMalloc(HEAP_SYSTEM, sizeof(s16) * 100);
|
|
str_ptr = str;
|
|
x = 0;
|
|
len = 0;
|
|
while (*str_ptr != '\0') {
|
|
#if VERSION_JPN
|
|
if (*str_ptr == ' ') {
|
|
x += 56;
|
|
}
|
|
else {
|
|
char_anim[len] = SeqLoadFontChar(str_ptr, flags);
|
|
if (char_anim[len]) {
|
|
char_pos[len] = x;
|
|
x += 56;
|
|
len++;
|
|
}
|
|
}
|
|
#else
|
|
char_anim[len] = SeqLoadFontChar(str_ptr, flags);
|
|
if (char_anim[len]) {
|
|
char_pos[len] = x;
|
|
x += 56;
|
|
len++;
|
|
}
|
|
#endif
|
|
str_ptr++;
|
|
}
|
|
work->spr_grp[grp_idx] = spr_grp = HuSprGrpCreate(len);
|
|
x = (x / 2) - 28;
|
|
for (i = 0; i < len; i++) {
|
|
s16 sprite = HuSprCreate(char_anim[i], 5, 0);
|
|
HuSprGrpMemberSet(spr_grp, i, sprite);
|
|
HuSprPosSet(spr_grp, i, char_pos[i] - x, 0.0f);
|
|
}
|
|
work->word_len = len;
|
|
HuMemDirectFree(char_anim);
|
|
HuMemDirectFree(char_pos);
|
|
return grp_idx;
|
|
}
|
|
|
|
static AnimData *SeqLoadFontChar(char *str, s16 flags)
|
|
{
|
|
s32 data_num;
|
|
s16 id;
|
|
char *list;
|
|
char c = *str;
|
|
if (c == 222 || c == 223) {
|
|
return NULL;
|
|
}
|
|
#if !VERSION_JPN
|
|
if (c == 32) {
|
|
return HuSprAnimRead(SeqReadFile(DATA_MAKE_NUM(DATADIR_GAMEMES, 10)));
|
|
}
|
|
#endif
|
|
for (id = 0, list = seqFontAlphaTbl; *list != 0; id++, list++) {
|
|
if (*list == c) {
|
|
data_num = DATA_MAKE_NUM(DATADIR_GAMEMES, id + (VERSION_JPN ? 20 : 21));
|
|
return HuSprAnimRead(SeqReadFile(data_num));
|
|
}
|
|
}
|
|
for (id = 0, list = seqFontNumTbl; *list != 0; id++, list++) {
|
|
if (*list == c) {
|
|
data_num = DATA_MAKE_NUM(DATADIR_GAMEMES, id + (VERSION_JPN ? 10 : 11));
|
|
return HuSprAnimRead(SeqReadFile(data_num));
|
|
}
|
|
}
|
|
for (id = 0, list = seqPunctTbl; *list != 0; id++, list++) {
|
|
if (*list == c) {
|
|
data_num = DATA_MAKE_NUM(DATADIR_GAMEMES, id + (VERSION_JPN ? 153 : 154));
|
|
return HuSprAnimRead(SeqReadFile(data_num));
|
|
}
|
|
}
|
|
if (str[1] == 222) { // ゛
|
|
list = seqFontKanaTbl;
|
|
list += 55;
|
|
id = 55;
|
|
}
|
|
else if (str[1] == 223) { // ゜
|
|
list = seqFontKanaTbl;
|
|
list += 75;
|
|
id = 75;
|
|
}
|
|
else {
|
|
list = seqFontKanaTbl;
|
|
id = 0;
|
|
}
|
|
while (*list != 0) {
|
|
if (*list == c) {
|
|
if (flags & 0x1) {
|
|
data_num = DATA_MAKE_NUM(DATADIR_GAMEMES, id + (VERSION_JPN ? 155 : 156));
|
|
}
|
|
else {
|
|
data_num = DATA_MAKE_NUM(DATADIR_GAMEMES, id + (VERSION_JPN ? 72 : 73));
|
|
}
|
|
return HuSprAnimRead(SeqReadFile(data_num));
|
|
}
|
|
id++;
|
|
list++;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static float ForceDefine480()
|
|
{
|
|
return 480.0f;
|
|
}
|
|
|
|
static void SeqPlayStartFX(void);
|
|
|
|
s32 MGSeqInitMGBasic(SeqWork *work, va_list params)
|
|
{
|
|
s16 i;
|
|
s16 word_grp;
|
|
|
|
work->state = va_arg(params, int);
|
|
if (work->state == 2) {
|
|
return MGSeqInitDraw(work, params);
|
|
}
|
|
work->type = 0;
|
|
work->angle = 0;
|
|
|
|
{
|
|
s32 word_katakana;
|
|
s32 word_flag;
|
|
s32 word_ofs;
|
|
word_katakana = 0;
|
|
if (work->state == 2 && seqLanguage == 0) {
|
|
word_katakana = 1;
|
|
}
|
|
if (word_katakana) {
|
|
word_flag = 1;
|
|
}
|
|
else {
|
|
word_flag = 0;
|
|
}
|
|
if (seqLanguage == 0) {
|
|
word_ofs = 0;
|
|
}
|
|
else {
|
|
word_ofs = 3;
|
|
}
|
|
word_grp = SeqMakeWord(work, wordMgTbl[work->state + word_ofs], word_flag);
|
|
}
|
|
HuSprGrpPosSet(work->spr_grp[word_grp], 0.0f, 0.0f);
|
|
|
|
for (i = 0; i < work->word_len; i++) {
|
|
HuSprTPLvlSet(work->spr_grp[word_grp], i, 1.0f);
|
|
HuSprPosSet(work->spr_grp[word_grp], i, -100.0f, HU_DISP_CENTERY);
|
|
}
|
|
if (seqPauseF) {
|
|
work->type = 2;
|
|
HuSprAttrSet(word_grp, 0, HUSPR_ATTR_DISPOFF);
|
|
}
|
|
else {
|
|
work->param[0] = 3;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
s32 MGSeqUpdateMGBasic(SeqWork *work)
|
|
{
|
|
s16 idx;
|
|
float scale;
|
|
if (work->param[0] != 0 && work->type != -1) {
|
|
switch (work->param[0]) {
|
|
case 2:
|
|
if (work->param[1] != -1) {
|
|
(void)work; // HACK: to introduce extra branch
|
|
}
|
|
else {
|
|
work->type = -1;
|
|
work->angle = 0.0f;
|
|
}
|
|
work->param[0] = 0;
|
|
break;
|
|
|
|
case 1:
|
|
work->time_max = work->param[1];
|
|
work->param[0] = 0;
|
|
break;
|
|
|
|
case 3:
|
|
work->type = 1;
|
|
work->param[0] = 0;
|
|
break;
|
|
|
|
default:
|
|
work->param[0] = 0;
|
|
break;
|
|
}
|
|
}
|
|
if (work->type == 2) {
|
|
return 1;
|
|
}
|
|
work->time += seqSpeed;
|
|
if (work->time >= work->time_max && work->type != -1) {
|
|
work->type = -1;
|
|
work->angle = 0.0f;
|
|
}
|
|
if (work->type) {
|
|
switch (work->type) {
|
|
case 1: {
|
|
float pos_x;
|
|
float time;
|
|
s16 i;
|
|
if (work->state == 0) {
|
|
if (work->time <= 40) {
|
|
for (i = 0; i < work->word_len; i++) {
|
|
time = work->time - ((20 / work->word_len) * (work->word_len - i - 1));
|
|
if (time < 0 || time > 20.0f) {
|
|
continue;
|
|
}
|
|
pos_x = (work->x - (0.5f * (work->word_len * 56))) + 28.0f + (i * 56);
|
|
if (time == 20.0f) {
|
|
HuSprPosSet(work->spr_grp[0], i, pos_x, work->y);
|
|
HuSprZRotSet(work->spr_grp[0], i, 0.0f);
|
|
}
|
|
else {
|
|
HuSprPosSet(work->spr_grp[0], i, pos_x - (((1.0 - sin(((time * 4.5f) * M_PI) / 180.0)) * (work->word_len * 56 * 2))),
|
|
work->y);
|
|
HuSprZRotSet(work->spr_grp[0], i, (time / 20.0f) * 390.0f);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
time = work->time - 40;
|
|
scale = work->scale_x + (0.5 * sin(((time * 9.0f) * M_PI) / 180.0));
|
|
for (i = 0; i < work->word_len; i++) {
|
|
pos_x = ((28.0f * scale) + (work->x - (0.5f * (scale * (work->word_len * 56))))) + (scale * (i * 56));
|
|
HuSprPosSet(work->spr_grp[0], i, pos_x, work->y);
|
|
HuSprScaleSet(work->spr_grp[0], i, scale, work->scale_y + sin(((time * 9.0f) * M_PI) / 180.0));
|
|
}
|
|
}
|
|
if (work->time == 40) {
|
|
idx = HuAudFXPlay(36);
|
|
work->stat |= 0x10;
|
|
}
|
|
if (work->time == 60) {
|
|
SeqPlayStartFX();
|
|
work->stat |= 0x4;
|
|
}
|
|
if (work->time >= 60) {
|
|
work->type = 0;
|
|
}
|
|
}
|
|
else {
|
|
if (work->time == 1) {
|
|
if (work->state == 1) {
|
|
HuAudFXPlay(37);
|
|
}
|
|
else {
|
|
HuAudFXPlay(40);
|
|
}
|
|
MGSeqPauseEnableCtrl(0);
|
|
work->stat |= 0x10;
|
|
}
|
|
if (work->time <= 20) {
|
|
time = work->time;
|
|
scale = work->scale_x + (0.5 * sin(((time * 9.0f) * M_PI) / 180.0));
|
|
for (i = 0; i < work->word_len; i++) {
|
|
HuSprAttrReset(work->spr_grp[0], i, HUSPR_ATTR_DISPOFF);
|
|
pos_x = ((28.0f * scale) + (work->x - (0.5f * (scale * (work->word_len * 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->word_len; i++) {
|
|
HuSprAttrReset(work->spr_grp[0], i, HUSPR_ATTR_DISPOFF);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if (work->time > 80) {
|
|
for (i = 0; i < work->word_len; i++) {
|
|
time = (work->time - 80) - ((20 / work->word_len) * (work->word_len - i - 1));
|
|
if (time < 0.0f || time > 20.0f) {
|
|
continue;
|
|
}
|
|
pos_x = (28.0f + (work->x - (0.5f * (work->word_len * 56)))) + (i * 56);
|
|
if (time == 20.0f) {
|
|
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->word_len * 56 * 2)), work->y);
|
|
HuSprZRotSet(work->spr_grp[0], i, (time / 20.0f) * 390.0f);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (work->time == 110) {
|
|
work->stat |= 0x4;
|
|
}
|
|
if (work->time >= 110) {
|
|
work->type = 0;
|
|
work->stat |= 8;
|
|
}
|
|
}
|
|
} break;
|
|
|
|
case -1: {
|
|
work->angle += seqSpeed * 0.1f;
|
|
scale = 1.0f - work->angle;
|
|
if (scale <= 0.0f) {
|
|
scale = 0.0f;
|
|
work->type = 0;
|
|
work->stat |= 0x8;
|
|
if (work->state == 0) {
|
|
MGSeqPauseEnableCtrl(1);
|
|
}
|
|
}
|
|
for (idx = 0; idx < work->word_len; idx++) {
|
|
HuSprTPLvlSet(work->spr_grp[0], idx, scale);
|
|
}
|
|
} break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
if (seqDoneF || (work->stat & 0x8)) {
|
|
MGSeqSprKill(work);
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
s32 MGSeqInitMGCommon(SeqWork *work, va_list params)
|
|
{
|
|
s16 i;
|
|
float tp_lvl;
|
|
s16 j;
|
|
s16 word_grp;
|
|
|
|
work->state = va_arg(params, int);
|
|
if (work->state == 2) {
|
|
return MGSeqInitDraw(work, params);
|
|
}
|
|
work->type = 0;
|
|
work->angle = 0;
|
|
tp_lvl = 1.0f;
|
|
for (i = 0; i < 4; i++) {
|
|
if (i == 0) {
|
|
s32 word_katakana;
|
|
s32 word_flag;
|
|
s32 word_ofs;
|
|
word_katakana = 0;
|
|
if (work->state == 2 && seqLanguage == 0) {
|
|
word_katakana = 1;
|
|
}
|
|
if (word_katakana) {
|
|
word_flag = 1;
|
|
}
|
|
else {
|
|
word_flag = 0;
|
|
}
|
|
if (seqLanguage == 0) {
|
|
word_ofs = 0;
|
|
}
|
|
else {
|
|
word_ofs = 3;
|
|
}
|
|
word_grp = SeqMakeWord(work, wordMgTbl[work->state + word_ofs], word_flag);
|
|
}
|
|
else {
|
|
s16 grp_idx;
|
|
s32 new_grp;
|
|
for (grp_idx = 0; grp_idx < 16; grp_idx++) {
|
|
if (work->spr_grp[grp_idx] == -1) {
|
|
break;
|
|
}
|
|
}
|
|
if (grp_idx == 16) {
|
|
new_grp = -1;
|
|
}
|
|
else {
|
|
work->spr_grp[grp_idx] = HuSprGrpCopy(work->spr_grp[word_grp]);
|
|
new_grp = grp_idx;
|
|
}
|
|
(void)new_grp;
|
|
word_grp = new_grp;
|
|
}
|
|
HuSprGrpPosSet(work->spr_grp[word_grp], 0.0f, 0.0f);
|
|
for (j = 0; j < work->word_len; j++) {
|
|
HuSprTPLvlSet(work->spr_grp[word_grp], j, tp_lvl);
|
|
HuSprPosSet(work->spr_grp[word_grp], j, -100.0f, HU_DISP_CENTERY);
|
|
HuSprPriSet(work->spr_grp[word_grp], j, i + 5);
|
|
HuSprAttrSet(work->spr_grp[word_grp], i, HUSPR_ATTR_LINEAR);
|
|
}
|
|
if (i == 0) {
|
|
tp_lvl -= 0.5;
|
|
}
|
|
else {
|
|
tp_lvl -= 0.1f;
|
|
}
|
|
}
|
|
if (seqPauseF) {
|
|
work->type = 2;
|
|
HuSprAttrSet(word_grp, 0, HUSPR_ATTR_DISPOFF);
|
|
}
|
|
else {
|
|
work->param[0] = 3;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
s32 MGSeqUpdateMGBattle(SeqWork *work)
|
|
{
|
|
s16 idx;
|
|
float scale;
|
|
if (work->param[0] != 0 && work->type != -1) {
|
|
switch (work->param[0]) {
|
|
case 2:
|
|
if (work->param[1] != -1) {
|
|
(void)work; // HACK: to introduce extra branch
|
|
}
|
|
else {
|
|
work->type = -1;
|
|
work->angle = 0.0f;
|
|
}
|
|
work->param[0] = 0;
|
|
break;
|
|
|
|
case 1:
|
|
work->time_max = work->param[1];
|
|
work->param[0] = 0;
|
|
break;
|
|
|
|
case 3:
|
|
work->type = 1;
|
|
work->param[0] = 0;
|
|
break;
|
|
|
|
default:
|
|
work->param[0] = 0;
|
|
break;
|
|
}
|
|
}
|
|
if (work->type == 2) {
|
|
return 1;
|
|
}
|
|
work->time += seqSpeed;
|
|
if (work->time >= work->time_max && work->type != -1) {
|
|
work->stat |= 0x4;
|
|
work->type = -1;
|
|
work->angle = 0.0f;
|
|
}
|
|
if (work->type) {
|
|
switch (work->type) {
|
|
case 1: {
|
|
s16 i, j;
|
|
float time;
|
|
float pos_x;
|
|
if (work->state == 0) {
|
|
if (work->time < 45) {
|
|
if (work->time > 10 && work->time <= 40) {
|
|
time = work->time - 10;
|
|
scale = 10.0f * (1.0f - (time / 30.0f));
|
|
pos_x = (work->x - (0.5f * (work->word_len * 56))) + 28.0f;
|
|
HuSprPosSet(work->spr_grp[0], 0, pos_x, work->y);
|
|
HuSprScaleSet(work->spr_grp[0], 0, work->scale_x + scale, work->scale_y + scale);
|
|
scale = time / 30.0f;
|
|
HuSprTPLvlSet(work->spr_grp[0], 0, scale);
|
|
}
|
|
for (i = 0; i < 4; i++) {
|
|
time = work->time - i;
|
|
if (time < 0 || time > 40) {
|
|
continue;
|
|
}
|
|
for (j = 1; j < work->word_len; j++) {
|
|
pos_x = (28.0f + (work->x - (0.5f * (work->word_len * 56)))) + (j * 56);
|
|
if (time == 40.0f) {
|
|
HuSprPosSet(work->spr_grp[i], j, pos_x, work->y);
|
|
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, HUSPR_ATTR_DISPOFF);
|
|
}
|
|
}
|
|
else {
|
|
s16 discard_cnt;
|
|
static float letterOfs[] = { 30, 20, 20, 3, -4, 20, -30, 20, 20, 20, -30, 20, -10, 40, 10, -40 };
|
|
float x, y;
|
|
float ofs_x, ofs_y;
|
|
float zrot, scale_ang;
|
|
x = pos_x;
|
|
y = work->y;
|
|
ofs_x = letterOfs[((j - 1) & 0x7) * 2];
|
|
ofs_y = letterOfs[(((j - 1) & 0x7) * 2) + 1];
|
|
zrot = 0.0f;
|
|
discard_cnt = 0;
|
|
scale_ang = 0.0f;
|
|
for (idx = 0; idx < 40.0f - time; idx++) {
|
|
if (x + ofs_x > HU_DISP_WIDTH || x + ofs_x < 0) {
|
|
ofs_x = -ofs_x;
|
|
discard_cnt++;
|
|
}
|
|
if (y + ofs_y > HU_DISP_HEIGHT || y + ofs_y < 0) {
|
|
ofs_y = -ofs_y;
|
|
discard_cnt++;
|
|
}
|
|
if (discard_cnt) {
|
|
zrot += 20.0f;
|
|
scale_ang = 0.0f;
|
|
}
|
|
x += ofs_x;
|
|
y += ofs_y;
|
|
}
|
|
HuSprPosSet(work->spr_grp[i], j, x, y);
|
|
HuSprScaleSet(work->spr_grp[i], j, work->scale_x * cos((M_PI * scale_ang) / 180.0), work->scale_y);
|
|
HuSprZRotSet(work->spr_grp[i], j, zrot);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if (work->time > 60) {
|
|
time = work->time - 60;
|
|
scale = 0.5 * sin((M_PI * (time * 9.0f)) / 180.0);
|
|
for (j = 0; j < work->word_len; j++) {
|
|
pos_x = (28.0f * (scale + work->scale_x)) + (work->x - (0.5f * ((work->word_len * 56) * (scale + work->scale_x))))
|
|
+ ((j * 56) * (scale + work->scale_x));
|
|
HuSprPosSet(work->spr_grp[0], j, pos_x, work->y);
|
|
HuSprScaleSet(work->spr_grp[0], j, work->scale_x + scale, work->scale_y + scale);
|
|
}
|
|
}
|
|
}
|
|
if (work->time == 60) {
|
|
HuAudFXPlay(36);
|
|
work->stat |= 0x10;
|
|
}
|
|
if (work->time == 80) {
|
|
work->stat |= 0x4;
|
|
SeqPlayStartFX();
|
|
}
|
|
if (work->time >= 80) {
|
|
work->type = 0;
|
|
}
|
|
}
|
|
else {
|
|
if (work->time == 1) {
|
|
if (work->state == 1) {
|
|
HuAudFXPlay(37);
|
|
}
|
|
else {
|
|
HuAudFXPlay(40);
|
|
}
|
|
MGSeqPauseEnableCtrl(0);
|
|
work->stat |= 0x10;
|
|
}
|
|
if (work->time <= 20) {
|
|
for (i = 1; i < 4; i++) {
|
|
for (j = 0; j < work->word_len; j++) {
|
|
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->word_len; j++) {
|
|
HuSprAttrReset(work->spr_grp[0], j, HUSPR_ATTR_DISPOFF);
|
|
pos_x = ((28.0f * scale) + (work->x - (0.5f * (scale * (work->word_len * 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->word_len; j++) {
|
|
HuSprAttrReset(work->spr_grp[0], j, HUSPR_ATTR_DISPOFF);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if (work->time > 80 && work->time <= 95) {
|
|
time = work->time - 80;
|
|
for (j = 0; j < work->word_len; j++) {
|
|
pos_x = (28.0f + (work->x - (0.5f * (work->word_len * 56)))) + (j * 56);
|
|
HuSprPosSet(
|
|
work->spr_grp[0], j, pos_x + ((HU_DISP_CENTERX - pos_x) * (1.0 - cos((M_PI * (time * 6.0)) / 180.0))), work->y);
|
|
}
|
|
if (time == 15.0f) {
|
|
for (j = 0; j < work->word_len; j++) {
|
|
HuSprAttrReset(work->spr_grp[1], j, HUSPR_ATTR_DISPOFF);
|
|
HuSprPosSet(work->spr_grp[1], j, HU_DISP_CENTERX, work->y);
|
|
HuSprTPLvlSet(work->spr_grp[1], j, 1.0f);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if (work->time > 105) {
|
|
for (j = 0; j < work->word_len; j++) {
|
|
time = work->time - 105;
|
|
time -= j * 3;
|
|
if (time < 0) {
|
|
continue;
|
|
}
|
|
scale = 1.0f - (time / 15.0f);
|
|
if (scale < 0.0f) {
|
|
scale = 0.0f;
|
|
}
|
|
HuSprPosSet(work->spr_grp[0], j, HU_DISP_CENTERX, work->y + ((-100.0f - work->y) * (time / 20.0f)));
|
|
HuSprTPLvlSet(work->spr_grp[0], j, scale);
|
|
HuSprPosSet(work->spr_grp[1], j, HU_DISP_CENTERX, work->y + ((580.0f - work->y) * (time / 20.0f)));
|
|
HuSprTPLvlSet(work->spr_grp[1], j, scale);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (work->time == 130) {
|
|
work->stat |= 0x4;
|
|
}
|
|
if (work->time >= 130) {
|
|
work->type = 0;
|
|
work->stat |= 0x8;
|
|
}
|
|
}
|
|
|
|
} break;
|
|
|
|
case -1: {
|
|
work->angle += seqSpeed * 0.1f;
|
|
scale = 1.0f - work->angle;
|
|
if (scale <= 0.0f) {
|
|
scale = 0.0f;
|
|
work->type = 0;
|
|
work->stat |= 0x8;
|
|
if (work->state == 0) {
|
|
MGSeqPauseEnableCtrl(1);
|
|
}
|
|
}
|
|
for (idx = 0; idx < work->word_len; idx++) {
|
|
HuSprTPLvlSet(work->spr_grp[0], idx, scale);
|
|
}
|
|
} break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
if (seqDoneF || (work->stat & 0x8)) {
|
|
MGSeqSprKill(work);
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
s32 MGSeqUpdateMG1vs3(SeqWork *work)
|
|
{
|
|
s16 idx;
|
|
float scale;
|
|
if (work->param[0] != 0 && work->type != -1) {
|
|
switch (work->param[0]) {
|
|
case 2:
|
|
if (work->param[1] != -1) {
|
|
(void)work; // HACK: to introduce extra branch
|
|
}
|
|
else {
|
|
work->type = -1;
|
|
work->angle = 0.0f;
|
|
}
|
|
work->param[0] = 0;
|
|
break;
|
|
|
|
case 1:
|
|
work->time_max = work->param[1];
|
|
work->param[0] = 0;
|
|
break;
|
|
|
|
case 3:
|
|
work->type = 1;
|
|
work->param[0] = 0;
|
|
break;
|
|
|
|
default:
|
|
work->param[0] = 0;
|
|
break;
|
|
}
|
|
}
|
|
if (work->type == 2) {
|
|
return 1;
|
|
}
|
|
work->time += seqSpeed;
|
|
if (work->time >= work->time_max && work->type != -1) {
|
|
work->stat |= 0x4;
|
|
work->type = -1;
|
|
work->angle = 0.0f;
|
|
}
|
|
if (work->type) {
|
|
switch (work->type) {
|
|
case 1: {
|
|
float time;
|
|
float scale_x, scale_y;
|
|
float pos_x, pos_y;
|
|
s16 i;
|
|
s16 j;
|
|
if (work->state == 0) {
|
|
if (work->time <= 10) {
|
|
scale = work->time / 10.0f;
|
|
time = work->time;
|
|
for (idx = 0; idx < work->word_len; idx++) {
|
|
scale_x = 0.3 * work->scale_x;
|
|
scale_y = 0.3 * work->scale_y;
|
|
pos_x = ((28.0f * scale_x) + (work->x - (0.5f * (scale_x * (work->word_len * 56))))) + (scale_x * (idx * 56));
|
|
pos_y = work->y - (150.0 * sin((M_PI * (((16.0f / 3.0f) * time) + 20.0f)) / 180.0));
|
|
HuSprPosSet(work->spr_grp[0], idx, pos_x, pos_y);
|
|
HuSprScaleSet(work->spr_grp[0], idx, scale_x, scale_y * cos(M_PI * (12.0f * time) / 180.0));
|
|
HuSprTPLvlSet(work->spr_grp[0], idx, scale);
|
|
}
|
|
}
|
|
else {
|
|
if (work->time <= 60) {
|
|
for (i = 0; i < 4; i++) {
|
|
for (idx = 0; idx < work->word_len; idx++) {
|
|
time = (work->time - 10) - (idx * 3) - i;
|
|
if (time < 0.0f) {
|
|
time = 0.0f;
|
|
}
|
|
else {
|
|
if (time > 30.0f) {
|
|
continue;
|
|
}
|
|
}
|
|
scale = 0.3 + (0.7 * (1.0 - cos((M_PI * (time * 3.0f)) / 180.0)));
|
|
scale_x = work->scale_x * scale;
|
|
scale_y = work->scale_y * scale;
|
|
pos_x = ((28.0f * scale_x) + (work->x - (0.5f * (scale_x * (work->word_len * 56))))) + (scale_x * (idx * 56));
|
|
pos_y = work->y - (150.0 * sin((M_PI * (((16.0f / 3.0f) * time) + 20.0f)) / 180.0));
|
|
HuSprPosSet(work->spr_grp[i], idx, pos_x, pos_y);
|
|
HuSprScaleSet(work->spr_grp[i], idx, scale_x, scale_y * cos(M_PI * (12.0f * time) / 180.0));
|
|
}
|
|
}
|
|
if (work->time == 60) {
|
|
for (i = 1; i < 4; i++) {
|
|
for (j = 0; j < work->word_len; j++) {
|
|
HuSprAttrSet(work->spr_grp[i], j, HUSPR_ATTR_DISPOFF);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if (work->time > 70) {
|
|
time = work->time - 70;
|
|
scale = 0.5 * sin((M_PI * (time * 9.0f)) / 180.0);
|
|
for (j = 0; j < work->word_len; j++) {
|
|
pos_x = (28.0f * (scale + work->scale_x)) + (work->x - (0.5f * ((work->word_len * 56) * (scale + work->scale_x))))
|
|
+ ((j * 56) * (scale + work->scale_x));
|
|
HuSprPosSet(work->spr_grp[0], j, pos_x, work->y);
|
|
HuSprScaleSet(work->spr_grp[0], j, work->scale_x + scale, work->scale_y + scale);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (work->time == 70) {
|
|
HuAudFXPlay(36);
|
|
work->stat |= 0x10;
|
|
}
|
|
if (work->time == 90) {
|
|
work->stat |= 0x4;
|
|
SeqPlayStartFX();
|
|
}
|
|
if (work->time >= 90) {
|
|
work->type = 0;
|
|
}
|
|
}
|
|
else {
|
|
if (work->time == 1) {
|
|
if (work->state == 1) {
|
|
HuAudFXPlay(37);
|
|
}
|
|
else {
|
|
HuAudFXPlay(40);
|
|
}
|
|
MGSeqPauseEnableCtrl(0);
|
|
work->stat |= 0x10;
|
|
}
|
|
if (work->time <= 20) {
|
|
for (i = 1; i < 4; i++) {
|
|
for (j = 0; j < work->word_len; j++) {
|
|
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->word_len; j++) {
|
|
HuSprAttrReset(work->spr_grp[0], j, HUSPR_ATTR_DISPOFF);
|
|
pos_x = ((28.0f * scale) + (work->x - (0.5f * (scale * (work->word_len * 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 (i = 1; i < 4; i++) {
|
|
for (j = 0; j < work->word_len; j++) {
|
|
HuSprAttrReset(work->spr_grp[i], j, HUSPR_ATTR_DISPOFF);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if (work->time > 80 || work->time < 140) {
|
|
for (i = 0; i < 4; i++) {
|
|
for (j = 0; j < work->word_len; j++) {
|
|
time = (work->time - 80) - i - j;
|
|
if (time < 0 || time > 40) {
|
|
continue;
|
|
}
|
|
if (time <= 20) {
|
|
float pos_base = (28.0f + (work->x - (0.5f * (work->word_len * 56)))) + (j * 56);
|
|
pos_x = (28.0f + (work->x - (0.5f * (work->word_len * 56)))) + ((work->word_len - j - 1) * 56);
|
|
HuSprPosSet(work->spr_grp[i], j, pos_base + ((time / 20.0f) * (pos_x - pos_base)),
|
|
work->y + (((HU_DISP_HEIGHT - 40) - work->y) * (time / 20.0f)));
|
|
}
|
|
else {
|
|
time -= 20.0f;
|
|
pos_x = (28.0f + (work->x - (0.5f * (work->word_len * 56)))) + ((work->word_len - j - 1) * 56);
|
|
pos_y = HU_DISP_HEIGHT - 40;
|
|
HuSprPosSet(work->spr_grp[i], j, pos_x, pos_y + ((-40.0f - pos_y) * (time / 20.0f)));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (work->time == 140) {
|
|
work->stat |= 0x4;
|
|
}
|
|
if (work->time >= 140) {
|
|
work->type = 0;
|
|
work->stat |= 0x8;
|
|
}
|
|
}
|
|
} break;
|
|
|
|
case -1: {
|
|
work->angle += seqSpeed * 0.1f;
|
|
scale = 1.0f - work->angle;
|
|
if (scale <= 0.0f) {
|
|
scale = 0.0f;
|
|
work->type = 0;
|
|
work->stat |= 0x8;
|
|
if (work->state == 0) {
|
|
MGSeqPauseEnableCtrl(1);
|
|
}
|
|
}
|
|
for (idx = 0; idx < work->word_len; idx++) {
|
|
HuSprTPLvlSet(work->spr_grp[0], idx, scale);
|
|
}
|
|
} break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
if (seqDoneF || (work->stat & 0x8)) {
|
|
MGSeqSprKill(work);
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
s32 MGSeqUpdateMGStory(SeqWork *work)
|
|
{
|
|
s16 idx;
|
|
float scale;
|
|
if (work->param[0] != 0 && work->type != -1) {
|
|
switch (work->param[0]) {
|
|
case 2:
|
|
if (work->param[1] != -1) {
|
|
(void)work; // HACK: to introduce extra branch
|
|
}
|
|
else {
|
|
work->type = -1;
|
|
work->angle = 0.0f;
|
|
}
|
|
work->param[0] = 0;
|
|
break;
|
|
|
|
case 1:
|
|
work->time_max = work->param[1];
|
|
work->param[0] = 0;
|
|
break;
|
|
|
|
case 3:
|
|
work->type = 1;
|
|
work->param[0] = 0;
|
|
break;
|
|
|
|
default:
|
|
work->param[0] = 0;
|
|
break;
|
|
}
|
|
}
|
|
if (work->type == 2) {
|
|
return 1;
|
|
}
|
|
work->time += seqSpeed;
|
|
if (work->time >= work->time_max && work->type != -1) {
|
|
work->stat |= 0x4;
|
|
work->type = -1;
|
|
work->angle = 0.0f;
|
|
}
|
|
if (work->type) {
|
|
switch (work->type) {
|
|
case 1: {
|
|
float pos_x, pos_y;
|
|
float time;
|
|
s16 i;
|
|
s16 j;
|
|
if (work->state == 0) {
|
|
if (work->time <= 30) {
|
|
for (idx = 0; idx < work->word_len; idx++) {
|
|
time = (work->time - (idx * 2));
|
|
if (time < 0.0f || time > 15.0f) {
|
|
continue;
|
|
}
|
|
pos_x = -50.0f;
|
|
HuSprPosSet(work->spr_grp[0], idx, pos_x + ((HU_DISP_CENTERX - pos_x) * (time / 15.0f)), work->y);
|
|
HuSprTPLvlSet(work->spr_grp[0], idx, 1.0f);
|
|
HuSprZRotSet(work->spr_grp[0], idx, (1.0 - (time / 15.0f)) * 180.0);
|
|
pos_x = HU_DISP_WIDTH + 50;
|
|
HuSprPosSet(work->spr_grp[1], idx, pos_x + ((HU_DISP_CENTERX - pos_x) * (time / 15.0f)), work->y);
|
|
HuSprTPLvlSet(work->spr_grp[1], idx, 1.0f);
|
|
HuSprZRotSet(work->spr_grp[1], idx, (1.0 - (time / 15.0f)) * -180.0);
|
|
}
|
|
if (work->time == 30) {
|
|
for (j = 0; j < work->word_len; j++) {
|
|
HuSprAttrSet(work->spr_grp[1], j, HUSPR_ATTR_DISPOFF);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if (work->time > 35 && work->time <= 45) {
|
|
time = work->time - 35;
|
|
for (idx = 0; idx < work->word_len; idx++) {
|
|
pos_x = (work->x - (0.5f * (work->word_len * 56))) + 28.0f + (idx * 56);
|
|
HuSprPosSet(work->spr_grp[0], idx, HU_DISP_CENTERX + ((pos_x - HU_DISP_CENTERX) * (time / 10.0f)), work->y);
|
|
}
|
|
}
|
|
else {
|
|
if (work->time > 55) {
|
|
time = work->time - 55;
|
|
scale = 0.5 * sin(M_PI * (9.0f * time) / 180.0);
|
|
for (j = 0; j < work->word_len; j++) {
|
|
pos_x = (28.0f * (scale + work->scale_x)) + (work->x - (0.5f * ((work->word_len * 56) * (scale + work->scale_x))))
|
|
+ ((j * 56) * (scale + work->scale_x));
|
|
HuSprPosSet(work->spr_grp[0], j, pos_x, work->y);
|
|
HuSprScaleSet(work->spr_grp[0], j, work->scale_x + scale, work->scale_y + scale);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (work->time == 55) {
|
|
HuAudFXPlay(36);
|
|
work->stat |= 0x10;
|
|
}
|
|
if (work->time == 75) {
|
|
SeqPlayStartFX();
|
|
work->stat |= 0x4;
|
|
}
|
|
if (work->time >= 75) {
|
|
work->type = 0;
|
|
}
|
|
}
|
|
else {
|
|
if (work->time == 1) {
|
|
if (work->state == 1) {
|
|
HuAudFXPlay(37);
|
|
}
|
|
else {
|
|
HuAudFXPlay(40);
|
|
}
|
|
MGSeqPauseEnableCtrl(0);
|
|
work->stat |= 0x10;
|
|
}
|
|
if (work->time <= 20) {
|
|
for (i = 1; i < 4; i++) {
|
|
for (j = 0; j < work->word_len; j++) {
|
|
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->word_len; j++) {
|
|
HuSprAttrReset(work->spr_grp[0], j, HUSPR_ATTR_DISPOFF);
|
|
pos_x = ((28.0f * scale) + (work->x - (0.5f * (scale * (work->word_len * 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 (i = 1; i < 4; i++) {
|
|
for (j = 0; j < work->word_len; j++) {
|
|
HuSprAttrReset(work->spr_grp[i], j, HUSPR_ATTR_DISPOFF);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (work->time > 80 && work->time < 160) {
|
|
for (i = 0; i < 4; i++) {
|
|
for (j = 0; j < work->word_len; j++) {
|
|
s16 initF;
|
|
float dx, dy;
|
|
time = (work->time - 80) - i;
|
|
if (time < 0 || time > 60) {
|
|
continue;
|
|
}
|
|
pos_x = (28.0f + (work->x - (0.5f * (work->word_len * 56)))) + (j * 56);
|
|
dx = 28.0f + (work->x - (0.5f * (work->word_len * 56)));
|
|
pos_y = work->y;
|
|
for (idx = initF = 0; idx < time; idx++) {
|
|
if (!initF) {
|
|
pos_x -= 20.0f;
|
|
if (pos_x <= dx) {
|
|
pos_x = 28.0f + (work->x - (0.5f * (work->word_len * 56)));
|
|
initF = 1;
|
|
dy = 25.0f;
|
|
dx = 10.0f;
|
|
}
|
|
}
|
|
else {
|
|
pos_x += dx;
|
|
pos_y += dy;
|
|
dx += 0.1;
|
|
dy -= 2.0f;
|
|
if (pos_y < 0.0f) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
HuSprPosSet(work->spr_grp[i], j, pos_x, pos_y);
|
|
}
|
|
}
|
|
}
|
|
if (work->time == 160) {
|
|
work->stat |= 0x4;
|
|
}
|
|
if (work->time >= 160) {
|
|
work->type = 0;
|
|
work->stat |= 0x8;
|
|
}
|
|
}
|
|
} break;
|
|
|
|
case -1: {
|
|
work->angle += seqSpeed * 0.1f;
|
|
scale = 1.0f - work->angle;
|
|
if (scale <= 0.0f) {
|
|
scale = 0.0f;
|
|
work->type = 0;
|
|
work->stat |= 0x8;
|
|
if (work->state == 0) {
|
|
MGSeqPauseEnableCtrl(1);
|
|
}
|
|
}
|
|
for (idx = 0; idx < work->word_len; idx++) {
|
|
HuSprTPLvlSet(work->spr_grp[0], idx, scale);
|
|
}
|
|
} break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
if (seqDoneF || (work->stat & 0x8)) {
|
|
MGSeqSprKill(work);
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
s32 MGSeqUpdateMG2vs2(SeqWork *work)
|
|
{
|
|
s16 idx;
|
|
float scale;
|
|
if (work->param[0] != 0 && work->type != -1) {
|
|
switch (work->param[0]) {
|
|
case 2:
|
|
if (work->param[1] != -1) {
|
|
(void)work; // HACK: to introduce extra branch
|
|
}
|
|
else {
|
|
work->type = -1;
|
|
work->angle = 0.0f;
|
|
}
|
|
work->param[0] = 0;
|
|
break;
|
|
|
|
case 1:
|
|
work->time_max = work->param[1];
|
|
work->param[0] = 0;
|
|
break;
|
|
|
|
case 3:
|
|
work->type = 1;
|
|
work->param[0] = 0;
|
|
break;
|
|
|
|
default:
|
|
work->param[0] = 0;
|
|
break;
|
|
}
|
|
}
|
|
if (work->type == 2) {
|
|
return 1;
|
|
}
|
|
work->time += seqSpeed;
|
|
if (work->time >= work->time_max && work->type != -1) {
|
|
work->stat |= 0x4;
|
|
work->type = -1;
|
|
work->angle = 0.0f;
|
|
}
|
|
if (work->type) {
|
|
switch (work->type) {
|
|
case 1: {
|
|
static s16 letterOfs[] = { -10, -50, 0, -30, 5, -60, -10, 60, 8, -40, 5, 50, -10, 20 };
|
|
|
|
float pos_x;
|
|
float time;
|
|
s16 i;
|
|
s16 j;
|
|
if (work->state == 0) {
|
|
if (work->time <= 30) {
|
|
time = work->time;
|
|
for (idx = 0; idx < work->word_len; idx++) {
|
|
pos_x = (28.0f + (work->x - (0.5f * (work->scale_x * (work->word_len * 56))))) + (idx * 56);
|
|
HuSprPosSet(work->spr_grp[0], idx, pos_x + ((1.0f - (time / 30.0f)) * letterOfs[(idx * 2)]),
|
|
work->y + ((1.0f - (time / 30.0f)) * letterOfs[(idx * 2) + 1]));
|
|
HuSprTPLvlSet(work->spr_grp[0], idx, time / 30.0f);
|
|
}
|
|
}
|
|
else {
|
|
if (work->time > 40 && work->time <= 60) {
|
|
time = work->time - 40;
|
|
scale = 0.5 * sin(((time * 9.0f) * M_PI) / 180.0);
|
|
for (j = 0; j < work->word_len; j++) {
|
|
pos_x = (28.0f * (scale + work->scale_x)) + (work->x - (0.5f * ((work->word_len * 56) * (scale + work->scale_x))))
|
|
+ ((j * 56) * (scale + work->scale_x));
|
|
HuSprPosSet(work->spr_grp[0], j, pos_x, work->y);
|
|
HuSprScaleSet(work->spr_grp[0], j, work->scale_x + scale, work->scale_y + scale);
|
|
}
|
|
}
|
|
}
|
|
if (work->time == 40) {
|
|
HuAudFXPlay(36);
|
|
work->stat |= 0x10;
|
|
}
|
|
if (work->time == 60) {
|
|
work->stat |= 0x4;
|
|
SeqPlayStartFX();
|
|
}
|
|
if (work->time >= 60) {
|
|
work->type = 0;
|
|
}
|
|
}
|
|
else {
|
|
if (work->time == 1) {
|
|
if (work->state == 1) {
|
|
HuAudFXPlay(37);
|
|
}
|
|
else {
|
|
HuAudFXPlay(40);
|
|
}
|
|
MGSeqPauseEnableCtrl(0);
|
|
work->stat |= 0x10;
|
|
}
|
|
if (work->time <= 20) {
|
|
for (i = 1; i < 4; i++) {
|
|
for (j = 0; j < work->word_len; j++) {
|
|
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->word_len; j++) {
|
|
HuSprAttrReset(work->spr_grp[0], j, HUSPR_ATTR_DISPOFF);
|
|
pos_x = ((28.0f * scale) + (work->x - (0.5f * (scale * (work->word_len * 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 (i = 1; i < 4; i++) {
|
|
for (j = 0; j < work->word_len; j++) {
|
|
HuSprAttrReset(work->spr_grp[i], j, HUSPR_ATTR_DISPOFF);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if (work->time > 80 && work->time < 140) {
|
|
time = work->time - 80;
|
|
for (idx = 0; idx < work->word_len; idx++) {
|
|
float radius = (idx * 56) - (((work->word_len - 1) * 56) / 2);
|
|
float angle = (1.0f + (1.0f - (ABS(radius) / 320.0f))) * 720.0f;
|
|
float new_scale;
|
|
radius *= 1.0 - (time / 60.0f);
|
|
HuSprPosSet(work->spr_grp[0], idx, (radius * sin(M_PI * (((time / 60.0f) * angle) + 90.0f) / 180.0)) + work->x,
|
|
(radius * cos(M_PI * (((time / 60.0f) * angle) + 90.0f) / 180.0)) + work->y);
|
|
HuSprZRotSet(work->spr_grp[0], idx, -(time / 60.0f) * 720.0f);
|
|
new_scale = 0.5 + (0.5 * (1.0f - (time / 60.0f)));
|
|
HuSprScaleSet(work->spr_grp[0], idx, new_scale, new_scale);
|
|
HuSprTPLvlSet(work->spr_grp[0], idx, 1.0f - (time / 60.0f));
|
|
}
|
|
}
|
|
}
|
|
if (work->time == 140) {
|
|
work->stat |= 0x4;
|
|
}
|
|
if (work->time >= 150) {
|
|
work->type = 0;
|
|
work->stat |= 0x8;
|
|
}
|
|
}
|
|
} break;
|
|
|
|
case -1: {
|
|
work->angle += seqSpeed * 0.1f;
|
|
scale = 1.0f - work->angle;
|
|
if (scale <= 0.0f) {
|
|
scale = 0.0f;
|
|
work->type = 0;
|
|
work->stat |= 0x8;
|
|
if (work->state == 0) {
|
|
MGSeqPauseEnableCtrl(1);
|
|
}
|
|
}
|
|
for (idx = 0; idx < work->word_len; idx++) {
|
|
HuSprTPLvlSet(work->spr_grp[0], idx, scale);
|
|
}
|
|
} break;
|
|
|
|
default:
|
|
|
|
break;
|
|
}
|
|
}
|
|
if (seqDoneF || (work->stat & 0x8)) {
|
|
MGSeqSprKill(work);
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
s32 MGSeqInitFlip(SeqWork *work, va_list params)
|
|
{
|
|
s16 i;
|
|
s16 word_grp;
|
|
s16 word_ofs;
|
|
work->state = va_arg(params, int);
|
|
if (work->state == 2) {
|
|
return MGSeqInitDraw(work, params);
|
|
}
|
|
work->type = 0;
|
|
work->angle = 0;
|
|
{
|
|
s32 word_ofs_temp;
|
|
s32 word_katakana;
|
|
s32 word_flag;
|
|
|
|
if (seqLanguage == 0) {
|
|
word_ofs_temp = 3;
|
|
}
|
|
else {
|
|
word_ofs_temp = 0;
|
|
}
|
|
word_ofs = word_ofs_temp;
|
|
word_katakana = 0;
|
|
if (work->state == 2 && word_ofs == 0) {
|
|
word_katakana = 1;
|
|
}
|
|
if (word_katakana) {
|
|
word_flag = 1;
|
|
}
|
|
else {
|
|
word_flag = 0;
|
|
}
|
|
|
|
word_grp = SeqMakeWord(work, wordMgTbl[work->state + word_ofs], word_flag);
|
|
}
|
|
HuSprGrpPosSet(work->spr_grp[word_grp], 0.0f, 0.0f);
|
|
for (i = 0; i < work->word_len; i++) {
|
|
HuSprTPLvlSet(work->spr_grp[word_grp], i, 0.0f);
|
|
HuSprPosSet(work->spr_grp[word_grp], i, (28.0f + (work->x - (0.5f * (work->word_len * 56)))) + (i * 56), work->y);
|
|
HuSprAttrSet(work->spr_grp[word_grp], i, HUSPR_ATTR_LINEAR);
|
|
HuSprAttrReset(work->spr_grp[word_grp], i, HUSPR_ATTR_DISPOFF);
|
|
}
|
|
work->alt_word_len = work->word_len;
|
|
{
|
|
s32 word_ofs_temp;
|
|
s32 word_katakana;
|
|
s32 word_flag;
|
|
|
|
if (seqLanguage == 0) {
|
|
word_ofs_temp = 0;
|
|
}
|
|
else {
|
|
word_ofs_temp = 3;
|
|
}
|
|
word_ofs = word_ofs_temp;
|
|
word_katakana = 0;
|
|
if (work->state == 2 && word_ofs == 0) {
|
|
word_katakana = 1;
|
|
}
|
|
if (word_katakana) {
|
|
word_flag = 1;
|
|
}
|
|
else {
|
|
word_flag = 0;
|
|
}
|
|
|
|
word_grp = SeqMakeWord(work, wordMgTbl[work->state + word_ofs], word_flag);
|
|
}
|
|
HuSprGrpPosSet(work->spr_grp[word_grp], 0.0f, 0.0f);
|
|
for (i = 0; i < work->word_len; i++) {
|
|
HuSprTPLvlSet(work->spr_grp[word_grp], i, 0.0f);
|
|
HuSprPosSet(work->spr_grp[word_grp], i, (28.0f + (work->x - (0.5f * (work->word_len * 56)))) + (i * 56), work->y);
|
|
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, HUSPR_ATTR_DISPOFF);
|
|
}
|
|
else {
|
|
work->param[0] = 3;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
s32 MGSeqUpdateFlip(SeqWork *work)
|
|
{
|
|
s16 idx;
|
|
float scale;
|
|
if (work->param[0] != 0 && work->type != -1) {
|
|
switch (work->param[0]) {
|
|
case 2:
|
|
if (work->param[1] != -1) {
|
|
(void)work; // HACK: to introduce extra branch
|
|
}
|
|
else {
|
|
work->type = -1;
|
|
work->angle = 0.0f;
|
|
}
|
|
work->param[0] = 0;
|
|
break;
|
|
|
|
case 1:
|
|
work->time_max = work->param[1];
|
|
work->param[0] = 0;
|
|
break;
|
|
|
|
case 3:
|
|
work->type = 1;
|
|
work->param[0] = 0;
|
|
break;
|
|
|
|
default:
|
|
work->param[0] = 0;
|
|
break;
|
|
}
|
|
}
|
|
if (work->type == 2) {
|
|
return 1;
|
|
}
|
|
work->time += seqSpeed;
|
|
if (work->time >= work->time_max && work->type != -1) {
|
|
work->stat |= 0x4;
|
|
work->type = -1;
|
|
work->angle = 0.0f;
|
|
}
|
|
if (work->type) {
|
|
switch (work->type) {
|
|
case 1: {
|
|
float time;
|
|
float pos_x;
|
|
s16 i;
|
|
if (work->state == 0) {
|
|
if (work->time <= 10) {
|
|
for (idx = 0; idx < work->alt_word_len; idx++) {
|
|
HuSprTPLvlSet(work->spr_grp[0], idx, work->time / 10.0f);
|
|
}
|
|
}
|
|
else {
|
|
if (work->time <= 30) {
|
|
time = work->time - 10;
|
|
if (time <= 10) {
|
|
for (idx = 0; idx < work->alt_word_len; idx++) {
|
|
HuSprScaleSet(work->spr_grp[0], idx, cos(M_PI * ((time / 10.0f) * 90.0f) / 180.0), 1.0f);
|
|
}
|
|
}
|
|
else {
|
|
time -= 10.0f;
|
|
for (idx = 0; idx < work->word_len; idx++) {
|
|
HuSprTPLvlSet(work->spr_grp[1], idx, 1.0f);
|
|
HuSprScaleSet(work->spr_grp[1], idx, sin(M_PI * ((time / 10.0f) * 90.0f) / 180.0), 1.0f);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if (work->time > 35 && work->time <= 55) {
|
|
time = work->time - 35;
|
|
scale = 0.5 * sin(((time * 9.0f) * M_PI) / 180.0);
|
|
for (i = 0; i < work->word_len; i++) {
|
|
pos_x = (28.0f * (scale + work->scale_x)) + (work->x - (0.5f * ((work->word_len * 56) * (scale + work->scale_x))))
|
|
+ ((i * 56) * (scale + work->scale_x));
|
|
HuSprPosSet(work->spr_grp[1], i, pos_x, work->y);
|
|
HuSprScaleSet(work->spr_grp[1], i, work->scale_x + scale, work->scale_y + scale);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (work->time == 35) {
|
|
HuAudFXPlay(36);
|
|
work->stat |= 0x10;
|
|
}
|
|
if (work->time == 55) {
|
|
work->stat |= 0x4;
|
|
SeqPlayStartFX();
|
|
}
|
|
if (work->time >= 75) {
|
|
work->type = 0;
|
|
}
|
|
}
|
|
else {
|
|
if (work->time == 1) {
|
|
if (work->state == 1) {
|
|
HuAudFXPlay(37);
|
|
}
|
|
else {
|
|
HuAudFXPlay(40);
|
|
}
|
|
MGSeqPauseEnableCtrl(0);
|
|
work->stat |= 0x10;
|
|
}
|
|
if (work->time <= 20) {
|
|
time = work->time;
|
|
scale = 0.5 * sin(M_PI * (9.0f * time) / 180.0);
|
|
for (i = 0; i < work->word_len; i++) {
|
|
HuSprTPLvlSet(work->spr_grp[1], i, 1.0f);
|
|
pos_x = (28.0f * (scale + work->scale_x)) + (work->x - (0.5f * ((work->word_len * 56) * (scale + work->scale_x))))
|
|
+ ((i * 56) * (scale + work->scale_x));
|
|
HuSprPosSet(work->spr_grp[1], i, pos_x, work->y);
|
|
HuSprScaleSet(work->spr_grp[1], i, work->scale_x + scale, work->scale_y + scale);
|
|
}
|
|
}
|
|
else {
|
|
if (work->time > 80 && work->time <= 160) {
|
|
time = work->time - 80;
|
|
for (idx = 0; idx < work->word_len; idx++) {
|
|
scale = time - (idx * 2);
|
|
if (scale < 0 || scale > 15.0f) {
|
|
continue;
|
|
}
|
|
HuSprScaleSet(work->spr_grp[1], idx, cos(M_PI * ((scale / 15.0f) * 90.0f) / 180.0), 1.0f);
|
|
}
|
|
for (idx = 0; idx < work->alt_word_len; idx++) {
|
|
scale = (time - 15.0f) - (idx * 2);
|
|
if (scale < 0 || scale > 30.0f) {
|
|
continue;
|
|
}
|
|
HuSprTPLvlSet(work->spr_grp[0], idx, 1.0f);
|
|
HuSprScaleSet(work->spr_grp[0], idx, sin(M_PI * ((scale / 30.0f) * 180.0f) / 180.0), 1.0f);
|
|
}
|
|
}
|
|
}
|
|
if (work->time == 160) {
|
|
work->stat |= 0x4;
|
|
}
|
|
if (work->time >= 160) {
|
|
work->type = 0;
|
|
work->stat |= 0x8;
|
|
}
|
|
}
|
|
} break;
|
|
|
|
case -1: {
|
|
work->angle += seqSpeed * 0.1f;
|
|
scale = 1.0f - work->angle;
|
|
if (scale <= 0.0f) {
|
|
scale = 0.0f;
|
|
work->type = 0;
|
|
work->stat |= 0x8;
|
|
if (work->state == 0) {
|
|
MGSeqPauseEnableCtrl(1);
|
|
}
|
|
}
|
|
for (idx = 0; idx < work->word_len; idx++) {
|
|
HuSprTPLvlSet(work->spr_grp[1], idx, scale);
|
|
}
|
|
} break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
if (seqDoneF || (work->stat & 0x8)) {
|
|
MGSeqSprKill(work);
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
s32 MGSeqUpdateMGBowser(SeqWork *work)
|
|
{
|
|
s16 idx;
|
|
float scale;
|
|
if (work->param[0] != 0 && work->type != -1) {
|
|
switch (work->param[0]) {
|
|
case 2:
|
|
if (work->param[1] != -1) {
|
|
(void)work; // HACK: to introduce extra branch
|
|
}
|
|
else {
|
|
work->type = -1;
|
|
work->angle = 0.0f;
|
|
}
|
|
work->param[0] = 0;
|
|
break;
|
|
|
|
case 1:
|
|
work->time_max = work->param[1];
|
|
work->param[0] = 0;
|
|
break;
|
|
|
|
case 3:
|
|
work->type = 1;
|
|
work->param[0] = 0;
|
|
break;
|
|
|
|
default:
|
|
work->param[0] = 0;
|
|
break;
|
|
}
|
|
}
|
|
if (work->type == 2) {
|
|
return 1;
|
|
}
|
|
work->time += seqSpeed;
|
|
if (work->time >= work->time_max && work->type != -1) {
|
|
work->stat |= 0x4;
|
|
work->type = -1;
|
|
work->angle = 0.0f;
|
|
}
|
|
if (work->type) {
|
|
switch (work->type) {
|
|
case 1: {
|
|
s16 i;
|
|
s16 j;
|
|
float angle;
|
|
float time_angle;
|
|
float time;
|
|
float pos_x, pos_y;
|
|
|
|
float temp_f25;
|
|
float center_x;
|
|
s16 spr_idx[16];
|
|
float scale_arr[16];
|
|
|
|
if (work->state == 0) {
|
|
if (work->time <= 60) {
|
|
center_x = (0.5 * (work->word_len * 56)) + 20.0;
|
|
for (idx = 0; idx < work->word_len; idx++) {
|
|
time = work->time - idx;
|
|
if (time < 0) {
|
|
scale_arr[idx] = 0.0f;
|
|
spr_idx[idx] = idx;
|
|
}
|
|
else {
|
|
if (time > 50.0f) {
|
|
time = 50.0f;
|
|
}
|
|
time_angle = 540.0 * (1.0f - (time / 50.0f));
|
|
pos_x = (28.0f + (0.5f * -(work->word_len * 56))) + (idx * 56);
|
|
angle = 180.0 * (atan2(pos_x, center_x) / M_PI);
|
|
pos_x = work->x + (center_x * sin(M_PI * (angle + time_angle) / 180.0));
|
|
pos_y = work->y - (HU_DISP_CENTERY * (1.0 - (time / 50.0f)));
|
|
HuSprPosSet(work->spr_grp[0], idx, pos_x, pos_y);
|
|
temp_f25 = 0.9 + (0.1 * cos(M_PI * (angle + time_angle) / 180.0));
|
|
HuSprScaleSet(work->spr_grp[0], idx, temp_f25 * cos(M_PI * (angle + time_angle) / 180.0), temp_f25);
|
|
scale_arr[idx] = cos(M_PI * (angle + time_angle) / 180.0);
|
|
spr_idx[idx] = idx;
|
|
}
|
|
}
|
|
for (i = 1; i < work->word_len; i++) {
|
|
for (idx = 0; idx < work->word_len - i; idx++) {
|
|
if (scale_arr[idx] > scale_arr[idx + 1]) {
|
|
j = spr_idx[idx];
|
|
spr_idx[idx] = spr_idx[idx + 1];
|
|
spr_idx[idx + 1] = j;
|
|
angle = scale_arr[idx];
|
|
scale_arr[idx] = scale_arr[idx + 1];
|
|
scale_arr[idx + 1] = angle;
|
|
}
|
|
}
|
|
}
|
|
for (idx = 0; idx < work->word_len; idx++) {
|
|
HuSprPriSet(work->spr_grp[0], spr_idx[idx], idx + 5);
|
|
}
|
|
}
|
|
else {
|
|
if (work->time > 60 && work->time <= 80) {
|
|
time = work->time - 60;
|
|
scale = 0.5 * sin(((time * 9.0f) * M_PI) / 180.0);
|
|
for (i = 0; i < work->word_len; i++) {
|
|
pos_x = (28.0f * (scale + work->scale_x)) + (work->x - (0.5f * ((work->word_len * 56) * (scale + work->scale_x))))
|
|
+ ((i * 56) * (scale + work->scale_x));
|
|
HuSprPosSet(work->spr_grp[0], i, pos_x, work->y);
|
|
HuSprScaleSet(work->spr_grp[0], i, work->scale_x + scale, work->scale_y + scale);
|
|
}
|
|
}
|
|
}
|
|
if (work->time == 60) {
|
|
HuAudFXPlay(36);
|
|
work->stat |= 0x10;
|
|
}
|
|
if (work->time == 80) {
|
|
work->stat |= 0x4;
|
|
SeqPlayStartFX();
|
|
}
|
|
if (work->time >= 100) {
|
|
work->type = 0;
|
|
}
|
|
}
|
|
else {
|
|
if (work->time == 1) {
|
|
if (work->state == 1) {
|
|
HuAudFXPlay(37);
|
|
}
|
|
else {
|
|
HuAudFXPlay(40);
|
|
}
|
|
MGSeqPauseEnableCtrl(0);
|
|
work->stat |= 0x10;
|
|
}
|
|
if (work->time <= 20) {
|
|
for (j = 1; j < 4; j++) {
|
|
for (i = 0; i < work->word_len; i++) {
|
|
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->word_len; i++) {
|
|
HuSprAttrReset(work->spr_grp[0], i, HUSPR_ATTR_DISPOFF);
|
|
pos_x = ((28.0f * scale) + (work->x - (0.5f * (scale * (work->word_len * 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)));
|
|
}
|
|
if (time == 20.0f) {
|
|
for (j = 1; j < 4; j++) {
|
|
for (i = 0; i < work->word_len; i++) {
|
|
HuSprAttrReset(work->spr_grp[j], i, HUSPR_ATTR_DISPOFF);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if (work->time > 80 && work->time <= 125) {
|
|
static float letterOfs[] = {
|
|
-30,
|
|
-30,
|
|
HU_DISP_WIDTH + 30,
|
|
-30,
|
|
HU_DISP_CENTERX + 52,
|
|
HU_DISP_HEIGHT + 30,
|
|
HU_DISP_WIDTH + 30,
|
|
HU_DISP_HEIGHT + 30,
|
|
-30,
|
|
HU_DISP_HEIGHT - 30,
|
|
HU_DISP_WIDTH + 30,
|
|
120,
|
|
HU_DISP_CENTERX + 162,
|
|
-30,
|
|
};
|
|
for (i = 0; i < 4; i++) {
|
|
time = work->time - 80 - i;
|
|
if (time < 0.0f || time > 15.0f) {
|
|
continue;
|
|
}
|
|
for (idx = 0; idx < work->word_len; idx++) {
|
|
pos_x = (28.0f + (work->x - (0.5f * (work->word_len * 56)))) + (idx * 56);
|
|
pos_x += (time / 15.0f) * (letterOfs[(idx * 2)] - pos_x);
|
|
pos_y = work->y + ((time / 15.0f) * (letterOfs[(idx * 2) + 1] - work->y));
|
|
HuSprPosSet(work->spr_grp[i], idx, pos_x, pos_y);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (work->time == 125) {
|
|
work->stat |= 0x4;
|
|
}
|
|
if (work->time >= 135) {
|
|
work->type = 0;
|
|
work->stat |= 0x8;
|
|
}
|
|
}
|
|
} break;
|
|
|
|
case -1: {
|
|
work->angle += seqSpeed * 0.1f;
|
|
scale = 1.0f - work->angle;
|
|
if (scale <= 0.0f) {
|
|
scale = 0.0f;
|
|
work->type = 0;
|
|
work->stat |= 0x8;
|
|
if (work->state == 0) {
|
|
MGSeqPauseEnableCtrl(1);
|
|
}
|
|
}
|
|
for (idx = 0; idx < work->word_len; idx++) {
|
|
HuSprTPLvlSet(work->spr_grp[0], idx, scale);
|
|
}
|
|
} break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
if (seqDoneF || (work->stat & 0x8)) {
|
|
MGSeqSprKill(work);
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
s32 MGSeqInitDraw(SeqWork *work, va_list params)
|
|
{
|
|
s16 word_grp;
|
|
work->state = 2;
|
|
work->seq_no = 13;
|
|
work->type = 0;
|
|
work->angle = 0.0f;
|
|
{
|
|
s32 word_flag;
|
|
s32 word_ofs;
|
|
|
|
if (seqLanguage == 0) {
|
|
word_flag = 1;
|
|
}
|
|
else {
|
|
word_flag = 0;
|
|
}
|
|
if (seqLanguage == 0) {
|
|
word_ofs = 0;
|
|
}
|
|
else {
|
|
word_ofs = 3;
|
|
}
|
|
|
|
word_grp = SeqMakeWord(work, wordMgTbl[2 + word_ofs], word_flag);
|
|
}
|
|
HuSprGrpPosSet(work->spr_grp[word_grp], HU_DISP_CENTERX, HU_DISP_CENTERY);
|
|
work->param[0] = 3;
|
|
return 1;
|
|
}
|
|
|
|
s32 MGSeqUpdateDraw(SeqWork *work)
|
|
{
|
|
s16 idx;
|
|
float scale;
|
|
s16 group = work->spr_grp[0];
|
|
if (work->param[0] != 0 && work->type != -1) {
|
|
switch (work->param[0]) {
|
|
case 2:
|
|
if (work->param[1] != -1) {
|
|
(void)work; // HACK: to introduce extra branch
|
|
}
|
|
else {
|
|
work->type = -1;
|
|
work->angle = 0.0f;
|
|
}
|
|
work->param[0] = 0;
|
|
break;
|
|
|
|
case 1:
|
|
work->time_max = work->param[1];
|
|
work->param[0] = 0;
|
|
break;
|
|
|
|
case 3:
|
|
work->type = 1;
|
|
work->param[0] = 0;
|
|
break;
|
|
|
|
default:
|
|
work->param[0] = 0;
|
|
break;
|
|
}
|
|
}
|
|
work->time += seqSpeed;
|
|
if (work->time >= work->time_max && work->type != -1) {
|
|
work->stat |= 0x4;
|
|
work->type = -1;
|
|
work->angle = 0.0f;
|
|
}
|
|
if (work->type) {
|
|
switch (work->type) {
|
|
case 1: {
|
|
float time;
|
|
float scale;
|
|
float zrot;
|
|
if (work->time <= 20) {
|
|
time = work->time;
|
|
zrot = 365.0f * (time / 20.0f);
|
|
scale = 1.3f * sin(M_PI * (90.0f * (time / 20.0f)) / 180.0);
|
|
HuSprGrpScaleSet(group, scale, scale);
|
|
HuSprGrpZRotSet(group, zrot);
|
|
}
|
|
if (work->time > 20 && work->time <= 25) {
|
|
HuSprGrpZRotSet(group, 0.0f);
|
|
time = work->time - 20;
|
|
scale = 1.0 + (0.3 * cos(M_PI * (90.0f * (time / 5.0f)) / 180.0));
|
|
HuSprGrpScaleSet(group, scale, scale);
|
|
}
|
|
if (work->time == 5) {
|
|
HuAudFXPlay(40);
|
|
}
|
|
if (work->time == 60) {
|
|
work->type = 0;
|
|
}
|
|
} break;
|
|
|
|
case -1: {
|
|
float tp_lvl;
|
|
work->angle += seqSpeed * 0.1f;
|
|
tp_lvl = 1.0f - work->angle;
|
|
if (tp_lvl <= 0.0f) {
|
|
tp_lvl = 0.0f;
|
|
work->state = 0;
|
|
work->stat |= 0x8;
|
|
}
|
|
HuSprGrpTPLvlSet(group, tp_lvl);
|
|
} break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
if (seqDoneF || (work->stat & 0x8)) {
|
|
MGSeqSprKill(work);
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static char *winCharNameTbl[] = {
|
|
"ﾏﾘｵ",
|
|
"MARIO",
|
|
"ﾙｲｰｼﾞ",
|
|
"LUIGI",
|
|
"ﾋﾟｰﾁ",
|
|
"PEACH",
|
|
"ﾖｯｼｰ",
|
|
"YOSHI",
|
|
"ﾜﾘｵ",
|
|
"WARIO",
|
|
"ﾄﾞﾝｷｰ",
|
|
VERSION_JPN ? "DK" : " DK ",
|
|
"ﾃﾞｲｼﾞｰ",
|
|
"DAISY",
|
|
"ﾜﾙｲｰｼﾞ",
|
|
"WALUIGI",
|
|
"ｸｯﾊﾟ",
|
|
"BOWSER",
|
|
"ｷﾉﾋﾟｵ",
|
|
"TOAD",
|
|
"ﾍｲﾎｰ",
|
|
VERSION_JPN ? "HEHOH" : "SHY GUY",
|
|
"ﾃﾚｻ",
|
|
VERSION_JPN ? "TERETHA" : "BOO",
|
|
"ﾉｺﾉｺ",
|
|
VERSION_JPN ? "NOKONOKO" : "KOOPA",
|
|
"ﾐﾆｸｯﾊﾟ",
|
|
VERSION_NTSC ? (VERSION_ENG ? "KOOPA KID" : "BABYBOWSER") : "MINI BOWSER",
|
|
"ｸﾘﾎﾞｰ",
|
|
VERSION_JPN ? "KURIBO" : "GOOMBA",
|
|
};
|
|
|
|
static char *winWordTbl[] = { "ｶﾁ", "WON!", "ﾊｲﾎﾞｸ", "LOSE", "ﾕｳｼｮｳ!", "CHAMPION!" };
|
|
|
|
static s16 winPosOfs[][5][2] = {
|
|
{ { VERSION_JPN ? 144 : 114, 0 }, { -144, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 } },
|
|
{ { 0, 35 }, { -144, -35 }, { 144, -35 }, { 0, 0 }, { 0, 0 } },
|
|
{ { 0, 105 }, { 0, -105 }, { -144, 0 }, { 144, 0 }, { 0, 0 } },
|
|
{ { 0, 105 }, { -144, -105 }, { 144, -105 }, { -144, 0 }, { 144, 0 } },
|
|
};
|
|
|
|
static s16 winnerNameW[8];
|
|
|
|
#define GET_LANG_IDX() ((seqLanguage == 0) ? 0 : 1)
|
|
#define GET_WIN_KANAF() ((seqLanguage == 0) ? 1 : 0)
|
|
|
|
s32 MGSeqInitWin(SeqWork *work, va_list params)
|
|
{
|
|
int win_type = va_arg(params, int);
|
|
s16 word_idx;
|
|
s16 word_grp;
|
|
s32 i;
|
|
s32 j;
|
|
s32 num_winners;
|
|
float word_w;
|
|
float word_x;
|
|
if (win_type < 0 && win_type >= 6) {
|
|
return 0;
|
|
}
|
|
if (win_type == 3) {
|
|
word_idx = GET_LANG_IDX();
|
|
}
|
|
else {
|
|
if (win_type == 4) {
|
|
word_idx = GET_LANG_IDX() + 2;
|
|
}
|
|
else {
|
|
word_idx = GET_LANG_IDX() + 4;
|
|
}
|
|
}
|
|
word_grp = SeqMakeWord(work, winWordTbl[word_idx], GET_WIN_KANAF());
|
|
winnerNameW[0] = work->word_len * (VERSION_JPN ? 56 : 50);
|
|
#if !VERSION_JPN
|
|
for (i = 0; i < work->word_len; i++) {
|
|
HuSprPosSet(work->spr_grp[word_grp], i, 25.0f + ((i * 50) - (0.5f * (work->word_len * 50))), 0.0f);
|
|
HuSprAttrSet(work->spr_grp[word_grp], i, HUSPR_ATTR_LINEAR);
|
|
}
|
|
#endif
|
|
num_winners = 0;
|
|
#if !VERSION_JPN
|
|
work->win_scale = 1.0f;
|
|
#endif
|
|
for (j = 0; j < 4; j++) {
|
|
int winner = va_arg(params, int);
|
|
(void)winner; // to match PAL
|
|
if (winner < 0) {
|
|
continue;
|
|
}
|
|
word_grp = SeqMakeWord(work, winCharNameTbl[(winner * 2) + GET_LANG_IDX()], 0);
|
|
#if VERSION_ENG
|
|
if (seqLanguage != 0) {
|
|
char *name = winCharNameTbl[(winner * 2) + GET_LANG_IDX()];
|
|
word_w = 0.0f;
|
|
for (i = word_w; i < work->word_len; i++, name++) {
|
|
if (*name == ' ') {
|
|
word_w += 30.0f;
|
|
}
|
|
else {
|
|
word_w += 50.0f;
|
|
}
|
|
}
|
|
name = winCharNameTbl[(winner * 2) + GET_LANG_IDX()];
|
|
word_x = 0.0f;
|
|
for (i = word_x; i < work->word_len; 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, HUSPR_ATTR_LINEAR);
|
|
if (*name == ' ') {
|
|
word_x += 30.0f;
|
|
}
|
|
else {
|
|
word_x += 50.0f;
|
|
}
|
|
}
|
|
if (work->win_scale == 0.6f || winner == 7 || winner == 13 || winner == 10) {
|
|
work->win_scale = 0.6f;
|
|
}
|
|
else {
|
|
work->win_scale = 0.75f;
|
|
}
|
|
winnerNameW[num_winners + 1] = word_w;
|
|
}
|
|
else if (winner == 7 || winner == 13) {
|
|
for (i = 0; i < work->word_len; i++) {
|
|
HuSprPosSet(work->spr_grp[word_grp], i, 26.0f + ((i * 52) - (0.5f * (work->word_len * 52))), 0.0f);
|
|
HuSprAttrSet(work->spr_grp[word_grp], i, HUSPR_ATTR_LINEAR);
|
|
}
|
|
work->win_scale = 0.8f;
|
|
winnerNameW[num_winners + 1] = work->word_len * 52;
|
|
}
|
|
else {
|
|
work->win_scale = 1.0f;
|
|
winnerNameW[num_winners + 1] = work->word_len * 56;
|
|
}
|
|
#elif VERSION_PAL
|
|
for (i = 0; i < work->word_len; i++) {
|
|
HuSprPosSet(work->spr_grp[word_grp], i, 25.0f + ((i * 50) - (0.5f * (work->word_len * 50))), 0.0f);
|
|
HuSprAttrSet(work->spr_grp[word_grp], i, HUSPR_ATTR_LINEAR);
|
|
}
|
|
if ((work->win_scale == 0.5f) || (winner == 13)) {
|
|
work->win_scale = 0.5f;
|
|
}
|
|
else if ((work->win_scale == 0.6f) || (winner == 7) || (winner == 10)) {
|
|
work->win_scale = 0.6f;
|
|
}
|
|
else {
|
|
work->win_scale = 0.75f;
|
|
}
|
|
winnerNameW[num_winners + 1] = work->word_len * 50;
|
|
#else
|
|
if (seqLanguage != 0) {
|
|
for (i = 0; i < work->word_len; i++) {
|
|
HuSprPosSet(work->spr_grp[word_grp], i, 25.0f + (i * 50 - (0.5f * (work->word_len * 50))), 0.0f);
|
|
HuSprAttrSet(work->spr_grp[word_grp], i, HUSPR_ATTR_LINEAR);
|
|
}
|
|
work->win_scale = 0.75f;
|
|
winnerNameW[num_winners + 1] = work->word_len * 50;
|
|
}
|
|
else if (winner == 7 || winner == 13) {
|
|
for (i = 0; i < work->word_len; i++) {
|
|
HuSprPosSet(work->spr_grp[word_grp], i, 26.0f + ((i * 52) - (0.5f * (work->word_len * 52))), 0.0f);
|
|
HuSprAttrSet(work->spr_grp[word_grp], i, HUSPR_ATTR_LINEAR);
|
|
}
|
|
work->win_scale = 0.8f;
|
|
winnerNameW[num_winners + 1] = work->word_len * 52;
|
|
}
|
|
else {
|
|
work->win_scale = 1.0f;
|
|
winnerNameW[num_winners + 1] = work->word_len * 56;
|
|
}
|
|
#endif
|
|
num_winners++;
|
|
}
|
|
if (num_winners == 0) {
|
|
return 0;
|
|
}
|
|
work->state = 0;
|
|
work->word_len = num_winners + 1;
|
|
work->angle = 0.0f;
|
|
work->type = 0;
|
|
for (j = 0; j < num_winners + 1; j++) {
|
|
if (num_winners == 1) {
|
|
#if VERSION_JPN
|
|
word_x = 32 + (winnerNameW[1] + winnerNameW[0]);
|
|
#else
|
|
word_x = 32.0f + ((float)winnerNameW[0] + (winnerNameW[1] * work->win_scale));
|
|
#endif
|
|
if (j == 0) {
|
|
word_x = (((HU_DISP_WIDTH - word_x) / 2.0f) + (word_x - (winnerNameW[0] / 2))) - HU_DISP_CENTERX;
|
|
}
|
|
else {
|
|
word_x = (((HU_DISP_WIDTH - word_x) / 2.0f) + (winnerNameW[1] / 2)) - HU_DISP_CENTERX;
|
|
}
|
|
}
|
|
else {
|
|
if (abs(winPosOfs[num_winners - 1][j][0]) == 144.0f) {
|
|
#if VERSION_ENG
|
|
if (winnerNameW[j] + 32 < HU_DISP_CENTERX) {
|
|
word_x = 176.0f;
|
|
}
|
|
else {
|
|
word_x = 32.0f + ((winnerNameW[j] * work->win_scale) / 2.0f);
|
|
}
|
|
if (winPosOfs[num_winners - 1][j][0] < 0) {
|
|
word_x = -(HU_DISP_CENTERX - word_x);
|
|
}
|
|
else {
|
|
word_x = (HU_DISP_WIDTH - word_x) - HU_DISP_CENTERX;
|
|
}
|
|
#elif VERSION_PAL
|
|
if (32.0f + (work->win_scale * winnerNameW[j]) < HU_DISP_CENTERX) {
|
|
word_x = 32.0f + ((winnerNameW[j] * work->win_scale) / 2.0f);
|
|
}
|
|
else {
|
|
word_x = 120.0f;
|
|
}
|
|
if (winPosOfs[num_winners - 1][j][0] < 0) {
|
|
word_x = -word_x;
|
|
}
|
|
#else
|
|
if (32 + winnerNameW[j] < HU_DISP_CENTERX) {
|
|
word_x = 32 + winnerNameW[j] / 2;
|
|
}
|
|
else {
|
|
word_x = 120.0f;
|
|
}
|
|
if (winPosOfs[num_winners - 1][j][0] < 0) {
|
|
word_x = -word_x;
|
|
}
|
|
#endif
|
|
}
|
|
else {
|
|
word_x = winPosOfs[num_winners - 1][j][0];
|
|
}
|
|
}
|
|
HuSprGrpPosSet(work->spr_grp[j], HU_DISP_CENTERX + word_x, HU_DISP_CENTERY + winPosOfs[num_winners - 1][j][1]);
|
|
}
|
|
if (seqPauseF) {
|
|
work->type = 1;
|
|
num_winners++;
|
|
for (j = 0; j < num_winners; j++) {
|
|
HuSprAttrSet(work->spr_grp[j], 0, HUSPR_ATTR_DISPOFF);
|
|
}
|
|
}
|
|
else {
|
|
work->param[0] = 3;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
s32 MGSeqUpdateWin(SeqWork *work)
|
|
{
|
|
s32 idx;
|
|
float tp_lvl;
|
|
s16 group = work->spr_grp[0];
|
|
if (work->param[0] != 0 && work->type != -1) {
|
|
switch (work->param[0]) {
|
|
case 2:
|
|
if (work->param[1] != -1) {
|
|
(void)work; // HACK: to introduce extra branch
|
|
}
|
|
else {
|
|
work->type = -1;
|
|
work->angle = 0.0f;
|
|
}
|
|
work->param[0] = 0;
|
|
break;
|
|
|
|
case 1:
|
|
work->time_max = work->param[1];
|
|
work->param[0] = 0;
|
|
break;
|
|
|
|
case 3:
|
|
work->type = 1;
|
|
work->param[0] = 0;
|
|
break;
|
|
|
|
default:
|
|
work->param[0] = 0;
|
|
break;
|
|
}
|
|
}
|
|
work->time += seqSpeed;
|
|
if (work->time >= work->time_max && work->type != -1) {
|
|
work->stat |= 0x4;
|
|
work->type = -1;
|
|
work->angle = 0.0f;
|
|
}
|
|
if (work->type) {
|
|
switch (work->type) {
|
|
case 1: {
|
|
float time;
|
|
float scale;
|
|
float zrot;
|
|
if (work->time <= 20) {
|
|
time = work->time;
|
|
zrot = 365.0f * (time / 20.0f);
|
|
scale = sin(M_PI * (90.0f * (time / 20.0f)) / 180.0);
|
|
HuSprGrpScaleSet(work->spr_grp[0], scale, scale);
|
|
HuSprGrpZRotSet(work->spr_grp[0], zrot);
|
|
scale = 1.0 + (5.0 * cos(M_PI * (90.0f * (time / 20.0f)) / 180.0));
|
|
tp_lvl = time / 20.0f;
|
|
for (idx = 1; idx < work->word_len; idx++) {
|
|
HuSprGrpTPLvlSet(work->spr_grp[idx], tp_lvl);
|
|
HuSprGrpScaleSet(work->spr_grp[idx], scale * work->win_scale, scale);
|
|
}
|
|
}
|
|
if (work->time > 20 && work->time <= 22) {
|
|
HuSprGrpZRotSet(work->spr_grp[0], 0.0f);
|
|
for (idx = 1; idx < work->word_len; idx++) {
|
|
float pos_x;
|
|
float ofs[2];
|
|
if (work->time == 21) {
|
|
ofs[0] = ((idx & 0x1) * 2) - 1;
|
|
ofs[1] = (idx & 0x2) ? 2 : -1;
|
|
}
|
|
else {
|
|
ofs[0] = ofs[1] = 0.0f;
|
|
}
|
|
if (work->word_len == 2) {
|
|
pos_x = winnerNameW[1] + winnerNameW[0] + 32;
|
|
pos_x = (((HU_DISP_WIDTH - pos_x) / 2.0f) + (winnerNameW[1] / 2)) - HU_DISP_CENTERX;
|
|
}
|
|
else {
|
|
if (abs(winPosOfs[work->word_len - 2][idx][0]) == 144.0f) {
|
|
if (winnerNameW[idx] + 32 < HU_DISP_CENTERX) {
|
|
pos_x = VERSION_ENG ? 176.0f : winnerNameW[idx] / 2 + 32;
|
|
}
|
|
else {
|
|
pos_x = VERSION_ENG ? 32.0f + ((winnerNameW[idx] * work->win_scale) / 2.0f) : 128.0f;
|
|
}
|
|
if (winPosOfs[work->word_len - 2][idx][0] < 0) {
|
|
pos_x = VERSION_ENG ? -(HU_DISP_CENTERX - pos_x) : -pos_x;
|
|
}
|
|
#if VERSION_ENG
|
|
else {
|
|
pos_x = (HU_DISP_WIDTH - pos_x) - HU_DISP_CENTERX;
|
|
}
|
|
#endif
|
|
}
|
|
else {
|
|
pos_x = winPosOfs[work->word_len - 2][idx][0];
|
|
}
|
|
}
|
|
HuSprGrpPosSet(work->spr_grp[idx], (HU_DISP_CENTERX + pos_x) + ofs[0],
|
|
ofs[1] + (HU_DISP_CENTERY + winPosOfs[work->word_len - 2][idx][1]));
|
|
}
|
|
}
|
|
if (work->time == 125) {
|
|
work->type = 0;
|
|
}
|
|
} break;
|
|
|
|
case -1: {
|
|
work->angle += seqSpeed * 0.1f;
|
|
tp_lvl = 1.0f - work->angle;
|
|
if (tp_lvl <= 0.0f) {
|
|
tp_lvl = 0.0f;
|
|
work->state = 0;
|
|
work->stat |= 0x8;
|
|
}
|
|
for (idx = 0; idx < work->word_len; idx++) {
|
|
HuSprGrpTPLvlSet(work->spr_grp[idx], tp_lvl);
|
|
}
|
|
} break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
if (seqDoneF || (work->stat & 0x8)) {
|
|
MGSeqSprKill(work);
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
s32 MGSeqInitRecord(SeqWork *work, va_list params)
|
|
{
|
|
AnimData *spr_data;
|
|
s16 spr_grp;
|
|
s16 time_pos[2];
|
|
s16 i;
|
|
s16 sprite;
|
|
s16 digit_idx;
|
|
s32 digit;
|
|
seqRecordVal = va_arg(params, int);
|
|
work->type = 0;
|
|
work->angle = 0.0f;
|
|
work->spr_grp[0] = spr_grp = HuSprGrpCreate(10);
|
|
spr_data = HuSprAnimRead(SeqReadFile(DATA_MAKE_NUM(DATADIR_GAMEMES, 9)));
|
|
sprite = HuSprCreate(spr_data, 0, 0);
|
|
HuSprGrpMemberSet(spr_grp, 0, sprite);
|
|
HuSprPosSet(spr_grp, 0, 0.0f, -32.0f);
|
|
spr_data = HuSprAnimRead(SeqReadFile(DATA_MAKE_NUM(DATADIR_GAMEMES, 8)));
|
|
sprite = HuSprCreate(spr_data, 0, 0);
|
|
HuSprGrpMemberSet(spr_grp, 1, sprite);
|
|
spr_data = HuSprAnimRead(SeqReadFile(DATA_MAKE_NUM(DATADIR_GAMEMES, 7)));
|
|
for (i = 0; i < 8; i++) {
|
|
sprite = HuSprCreate(spr_data, 0, 0);
|
|
HuSprGrpMemberSet(spr_grp, i + 2, sprite);
|
|
}
|
|
if (omcurovl == OVL_M407 || omcurovl == OVL_M453 || omcurovl == OVL_M459 || omcurovl == OVL_M460 || omcurovl == OVL_M462
|
|
|| omcurovl == OVL_M442) {
|
|
digit_idx = 0;
|
|
if (seqRecordVal > 9999) {
|
|
seqRecordVal = 9999;
|
|
}
|
|
digit = seqRecordVal / 1000;
|
|
if (digit != 0) {
|
|
HuSprBankSet(spr_grp, digit_idx + 2, digit);
|
|
seqRecordVal -= digit * 1000;
|
|
digit_idx++;
|
|
}
|
|
|
|
digit = seqRecordVal / 100;
|
|
if (digit != 0 || digit_idx != 0) {
|
|
HuSprBankSet(spr_grp, digit_idx + 2, digit);
|
|
seqRecordVal -= digit * 100;
|
|
digit_idx++;
|
|
}
|
|
digit = seqRecordVal / 10;
|
|
if (digit != 0 || digit_idx != 0) {
|
|
HuSprBankSet(spr_grp, digit_idx + 2, digit);
|
|
seqRecordVal -= digit * 10;
|
|
digit_idx++;
|
|
}
|
|
HuSprBankSet(spr_grp, digit_idx + 2, seqRecordVal);
|
|
digit_idx++;
|
|
for (i = digit_idx; i < 8; i++) {
|
|
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++) {
|
|
HuSprPosSet(spr_grp, i + 2, (-((digit_idx * 44) + 48) / 2) + 70 + (i * 44), 32.0f);
|
|
}
|
|
}
|
|
else {
|
|
s16 x;
|
|
digit_idx = 0;
|
|
digit = seqRecordVal / (600 * REFRESH_RATE);
|
|
if (digit != 0) {
|
|
HuSprBankSet(spr_grp, digit_idx + 2, digit);
|
|
seqRecordVal -= digit * (600 * REFRESH_RATE);
|
|
digit_idx++;
|
|
}
|
|
digit = seqRecordVal / (60 * REFRESH_RATE);
|
|
HuSprBankSet(spr_grp, digit_idx + 2, digit);
|
|
seqRecordVal -= digit * (60 * REFRESH_RATE);
|
|
digit_idx++;
|
|
HuSprBankSet(spr_grp, digit_idx + 2, 10);
|
|
time_pos[0] = digit_idx;
|
|
digit_idx++;
|
|
digit = seqRecordVal / (10 * REFRESH_RATE);
|
|
HuSprBankSet(spr_grp, digit_idx + 2, digit);
|
|
seqRecordVal -= digit * (10 * REFRESH_RATE);
|
|
digit_idx++;
|
|
digit = seqRecordVal / REFRESH_RATE;
|
|
HuSprBankSet(spr_grp, digit_idx + 2, digit);
|
|
seqRecordVal -= digit * REFRESH_RATE;
|
|
digit_idx++;
|
|
HuSprBankSet(spr_grp, digit_idx + 2, 11);
|
|
time_pos[1] = digit_idx;
|
|
digit_idx++;
|
|
if (omcurovl == OVL_M405 || omcurovl == OVL_M432 || omcurovl == OVL_M461) {
|
|
seqRecordVal = (float)seqRecordVal * (101.5 / REFRESH_RATE);
|
|
}
|
|
else {
|
|
seqRecordVal = (float)seqRecordVal * (100.0 / REFRESH_RATE);
|
|
}
|
|
digit = seqRecordVal / 10;
|
|
HuSprBankSet(spr_grp, digit_idx + 2, digit);
|
|
seqRecordVal -= digit * 10;
|
|
digit_idx++;
|
|
HuSprBankSet(spr_grp, digit_idx + 2, seqRecordVal);
|
|
digit_idx++;
|
|
for (i = digit_idx; i < 8; i++) {
|
|
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;
|
|
for (i = 0; i < digit_idx; i++) {
|
|
HuSprPosSet(spr_grp, i + 2, x, 32.0f);
|
|
if (time_pos[0] == i || time_pos[1] == i) {
|
|
x += 22;
|
|
}
|
|
else {
|
|
x += 44;
|
|
}
|
|
}
|
|
}
|
|
HuSprGrpPosSet(spr_grp, HU_DISP_CENTERX, HU_DISP_CENTERY);
|
|
work->param[0] = 3;
|
|
return 1;
|
|
}
|
|
|
|
s32 MGSeqUpdateRecord(SeqWork *work)
|
|
{
|
|
s16 group;
|
|
if (_CheckFlag(FLAG_ID_MAKE(1, 12))) {
|
|
work->state = 0;
|
|
work->stat |= 0xC;
|
|
}
|
|
else {
|
|
group = work->spr_grp[0];
|
|
if (work->param[0] != 0 && work->type != -1) {
|
|
switch (work->param[0]) {
|
|
case 2:
|
|
if (work->param[1] != -1) {
|
|
(void)work; // HACK: to introduce extra branch
|
|
}
|
|
else {
|
|
work->type = -1;
|
|
work->angle = 0.0f;
|
|
}
|
|
work->param[0] = 0;
|
|
break;
|
|
|
|
case 1:
|
|
work->time_max = work->param[1];
|
|
work->param[0] = 0;
|
|
break;
|
|
|
|
case 3:
|
|
work->type = 1;
|
|
work->param[0] = 0;
|
|
break;
|
|
|
|
default:
|
|
work->param[0] = 0;
|
|
break;
|
|
}
|
|
}
|
|
work->time += seqSpeed;
|
|
if (work->time >= work->time_max && work->type != -1) {
|
|
work->stat |= 0x4;
|
|
work->type = -1;
|
|
work->angle = 0.0f;
|
|
}
|
|
if (work->type) {
|
|
switch (work->type) {
|
|
case 1: {
|
|
if (work->time <= 10) {
|
|
HuSprGrpTPLvlSet(group, work->time / 10.0);
|
|
}
|
|
if (work->time == 5) {
|
|
HuAudFXPlay(38);
|
|
}
|
|
if (work->time == 30) {
|
|
work->type = 0;
|
|
}
|
|
} break;
|
|
|
|
case -1: {
|
|
float tp_lvl;
|
|
work->angle += seqSpeed * 0.1f;
|
|
tp_lvl = 1.0f - work->angle;
|
|
if (tp_lvl <= 0.0f) {
|
|
tp_lvl = 0.0f;
|
|
work->state = 0;
|
|
work->stat |= 0x8;
|
|
}
|
|
HuSprGrpTPLvlSet(group, tp_lvl);
|
|
} break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (seqDoneF || (work->stat & 0x8)) {
|
|
MGSeqSprKill(work);
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static void PauseProc(void);
|
|
|
|
void MGSeqPauseInit(void)
|
|
{
|
|
MGSeqPauseEnableCtrl(0);
|
|
HuWinInit(1);
|
|
pauseProcess = HuPrcCreate(PauseProc, 100, 4096, 0);
|
|
HuPrcSetStat(pauseProcess, PROCESS_STAT_PAUSE_EN | PROCESS_STAT_UPAUSE_EN);
|
|
pauseActiveF = 1;
|
|
pauseExitF = 0;
|
|
pauseWaitF = 0;
|
|
}
|
|
|
|
#define PAUSE_WIN_X (HU_DISP_CENTERX - 206)
|
|
#define PAUSE_WIN_DIST (HU_DISP_CENTERX + 112)
|
|
#define PAUSE_EXIT_Y (HU_DISP_HEIGHT - 80)
|
|
|
|
static void PauseProc(void)
|
|
{
|
|
s16 mg;
|
|
s16 i;
|
|
s16 j;
|
|
|
|
s16 char_mess_map[4];
|
|
s16 char_mess[4][4];
|
|
s16 window[3] = { -1, -1, -1 };
|
|
|
|
SeqWork work;
|
|
static char *pauseStr[] = { "ﾎﾟｰｽﾞ", "PAUSE" };
|
|
float ratio;
|
|
|
|
HuAudFXPlay(5);
|
|
for (i = 0; i < 16; i++) {
|
|
work.sprite[i] = work.spr_grp[i] = -1;
|
|
}
|
|
SeqMakeWord(&work, pauseStr[GET_LANG_IDX()], 0);
|
|
for (i = 0; i < work.word_len; i++) {
|
|
HuSprPriSet(work.spr_grp[0], i, 0);
|
|
}
|
|
for (i = 0; i < 4; i++) {
|
|
char_mess_map[i] = 0;
|
|
}
|
|
for (i = 0; i < 4; i++) {
|
|
char_mess[GWPlayerCfg[i].group][char_mess_map[GWPlayerCfg[i].group]] = GWPlayerCfg[i].character;
|
|
char_mess_map[GWPlayerCfg[i].group]++;
|
|
}
|
|
mg = omMgIndexGet(omcurovl);
|
|
if (mgInfoTbl[mg].inst_mess[1] == 0 && mgInfoTbl[mg].inst_mess[2] == 0) {
|
|
for (i = 1; i <= 20; i++) {
|
|
ratio = sin(M_PI * (i * 4.5f) / 180.0);
|
|
HuSprGrpPosSet(work.spr_grp[0], HU_DISP_CENTERX, (ratio * 290) - 50.0f);
|
|
HuPrcVSleep();
|
|
}
|
|
}
|
|
else {
|
|
if (mgPracticeEnableF && !_CheckFlag(FLAG_ID_MAKE(1, 12))) {
|
|
window[2] = HuWinExCreateStyled(-10000.0f, PAUSE_EXIT_Y, 412, 42, -1, 0);
|
|
HuWinPriSet(window[2], 0);
|
|
HuWinDispOn(window[2]);
|
|
HuWinMesSpeedSet(window[2], 0);
|
|
HuWinAttrSet(window[2], 0x800);
|
|
HuWinMesSet(window[2], MAKE_MESSID(0x33, 0xA1));
|
|
}
|
|
if (mgInfoTbl[mg].inst_mess[2]) {
|
|
s16 insert_idx;
|
|
window[0] = HuWinExCreateStyled(-10000.0f, HU_DISP_CENTERY - 100, 412, 120, -1, 0);
|
|
HuWinPriSet(window[0], 0);
|
|
HuWinDispOn(window[0]);
|
|
HuWinMesSpeedSet(window[0], 0);
|
|
HuWinMesSet(window[0], mgInfoTbl[mg].inst_mess[1]);
|
|
window[1] = HuWinExCreateStyled(-10000.0f, HU_DISP_CENTERY + 36, 412, 120, -1, 0);
|
|
HuWinPriSet(window[1], 0);
|
|
HuWinDispOn(window[1]);
|
|
HuWinMesSpeedSet(window[1], 0);
|
|
HuWinMesSet(window[1], mgInfoTbl[mg].inst_mess[2]);
|
|
for (i = insert_idx = 0; i < 4; i++) {
|
|
for (j = 0; j < char_mess_map[i]; j++) {
|
|
HuWinInsertMesSet(window[0], char_mess[i][j], (s16)insert_idx);
|
|
HuWinInsertMesSet(window[1], char_mess[i][j], (s16)insert_idx);
|
|
insert_idx++;
|
|
}
|
|
}
|
|
for (i = 1; i <= 20; i++) {
|
|
ratio = sin(M_PI * (i * 4.5f) / 180.0);
|
|
HuSprGrpPosSet(work.spr_grp[0], HU_DISP_CENTERX, (ratio * 150) - 50.0f);
|
|
HuWinPosSet(window[0], (PAUSE_WIN_DIST + PAUSE_WIN_X) * ratio - PAUSE_WIN_DIST, HU_DISP_CENTERY - 100);
|
|
HuWinPosSet(window[1], -(PAUSE_WIN_DIST - PAUSE_WIN_X) * ratio + PAUSE_WIN_DIST, HU_DISP_CENTERY + 32);
|
|
if (window[2] != -1) {
|
|
HuWinPosSet(window[2], PAUSE_WIN_X, (PAUSE_EXIT_Y + 4) + (100 * (1.0 - ratio)));
|
|
}
|
|
HuPrcVSleep();
|
|
}
|
|
}
|
|
else {
|
|
window[0] = HuWinExCreateStyled(-10000.0f, HU_DISP_CENTERY - 70, 412, 120, -1, 0);
|
|
HuWinPriSet(window[0], 0);
|
|
HuWinDispOn(window[0]);
|
|
HuWinMesSpeedSet(window[0], 0);
|
|
HuWinMesSet(window[0], mgInfoTbl[mg].inst_mess[1]);
|
|
for (i = 1; i <= 20; i++) {
|
|
ratio = sin(M_PI * (i * 4.5f) / 180.0);
|
|
HuSprGrpPosSet(work.spr_grp[0], HU_DISP_CENTERX, (ratio * 150) - 50.0f);
|
|
HuWinPosSet(window[0], (PAUSE_WIN_DIST + PAUSE_WIN_X) * ratio - PAUSE_WIN_DIST, HU_DISP_CENTERY - 70);
|
|
if (window[2] != -1) {
|
|
HuWinPosSet(window[2], -(PAUSE_WIN_DIST - PAUSE_WIN_X) * ratio + PAUSE_WIN_DIST, PAUSE_EXIT_Y + 4);
|
|
}
|
|
HuPrcVSleep();
|
|
}
|
|
}
|
|
}
|
|
MGSeqPauseEnableCtrl(1);
|
|
pauseWaitF = 1;
|
|
while (!pauseExitF) {
|
|
HuPrcVSleep();
|
|
}
|
|
pauseWaitF = 0;
|
|
if (window[0] == -1 && window[1] == -1) {
|
|
for (i = 1; i <= 10; i++) {
|
|
ratio = cos(M_PI * (i * 9.0f) / 180.0);
|
|
HuSprGrpPosSet(work.spr_grp[0], HU_DISP_CENTERX, (ratio * 290) - 50.0f);
|
|
HuPrcVSleep();
|
|
}
|
|
}
|
|
else {
|
|
if (window[1] != -1) {
|
|
for (i = 1; i <= 10; i++) {
|
|
ratio = cos(M_PI * (i * 9.0f) / 180.0);
|
|
HuSprGrpPosSet(work.spr_grp[0], HU_DISP_CENTERX, (ratio * 150) - 50.0f);
|
|
HuWinPosSet(window[0], (PAUSE_WIN_DIST + PAUSE_WIN_X) * ratio - PAUSE_WIN_DIST, HU_DISP_CENTERY - 100);
|
|
HuWinPosSet(window[1], -(PAUSE_WIN_DIST - PAUSE_WIN_X) * ratio + PAUSE_WIN_DIST, HU_DISP_CENTERY + 32);
|
|
if (window[2] != -1) {
|
|
HuWinPosSet(window[2], PAUSE_WIN_X, (PAUSE_EXIT_Y + 4) + (100 * (1.0 - ratio)));
|
|
}
|
|
HuPrcVSleep();
|
|
}
|
|
}
|
|
else {
|
|
for (i = 1; i <= 10; i++) {
|
|
ratio = cos(M_PI * (i * 9.0f) / 180.0);
|
|
HuSprGrpPosSet(work.spr_grp[0], HU_DISP_CENTERX, (ratio * 150) - 50.0f);
|
|
HuWinPosSet(window[0], (PAUSE_WIN_DIST + PAUSE_WIN_X) * ratio - PAUSE_WIN_DIST, HU_DISP_CENTERY - 70);
|
|
if (window[2] != -1) {
|
|
HuWinPosSet(window[2], -(PAUSE_WIN_DIST - PAUSE_WIN_X) * ratio + PAUSE_WIN_DIST, PAUSE_EXIT_Y + 4);
|
|
}
|
|
HuPrcVSleep();
|
|
}
|
|
}
|
|
}
|
|
omSysPauseCtrl(0);
|
|
if (window[0] != -1) {
|
|
HuWinKill(window[0]);
|
|
}
|
|
if (window[1] != -1) {
|
|
HuWinKill(window[1]);
|
|
}
|
|
if (window[2] != -1) {
|
|
HuWinKill(window[2]);
|
|
}
|
|
HuSprGrpKill(work.spr_grp[0]);
|
|
pauseProcess = NULL;
|
|
pauseActiveF = 0;
|
|
HuPrcEnd();
|
|
do {
|
|
HuPrcVSleep();
|
|
} while (1);
|
|
}
|
|
|
|
void MGSeqPauseKill(void)
|
|
{
|
|
pauseExitF = 1;
|
|
}
|
|
|
|
void MGSeqPauseEnableCtrl(s32 flag)
|
|
{
|
|
if (!_CheckFlag(FLAG_ID_MAKE(1, 8))) {
|
|
omSysPauseEnable(flag);
|
|
}
|
|
}
|
|
|
|
static void PracticeProc(void);
|
|
|
|
static s16 practiceTbl[][2] = {
|
|
OVL_M401,
|
|
1,
|
|
OVL_M402,
|
|
1,
|
|
OVL_M403,
|
|
1,
|
|
OVL_M405,
|
|
1,
|
|
OVL_M406,
|
|
0,
|
|
OVL_M407,
|
|
1,
|
|
OVL_M408,
|
|
0,
|
|
OVL_M409,
|
|
0,
|
|
OVL_M410,
|
|
1,
|
|
OVL_M411,
|
|
2,
|
|
OVL_M412,
|
|
1,
|
|
OVL_M413,
|
|
0,
|
|
OVL_M414,
|
|
2,
|
|
OVL_M415,
|
|
1,
|
|
OVL_M443,
|
|
2,
|
|
OVL_M416,
|
|
1,
|
|
OVL_M417,
|
|
1,
|
|
OVL_M418,
|
|
1,
|
|
OVL_M419,
|
|
1,
|
|
OVL_M420,
|
|
1,
|
|
OVL_M421,
|
|
1,
|
|
OVL_M422,
|
|
1,
|
|
OVL_M423,
|
|
1,
|
|
OVL_M424,
|
|
1,
|
|
OVL_M425,
|
|
1,
|
|
OVL_M426,
|
|
1,
|
|
OVL_M427,
|
|
0,
|
|
OVL_M428,
|
|
0,
|
|
OVL_M429,
|
|
2,
|
|
OVL_M430,
|
|
1,
|
|
OVL_M431,
|
|
1,
|
|
OVL_M432,
|
|
1,
|
|
OVL_M433,
|
|
0,
|
|
OVL_M434,
|
|
1,
|
|
OVL_M404,
|
|
0,
|
|
OVL_M438,
|
|
1,
|
|
OVL_M439,
|
|
2,
|
|
OVL_M440,
|
|
1,
|
|
OVL_M441,
|
|
1,
|
|
OVL_M442,
|
|
1,
|
|
OVL_M455,
|
|
0,
|
|
OVL_M456,
|
|
0,
|
|
OVL_INVALID,
|
|
0,
|
|
};
|
|
|
|
void MGSeqPracticeInit(void)
|
|
{
|
|
Process *process;
|
|
s16 i;
|
|
process = HuPrcCurrentGet();
|
|
if (!_CheckFlag(FLAG_ID_MAKE(1, 12))) {
|
|
return;
|
|
}
|
|
wipeFadeInF = 0;
|
|
for (i = 0; practiceTbl[i][0] != OVL_INVALID; i++) {
|
|
if (omcurovl == practiceTbl[i][0]) {
|
|
break;
|
|
}
|
|
}
|
|
if (practiceTbl[i][0] != -1) {
|
|
HuPrcChildCreate(PracticeProc, 10, 8192, 0, process);
|
|
}
|
|
}
|
|
|
|
static void PracticeProc(void)
|
|
{
|
|
|
|
s16 group;
|
|
s16 sprite;
|
|
AnimData *anim;
|
|
s16 i;
|
|
s16 *practice;
|
|
float time;
|
|
static float yPosTbl[] = { 53, HU_DISP_HEIGHT - 56, HU_DISP_CENTERY };
|
|
time = 0.0f;
|
|
for (i = 0; practiceTbl[i][0] != OVL_INVALID; i++) {
|
|
if (omcurovl == practiceTbl[i][0]) {
|
|
break;
|
|
}
|
|
}
|
|
practice = &practiceTbl[i][0];
|
|
group = HuSprGrpCreate(1);
|
|
HuSprGrpPosSet(group, 0, 0);
|
|
anim = HuSprAnimRead(SeqReadFile(DATA_MAKE_NUM(DATADIR_GAMEMES, 5)));
|
|
sprite = HuSprCreate(anim, 1, 0);
|
|
HuSprGrpMemberSet(group, 0, sprite);
|
|
HuSprPosSet(group, 0, HU_DISP_CENTERX, yPosTbl[practice[1]]);
|
|
do {
|
|
if (!wipeFadeInF || WipeStatGet()) {
|
|
HuSprAttrSet(group, 0, HUSPR_ATTR_DISPOFF);
|
|
HuPrcVSleep();
|
|
continue;
|
|
}
|
|
HuSprAttrReset(group, 0, HUSPR_ATTR_DISPOFF);
|
|
for (i = 0; i < 4; i++) {
|
|
if (!(HuPadBtnDown[GWPlayerCfg[i].pad_idx] & PAD_TRIGGER_Z)) {
|
|
continue;
|
|
;
|
|
}
|
|
if (!GWPlayerCfg[i].iscom) {
|
|
break;
|
|
}
|
|
}
|
|
if (i != 4) {
|
|
break;
|
|
}
|
|
HuSprTPLvlSet(group, 0, fabs(sin(M_PI * time / 180.0)));
|
|
time += 2.0f;
|
|
HuPrcVSleep();
|
|
} while (1);
|
|
omSysExitReq = 1;
|
|
HuPrcEnd();
|
|
do {
|
|
HuPrcVSleep();
|
|
} while (1);
|
|
}
|
|
|
|
static s16 seqStartFXTbl[][2]
|
|
= { OVL_M401, 17, OVL_M402, 16, OVL_M403, 12, OVL_M404, 12, OVL_M405, 17, OVL_M406, 12, OVL_M407, 16, OVL_M408, 12, OVL_M409, 16, OVL_M410, 12,
|
|
OVL_M411, 16, OVL_M412, 12, OVL_M413, 16, OVL_M414, 16, OVL_M415, 16, OVL_M416, 16, OVL_M417, 17, OVL_M418, 16, OVL_M419, 16, OVL_M420, 16,
|
|
OVL_M421, 16, OVL_M422, 12, OVL_M423, 12, OVL_M424, 16, OVL_M425, 16, OVL_M426, 16, OVL_M427, 12, OVL_M428, 12, OVL_M429, 16, OVL_M430, 12,
|
|
OVL_M431, 16, OVL_M432, 12, OVL_M433, 12, OVL_M434, 16, OVL_M435, 12, OVL_M436, 16, OVL_M437, 12, OVL_M438, 16, OVL_M439, 12, OVL_M440, 16,
|
|
OVL_M441, 16, OVL_M442, 16, OVL_M443, -1, OVL_M444, -1, OVL_M445, 12, OVL_M446, -1, OVL_M447, 12, OVL_M448, -1, OVL_M449, 16, OVL_M450, 12,
|
|
OVL_M455, 17, OVL_M456, 17, OVL_M457, 12, OVL_M458, 12, OVL_M459, 17, OVL_M460, 12, OVL_M461, 12, OVL_M462, 12, OVL_INVALID, 0 };
|
|
|
|
static void SeqPlayStartFX(void)
|
|
{
|
|
s16 i;
|
|
for (i = 0; seqStartFXTbl[i][0] != OVL_INVALID; i++) {
|
|
if (omcurovl == seqStartFXTbl[i][0]) {
|
|
break;
|
|
}
|
|
}
|
|
if (seqStartFXTbl[i][0] == OVL_INVALID || seqStartFXTbl[i][1] == -1) {
|
|
return;
|
|
}
|
|
HuAudFXPlay(seqStartFXTbl[i][1]);
|
|
}
|
|
|
|
void MGSeqPracticeExitCheck(omObjData *object)
|
|
{
|
|
s16 input;
|
|
s16 i;
|
|
mgQuitExtraF = 0;
|
|
if (object->work[0] == 0) {
|
|
if (omMgIndexGet(omcurovl) == -1) {
|
|
omDelObjEx(HuPrcCurrentGet(), object);
|
|
return;
|
|
}
|
|
object->work[0]++;
|
|
}
|
|
if (!omPauseChk() || _CheckFlag(FLAG_ID_MAKE(1, 12)) || !pauseWaitF) {
|
|
return;
|
|
}
|
|
for (i = input = 0; i < 4; i++) {
|
|
input |= HuPadBtnDown[i];
|
|
}
|
|
if (input & PAD_TRIGGER_Z) {
|
|
HuAudFXPlay(3);
|
|
pauseExitF = 1;
|
|
omSysPauseCtrl(0);
|
|
omSysExitReq = 1;
|
|
mgQuitExtraF = 1;
|
|
omDelObjEx(HuPrcCurrentGet(), object);
|
|
}
|
|
}
|