Trifels Mahou Gakuen

Trifels Mahou Gakuen
Developer: ASCII Publisher: ASCII Platform: PlayStation Released in JP: April 20, 2000 This game has uncompiled source code. This game has debugging material. This game has a hidden sound test. This game has a hidden level select.

Taisen Renai Simulation: Trifels Mahou Gakuen is a battle dating simulation game.

Debug Mode

Use the following code, after that select "はじめから" in title screen to display a debug menu. Select "DEBUG MODE" to switch to next page, select "GAME START" to crash the game.

8005652C 0009
8008BE84 0000
8008BE86 0400
8008BE88 4000
8008BE8A E801

(Source: Original TCRF research)

STAGE START

Execute some program.

Text	Notes
START
AITE	Set player 2 mode.
1P PLYAYER	Player 1 character.
2P PLYAYER	Player 2 character.
DAY	Date
TIME	GOZEN (AM), GOGO (PM), YUUGATA (Afternoon)
TASK	Select load program.
OPT ALBM	Enable/Disable album viewer in option menu.
OPT BUTO
ALBM ALL PIC	Unlock all pictures in album.
SETUMEI GAL	Commentary Character.

Sound Test

SOUND TEST MODE

Sound test.

• Circle: SFX test mode.
• Square: Instrument test mode.
• Left, Right: Select file.
• Start: Exit.

• Left, Right: Select number.
• Up, Down: Select menu.
• Circle: Play.
• X: Exit.

XA TEST MODE

CD-XA test.

• Left, Right: Select number.
• Start: Exit.

Uncompiled Source Code

...But what does it mean? This game has text or audio that needs to be translated. If you are fluent with this language, please read our translation guidelines and then submit a translation!

Present in OVR/SL.BIN.

address 0x8000

//==================================================================================
//==================================================================================
//	staff.cpp	：	スタッフロ－ル
//==================================================================================
//==================================================================================

//==================================================================================
//	INCLUDE FILES
//==================================================================================
#include "AllInOne.h"
#include "ts_def.h"
#include "gm_ctrl.h"

#include <libpress.h>
#include "ts_movie.h"
#include "

address 0x82B8

ame.h"
#include "se.h"
#include "savedata.h"
#include "staff.h"
#include "stf.def"
//==================================================================================
//	DEFINE
//=============================

Present in OVR/FOL.BIN.

address 0x16C00

creenOfA();	//	画面設定：ＯＦＦ
	ClipOff();			//	CLIP設定：閉じる
	setMmV1();			//	
	Wx();				//	GsClip()：設定

	// 魔法祭１日目、夕方か？
	if( (*syscom==SC_PLY2)&&(stage==ST_SCHOOL)&&(gmday==0) ){
		//	武闘大会
		//	タスク実行
		_ButoMain	*stb;
		stb = NewMt(_ButoMain)(&loop_flg);
		while( loop_flg ){
			stb->Execute();
			Wx();
		}
		*syscom = SC_DOK;
	} else {
		//	この指止まれ
		switch( *syscom ){
		case SC_PLY0:	gmtime = 0;	break;
		case SC_PLY1:	gmtime = 1;	break;
		case SC_PLY2:	gmtime = 2;	break;
		}
		GameGetPlay();
		//	タスク実行
		_YubiMain	*sty;
		sty = NewMt(_YubiMain)(&loop_flg);
		while( loop_flg ){
			sty->Execute();
			Wx();
		}
		//	次のシステム番号設定
			#if( 1 )
		switch( *syscom ){
		case SC_PLY0:	*syscom = SC_SIN0;	break;
		case SC_PLY1:	*syscom = SC_SIN1;	break;
		case SC_PLY2:	*syscom = SC_SIN2;	break;
			#else
		switch( *syscom ){
		case SC_PLY0:	*syscom = SC_ISU;	break;
		case SC_PLY1:	*syscom = SC_ISU;	break;
		case SC_PLY2:	*syscom = SC_ISU;	break;
			#endif
		}
	}
//	*syscom = SC_PLY0;		//	for debug
	*flg = 1;
	//	関数終了と、ともに、Delete();
}
//==================================================================================
//	タスク設定関数
//==================================================================================
void	func_ply(int *syscom)
{
	byte	*cp = gbWork;
	int		flag = 0;
	TG(0).Insert(NewMt(_scPly)(syscom,&flag));
	vloop(&flag,vwfast);
	gbWork = cp;
}
//==================================================================================
//	午前・午後・夕方の遊び(この指とまれ)
//==================================================================================
void	(*func_PLY0)(int *sysco) = func_ply;
void	(*func_PLY1)(int *sysco) = func_ply;
void	(*func_PLY2)(int *sysco) = func_ply;
//==================================================================================

//==================================================================================
//	この指とまれ：INIT
//==================================================================================
static	void	GameGetPlay( void )
{
	GameStageSel();
	NowOn();
	if( gmday+gmtime )	Bgm(3+stage);
	LoadFileProg(0);
	#ifndef ROM
		//	push_wait2();
		//	NowOf();
	#endif
}

//==================================================================================
//	BGを消す
//==================================================================================
void	_OtherProcClear( void )
{
	BgOff();				//	
	ScreenGain = 0x10;		//	
	srand(vscnt);			//	乱数設定は、ここでしよう
}

//==================================================================================
//	デバック設定
//==================================================================================
//#define DEB
#define DEBP0 1
#define DEBP1 2
#define DEBTP 0
#define DEBSC SC_PLY0
#define DEB_ST 1
//==================================================================================
extern void GameStageInit(void);
static	void InitGame(void)
{
	int i;
	pdmode=0;
	gmode=-1;
	gmtype=DEBTP;
	trgply=0;
//	*sysco=0;
	senko=1;
	stage=DEB_ST;
	chcwait=0;
	player[0]=0;
	player[1]=1;
	menuco=menufg=nowfg=0;
	sprog=eveco=evefg=wdf=0;
	for(i=0; i<7; i++) itemlist[i]=-1;

//#ifdef DEB
//	sysco=DEBSC;
	player[0]=DEBP0;
	player[1]=DEBP1;
	ParaInitGame();
	GameStageInit();
	ParaInitDay(0);
	ParaInitDay(1);
	gmode=1;
	gmday=0;
//#endif
}

//=========================================================================
//	DEBUG 情報 設定
//=========================================================================
int		Debug_DataSet( void )
{
#if( START_DATA_SET )
	InitGame();

	gmtype		= 0;			//	相手ﾌﾟﾚｲﾔ- : 0:COM , 1:人
	trgply		= 0;			//	0:先行 1:後行
	player[0]	= 0;			//	ﾌﾟﾚｲﾔ-1P
	player[1]	= 1;			//	ﾌﾟﾚｲﾔ-2P
//	stage		= ST_SEA;		//	ｽﾃ-ｼﾞ : ST_SEA,ST_SCHOOL,ST_STAN,ST_SNOW
//	stage		= ST_SCHOOL;	//	ｽﾃ-ｼﾞ : ST_SEA,ST_SCHOOL,ST_STAN,ST_SNOW
//	stage		= ST_STAN;		//	ｽﾃ-ｼﾞ : ST_SEA,ST_SCHOOL,ST_STAN,ST_SNOW
	stage		= ST_SNOW;		//	ｽﾃ-ｼﾞ : ST_SEA,ST_SCHOOL,ST_STAN,ST_SNOW
	if(gmtype==0)	comply=1;	//	CPUﾌﾗｸｸﾞ設定
	else			comply=-1;

	GameStageInit();

	gmday		= 0;			//	何日め？ 		: 0,1,2
	gmtime		= 2;			//	午前/昼/午後	: 0,1,2
//	trggal		= 0x140;		//	

		#if( 0 )
	//この指特別イベント
	if(stage==ST_SEA){
//		playevf[0]=0x00;		//マリエン
		playevf[1]=0x01;		//大波
	}
	if(stage==ST_SCHOOL){
		playevf[0]=0x10;			//校長
		playevf[1]=0x00;			//突風：１Ｐが先行の場合のみ
	}
	if(stage==ST_STAN){
//		playevf[0]=0;			//お披露目：１日目午前
	}
		#endif

	DEBUG_START_MODE();			//	開始ステ－ジ設定

	return( SC_ISU );			//	椅子取り
//	return( SC_STT );			//	タイトル
//	return( SC_PSL );			//	プレイヤ－セレクト
//	return( SC_PLY2 );			//	夕方の遊び：（武踏大会）
//	return( SC_PLY1 );			//	午後の遊び
//	return( SC_PLY0 );			//	午前の遊び
//	return( SC_FOL );			//	フォロ－合戦
//	return( SC_DOK );			//	ドキドキ　ランキング
//	return( SC_CHO );			//	チョコもらい
//	return( SC_TEA );			//	おやつ
//	return( SC_SIN0 );			//	イベント
//	return( SC_YUU );			//	夕暮れ
//	return( SC_NIG );			//	夜のイベント
//	return( SC_DBG );			//	デバックモ－ド
//	return( SC_GMP );			//	プロロ－グ
#else
	gmtype		= 0;			//	相手ﾌﾟﾚｲﾔ- : 0:COM , 1:人
	player[0]	= 0;			//	ﾌﾟﾚｲﾔ-1P
	player[1]	= 1;			//	ﾌﾟﾚｲﾔ-2P
	stage		= ST_SNOW;		//	ｽﾃ-ｼﾞ : ST_SEA,ST_SCHOOL,ST_STAN,ST_SNOW
	gmday		= 0;			//	何日め？ 		: 0,1,2
	gmtime		= 0;			//	午前/昼/午後	: 0,1,2
	if(gmtype==0)	comply=1;	//	CPUﾌﾗｸｸﾞ設定
	else			comply=-1;

	DEBUG_START_MODE();			//	開始ステ－ジ設定

	return( SC_STT );			//	タイトル
#endif
}
//==================================================================================
//==================================================================================
//	開始デバックモ－ド
//==================================================================================
//==================================================================================
	typedef struct {
		char	*str;
		int		code;
		int		data;
	} DEBUG_GAME_DATA;

struct	_DebugStart : public tMtUser{
private:
	int		*flg;
	int		prog_no;
public:
	_DebugStart( int *_flg )	{	flg = _flg;	}
	_DebugStart()				{	;			}
	void	Start(int code);
	void	func000( void );
	void	func001( void );
	void	func002( void );
};
//==================================================================================
//	呼び出しメイン
//==================================================================================
void	DEBUG_START_MODE( void )
{
	int		flag = 0;
	TG(0).Insert(NewMt(_DebugStart)(&flag));
	vloop(&flag,vwfast);
}
//==================================================================================
//	
//==================================================================================
void	_DebugStart::Start( int code )
{
		#if( 0 )
	static	DEBUG_GAME_DATA		data[]={
		{	"SELECT STAGE",				0,			0	},	//	
		{	"NORMAL GAME START\n",		SC_STT,		0	},	//	
		{	"ISU-TORI AND FOLLOW\n",	SC_ISU,		0	},	//	
		{	"DOKIDOKI RANKING\n",		SC_DOK,		0	},	//	
		{	"ASOBI GOZEN\n",			SC_PLY0,	0	},	//	
		{	"ASOBI GOGO\n",				SC_PLY1,	0	},	//	
		{	"ASOBI YUUGATA\n",			SC_PLY2,	0	},	//	
		{	"OYATU\n",					SC_TEA,		0	},	//	
		{	"IVENT\n",					SC_SIN0,	0	},	//	
		{	"NIGHT\n",					SC_NIG,		0	},	//	
		{	"GAME PROLOGUE\n",			SC_GMP,		0	},	//	
		{	"CHOKO\n",					SC_CHO,		0	},	//	
	};
		#endif

	static char stbl[4] ={ST_SNOW,ST_SEA,ST_SCHOOL,ST_STAN};
	static char *ttbl[4]={"SNOW","SEA","SCHOOL","STAN"};
	int		stgno;

	FntLoad( 64*15 , 256*0 );
	SetDumpFnt( FntOpen(16,16,320,240,0,1024) );

	Wx();

	stgno = 0;
	while(1){
		if( CHKPAD(0,Push,PAD_RI) )	stgno++;
		if( CHKPAD(0,Push,PAD_LE) )	stgno--;
		if( stgno < 0 )				stgno = 3;
		if( stgno > 3 )				stgno = 0;

		if( CHKPAD(0,Push,BTN_RI) ){
			stage = stbl[stgno];
			break;
		}
		FntPrint("\nSELECT STAGE NO = %s\n" , ttbl[stgno]);
		Wx();
		FntFlush(-1);
	}
	Wx();
	*flg = 1;
	//	関数終了と、ともに、Delete();
}


//==================================================================================
//==================================================================================
//	デバック　ＶＲＡＭ関連
//==================================================================================
//==================================================================================

//=========================================================================
//	初回 DEBUG VRAM 設定
//=========================================================================
void	DebugFirstVramSet( void )
{
	RECT	rect;
	int		x;

	#if( SUB_MASTER_MODE )
		return;
	#endif

//	return;

	setRECT( &rect, 0, 0, 1024, 512 );
	ClearImage( &rect, 0x60, 0x60, 0x60 );

	setRECT( &rect, 0, 0, 64, 256 );
	for( x=0 ; x<32 ; x+=2 ){
		rect.x = 64*x;
		ClearImage( &rect, 0x30, 0x30, 0x30 );
	}
	setRECT( &rect, 0, 256, 64, 256 );
	for( x=1 ; x<32 ; x+=2 ){
		rect.x = 64*x;
		ClearImage( &rect, 0x30, 0x30, 0x30 );
	}
	DrawSync(0);
}

//=========================================================================
//	VRAM VIEW
//=========================================================================
void	DebugVramViewer( void )
{
	DISPENV		disp;
	u_short		padd, opadd, tpadd;

	GetDispEnv(&disp);
	padd = CHKPAD(0,Data,0xffff);

	do {
		PutDispEnv(&disp);

		opadd = padd;

		padd = PadRead(0) & 0x0000ffff;

		tpadd = ~opadd & padd;

		if (padd & PADLleft)	disp.disp.x -= 8;
		if (padd & PADLright)	disp.disp.x += 8;
		if (padd & PADLup)		disp.disp.y -= 8;
		if (padd & PADLdown)	disp.disp.y += 8;

		if (tpadd & PADRright) {
			switch (disp.disp.w) {
			default:
				disp.disp.w = 640;
				break;
			case 320:
				disp.disp.w = 256;
				break;
			case 360:
				disp.disp.w = 320;
				break;
			case 512:
				disp.disp.w = 360;
				break;
			case 640:
				disp.disp.w = 512;
				break;
			}
		}

		if (tpadd & PADRdown)	disp.disp.h = (disp.disp.h == 240? 480: 240);

		if (tpadd & PADRup)	disp.isrgb24 ^= 1;

		VSync(0);
	} while (!(tpadd & PADstart));
}

//=========================================================================
//	SAOUND MODE
//=========================================================================
void	DebugSoundMode( tMtUser *user )
{
	static	int	seno,idno;

//	DebInit2( 64*5, 256*1, 16, 16 );

	seno = 0;
	idno = SE_TYPE_EVE;
	while( 1 ){
		if( CHKPAD(0,Push,BTN_ST) )	break;

		if( CHKPAD(0,Push,PAD_UP) )	idno++;
		if( CHKPAD(0,Push,PAD_DO) )	idno--;
		if( CHKPAD(0,Push,PAD_RI) )	seno++;
		if( CHKPAD(0,Push,PAD_LE) )	seno--;
		if( CHKPAD(0,Push,BTN_RI) )	SeExe( seno ,idno );
		if( CHKPAD(0,Push,BTN_DO) )	SeClose( idno );
		if( CHKPAD(0,Push,BTN_UP) )	printf("SENO=%d : ID=%d\n",seno,idno);

		FntPrint("SENO=%d : ID=%d\n",seno,idno);
		FntFlush(-1);
		user->Wx();
	}
}

//=========================================================================
//	VRAM VIEW 呼び出しメイン
//=========================================================================
void	DebugProcCheck( void )
{
	if( CHKPAD(0,Data,TRG_R2 ) ){
		if( CHKPAD(0,Push,BTN_ST) ){
			DebugVramViewer();
		}
	}
	if( CHKPAD(0,Data,TRG_L2) ){
		VSync(3);
	}
}

address 0x1C000

// ============================================================ //
				//																//
				//	ロード/セーブ　回り											//
				//																//
				//					使いまわし　To　吉丸　慎一郎				//
				//																//
				// ============================================================ //

// ========================== //
// |                        | //
// | インクルードファイル部 | //
// |                        | //
// ========================== //  ------------------------------ 
//↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓


#include "AllInOne.h"
#include <libmcrd.h>

#include "ts_def.h"
#include "gm_ctrl.h"

#include "com.h"
#include "gam.h"
//#include "rom.h"
#include "m.h"

//#include "mtask.h"

#define DEBM 1

//#include "card.h"
#include "sl.h"

	#if( 0 )
#include "p_cp.h"			//	追加
#include "p_cpw.h"			//	追加
#include "p_ch.h"			//	追加
#include "p_sf.h"			//	追加
#include "p_dpsy.h"			//	追加
#include "p_sys.h"			//	追加
#include "p_gam.h"			//	追加
#include "p_card.h"			//	追加
#include "p_para.h"			//	追加
	#endif

#include "savedata.h"


#define		SLMODE_LOAD	0
#define		SLMODE_SAVE	1


////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////
//↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓

	// ＳＥ
	#define SE_SETTLE 		0
	#define	SE_SERECT 		1
	#define	SE_BOO			2

	// セーブエリア

 	extern	SYSTEM_DATA_WORK	sysdat_work;			// システム関連
	extern 	char 				MSaveBuff[0x5000];		//

			SLINF				savehead[6];			//
 			SAVE_DATA_WORK		savedata[6];			// セーブ関連



	// ●ＳＬ画面で使用するバッファ
				char 		*SLnewbuff_GD ;			//  0x7000 

	// ●スプライト表示ワーク
		static	u_long		SlOt[100];			// OT Work
		static	u_long		SlOtb[100  ];			// 
		static	SPRT		SlSp [ 36+1];			// 
		static	SPRT		SlkSp[  6+1];			// 
		static	SPRT		SlBg [ 20  ];			// 
		static	DR_TPAGE	SlDrm[  4  ];			// 

#if( 0 )

	// ●ステージで初期化されるがサンプル
		static SLINF slt[6]=						//
		{											//
			{ 0, 0, 0, 0, 1 },						//
			{ 1, 1, 0, 0, 2 },						//
			{ 2, 0, 0, 0, 3 },						//
			{-1, 1, 0, 1, 2 },						//
			{ 0, 0, 0, 1, 3 },						//
			{ 0, 1, 0, 2, 3 },						//
		};											//

	// ●
		static	int 		slmode;					// 実行ＩＤになる (SlControl)
		static	int 		slcd;					// 現在選択中の場所
		static	int 		sl_flag;				// 0:ロード		1:セーブ
	
		extern	void	_MCardSysInit	(void);		// カード初期化
		extern	int 	SL_ChkCard		(int mode);	// カードチェック



static	int 		slmess;							//
static	int 		cinfo2;							//
		int			SL_EXIT = 0;					//	モードEXIT
		
		extern	int		SlScriptMesPut( int no );

////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////
//↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓

//extern	void 	MmVs			(void);			//	追加

static 	void 	SlControl		(void);
static 	int 	SlMescon		(void);
static 	void 	SlModeCheck		(void);
static 	void 	SlGetData		(void);
		int 	SlSelMes		(int type);
		void 	SlSetMes		(int type);

extern 	int 	vscnt;
extern	int		wdf;
extern	int		gmode;

extern 	int 	PadDataRead		(int p, int nn);		// パッドデータ更新						(  )
extern  int 	ClipFade		(int type);				// クリップエリアによる画面の ON/OFF	( R:\tr_main\gc.cpp ) 



int	SL_loaddata	(void)		{ ; }


int 	cinfo;
char 	*cardbuf;



static	void	SlChkInf		(void);					//
		void	SlV				(void);					//


static	void LoadFileSlCG		(void);					// ＳＬのＧＤデータを読み出す	
static	void	MEM_SEPUT		(int id);				// ＳＬでのＳＥプット			





////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////
//↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓


// ===================================== //
// 内部：初期化							 //
//										 //
// SL_CG(SL.H) にてアドレスを切ってある	 //
// にグラフィックデータを読み込む		 //
// ===================================== //
// 確認
static void LoadFileSlCG(void)
{
 #ifdef ROM
	MmFileRead("\\ET\\SL.GD;1"	, (void *)SLnewbuff_GD );

 #else
	read_in_file("ET\\sl.gd"	, (char *)SLnewbuff_GD );

 #endif
}


// ==================================== //
// ●テクスチャ転送						//
// ==================================== //

static void SL_SetTexture(ULONG *addr, int tpnum, int clnum, int tu, int tv)
{
  RECT rect;
  SXY *t = &Textbl[tpnum];
	GsGetTimInfo(addr+1, &timinf);

	if(tpnum < 0x100)
	{
		texRect.x=t->x + tu;
		texRect.y=t->y + tv;
		texRect.w=timinf.pw;
		texRect.h=timinf.ph;
		LoadImage(&texRect,timinf.pixel);
	}

	if(clnum < 0x100)
	{
	  SXY *c=&Cluttbl[clnum];
		rect.x=c->x+640;
		rect.y=c->y;
		rect.w=timinf.cw;
		rect.h=timinf.ch;
		LoadImage(&rect,timinf.clut);
	}
}




// ==================================== //
// ●スプライト転送						//
// ==================================== //

static void SL_SetSprFirst(SPRT *sp, SPRDF *d)
{
  SPRD *sd;
	sd=&d->sd;
	SetSprt			(sp);
	SetShadeTex		(sp, (d->atr & 2)? 0:1);
	SetSemiTrans	(sp, d->atr & 1);
//	SetSemiTrans	(sp,  1);
	setRGB0			(sp, 128,128,128);
	SetSprData		(sp, sd);

	sp->clut = 	((clut[d->cl])+40);
}





// ==================================== //
// スプライト初期化						//
// ==================================== //
static void SlDpInit(void)
{
	 int	i , j , x , y;
	 short	*td;
	 char	*buf;

	SPRT	*sp;
	SPRT	*sp1;
	SPRT	*sp2;

	// ====================	//
	//	常駐ＣＧ			//
	// ====================	//
		LoadFileSlCG();

		for(i=0; i<FILE_CNT; i++)
		{
			td = &cgtd[i][0];
			SL_SetTexture((ulong *)GTfdata(i,(byte *)SLnewbuff_GD), *td, *(td+1), *(td+2), *(td+3));
		}

	ClearOTag	( SlOt  	, 100	);					//	ＯＴを初期化する
	ClearOTag	( SlOtb 	, 100	);					//	
	SetDr0		( &SlDrm[0] , SLTP0	);					//	
	SetDr0		( &SlDrm[1] , SLTP0	);					//	
	SetDr0		( &SlDrm[2] , SLTP1	);					//	
	SetDr2		( &SlDrm[3] , SLTP1	);					//	

	sp=SlSp, sp1=&SlSp[12], sp2=SlkSp;
	x=INFX;
	for(i=0; i<6; i++, sp1++,sp2++)
	{
		if(i==3) x+=INFW;
		y=INFY+INFH*(i%3);

		for(j=0;j<2;j++,sp++)
		{
			SL_SetSprFirst(sp, &SlSpd[1]);		//name
			sp->x0=x;
			if(j) sp->x0+=60;
			sp->y0=y+15+0x100;
		}

		SL_SetSprFirst(sp1, &SlSpd[2]);			//stage
		sp1->x0=x, sp1->y0=y+0x100;
		sp1++;

		SL_SetSprFirst(sp1, &SlSpd[3]);			//day
		sp1->x0=x+84, sp1->y0=y+1+0x100;
		sp1++;

		SL_SetSprFirst(sp1, &SlSpd[8]);			//mess
		sp1->x0=x+8, sp1->y0=y+8+0x100;
		sp1++;

		SL_SetSprFirst(sp1, &SlSpd[4]);			//waku
		sp1->x0=x-4, sp1->y0=y-4;


//		SL_SetSprFirst(sp2, &SlSpd[5]);			//kage
		sp2->x0=sp1->x0, sp2->y0=sp1->y0;
	}
	SL_SetSprFirst(sp1, &SlSpd[6]);			//back

//	SL_SetSprFirst(sp2, &SlSpd[7]);			//back kage


	sp = SlSp;
	for(i=0;i<12;i++,sp++)
	{
	//	if(i>=2) SSH(sp,50);
		SSH(sp,50);
		AddPrim(&SlOt, sp);
	}
	AddPrim(&SlOt, &SlDrm[1]);				// プリミティブをＯＴに登録

	for(i=0;i<24+1;i++,sp++)
	{
	//	if(i>=4) SSH(sp,80);
		SSH(sp,80);
		AddPrim(&SlOt, sp);
	}
	AddPrim(&SlOt, &SlDrm[2]);

	sp = SlkSp;
	for(i=0;i<6+1;i++,sp++)
		AddPrim(&SlOt, sp);

	AddPrim(&SlOt, &SlDrm[3]);

	sp = SlBg;
	for(i=0; i<20; i++,sp++)
	{
		SL_SetSprFirst(sp, &SlSpd[0]);
		sp->x0 = (i%5)*64 ;
		sp->y0 = (i/5)*64 ;
		AddPrim  (&SlOtb, sp);
	}
	AddPrim(&SlOtb, &SlDrm[0]);

	gmode=8;	// DrawAll時の分岐ＩＤ

}


// ===================================== //
//										 //
// ===================================== //
static void SlChkInf(void)
{
  int i,j;
  SPRT *sp,*sp1;
 
  SLINF *t;

	t=slt;
	sp=SlSp, sp1=&SlSp[12];


	// メモリーカード内に記憶する場所の数（６回）ループ
	//
	//

	for(i=0;i<6;i++,t++,sp+=2,sp1+=4)
	{
		if(t->stage<0)
		{
			// データがありません
	
			((sp1+2) ->y0) &=  0xff;		//no data
			( sp     ->y0) |= 0x100;
			((sp+1)  ->y0) |= 0x100;
			( sp1    ->y0) |= 0x100;
			((sp1+1) ->y0) |= 0x100;
		}
		else
		{
			((sp1+2) ->y0) |= 0x100;		//data
			( sp     ->y0) &= 0xff;
			((sp+1)  ->y0) &= 0xff;
			( sp1    ->y0) &= 0xff;
			((sp1+1) ->y0) &= 0xff;
			( sp     ->v0)  = (t->p1)   *32;
			((sp+1)  ->v0)  = (t->p2)   *32+16;
			( sp1    ->v0)  = (t->stage)*16;
			((sp1+1) ->v0)  = (t->day)  *12;
		}
	}
}


//
//
static void SlModeCheck(void)
{
	int		i;									//

	// メモリーカード詳細等

	for(i=0;i<6;i++)							// 初期化を行う
		slt[i].stage = -1;						// 

	slmode	= MODE_CHECK;						// card check
	slmess	= 0;								//
	slcd	= 6;								//


	SlChkInf();									// メモリ記憶内容をスプライトを定義
	SlMescon();									// メッセージ表示
	SlV();										// Vwait
}												//



static void SlSel(int old)
{
  int i;
  SPRT *sp;
	if(old!=-1)
	{
		if(old == 6)
		{
			sp = &SlSp[36];
			SSH(sp,80);
		}
		else
		{
			sp = &SlSp[old*2];
			for(i=0;i<2;i++,sp++) SSH(sp,50);
			sp=&SlSp[12+old*4];
			for(i=0;i<4;i++,sp++) SSH(sp,80);
		}
	}
	if(slcd==6)
	{
		sp=&SlSp[36];
		SSH(sp,128);
	}
	else
	{
		sp=&SlSp[slcd*2];
		for(i=0;i<2;i++,sp++) SSH(sp,128);
		sp=&SlSp[12+slcd*4];
		for(i=0;i<4;i++,sp++) SSH(sp,128);
	}
}


// ===================================== //
// 内部：	セーブデータをメインに設定	 //
//										 //
//										 //
// ===================================== //
// 確認
static void SlGetData(void)
{
	//	char *buf;
	//
	//	buf = cardbuf + INF_DATA	+ slcd * INF_MAS;
	//	GetGameSave0(buf);
	//
	//	buf = cardbuf + FILE_HDSIZE + slcd * DAT_MAS;
	//	GetGameSave1(buf	);
	//	GetParaSave	(buf+64	);
	//
}



////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////
//↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓



// ===================================== //
// 外部参照：セーブデータをメインに設定	 //
//										 //
//										 //
// ===================================== //
// 確認
void SlSetData(void)
{
	//	char *buf=cardbuf+INF_DATA+slcd*INF_MAS;
	//
	//	SetGameSave0	( buf	);
	//	buf = cardbuf+FILE_HDSIZE + slcd*DAT_MAS;
	//	SetGameSave1	( buf	);
	//	SetParaSave		( buf+64);
}






// ===================================== //
//	VSync								 //
//										 //
// ===================================== //
// 確認


extern	tMtUser *texec;


void SlV(void)
{
extern	void	DebugProcCheck( void );

	DebugProcCheck();
	texec->Wx();


	//	WordsConLite();							//
	//	VsyncWait();							// 起動からの絶対時間を垂直同期間隔を返す
	//
	//	DrawSync	(0);						// キュー登録すべて描画終了を待つ
	//	ComDraw		();							// クリッピング領域指定？
	//											//
	//	DrawOTag(&SlOtb);						//
	//	if(sl_flag>=0)							//
	//		DrawOTag(&SlOt);					// 登録されたプリミティブをまとめて実行。 
	//
	//	DrawCpDp	();							//
	//	ComDrawSet	();							//
	//
	//	MmVs();									//
	//	PadDataRead(0, 3);						//	パッドーデータ更新
	//
	//	#ifndef ROM								//
	//		DebPrintFnt(1);						//
	//	#endif									//

}




void	SL_Sync(void)
{
		ComDraw			( );					// クリッピング領域指定？
												//
		DrawOTag	(SlOtb);					//
		if(sl_flag>=0)							//
			DrawOTag(SlOt );					// 登録されたプリミティブをまとめて実行。
												//
		DrawSync		(0);					// キュー登録すべて描画終了を待つ
												//
		//DrawCpDp		( );					//
		//ComDrawSet	( );					//
		//MmVs();								//
		//PadDataRead(0, 3);					//	パッドーデータ更新

}



// 情報書き換えです。
static void SlSelc(void)
{
  int n;
  SPRT *sp;
	n=112+(vscnt&0xf)*2;
	sp=&SlSp[36];
	if(slcd!=6) sp=&SlSp[12+slcd*4+3];
	SSH(sp,n);
}

static int SlSelcon2(void)
{
	static int cd=-1;

	if(cd!=slcd)
	{
		SlSel(cd);
		cd=slcd;
		MEM_SEPUT( SE_SERECT );
	}
	else
	{
		SlSelc();
	}
}


// ●６個選択可能時
// 

static int SlSelcon(void)
{
  static int old;
  		 int n,cnt;

//	if(slcd==6)
//	{
//		// Exit 機能（なくなります）
//
//		if(cbMARU) return -1;
//		else 
//			if(lev1u)
//				slcd=old;
//
//		SL_EXIT
//	}
//	else
//	{

		old=slcd;

		if (PuBATU)
		{
			SL_EXIT = 1;
			return -1;
		}

		if(cbMARU)
		{
			if((sl_flag==SLMODE_LOAD)&&(slt[slcd].stage<0))
			{	
				//そこにデータはありません
				slmess = (10+sl_flag+0x100);
				MEM_SEPUT( SE_BOO );
			}
			else
			{
				MEM_SEPUT( SE_SETTLE );
				return 1;
			}
		}
		if((lev1l)&&(slcd>=3))
			slcd-=3;

		if((lev1r)&&(slcd<3))
			slcd+=3;
		
		if(lev1u)
		{
			if((slcd!=0)&&(slcd!=3)) slcd--;
		}

		// ↓なくなります。
		if(lev1d)
		{
			if((slcd==2)||(slcd==5)) slcd=old;
			else
				slcd++;
		}
//	}

	return 0;
}


static int SlControlS(int cond)
{
	if( (cinfo2=SL_ChkCard(1) ) == cond )
	{
		SlModeCheck();
		return 1;
	}
	return 0;
}



// Main -> Card
void M2C_DATASET(int pos)
{
	int	i;
	
	if ((pos<0) || (pos>5))
	{}
	else
	{
		// 今回のデータを入力
		savehead[pos].stage = stage		;
		savehead[pos].day	= gmday		;
		savehead[pos].type	= gmtype	;
		savehead[pos].p1	= player[0]	;
		savehead[pos].p2	= player[1]	;
		savehead[pos].senko	= senko		;
		for(i=0;i<7;i++) savedata[pos].comtvt	[i] = 0;//comtvt	[i];
		for(i=0;i<5;i++) savedata[pos].asobit	[i] = 0;//asobit	[i];
		for(i=0;i<2;i++) savedata[pos].oyatu	[i] = 0;//oyatu		[i];
		for(i=0;i<6;i++) savedata[pos].oyatu_s	[i] = 0;//oyatu_s	[i];
		for(i=0;i<7;i++) savedata[pos].itemlist	[i] = 0;//itemlist	[i];
		for(i=0;i<2;i++) savedata[pos].yu_henji	[i] = 0;//yu_henji	[i];
		for(i=0;i<2;i++) savedata[pos].ap		[i] = 0;//ap		[i];
		for(i=0;i<4;i++) savedata[pos].playevf	[i] = 0;//playevf	[i];
		for(i=0;i<4;i++) savedata[pos].lunchw	[i] = 0;//lunchw	[i];

		// ●メモリーカード表示部分
		//
			int 	size ,i;
			char	*Sadr;
			char	*Dadr = &MSaveBuff[0];
			long	Asize = 0;
			long	Bsize = 0;


			size = (int  )(sizeof(SLINF) * 6);
			Sadr = (char*)&savehead[0];
			for ( i=0 ; i<size ; i++ )
			{
				*Dadr++ = *Sadr++ ;
			}
			Asize += size;

		// ●アルバム
		//
			size = (int  )(sizeof(SYSTEM_DATA_WORK) );
			Sadr = (char*)&sysdat_work;
			for ( i=0 ; i<size ; i++ )
			{
				*Dadr++ = *Sadr++ ;
			}
			Asize += size;
			Bsize = Asize;


		// ●内部データ
		//
			size = (int  )(sizeof(SAVE_DATA_WORK) * 6);
			Sadr = (char*)&savedata[0];
			for ( i=0 ; i<size ; i++ )
			{
				*Dadr++ = *Sadr++ ;
			}
			Asize += size;

	}
	
}




static void SlControl(void)
{
	int i;
	int	n;
	int	r;

	long	test;
	long	fc;


	deb[16] = slmode;
	deb[17] = slmess;


	switch(slmode)
	{
		// ========================	//
		// ●カードをチェックする	//
		// ========================	//
		case MODE_CHECK:

			n = SL_ChkCard(0);
			cinfo = n;

			if(
				    ( (sl_flag==SLMODE_SAVE) && ((n==CARDSTS_OK) || (n==CARDSTS_NEW) || (n==CARDSTS_UNFMT)) )
				|| 	( (sl_flag==SLMODE_LOAD) && ((n==CARDSTS_OK) || (n==CARDSTS_NEW)                      ) )
			)
			{
				r = 0;

			//	if( SL_read(1) )
			//	{
			//	}

				SlChkInf();						// 表示用のスプライト初期化

				if(sl_flag==SLMODE_LOAD)
				{								// load
					if(r==0)
					{
						slmode   = MODE_NOFILE;	//
						//slmess = 2;			// セーブデータ無
					}
					else
					{
						slmode = MODE_SELECT_L;	//
						slcd   = 0;				//
					}
				}
				else
				{								// SAVE
					slmode = MODE_SELECT_S;		//
					slcd   = 0;
				}
			}
			else
			{
				slmode = MODE_WAIT;
				
				if( (sl_flag==SLMODE_LOAD) && (n==CARDSTS_UNFMT) )
				{
					slmess=4;										// 別のカードを挿入してください
				}
				if(n==CARDSTS_NOCARD)
				{
					slmess=1;										// カードが挿入されていない
				}
				if(n==CARDSTS_ERR)
				{
					slmess=6;										// 壊れ
				}
			}
			break;

		// ========================	//
		// ●カードチェック			//
		// ========================	//
		case MODE_WAIT:
			SlControlS(CARDSTS_NOCARD);						// カードが抜かれたら初期化
			if(cinfo2==CARDSTS_NEW)							// 新しいカードがささったらチェックへ
				slmode = MODE_CHECK;
			break;


		// ========================	//
		// ●該当ファイルなし		// ただし！LOADからしか来ません
		// ========================	//
		case MODE_NOFILE:
			SlSelMes (2) ;									// 別のカードを挿入してください
			SL_EXIT = 1  ;									//

		//	SlControlS(CARDSTS_NOCARD);						// カードが抜かれたら初期化
		//	if(cinfo2 == CARDSTS_NEW)
		//		slmode = MODE_CHECK;
		//
		//	if (PuBATU)
		//	{
		//		SL_EXIT = 1;
		//	}
			break;

		// ========================	//
		// ●SAVE/LOAD位置決定		//
		// ========================	//
		case MODE_SELECT_S:
		case MODE_SELECT_L:
	
		// カードを抜かれたらやり直し
		//	n = SL_ChkCard(0);
		//	if(n==CARDSTS_NOCARD)
		//		slmode =  MODE_CHECK;

			slmess	= 10+ sl_flag ; 
			n		= SlSelcon();						// ６個自由選択
			if(n==1)
			{
				slmode++;
			}
		//	SlControlS(CARDSTS_NOCARD);					// カードが抜かれたら初期化
			break;

		// ========================	//
		// ●SAVE/LOAD行動決定		//
		// ========================	//
		case MODE_LOAD_CHECK:
		case MODE_SAVE_CHECK:

			r = SlSelMes(12+sl_flag);					//	メッセージ処理
			if(r==0) slmode++;
			if(r==1) slmode--;
			SlControlS(CARDSTS_NOCARD);					// カードが抜かれたら初期化
			break;


		// ========================	//
		// ●セーブ					//
		// ========================	//
		case MODE_SAVE:								//

		
			// M2C_DATASET(slcd);					// ←現在のデータをつむ

			extern	int	SL_savedata(void);			//
			n=SL_savedata();						//
													//
			SlModeCheck();							//
													//
			switch(n)								//
			{
				case CARDSTS_OK:					//	完了
					slmode = MODE_END;				//	
					break;							//

				case CARDSTS_FULL:					//	memory full
					slmess = 5;						//
					slmode = MODE_WAIT;				//
					break;							//

				case CARDSTS_UNFMT:					//	not format
					slmess = 4;						//
					slmode = MODE_WAIT;				//
					break;							//
				
				case CARDSTS_NOCARD:				// No Card
					slmess = 1;						// 
					slmode = MODE_WAIT;				//
					break;							//

				case CARDSTS_DATAERROR:				//	error format
					slmess = 6;						//
					slmode = MODE_WAIT;				//
					break;							//
			}
			break;

		// ========================	//
		// ●ロードチェック			//
		// ========================	//
		case MODE_LOAD:
			n 		= SL_loaddata();
			slmode	= MODE_SELECT_L;				// 中止
			if(n==0)								// load comp.
				slmode=-2;
			break;

		// ========================	//
		// ●エグジット処理			//
		// ========================	//
		case MODE_END:
			slmode=-1;
			break;
			
	}

	SlSelcon2();									// 移動によるオブジェの輝度変更

	if(SL_EXIT)
	{
		MEM_SEPUT( SE_SETTLE );
		slmode=-1;
	}


}




// ===================================== //
// 内部：メッセージ処理？				 //
//										 //
//										 //
// ===================================== //
// 確認

int oldsm = -1;

static int SlMescon(void)
{
	if(slmess!=oldsm)
	{
		slmess&= 0xff   ;
		oldsm  = slmess ;
		//CpWords((u_char*)mes[sm]);			//?
		SlScriptMesPut(oldsm);
		return 1;
	}
	return 0;
}


int SlSelMes(int type)									//
{														//
	static int cd = 0;									//
	slmess = type;										//
	oldsm  = slmess ;

	cd = SlScriptMesPut(type);							//
														//
	return( cd );										//


//#if( 0 )
//	if(SlMescon())										//	メッセージ処理
//	{													//
//		SfBarPos(-1);									// Sf.cpp
//		cd=0;											//
//	}													//
//	else												//
//	{													//
//		if (cbMARU)										//
//		{												//
//			MEM_SEPUT( SE_SETTLE );						//
//			return cd+1;								//
//		}												//
//		if ((lev1l) && (cd==1))							//
//		{												//
//			MEM_SEPUT( SE_SERECT );						//
//			SfBarPos(-1);								// Sf.cpp
//			cd=0;										//
//		}												//
//		if((lev1r)&&(cd==0))							//
//		{												//
//			MEM_SEPUT( SE_SERECT );						//
//			SfBarPos(6);								// Sf.cpp
//			cd=1;										//
//		}												//
//	}													//
//	return 0;											//
//#endif

}														//






void SlSetMes(int type)
{														//
	slmess = type;										//
	SlMescon();											//	メッセージ処理
														//
	SlV();												// Vwait
	SlV();												// Vwait
}



////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////
#include "se.h"

	extern void	SeDataPut(int Type);
	extern void SeSettle		(void);
	extern void SeCansel		(void);
	extern void SeSelect		(void);
	extern void SeFale			(void);
	


static	void	MEM_SEPUT(int id)
{
	// SE 出力する関数
	switch(id)
	{
		case SE_SETTLE:
			SeSettle();
			break;

		case SE_SERECT:
			SeSelect();
			break;

		case SE_BOO:
			SeFale();
			break;

	}
}








////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////

// ===================================== //
//	0:ロード、1:セーブ					 //
//										 //
// ===================================== //

int SlC ( int mode )
{
	int		r ;

	sl_flag	 = -1;
	gmode	 = -1;

		#if( 0 )
extern	void	SlScttest( void );
	SlScttest();
		#endif


	SLnewbuff_GD  = new char[ 0x7000];			// グラフィックリードバッファ
	Bgm(1+1);									// BGM 開始：BgmCall直接呼び出しは使用禁止


	wdf		=  0;								//

	_MCardSysInit();							// メモリーカード初期化	
	SlModeCheck();								// とりあえず初期化
	SlDpInit();									// SAVE / LOAD　画像初期化

	// フェードイン
	while(1)									//
	{											//
		if(ClipFade(0x102)==1)					//
			break;								// hi-speed
		SlV();									// Vwait
	}											//

	sl_flag = mode;								// 0:ロード、1:セーブ

	SL_EXIT = 0;								//	モードEXIT


	while (1)
	{
		r=1;

		if(mode==SLMODE_SAVE)
		{										// セーブ時
			r = SlSelMes(7);					//	メッセージ？処理
			if(r==1) break;						//
		}										//
												//

		if(r==1)
		{
			SlSetMes(0);						// メッセージ処理
		//	InitMemCard();						// メモリーカード初期化
			SlModeCheck();						// 記憶内容表示（メモリーカード）


			while(1)
			{
				SlMescon	();					//	メッセージ処理
				SlV			();					//	Vwait
				SlControl	();					// 

				if(slmode<0)					// 
					break;						// 
			}
			//StopMemCard();					//メモリーカード終了



			if(slmode==-2)						//
			{									//	データロード
			//	SlGetData();					//	メインメモリへデータを転送
			}									//
			break;								//
		}
		SlV();									// Vwait
	}

	while(1)									//
	{											//
		SlV();									// Vwait
		if(ClipFade(2)==1) break;
	}
	DisCpDp(-1);								//cp all off
	gmode = 1;									//
	//////////////////////////////////////////////


	//	●メモリ開放

		release	SLnewbuff_GD;




	return slmode;
}

////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////



// ヘッダー設定
void headset(void)
{
	char *Sadr;
	char *Dadr;
	int	 size;
	int	 i;

	Sadr = &MSaveBuff[0] ;
	Dadr = (char*)&savehead[0];
	size = (int  )(sizeof(SLINF) * 6);
	for ( i=0 ; i<size ; i++ )
	{
		*Dadr++ = *Sadr++ ;
	}

	Dadr = (char*)&sysdat_work;
	size = (int  )(sizeof(SYSTEM_DATA_WORK) );
	for ( i=0 ; i<size ; i++ )
	{
		*Dadr++ = *Sadr++ ;
	}
}


#endif

address 0x24000

//----------------------------------------------------------------------------------
#ifndef _SL_H
#define _SL_H
//==================================================================================

#define SL_CG 0x80180000
#define SL_DATA 0x8017E000
#define INF_DATA 8192-128		//ブロックの後ろ
#define INF_MAS 16				//データ情報
#define DAT_MAS 1200			//１ファイルのデータ
#define FILE_HDSIZE 128*4

#define FILE_CNT 7
#define SLTP0 6
#define SLTP1 26
#define SLCL0 10
#define SLCL1 11
#define SLCL2 32
#define SLCL3 33
#define SLCL4 34
#define SLCLK 68
#define INFX 32
#define INFY 20
#define INFW 134
#define INFH 44

enum cont_mode{
	MODE_CHECK=0,
	MODE_WAIT,
	MODE_NOFILE,
	MODE_SELECT_S,
	MODE_SAVE_CHECK,
	MODE_SAVE,
	MODE_SELECT_L,
	MODE_LOAD_CHECK,
	MODE_LOAD,
	MODE_END,
};

typedef struct {
	int stage,day,type,p1,p2;
} SLINF;

static SPRT		SlSp[36+1], SlkSp[6+1];
static SPRT		SlBg[20];
static ULONG	SlOt,SlOtb;
static DR_TPAGE	SlDrm[4];
static int slf,slmode,slcd,slmess,cinfo2;
static SLINF slt[6]={
	{0,0,0,0,1},
	{1,1,0,0,2},
	{2,0,0,0,3},
	{-1,1,0,1,2},
	{0,0,0,1,3},
	{0,1,0,2,3},
};

static short cgtd[][4]={
	//bg0,sl_cname,sl_data,sl_w,back,sl_ws,backs,
	{SLTP0,SLCL0, 0,0},
	{SLTP0,SLCL1, 64/2,0},
	{SLTP1,SLCL2, 0,0},
	{SLTP1,SLCL3, 128/4,0},
	{SLTP1,SLCL4, 128/4,96},
	{SLTP1,0x100, 120/4,40},
	{SLTP1,0x100, 128/4,96+12},
};

static SPRDF SlSpd[]={
	{ 0, SLTP0,SLCL0, { 0,0, 64,64, 0,0}}, 		//0:BG
	{ 2, SLTP0,SLCL1, { 0,0, 62,16, 64,0}}, 	//1:Name
	{ 2, SLTP1,SLCL2, { 0,0, 84,16, 0,0}}, 		//2:Stage name
	{ 2, SLTP1,SLCL2, { 0,0, 32,12, 84,0}}, 	//3:Day
	{ 3, SLTP1,SLCL3, { 0,0, 128,40, 128,0}}, 	//4:Waku
	{ 1, SLTP1,SLCLK, { 0,0, 132,42, 120,40}}, 	//5:Waku kage
	{ 2, SLTP1,SLCL4, { 160-14,150, 28,12, 128,96}}, 	//6:Back
	{ 1, SLTP1,SLCLK, { 160-14,150, 32,20, 128,96+12}}, 	//7:Back kage
	{ 2, SLTP1,SLCL2, { 0,0, 116,12, 0,64}}, 		//8:mess
};

//	とりあえず・・・
#if( 0 )
// =======================================================================
static char mes0[]="
　メモリーカードのチェック中です。E";

static char mes1[]="
　メモリーカードをセットしてください。E";

static char mes2[]="
　セーブデータがありません。

　ほかのメモリーカードをセットしてください。E";

static char mes3[]="
メモリーカードがフォーマットされていません。

フォーマットしてよろしいですか？

　　　　　　BR5は　い　　　　いいえ

E";

static char mes4[]="
メモリーカードがフォーマットされていません。

ほかのメモリーカードをセットしてください。E";

static char mes5[]="
１ブロック必要です。ほかのメモリーカードを

セットするか、メモリーカード管理画面で

不要なデータを消してください。E";

static char mes6[]="
メモリーカードが壊れています。

ほかのメモリーカードをセットしてください。E";

static char mes7[]="
　セーブするのか？

　　　　　　BR5は　い　　　　いいえ

E";

static char mes9[]="
　データのセーブに失敗しました。

　もう一度セーブしますか？

　　　　　　BR5は　い　　　　いいえ

E";

static char mes8[]="
　データのロードに失敗しました。

　もう一度ロードしますか？

　　　　　　BR5は　い　　　　いいえ

E";

static char mes10[]="
　ロードするファイルを選んでください。

　　　○ボタンで決定します。E";

static char mes11[]="
　セーブするファイルを選んでください。

　　　○ボタンで決定します。E";

static char mes13[]="
　このファイルにデータをセーブします。

　よろしいですか？

　　　　　　BR5は　い　　　　いいえ

E";

static char mes12[]="
　このファイルのデータをロードします。

　よろしいですか？

　　　　　　BR5は　い　　　　いいえ

E";

static char mes14[]="
　セーブ中です。

　メモリーカードを抜かないでください。E";

static char mes15[]="
　ロード中です。

　メモリーカードを抜かないでください。E";
// =======================================================================
#else
// =======================================================================
static char mes0[]="　メモリーカードのチェック中です。E";
static char mes1[]="　メモリーカードをセットしてください。E";
static char mes2[]="　セーブデータがありません。　ほかのメモリーカードをセットしてください。E";
static char mes3[]="メモリーカードがフォーマットされていません。フォーマットしてよろしいですか？　　　　　　BR5は　い　　　　いいえE";
static char mes4[]="メモリーカードがフォーマットされていません。ほかのメモリーカードをセットしてください。E";
static char mes5[]="１ブロック必要です。ほかのメモリーカードをセットするか、メモリーカード管理画面で不要なデータを消してください。E";
static char mes6[]="メモリーカードが壊れています。ほかのメモリーカードをセットしてください。E";
static char mes7[]="　セーブするのか？　　　　　　BR5は　い　　　　いいえE";
static char mes9[]="　データのセーブに失敗しました。　もう一度セーブしますか？　　　　　　BR5は　い　　　　いいえE";
static char mes8[]="　データのロードに失敗しました。　もう一度ロードしますか？　　　　　　BR5は　い　　　　いいえE";
static char mes10[]="　ロードするファイルを選んでください。　　　○ボタンで決定します。E";
static char mes11[]="　セーブするファイルを選んでください。　　　○ボタンで決定します。E";
static char mes13[]="　このファイルにデータをセーブします。　よろしいですか？　　　　　　BR5は　い　　　　いいえE";
static char mes12[]="　このファイルのデータをロードします。　よろしいですか？　　　　　　BR5は・

address 0x25530

s14[]="　セーブ中です。　メモリーカードを抜かないでください。E";
static char mes15[

(Source: Original TCRF research)