1263 lines
No EOL
28 KiB
C
1263 lines
No EOL
28 KiB
C
#include "game/armem.h"
|
|
#include "game/sprite.h"
|
|
#include "game/process.h"
|
|
#include "game/gamework_data.h"
|
|
#include "game/objsub.h"
|
|
#include "game/hsfman.h"
|
|
#include "math.h"
|
|
|
|
#include "stdarg.h"
|
|
|
|
void MGSeqStub(void);
|
|
|
|
void MGSeqPauseEnableCtrl(s32 flag);
|
|
|
|
extern s16 HuSysVWaitGet(s16 param);
|
|
|
|
typedef struct seq_work SeqWork;
|
|
|
|
typedef int (*SeqUpdateFunc)(SeqWork *work);
|
|
typedef int (*SeqInitFunc)(SeqWork *work, va_list params);
|
|
|
|
typedef struct seq_work {
|
|
SeqUpdateFunc update;
|
|
char *data;
|
|
float x;
|
|
float y;
|
|
float scale_x;
|
|
float scale_y;
|
|
float unk_18;
|
|
float work_float[2];
|
|
float unk_24;
|
|
s16 time;
|
|
s16 time_max;
|
|
s16 work_s16[4];
|
|
s16 param[2];
|
|
s16 type;
|
|
s16 spr_grp[16];
|
|
s16 sprite[16];
|
|
u8 seq_no;
|
|
u8 stat;
|
|
u8 unk_7C;
|
|
u8 unk_7D;
|
|
} SeqWork;
|
|
|
|
typedef struct seq_info {
|
|
SeqInitFunc init;
|
|
SeqUpdateFunc update;
|
|
float x;
|
|
float y;
|
|
float scale_x;
|
|
float scale_y;
|
|
s32 time_max;
|
|
} SeqInfo;
|
|
|
|
static int SeqInitTimer(SeqWork *work, va_list params);
|
|
static int SeqUpdateTimer(SeqWork *work);
|
|
|
|
static int SeqInitType2(SeqWork *work, va_list params);
|
|
static int SeqUpdateType2(SeqWork *work);
|
|
|
|
static int SeqInitMGBasic(SeqWork *work, va_list params);
|
|
static int SeqUpdateMGBasic(SeqWork *work);
|
|
static int SeqInitMGCommon(SeqWork *work, va_list params);
|
|
static int SeqUpdateMG1vs3(SeqWork *work);
|
|
static int SeqUpdateMGBattle(SeqWork *work);
|
|
static int SeqUpdateMGStory(SeqWork *work);
|
|
static int SeqUpdateMG2vs2(SeqWork *work);
|
|
static int SeqUpdateMGBowser(SeqWork *work);
|
|
|
|
static int SeqInitWin(SeqWork *work, va_list params);
|
|
static int SeqUpdateWin(SeqWork *work);
|
|
static int SeqInitDraw(SeqWork *work, va_list params);
|
|
static int SeqUpdateDraw(SeqWork *work);
|
|
static int SeqInitRecord(SeqWork *work, va_list params);
|
|
static int SeqUpdateRecord(SeqWork *work);
|
|
|
|
static int SeqInitFlip(SeqWork *work, va_list params);
|
|
static int SeqUpdateFlip(SeqWork *work);
|
|
|
|
s32 mgSeqInitF = -1;
|
|
|
|
static SeqInfo seqInfoTbl[] = {
|
|
{ NULL, NULL, 292.0f, 240.0f, 1.0f, 1.0f, 60 },
|
|
{ SeqInitTimer, SeqUpdateTimer, 292.0f, 64.0f, 1.0f, 1.0f, 60 },
|
|
{ SeqInitType2, SeqUpdateType2, 292.0f, 240.0f, 0.5f, 0.5f, 60 },
|
|
{ SeqInitMGBasic, SeqUpdateMGBasic, 292.0f, 240.0f, 1.0f, 1.0f, 180 },
|
|
{ SeqInitMGCommon, SeqUpdateMG1vs3, 292.0f, 240.0f, 1.0f, 1.0f, 180 },
|
|
{ SeqInitWin, SeqUpdateWin, 292.0f, 240.0f, 1.0f, 1.0f, 180 },
|
|
{ SeqInitMGCommon, SeqUpdateMGBattle, 292.0f, 240.0f, 1.0f, 1.0f, 180 },
|
|
{ SeqInitMGCommon, SeqUpdateMGStory, 292.0f, 240.0f, 1.0f, 1.0f, 180 },
|
|
{ SeqInitMGBasic, SeqUpdateMGBasic, 292.0f, 240.0f, 1.0f, 1.0f, 180 },
|
|
{ SeqInitMGCommon, SeqUpdateMG2vs2, 292.0f, 240.0f, 1.0f, 1.0f, 180 },
|
|
{ SeqInitFlip, SeqUpdateFlip, 292.0f, 240.0f, 1.0f, 1.0f, 180 },
|
|
{ SeqInitMGCommon, SeqUpdateMGBowser, 292.0f, 240.0f, 1.0f, 1.0f, 180 },
|
|
{ SeqInitWin, SeqUpdateWin, 292.0f, 240.0f, 1.0f, 1.0f, 180 },
|
|
{ SeqInitDraw, SeqUpdateDraw, 292.0f, 240.0f, 1.0f, 1.0f, 60 },
|
|
{ SeqInitRecord, SeqUpdateRecord, 292.0f, 240.0f, 1.0f, 1.0f, 180 },
|
|
{ NULL, NULL, 292.0f, 240.0f, 1.0f, 1.0f, 60 },
|
|
{ NULL, NULL, 292.0f, 240.0f, 1.0f, 1.0f, 60 },
|
|
};
|
|
|
|
static s32 seqType2SprTbl[6] = {
|
|
0, 0, 0, 0, 0, 0
|
|
};
|
|
|
|
static s16 mgSeqTypeTbl[9] = {
|
|
8,
|
|
4,
|
|
9,
|
|
11,
|
|
6,
|
|
10,
|
|
7,
|
|
11,
|
|
7
|
|
};
|
|
|
|
static char lbl_8012F336[] = {
|
|
0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8,
|
|
0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0,
|
|
0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8,
|
|
0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0,
|
|
0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8,
|
|
0xD9, 0xDA, 0xDB, 0xDC, 0xA6, 0xDD, 0xA7, 0xA8,
|
|
0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB6,
|
|
0xB7, 0xB8, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF,
|
|
0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xCA, 0xCB, 0xCC,
|
|
0xCD, 0xCE, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0x21,
|
|
0x3F, 0xB0, 0x00
|
|
};
|
|
|
|
static char lbl_8012F389[] = "x first\n";
|
|
static char lbl_8012F392[] = "y first\n";
|
|
|
|
static s16 seqMaxTime[8];
|
|
static SeqWork seqWorkData[8];
|
|
|
|
static s16 seqTimer;
|
|
static u8 seqDoneF;
|
|
u8 lbl_801D3D94;
|
|
static s16 seqSpeed;
|
|
static s16 seqPauseF;
|
|
static s32 seqRecordVal;
|
|
static s32 pauseWaitF;
|
|
static s32 pauseExitF;
|
|
static s32 pauseActiveF;
|
|
static Process *pauseProcess;
|
|
static s32 seqLanguage;
|
|
|
|
void fn_80036BC8(void);
|
|
|
|
|
|
void MGSeqInit(void)
|
|
{
|
|
int 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(MAKE_DIR_NUM(DATADIR_GAMEMES));
|
|
HuAR_DVDtoARAM(MAKE_DIR_NUM(DATADIR_MGCONST));
|
|
while(HuARDMACheck());
|
|
fn_80036BC8();
|
|
mgSeqInitF = -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(u8 seq_no, va_list params)
|
|
{
|
|
SeqWork *work;
|
|
SeqInfo *info;
|
|
int i;
|
|
int temp;
|
|
work = seqWorkData;
|
|
info = &seqInfoTbl[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 = (s32)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->work_s16[0] = work->work_s16[1] = work->work_s16[2] = work->work_s16[3] = 0;
|
|
work->work_float[0] = work->work_float[1] = 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 == 3) {
|
|
if(GWSystem.mg_next == 0xFFFF) {
|
|
type = 8;
|
|
} else {
|
|
type = mgSeqTypeTbl[mgInfoTbl[GWSystem.mg_next].type];
|
|
}
|
|
}
|
|
//FIXME: Fix truncation of type
|
|
ret = CreateSeq(type, params);
|
|
va_end(params);
|
|
return ret;
|
|
}
|
|
|
|
u8 MGSeqStatGet(s16 id)
|
|
{
|
|
SeqWork *work;
|
|
u8 ret = 0;
|
|
if(id < 0) {
|
|
int 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, s16 param1, s16 param2)
|
|
{
|
|
if(id >= 0 && id < 8) {
|
|
if(seqWorkData[id].stat != 0) {
|
|
seqWorkData[id].stat = 8;
|
|
}
|
|
}
|
|
}
|
|
|
|
void MGSeqKillAll(s16 id, s16 param1, s16 param2)
|
|
{
|
|
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)
|
|
{
|
|
int 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);
|
|
}
|
|
|
|
static int SeqInitTimer(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->work_s16[0] = duration;
|
|
if(x >= 0) {
|
|
work->x = x;
|
|
}
|
|
if(y >= 0) {
|
|
work->y = y;
|
|
}
|
|
work->work_s16[2] = 0;
|
|
work->work_s16[1] = 2;
|
|
work->work_float[0] = 0;
|
|
work->spr_grp[0] = spr_grp = HuSprGrpCreate(4);
|
|
HuSprGrpScaleSet(spr_grp, work->scale_x, work->scale_y);
|
|
spr_anim = HuSprAnimRead(SeqReadFile(MAKE_DATA_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(MAKE_DATA_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(MAKE_DATA_NUM(DATADIR_GAMEMES, 0)));
|
|
sprite = HuSprCreate(spr_anim, 6, 0);
|
|
HuSprGrpMemberSet(spr_grp, 3, sprite);
|
|
HuSprPosSet(spr_grp, 3, 0, 0);
|
|
if(seqPauseF) {
|
|
work->work_s16[1] = 1;
|
|
for(i=0; i<2; i++) {
|
|
HuSprAttrSet(spr_grp, i, SPRITE_ATTR_HIDDEN);
|
|
(void)i; //Hack for Matching
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static int SeqUpdateTimer(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->work_s16[1] != -1) {
|
|
switch(work->param[0]) {
|
|
case 2:
|
|
switch(work->param[1]) {
|
|
case -1:
|
|
work->stat |= 0x4;
|
|
work->work_s16[1] = -1;
|
|
work->work_float[0] = 0.0f;
|
|
break;
|
|
|
|
case 0:
|
|
work->work_s16[1] = 2;
|
|
work->work_float[0] = 0.0f;
|
|
break;
|
|
|
|
case 1:
|
|
work->work_s16[1] = 3;
|
|
work->work_float[0] = 0.0f;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
work->param[0] = 0;
|
|
break;
|
|
|
|
case 1:
|
|
if(work->param[1] < 0 && !(work->stat & 0x4)) {
|
|
work->stat |= 0x4;
|
|
work->work_s16[1] = -1;
|
|
work->work_float[0] = 0.0f;
|
|
} else {
|
|
if(work->param[1] > 99) {
|
|
work->work_s16[0] = 99;
|
|
} else {
|
|
if(work->work_s16[0] != work->param[1]) {
|
|
work->work_s16[0] = work->param[1];
|
|
if(work->param[1] <= 5) {
|
|
HuAudFXPlay(6);
|
|
work->work_s16[1] = 3;
|
|
work->work_float[0] = 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, SPRITE_ATTR_HIDDEN);
|
|
}
|
|
work->work_s16[1] = 3;
|
|
work->param[0] = 0;
|
|
break;
|
|
|
|
default:
|
|
work->param[0] = 0;
|
|
break;
|
|
}
|
|
}
|
|
if(work->work_s16[1] == 1) {
|
|
return 1;
|
|
}
|
|
if(work->work_s16[0] > 99) {
|
|
digits[0] = digits[1] = 9;
|
|
} else {
|
|
s32 value;
|
|
value = work->work_s16[0]/10;
|
|
digits[1] = value;
|
|
digits[0] = work->work_s16[0]-(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->work_s16[1] != 0) {
|
|
switch(work->work_s16[1]) {
|
|
case 2:
|
|
{
|
|
float scale_x, scale_y;
|
|
scale = fabs(((sin((work->work_float[0]*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->work_float[0] += seqSpeed*5.0f;
|
|
if(work->work_float[0] > 130.0f) {
|
|
work->work_s16[1] = 0;
|
|
break;
|
|
}
|
|
HuSprGrpScaleSet(spr_grp, scale_x, scale_y);
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
{
|
|
scale = sin((work->work_float[0]*M_PI)/180)+1.0;
|
|
tp_lvl = 1.0-(sin((work->work_float[0]*M_PI)/180)*0.5);
|
|
work->work_float[0] += seqSpeed*18.0f;
|
|
if(work->work_float[0] > 180.0f) {
|
|
work->work_s16[1] = 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->work_float[0] += 1.0f;
|
|
if(work->work_float[0] < 60.0f) {
|
|
break;
|
|
}
|
|
tp_lvl = 1.0-((work->work_float[0]-60.0f)/20.0f);
|
|
if(tp_lvl <= 0.0f) {
|
|
tp_lvl = 0.0f;
|
|
work->work_s16[1] = 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;
|
|
}
|
|
}
|
|
|
|
static int SeqInitType2(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->work_s16[1] = 0;
|
|
work->work_float[0] = 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->work_s16[3] = 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->work_s16[2] = 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->work_s16[1] = 1;
|
|
for(i=0; i<work->work_s16[3]; i++) {
|
|
HuSprAttrSet(spr_grp, i, SPRITE_ATTR_HIDDEN);
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static int SeqUpdateType2(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->work_s16[2]), work->y);
|
|
HuSprGrpScaleSet(spr_grp, work->scale_x, work->scale_y);
|
|
if(work->param[0] != 0 && work->work_s16[1] != -1) {
|
|
switch(work->param[0]) {
|
|
case 2:
|
|
if(work->param[1] != -1) {
|
|
(void)work; //HACK: to introduce extra branch
|
|
} else {
|
|
work->work_s16[1] = -1;
|
|
work->work_float[0] = 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->work_s16[3]; i++) {
|
|
HuSprAttrReset(spr_grp, i, SPRITE_ATTR_HIDDEN);
|
|
(void)i;
|
|
}
|
|
work->work_s16[1] = 0;
|
|
work->param[0] = 0;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
work->param[0] = 0;
|
|
break;
|
|
}
|
|
}
|
|
if(work->work_s16[1] == 1) {
|
|
return 1;
|
|
}
|
|
work->time += seqSpeed;
|
|
if(work->time >= work->time_max && work->work_s16[1] != -1) {
|
|
work->stat |= 0x4;
|
|
work->work_s16[1] = -1;
|
|
work->work_float[0] = 0.0f;
|
|
}
|
|
if(work->work_s16[1] != 0) {
|
|
if(work->work_s16[1] != -1) {
|
|
(void)work; //HACK: to introduce extra branch
|
|
} else {
|
|
s16 i;
|
|
work->work_float[0] += seqSpeed*0.1f;
|
|
tp_lvl = 1.0f-work->work_float[0];
|
|
if(tp_lvl <= 0.0f) {
|
|
tp_lvl = 0.0f;
|
|
work->work_s16[1] = 0;
|
|
work->stat |= 0x8;
|
|
}
|
|
for(i=0; i<work->work_s16[3]; i++) {
|
|
HuSprTPLvlSet(spr_grp, i, tp_lvl);
|
|
(void)i;
|
|
}
|
|
}
|
|
}
|
|
if(seqDoneF || (work->stat & 0x8)) {
|
|
MGSeqSprKill(work);
|
|
return 0;
|
|
} else {
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
|
|
static char seqFontAlphaTbl[] = {
|
|
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
|
|
'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
|
|
'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
|
|
'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
|
|
'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
|
|
'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
|
|
'w', 'x', 'y', 'z', '\0'
|
|
};
|
|
|
|
static char seqFontKanaTbl[] = {
|
|
0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8,
|
|
0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0,
|
|
0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8,
|
|
0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0,
|
|
0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8,
|
|
0xD9, 0xDA, 0xDB, 0xDC, 0xA6, 0xDD, 0xA7, 0xA8,
|
|
0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB6,
|
|
0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE,
|
|
0xBF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xCA, 0xCB,
|
|
0xCC, 0xCD, 0xCE, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE,
|
|
0xB0, 0x00
|
|
};
|
|
|
|
static char seqFontNumTbl[] = {
|
|
'0', '1', '2', '3', '4', '5', '6', '7',
|
|
'8', '9', '\0'
|
|
};
|
|
|
|
static s32 *letterBufTbl[5] = { };
|
|
|
|
static char wordStartE[] = "START!";
|
|
|
|
static char seqPunctTbl[] = {
|
|
'!', '?', '\0'
|
|
};
|
|
|
|
static char wordStartJ[] = {
|
|
0xBD, 0xC0, 0xB0, 0xC4, 0x21, 0x00
|
|
};
|
|
|
|
static char wordFinishJ[] = {
|
|
0xCC, 0xA8, 0xC6, 0xAF, 0xBC, 0xAD, 0x21, 0x00
|
|
};
|
|
|
|
static char wordDrawJ[] = {
|
|
0xCB, 0xB7, 0xDC, 0xB9, 0x21, 0x00
|
|
};
|
|
|
|
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 *char_pos;
|
|
char *str_ptr;
|
|
s16 spr_grp;
|
|
s16 i;
|
|
s16 x;
|
|
s16 grp_idx;
|
|
s16 len;
|
|
AnimData **char_anim;
|
|
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) {
|
|
char_anim[len] = SeqLoadFontChar(str_ptr, flags);
|
|
if(char_anim[len]) {
|
|
char_pos[len] = x;
|
|
x += 56;
|
|
len++;
|
|
}
|
|
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->work_s16[3] = len;
|
|
HuMemDirectFree(char_anim);
|
|
HuMemDirectFree(char_pos);
|
|
return grp_idx;
|
|
}
|
|
|
|
static s32 SeqCloneWord(SeqWork *work, s16 grp_idx)
|
|
{
|
|
s16 i;
|
|
|
|
return i;
|
|
}
|
|
|
|
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(c == 32) {
|
|
return HuSprAnimRead(SeqReadFile(MAKE_DATA_NUM(DATADIR_GAMEMES, 10)));
|
|
}
|
|
for(id = 0, list=seqFontAlphaTbl; *list != 0; id++, list++) {
|
|
if(*list == c) {
|
|
data_num = MAKE_DATA_NUM(DATADIR_GAMEMES, id+21);
|
|
return HuSprAnimRead(SeqReadFile(data_num));
|
|
}
|
|
}
|
|
for(id = 0, list=seqFontNumTbl; *list != 0; id++, list++) {
|
|
if(*list == c) {
|
|
data_num = MAKE_DATA_NUM(DATADIR_GAMEMES, id+11);
|
|
return HuSprAnimRead(SeqReadFile(data_num));
|
|
}
|
|
}
|
|
for(id = 0, list=seqPunctTbl; *list != 0; id++, list++) {
|
|
if(*list == c) {
|
|
data_num = MAKE_DATA_NUM(DATADIR_GAMEMES, id+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 = MAKE_DATA_NUM(DATADIR_GAMEMES, id+156);
|
|
} else {
|
|
data_num = MAKE_DATA_NUM(DATADIR_GAMEMES, id+73);
|
|
}
|
|
return HuSprAnimRead(SeqReadFile(data_num));
|
|
}
|
|
id++;
|
|
list++;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static float ForceDefine480()
|
|
{
|
|
return 480.0f;
|
|
}
|
|
|
|
static void SeqPlayStartFX(void);
|
|
|
|
static int SeqInitMGBasic(SeqWork *work, va_list params)
|
|
{
|
|
s16 i;
|
|
s16 word_grp;
|
|
|
|
work->work_s16[1] = va_arg(params, int);
|
|
if(work->work_s16[1] == 2) {
|
|
return SeqInitDraw(work, params);
|
|
}
|
|
work->type = 0;
|
|
work->work_float[0] = 0;
|
|
|
|
{
|
|
s32 word_katakana;
|
|
s32 word_flag;
|
|
s32 word_ofs;
|
|
word_katakana = 0;
|
|
if(work->work_s16[1] == 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->work_s16[1]+word_ofs], word_flag);
|
|
}
|
|
HuSprGrpPosSet(work->spr_grp[word_grp], 0.0f, 0.0f);
|
|
|
|
for(i=0; i<work->work_s16[3]; i++) {
|
|
HuSprTPLvlSet(work->spr_grp[word_grp], i, 1.0f);
|
|
HuSprPosSet(work->spr_grp[word_grp], i, -100.0f, 240.0f);
|
|
}
|
|
if(seqPauseF) {
|
|
work->type = 2;
|
|
HuSprAttrSet(word_grp, 0, SPRITE_ATTR_HIDDEN);
|
|
} else {
|
|
work->param[0] = 3;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static int SeqUpdateMGBasic(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->work_float[0] = 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->work_float[0] = 0.0f;
|
|
}
|
|
if(work->type != 0) {
|
|
switch(work->type) {
|
|
case 1:
|
|
{
|
|
float pos_x;
|
|
float time;
|
|
s16 i;
|
|
if(work->work_s16[1] == 0) {
|
|
if(work->time <= 40) {
|
|
for(i=0; i<work->work_s16[3]; i++) {
|
|
time = work->time-((20/work->work_s16[3])*(work->work_s16[3]-i-1));
|
|
if(time < 0 || time > 20.0f) {
|
|
continue;
|
|
}
|
|
pos_x = (work->x-(0.5f*(work->work_s16[3]*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->work_s16[3]*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->work_s16[3]; i++) {
|
|
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, 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->work_s16[1] == 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->work_s16[3]; i++) {
|
|
HuSprAttrReset(work->spr_grp[0], i, SPRITE_ATTR_HIDDEN);
|
|
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);
|
|
}
|
|
}
|
|
} else {
|
|
if(work->time > 80) {
|
|
for(i=0; i<work->work_s16[3]; i++) {
|
|
time = (work->time-80)-((20/work->work_s16[3])*(work->work_s16[3]-i-1));
|
|
if(time < 0.0f || time > 20.0f) {
|
|
continue;
|
|
}
|
|
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);
|
|
} 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);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(work->time == 110) {
|
|
work->stat |= 0x4;
|
|
}
|
|
if(work->time >= 110) {
|
|
work->type = 0;
|
|
work->stat |= 8;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case -1:
|
|
{
|
|
work->work_float[0] += seqSpeed*0.1f;
|
|
scale = 1.0f-work->work_float[0];
|
|
if(scale <= 0.0f) {
|
|
scale = 0.0f;
|
|
work->type = 0;
|
|
work->stat |= 0x8;
|
|
if(work->work_s16[1] == 0) {
|
|
MGSeqPauseEnableCtrl(1);
|
|
}
|
|
}
|
|
for(idx=0; idx<work->work_s16[3]; idx++) {
|
|
HuSprTPLvlSet(work->spr_grp[0], idx, scale);
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
if(seqDoneF || (work->stat & 0x8)) {
|
|
MGSeqSprKill(work);
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static int SeqInitMGCommon(SeqWork *work, va_list params)
|
|
{
|
|
s16 i;
|
|
float tp_lvl;
|
|
s16 j;
|
|
|
|
s16 word_grp;
|
|
|
|
work->work_s16[1] = va_arg(params, int);
|
|
if(work->work_s16[1] == 2) {
|
|
return SeqInitDraw(work, params);
|
|
}
|
|
work->type = 0;
|
|
work->work_float[0] = 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->work_s16[1] == 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->work_s16[1]+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->work_s16[3]; j++) {
|
|
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);
|
|
}
|
|
if(i == 0) {
|
|
tp_lvl -= 0.5;
|
|
} else {
|
|
tp_lvl -= 0.1f;
|
|
}
|
|
}
|
|
if(seqPauseF) {
|
|
work->type = 2;
|
|
HuSprAttrSet(word_grp, 0, SPRITE_ATTR_HIDDEN);
|
|
} else {
|
|
work->param[0] = 3;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static int SeqInitDraw(SeqWork *work, va_list params)
|
|
{
|
|
|
|
}
|
|
|
|
static void SeqPlayStartFX(void)
|
|
{
|
|
|
|
}
|
|
|
|
void MGSeqPauseEnableCtrl(s32 flag)
|
|
{
|
|
|
|
} |