/* *****************************************************************************
	Title : game.c
***************************************************************************** */

#include	"main.h"									/* main.h				*/


#define		GM_EXIT				FALSE
#define		GM_SCREEN_SAVE		FALSE					/* 画像保存（広告用）	*/
#define		GM_DEATHLESS		FALSE					/* 不死身				*/
#define		GM_TITLE_TEST		FALSE					/* 仮ﾀｲﾄﾙ				*/


#define		GM_DEBUG			FALSE					/* 当たり判定用			*/
#define		GM_MOVE_DEBUG		FALSE					/* 移動					*/
#define		GM_SWD_DEBUG		FALSE					/* 剣					*/
#define		GM_IWIN_DEBUG		FALSE					/* ｱｲﾃﾑ･ｳｨﾝﾄﾞｳ			*/
#define		GM_FLOOR_DEBUG		FALSE					/* ﾌﾛｱ					*/

#define		GM_ATTACK_DEBUG		FALSE					/* 攻撃					*/
#define		GM_ATBLK_DEBUG		FALSE					/* 攻撃■表示			*/

#define		GM_DAMAGE_DEBUG		FALSE					/* ﾀﾞﾒｰｼﾞ				*/
#define		GM_LOADST_DEBUG		FALSE					/* LOAD STAGE			*/

#define		GM_ENEMY_ACT_DEBUG	FALSE					/* 敵ｱﾙｺﾞ				*/
#define		GM_ENMCDMG_DEBUG	FALSE					/* toﾌﾟﾚｲﾔｰﾀﾞﾒｰｼﾞ		*/
#define		GM_ENMHIT_DEBUG		FALSE					/* toﾌﾟﾚｲﾔｰﾀﾞﾒｰｼﾞ		*/
#define		GM_CANCEL_DEBUG		FALSE					/* ｷｬﾝｾﾙ				*/

#define		GM_SHIELD_DEBUG		FALSE					/* 盾防御				*/

#define		GM_MAGICIAN_DEBUG	FALSE					/* 魔法使い				*/
#define		GM_MAGIC_DEBUG		FALSE					/* 魔法ｽﾍﾟﾙ				*/
#define		GM_SLIME_DEBUG		FALSE					/* ｽﾗｲﾑ					*/
#define		GM_TESTA_DEBUG		FALSE					/* ﾃｽﾀﾛｯｻ				*/
#define		GM_DRAGON_DEBUG		FALSE					/* ﾄﾞﾗｺﾞﾝ				*/

#define		GM_HEAL_DEBUG		FALSE					/* HEAL POTION			*/
#define		GM_PARAM_DEBUG		FALSE					/* ﾌﾟﾚｲﾔｰﾊﾟﾗﾒｰﾀ			*/

#define		GM_RING_DEBUG		FALSE					/* ﾘﾝｸﾞ					*/
#define		GM_SCORE_DEBUG		FALSE					/* SCORE				*/

#define		GM_PALETTE_DEBUG	FALSE					/* PALETTE				*/

#define		GM_TEST				TRUE
#define		GM_CONTINUE_DEBUG	FALSE


#define		GM_ENEMY_FUNC_NUM	16						/* ENEMYｱﾙｺﾞ関数		*/



/* -----------------------
	グローバル変数
------------------------ */

/* ＥＸＴＥＲＮ関連 */
extern	PAD		*PadInfo;								/* ﾊﾟｯﾄﾞ情報				*/
extern	VBLKMNG	VblkMng;								/* VBLANK管理構造体			*/
extern	ASPRMNG	ASprMng;								/* ASPRMNG					*/
extern	SPRANM	SprAnm[ SPR_REG_MAX];					/* SprAnm					*/
extern	char	buf[ 32];								/* ﾃﾝﾎﾟﾗﾘﾊﾞｯﾌｧ				*/

/* ゲーム内容関連 */
GAMEMNG		GameMng;									/* ｹﾞｰﾑ管理構造体			*/
STAGEMNG	StgMng;										/* ｽﾃｰｼﾞ構造体				*/
PLINFO		GmPlInfo;									/* ﾌﾟﾚｲﾔｰ用情報構造体		*/
GMOBJ		GmPly;										/* ﾌﾟﾚｲﾔｰ用ｵﾌﾞｼﾞｪｸﾄ			*/
GMOBJ		GmEmy[ GM_FLOOR_ENEMY_MAX];					/* 敵ｷｬﾗｸﾀ用ｵﾌﾞｼﾞｪｸﾄ		*/
ENMINFO		GmEmyInfo[ GM_FLOOR_ENEMY_MAX];				/* 敵ｷｬﾗｸﾀ用情報配列		*/
u_char		GmBlock[ 6];								/* 当たり判定用				*/
DMGINFO		GmDmgInfo[ GM_DMGINFO_MAX];					/* ﾀﾞﾒｰｼﾞ情報構造体			*/
SPRANM		*GmCur[ 2];									/* ｶｰｿﾙは2つ				*/
u_char		GmCurIdx;									/* ｶｰｿﾙ･ｲﾝﾃﾞｯｸｽ				*/
SPRANM		*GmKey;										/* 鍵						*/
SPRANM		*GmTrs;										/* 宝箱						*/
GMTRSINFO	GmTrsInfo;									/* 宝箱出現用情報構造体		*/
GMHEAL		GmHeal;										/* Heal Potion 用			*/
GMPOS		GmHolePos;									/* Hole 中心座標			*/
GMPOS		GmFPos[ 5];									/* Fannel 座標				*/
GMTITLE		GmOP;										/* ﾀｲﾄﾙ用構造体				*/


/* 変数関連 */
u_char		GmIndex;									/* ｹﾞｰﾑ状態ｲﾝﾃﾞｯｸｽ			*/
u_char		GmSStepTest;								/* ﾒｲﾝ状態変数				*/
u_char		GmTmpVal;									/* ﾃﾝﾎﾟﾗﾘ変数				*/
short		GmTmpVals;									/* ﾃﾝﾎﾟﾗﾘ変数 short			*/
SCRMNG		*GmScrT;									/* ﾃﾝﾎﾟﾗﾘ SCRMNG			*/
u_char		GmDmgNum;									/* ﾀﾞﾒｰｼﾞ構造体登録数		*/
u_char		GmDFNum;									/* ﾄﾞﾗｺﾞﾝ弾数				*/

/* 一時的な代用 */
u_short		GmTmpFlag;
u_short		GmTmpHScore = GM_HIGH_SCORE;


/* ///  ■当たり判定グローバル変数定義■  /// */
#include	"block.h"

/* ///  ■関数定義■  /// */
void	( near *GmMoveEnemyFunc[ GM_ENEMY_FUNC_NUM])( u_char) = {
			GmMoveENEMY,
			GmMoveKnight,
			GmMoveKnight,
			GmMoveKnight,
			GmMoveSlime,
			GmMoveENEMY,
			GmMoveMagician,
			GmMoveENEMY,
			GmMoveENEMY,
			GmMoveKnight,
			GmMoveKnight,
			GmMoveKnight,
			GmMoveENEMY,
			GmMoveENEMY,
			GmMoveDragon,
			GmMoveTestarossa
		};

#if GM_TEST
char	( near *GmTreasureFunc[ GM_FLOOR_NUM])( u_char) = {
			GmTrsFloor01,
			GmTrsFloor02,
			GmTrsFloor03,
			GmTrsFloor04,
			GmTrsFloor05,
			GmTrsFloor06,
			GmTrsFloor07,
			GmTrsFloor08,
			GmTrsFloor09,
			GmTrsFloor10,
			GmTrsFloor11,
			GmTrsFloor12,
			GmTrsFloor13,
			GmTrsFloor14,
			GmTrsFloor15,
			GmTrsFloor16,
			GmTrsFloor17,
			GmTrsFloor18,
			GmTrsFloor19,
			GmTrsFloor20
		};
#endif

/* ///  ■アイテム名定義■  /// */
u_char		*GmItemName[ GM_ITEM_02_NUM] = {
			"light edge",
			"long sword",
			"  k blade ",
			"s dragonar",
			"hour glass",
			"  hammer  ",
			" whistle  ",
			"   wing   "
		};

u_char		ano = 0;


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：ゲーム初期化関数です。
		  	：ゲーム中、一度しかコールされません。
		  	：
　履　　歴	：Ver 1.00		2000/12/19		K.Kimura		初版
****************************************************************************** */
void	GmInit( void)
{
	u_char		i;
	static	SYSRECT		*ptr;
	static	GMKDTPOINT	*p;


	GmInitData();
	GmInitData2( 0);

	GmIndex = GMI_OPENING;

	SndSetInst( SND_INST_FR, (INSTBIT_BGM | INSTBIT_SE));		/* 音色設定	*/

	/* ///  当たり判定データの再設定  /// */
	for (i = 0; i < GM_BLOCK_DAMAGE_MAX; i++)
	{
		ptr = &GmBlkDamage[ i];
		ptr->r = ( ptr->l + ptr->r - 1);
		ptr->b = ( ptr->t + ptr->b - 1);
	}

	for (i = 0; i < GM_BLOCK_ATTACK_MAX; i++)
	{
		ptr = &GmBlkAttack[ i];
		ptr->r = ( ptr->l + ptr->r - 1);
		ptr->b = ( ptr->t + ptr->b - 1);
	}

	for (i = 0; i < 4; i++)
	{
		ptr = &GmBlkColl[ i];
		ptr->r = ( ptr->l + ptr->r - 1);
		ptr->b = ( ptr->t + ptr->b - 1);
	}

	/* ///  宝箱位置の再設定  /// */
	for (i = 0; i < GM_FLOOR_NUM; i++)
	{
		p = &GmKDTPoinrt[ i];

		/* 鍵 */
		p->kidx = ((p->ky / GM_SCREEN_AREA_EYC) * 3) + (p->kx / (GM_SCREEN_AREA_EXC - 2));
		p->kx = (p->kx % (GM_SCREEN_AREA_EXC - 2));
		p->ky = (p->ky % GM_SCREEN_AREA_EYC);

		/* 扉 */
		p->didx = ((p->dy / GM_SCREEN_AREA_EYC) * 3) + (p->dx / (GM_SCREEN_AREA_EXC - 2));
		p->dx = (p->dx % (GM_SCREEN_AREA_EXC - 2));
		p->dy = (p->dy % GM_SCREEN_AREA_EYC);

		/* 宝箱 */
		p->tidx = ((p->ty / GM_SCREEN_AREA_EYC) * 3) + (p->tx / (GM_SCREEN_AREA_EXC - 2));
		p->tx = (p->tx % (GM_SCREEN_AREA_EXC - 2));
		p->ty = (p->ty % GM_SCREEN_AREA_EYC);
	}

	/* 扉グラフィック番号の設定 */
	for (i = 0; i < 6; i++)
	{
		GmDoorData[ 1][ i] |= 0x4000;			/* 水平反転	*/
		GmDoorData[ 3][ i] |= 0x4000;
	}

	GmTmpFlag = 0;


#if GM_SCREEN_SAVE
	bs_sprite_set_range( 0, 128);
#endif

}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：ゲーム・データ初期化関数です。
		  	：
　履　　歴	：Ver 1.00		2000/12/19		K.Kimura		初版
****************************************************************************** */
void	GmInitData( void)
{
	memset( &StgMng, 0, sizeof( STAGEMNG));
	memset( &GmPly, 0, sizeof( GMOBJ));								/* ﾌﾟﾚｲﾔｰ用ｵﾌﾞｼﾞｪｸﾄ		*/
	memset( GmEmy, 0, sizeof( GMOBJ) * GM_FLOOR_ENEMY_MAX);			/* 敵ｷｬﾗ用ｵﾌﾞｼﾞｪｸﾄ		*/
	memset( GmEmyInfo, 0, sizeof( ENMINFO) * GM_FLOOR_ENEMY_MAX);	/* 敵ｷｬﾗｸﾀ用情報配列	*/
	memset( GmDmgInfo, 0, sizeof( DMGINFO) * GM_DMGINFO_MAX);		/* ﾀﾞﾒｰｼﾞ情報構造体		*/
	memset( &GmTrsInfo, 0, sizeof( GMTRSINFO));						/* 宝箱出現情報構造体	*/
	memset( &GmHeal, 0, sizeof( GMHEAL));							/* HEAL POTION用		*/
	memset( &GmHolePos, 0, sizeof( GMPOS));

	GmTrsInfo.ldEidx = 0xff;
	GmTrsInfo.lsEidx = 0xff;

	/* ///  ステージ初期設定  /// */
	StgMng.scr = ScrGetBGInfo( 0);						/* BG0を使用（強制）*/

	StgMng.scr->x = 0;									/* 各ﾊﾟﾗﾒｰﾀの設定	*/
	StgMng.scr->y = 0;
	StgMng.scr->regX = 0;								/* 登録開始座標		*/
	StgMng.scr->regY = 0;
	StgMng.scr->w = SCR_MAP_WIDTH;						/* MAPﾃﾞｰﾀｻｲｽﾞ		*/
	StgMng.scr->h = SCR_MAP_HEIGHT;

}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：ゲーム・データ初期化関数２です。
		  	：コンティニュー判別が入っています。
		  	：
　履　　歴	：Ver 1.00		2000/12/19		K.Kimura		初版
****************************************************************************** */
void	GmInitData2( u_char	mode)
{
	static	GMPOS		*pos;


	if (mode)
	{
		/* ///  ■ フロア到達状態に設定■  /// */
		memset( &GmPlInfo.score, 0, 10);
#if 0
------------------------------( 10 Byte)-------------
	u_short		score;										/* SCORE					*/
	char		cnt1, cnt2;									/* ｶｳﾝﾄ						*/
	u_char		dcnt;										/* ﾀﾞﾒｰｼﾞ･ｶｳﾝﾀ				*/
	u_char		ccnt;										/* ｷｬﾝｾﾙ ･ｶｳﾝﾀ				*/
	u_char		key;										/* 鍵所持ﾌﾗｸﾞ				*/
	u_char		trs;										/* 宝箱取得ﾌﾗｸﾞ				*/
	u_short		flag;										/* 状態ﾌﾗｸﾞ					*/
-----------------------------------------------------
#endif
		memset( GameMng.enemyDF, 0, GM_FLOOR_IDX_NUM);
		GameMng.flag	= 0;;								/* ｽﾃｰｼﾞﾚﾍﾞﾙのﾌﾗｸﾞ			*/
		GameMng.splIdx	= 0;								/* 呪文開始ｲﾝﾃﾞｯｸｽ			*/
		GameMng.floor7	= 0;								/* ﾌﾛｱ7での剣振り回数		*/
		GameMng.floor19	= 0;								/* ﾌﾛｱ19でのﾘﾝｸﾞ設置		*/

		GmPlInfo.hp = GmPlInfo.mhp;							/* HP 全回復				*/

#if 0
		/* 最上階コンティニューはなし */
		if (GameMng.floor == (GM_FLOOR_NUM - 1))
			GameMng.floor = (GM_FLOOR_NUM - 2);
#endif

		/* プレイヤーの向き設定 */
		GameMng.bgm		= 255;
	}
	else
	{
		/* ///  ■コンティニュー時に影響有り■  /// */
		memset( &GameMng, 0, sizeof( GAMEMNG));
		memset( &GmPlInfo, 0, sizeof( PLINFO));

		/* ///  変数初期設定  /// */
		GameMng.floor	= 0;
		GameMng.fidx	= 0;
		GameMng.healF[ 0] = 1;							/* FLOOR-1 は例外		*/
		GameMng.visitF[ 0] = 1;							/* FLOOR-1 は例外		*/

		/* ///  プレイヤー初期設定  /// */
		GmSetParamPlayer();

		GameMng.bgm		= 0;
		SndPlayBGM( SND_BGM005_FR, PLAY_LOOP);				/* BGM再生			*/
	}

#if GM_DRAGON_DEBUG
	GameMng.floor	= 11;
#endif

	GameMng.type	= 255;
	GameMng.iwin	= NULL;

	GmHeal.flag  = 2;									/* HEAL POTION 演出終了	*/
	GmPlInfo.key = 0;									/* KEY 初期化	*/

	/* ハイスコア読み込み */
	GameMng.hscore	= GM_HIGH_SCORE;					/* 初期設定			*/

	if (GmPly.aspr != NULL)
	{
		/* 座標再設定 */
		pos = &GmStartPos[ GameMng.floor];
		GameMng.fidx = ((pos->y / GM_SCREEN_AREA_EYC) * 3) + (pos->x / (GM_SCREEN_AREA_EXC - 2));
		GmPly.aspr->x = ((pos->x % (GM_SCREEN_AREA_EXC - 2)) << 3);
		GmPly.aspr->y = ((pos->y % GM_SCREEN_AREA_EYC) << 3);

		GmCheckParamPlayer();

		if (mode == 0)
		{
			GmPly.aspr->x = 16;
			GmPly.aspr->y = 88;
		}
	}

}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：ゲーム初期化関数です。
		  	：
　履　　歴	：Ver 1.00		2000/12/19		K.Kimura		初版
****************************************************************************** */
void	GmMain( void)
{
	/* ///  メイン無限ループ  /// */
	while (GmIndex != GMI_END)
	{
		/* ///  状態分岐  /// */
		switch ( GmIndex)
		{
			/* ///  ■オープニング  /// */
			case GMI_OPENING:
#if	GM_EXIT
	DbgPrintPort("< OPENING >\n\r");
#endif
				GmTitle();
				break;


			/* ///  ■メイン  /// */
			case GMI_MAIN:
#if	GM_EXIT
	DbgPrintPort("< MAIN ROUTINE >\n\r");
#endif
				GmMainTestarossa();
				break;


			case GMI_SOUNDTEST:
#if GM_EXIT
	DbgPrintPort("..( SOUND_TEST )\r\n");
#endif
				break;


			case GMI_NAME:
#if GM_EXIT
	DbgPrintPort("..( NAME )\r\n");
#endif
				break;


			/* ///  ■エンディング  /// */
			case GMI_ENDING:
#if GM_EXIT
	DbgPrintPort("..( ENDING )\r\n");
#endif
			    GmCredit();
				break;


			default:
				break;
		}
	}
#if GM_EXIT
	DbgPrintPort("GmMain() .. EXIT\r\n");
#endif

}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：ゲーム・タイトル処理
		  	：
　履　　歴	：Ver 1.00		2000/12/20		K.Kimura		初版
****************************************************************************** */
void	GmTitle( void)
{
	char		i, idx;
	u_short		size;
	static	GMTITLE		*p;



	/* ///  各処理の初期化  /// */
	SysSetHeapBase( _pc->_heap);
	SysInitHeap();										/* ﾋｰﾌﾟｱﾄﾞﾚｽ初期化		*/
	SprInit( 0);										/* ｽﾌﾟﾗｲﾄ初期化			*/
	ScrInit();											/* ｽｸﾘｰﾝ処理			*/
	sys_wait( 1);

	if (bgm_check())
		bgm_stop();										/* ｻｳﾝﾄﾞ停止			*/

#if GM_TITLE_TEST
	/* ///  タイトル画面表示  /// */
	FntPrint( 0, 16, 4, "TESTAROSSA", FNT_MODE_ADDY, FNT_PALETTE_NUM);
	FntPrint( 0, 15, 7, "v0.9a", FNT_MODE_ADDY, FNT_PALETTE_NUM);
	FntPrint( 0, 12, 4, "PUSH START", FNT_MODE_ADDY, FNT_PALETTE_NUM);
	FntPrint( 0, 5, 6, "XELFLEX", FNT_MODE_ADDY, FNT_PALETTE_NUM);
#else

	/* ///  タイトル・データ読み込み  /// */

	display_control( 0x0007);							/* ALL ON				*/
	sys_wait( 1);

	/* パレット変更 */
	GmFadeOut( 0x08, 1);
	sys_wait( 1);

	GmTmpVals = 1;

	/* ＶＲＡＭへ転送 */
	GmTmpVals += ( short)SprSetChracter( GRP_T_TITLE_1_FRC, GmTmpVals);
	SprSetChracter( GRP_T_TITLE_2_FRC, GmTmpVals);


	/* ///  ★前面ＭＡＰデータの読み込み  /// */
	GmScrT = ScrGetBGInfo( 0);
	GmScrT->data = SysGetHeap();
	size = ScrLoadMapData( MAP_T_MAP_OMC, GMPAL_TITLE_01, 1, GmScrT->data);
	GmScrT->data += 16;									/* ﾍｯﾀﾞ飛ばし		*/
	SysAddHeap( size);

	/* ///  ★背景ＭＡＰデータの読み込み  /// */
	GmScrT = ScrGetBGInfo( 1);
	GmScrT->data = SysGetHeap();
	size = ScrLoadMapData( MAP_T_MAP_OMC, GMPAL_TITLE_02, GmTmpVals, GmScrT->data);
	GmScrT->data += 16;									/* ﾍｯﾀﾞ飛ばし		*/
	SysAddHeap( size);

	for (i = 0; i < 2; i++)
	{
		GmScrT = ScrGetBGInfo( i);

		GmScrT->x = 0;									/* 各ﾊﾟﾗﾒｰﾀの設定	*/
		GmScrT->y = 0;
		GmScrT->regX = 0;								/* 登録開始座標		*/
		GmScrT->regY = 0;
		GmScrT->w = SCR_MAP_WIDTH;						/* MAPﾃﾞｰﾀｻｲｽﾞ		*/
		GmScrT->h = SCR_MAP_HEIGHT;

		ScrDispScreen( i);
	}

	GmFadeIn( 0x05, 1);
	sys_wait( 1);

#endif

	/* ///  選択項目の生成  /// */
	p	  = &GmOP;
	idx	  = 0;
	p->cx = 7;
	p->select[ idx++] = GM_SEL_START;					/* 不動					*/

#if GM_CONTINUE_DEBUG
	sprintf( buf, "PLAY_NUM::%u\r\n", GameMng.playNum);
	DbgPrintPort( buf);
#endif

	if (GameMng.playNum)
	{
		p->cx--;
		p->select[ idx++] = GM_SEL_CONTINUE;			/* CONTINUE				*/
	}

/*	if (GmPlInfo.item[ 0] & GM_ITEM_SOUND_DIC)
*/	if (GmTmpFlag & 0x0001)
		p->select[ idx++] = GM_SEL_MUSIC_MODE;			/* MUSIC MODE			*/

	p->select[ idx] = GM_SEL_EXIT;						/* EXIT					*/
	p->cex = ( 7 - idx);

	GmDispTitleSelect();								/* 選択項目の描画		*/

	/* ///  ＶＢＬＡＮＫ処理  /// */
	VblkLoopInit();										/* 初期化				*/
	VblkRegEvent( VBLK_MOVE_MODE, GmMoveTitle);			/* 関数登録				*/
	VblkLoop();											/* VBLANK LOOP			*/
}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：
		  	：
　履　　歴	：Ver 1.00		2000/12/19		K.Kimura		初版
****************************************************************************** */
void	GmMoveTitle( void *func)
{
	static	GMTITLE		*p;
	char		i;


	p = &GmOP;

	if (PadInfo->padr & KEY_Y2)
	{
		if (p->cx < 7)
			p->cx++;

		se_play_n( GMSE_CURSOR);							/* SE	*/
	}

	if (PadInfo->padr & KEY_Y4)
	{
		if (p->cx > p->cex)
			p->cx--;

		se_play_n( GMSE_CURSOR);							/* SE	*/
	}

#if GM_EXIT
	if (PadInfo->padt & KEY_B)
	{
		GmIndex = GMI_ENDING;
		GmSStepTest = GMT_END;
		VblkMng.loopExit = 1;						/* LOOP脱出					*/

		if (bgm_check())
			bgm_stop();

		return;
	}
#endif

	/* ＭＵＳＩＣ−ＭＯＤＥ判定 */
	if ( p->select[ 7 - p->cx] == GM_SEL_MUSIC_MODE)
	{
		if (PadInfo->padr & KEY_Y1)
		{
			if (p->sndNum > 0)
				p->sndNum--;
		}

		if (PadInfo->padr & KEY_Y3)
		{
			if (p->sndNum < ((GM_MUSIC_NUM + GM_SE_NUM)- 1))
				p->sndNum++;
		}
	}


	if (PadInfo->padt & KEY_X4)
	{
		if (bgm_check())
			bgm_stop();
	}

	if (p->select[ 7 - p->cx] != GM_SEL_MUSIC_MODE)
	{
		if (bgm_check())
			bgm_stop();
	}

	if (PadInfo->padt & KEY_X1)
	{
		if (bgm_check())
			bgm_fadeout();
	}

	/* ///  決定  /// */
	if (PadInfo->padt & (KEY_X3 | KEY_X2))
	{
		p->sel = p->select[ 7 - p->cx];

#if GM_CONTINUE_DEBUG
	sprintf( buf, "SELECT::%d,%d,%d,%d\r\n",p->select[0],p->select[1],p->select[2],p->select[3]);
	DbgPrintPort( buf);
#endif

		switch ( p->sel)
		{
			/* ＧＡＭＥ ＳＴＡＲＴ */
			case GM_SEL_START:
				PadInfo->padt = 0;
				se_play_n( GMSE_DECIDE);

				GameMng.playNum = 0;

				GmFadeOut( 0x08, 1);
				sys_wait( 1);

				GmIndex = GMI_MAIN;							/* ｹﾞｰﾑｽﾀｰﾄ					*/
				GmSStepTest = GMT_LOAD;						/* ﾒｲﾝ状態変数				*/
				VblkMng.loopExit = 1;						/* LOOP脱出					*/

/*				func = NULL;								/* 関数登録抹消				*/
				break;


			/* ＧＡＭＥ ＣＯＮＴＩＮＵＥ */
			case GM_SEL_CONTINUE:
				PadInfo->padt = 0;
				se_play_n( GMSE_DECIDE);

				GmFadeOut( 0x08, 1);
				sys_wait( 1);

				GmIndex = GMI_MAIN;							/* ｹﾞｰﾑｽﾀｰﾄ					*/
				GmSStepTest = GMT_CONTINUE;					/* ﾒｲﾝ状態変数				*/
				VblkMng.loopExit = 1;						/* LOOP脱出					*/
/*				func = NULL;								/* 関数登録抹消				*/
				break;


			/* ＭＵＳＩＣ ＭＯＤＥ */
			case GM_SEL_MUSIC_MODE:
				if (p->sndNum >= GM_MUSIC_NUM)
				{
					se_play_n( p->sndNum - GM_MUSIC_NUM);	/* SE再生					*/
				}
				else
				{
					if (bgm_check())
						bgm_stop();

					SndPlayBGM( p->sndNum, PLAY_LOOP);		/* BGM再生					*/
				}
				break;


			/* ＧＡＭＥ ＥＸＩＴ */
			case GM_SEL_EXIT:
#if GM_CONTINUE_DEBUG
	DbgPrintPort("--- < GAME_EXIT!! > ---\r\n");
#endif
				GmIndex = GMI_END;							/* ｹﾞｰﾑ終了					*/
				VblkMng.loopExit = 1;						/* LOOP脱出					*/
/*				func = NULL;								/* 関数登録抹消				*/
				break;
		}
	}

	if ((PadInfo->padr & PAD_TRG_DURL_Y) == 0)
		return;

	/* ///  ■文字列描画■  /// */
	GmDispTitleSelect();

}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：ゲーム・タイトル処理
		  	：
　履　　歴	：Ver 1.00		2000/12/20		K.Kimura		初版
****************************************************************************** */
void	GmMainTestarossa( void)
{

	/* ///  各処理の初期化  /// */
	SysSetHeapBase( _pc->_heap);
	SysInitHeap();										/* ﾋｰﾌﾟｱﾄﾞﾚｽ初期化		*/
	SprInit( 0);										/* ｽﾌﾟﾗｲﾄ処理:変数のみ	*/
	ScrInit();											/* ｽｸﾘｰﾝ処理			*/
	GmInitData();										/* ｽﾃｰｼﾞﾃﾞｰﾀの初期化	*/


#if	GM_DEBUG
	DbgPrintPort("'PAGODA' PORT DEBUG\n\r");			/* ﾃﾞﾊﾞｯｸﾞ用			*/
#endif

	/* ///  ■常駐必須データの読み込み■  /// */
	AnmLoad( CHR_PLAYER);								/* 自ｷｬﾗｱﾆﾒの読み込み	*/

	/* ///  ■ＰＬＡＹＥＲアニメーション設定（不変なので、ここでＯＫ）■  /// */
	GmPly.aspr = AnmChrInit( CHR_PLAYER, (GMPAL_PLAYER - 8), GMPRW_PLAYER);
	AnmSet( GmPly.aspr, CHR_PLAYER, 0, 0, (ANM_MODE_ACTIVE | ANM_MODE_LOOP | ANM_MODE_NODISP));
	GmPly.aspr->base = VRM_PLAYER0;
	GmPly.aspr->cptr = ( FileGetPointer( TFD_GRAPH, GRP_CHR000_FRB) + 16);
	GmPly.aspr->useSprNum = GmUseSprChr[ CHR_PLAYER];

	GmInitData2( GameMng.playNum);						/* ｽﾃｰｼﾞﾃﾞｰﾀの初期化	*/

	GmLoadItemWindowData();								/* ITEM WIN	読み込み	*/
	GmSetItemWindowData();								/* 上と 1 SET			*/

#if	GM_IWIN_DEBUG
	DbgPrintPort("-- GmLoadItemWindowData .. OK\n\r");
#endif

	/* ///  ■ヒープアドレスの再設定■  /// */
	SysSetHeapBase( SysGetHeap());						/* ﾋｰﾌﾟﾍﾞｰｽｱﾄﾞﾚｽの変更	*/
	SysInitHeap();										/* ﾋｰﾌﾟｱﾄﾞﾚｽ初期化		*/

	/* ///  ■アイテムウインドウ関連■  /// */
	screen_set_scroll( 1, 256 - GM_IWIN_SX, 0);
	GmSetItemWindowBase( 1, 0, 0, 0, 4);				/* 初期設定（一部）		*/
	GmDispHitPoint( GmPlInfo.hp);						/* HP 表示				*/

#if	GM_IWIN_DEBUG
	DbgPrintPort("-- GmSetItemWindowBase .. OK\n\r");
#endif

	if (GameMng.playNum == 0)							/* START?				*/
		GameMng.flag |= GM_MNGFLAG_START;

	GameMng.flag |= GM_MNGFLAG_CONTINUE;

	if (GameMng.playNum < 255)
		GameMng.playNum++;

	while (GmSStepTest != GMT_END)
	{
		/* ///  ゲーム状態分岐  /// */
		switch ( GmSStepTest)
		{
			/* ///  コンティニュー処理  /// */
			case GMT_CONTINUE:
				/*
					1) STAGE構造体の設定
					2) ﾌﾟﾚｲﾔｰﾃﾞｰﾀのﾛｰﾄﾞ
					※ 所詮は、最後にプレイしてたフロアのスタートからとなる
				*/


			/* ///  データロード処理  /// */
			case GMT_LOAD:											/* MAP切り替え時		*/
				SysInitHeap();										/* ﾋｰﾌﾟｱﾄﾞﾚｽ初期化		*/
				SprInit( 1);								/* ASprMng初期化：PLAYER以外 	*/

				GmSetStageData( GameMng.floor, GameMng.fidx);
				GmLoadStage( 0);
				GmCheckParamPlayer();								/* PLAYER ﾊﾟﾗﾒｰﾀ更新	*/


			/* ///  ＭＡＰ変更（スクロール込み）処理  /// */
			case GMT_CHANGE_MAP:
				VblkLoopInit();										/* 初期化				*/
				VblkRegEvent( VBLK_MOVE_MODE, GmChangeBGMain);		/* 関数登録				*/
				VblkLoop();											/* VBLANK LOOP			*/


			/* ///  ゲーム・メイン処理  /// */
			case GMT_GAME:
				GmDispStatus();
				FntFlush();

				if (GameMng.flag & GM_MNGFLAG_START)				/* START ?				*/
					GmPutDorrCG( 1, 6, 10, 1, 1);

				if (GameMng.flag & GM_MNGFLAG_CONTINUE)				/* CONTINUE ?			*/
				{
					GmFadeIn( 0x03, 1);
					GameMng.flag &= ~GM_MNGFLAG_CONTINUE;
				}

				if (GameMng.flag & GM_MNGFLAG_START)				/* START ?				*/
				{
					GmInitOPEvent();
					GameMng.flag &= ~GM_MNGFLAG_START;
				}

				VblkLoopInit();										/* 初期化				*/
				VblkSetPause( 1);									/* PAUSE 機能 ON		*/
				VblkRegEvent( VBLK_MOVE_MODE, GmMoveMain);			/* 関数登録				*/
				VblkRegEvent( VBLK_MOVE_MODE, GmHealPotion);		/* 関数登録				*/
				VblkLoop();											/* VBLANK LOOP			*/
				break;


			/* ///  ゲーム・ステータス処理  /// */
			case GMT_STATUS:
				GmInitStatus( 0);									/* ｱﾆﾒ STOP				*/
				GmScrollIWIN( -1);									/* ITEMｳｨﾝﾄﾞｳ表示		*/
				GmDispItemName();									/* ITEM名の表示			*/
				GmCur[ 0]->mode &= ~ANM_MODE_NODISP;
				GmCur[ 1]->mode &= ~ANM_MODE_NODISP;

				VblkLoopInit();										/* 初期化				*/
				VblkRegEvent( VBLK_MOVE_MODE, GmMoveStatus);		/* 関数登録				*/
				VblkRegEvent( VBLK_MOVE_MODE, GmHealPotion);		/* 関数登録				*/
				VblkLoop();											/* VBLANK LOOP			*/

				GmScrollIWIN( 1);									/* ITEM ｳｨﾝﾄﾞｳ隠蔽		*/
				GmInitStatus( 1);									/* ｱﾆﾒ START			*/
				break;


			/* ///  ヒント絵処理  /// */
			case GMT_HINTWALL:
				GmInitHintWall();

				VblkLoopInit();										/* 初期化				*/
				VblkRegEvent( VBLK_MOVE_MODE, GmMoveHintWall);		/* 関数登録				*/
				VblkLoop();											/* VBLANK LOOP			*/
				break;


			/* ///  ゲームオーバー  /// */
			case GMT_GAMEOVER:
				GmInitGameOver();

				VblkLoopInit();										/* 初期化				*/
				VblkRegEvent( VBLK_MOVE_MODE, GmMoveGameOver);		/* 関数登録				*/
				VblkLoop();											/* VBLANK LOOP			*/
				break;


			/* ///  テスタロッサ死亡  /// */
			case GMT_GAMEEND:
				GmInitGameEND();

				VblkLoopInit();										/* 初期化				*/
				VblkRegEvent( VBLK_MOVE_MODE, GmMoveGameEND);		/* 関数登録				*/
				VblkLoop();											/* VBLANK LOOP			*/
				break;


			/* ///  例外処理  /// */
			default:
				break;
		}
	}

}


/* ******************************************************************************
　関　　数	：GmSetStageData
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：ステージデータの読み込み
		  	：
　履　　歴	：Ver 1.00		2000/12/20		K.Kimura		初版
****************************************************************************** */
void	GmSetStageData( u_char floor, u_char idx)
{
	static	u_short		i;
	static	u_char far	*p;


	p = FileGetPointer( TFD_DATA, BIN_STAGE_BIN);		/* stage.bin ｱﾄﾞﾚｽ取得	*/

#if GM_LOADST_DEBUG
	sprintf( buf, "header::%2x,%2x,%2x,%2x\r\n", p[0], p[1], p[2], p[3]);
	DbgPrintPort( buf);
#endif
	p += GM_DATA_STAGE_BOUND;							/* ﾍｯﾀﾞ情報ｼﾞｬﾝﾌﾟ		*/
														/* ｽﾃｰｼﾞﾃﾞｰﾀ･ｱﾄﾞﾚｽ取得	*/
	p += (((( u_short)floor * GM_FLOOR_IDX_NUM) + idx) * GM_DATA_STAGE_BOUND);

	/*
		現在のフロア（インデックス）に必要な情報を取得する。
		情報内容は、敵キャラ数や、その種類、ＢＧ、ＢＧＭなど
	*/

	/* ///  ＢＧＭ,敵キャラ数,フラグ,ＢＧを取得  /// */
	memcpy( &StgMng, p, GM_DATA_STAGE_HDSIZE);
	p += GM_DATA_STAGE_HDSIZE;							/* ﾍｯﾀﾞ飛ばし			*/


	if (floor >= 6)
		StgMng.flag = GM_FLAG_DARKROOM;


#if GM_LOADST_DEBUG
	DbgPrintPort("< STAGE DATA >\r\n");
	sprintf( buf, "BGM::%d\r\n", StgMng.bgm);
	DbgPrintPort( buf);
	sprintf( buf, "ENUM::%d\r\n", StgMng.ennum);
	DbgPrintPort( buf);
	sprintf( buf, "FLAG::%d\r\n", StgMng.flag);
	DbgPrintPort( buf);
	sprintf( buf, "BG_TYPE::%d\r\n", StgMng.type);
	DbgPrintPort( buf);
#endif

	/* ///  ■もう一回お願いします（わぁ、最低だ）■  /// */
	memset( GmEmy, 0, sizeof( GMOBJ) * GM_FLOOR_ENEMY_MAX);			/* 敵ｷｬﾗ用ｵﾌﾞｼﾞｪｸﾄ		*/
	memset( GmEmyInfo, 0, sizeof( ENMINFO) * GM_FLOOR_ENEMY_MAX);	/* 敵ｷｬﾗｸﾀ用情報配列	*/

	/* ///  ★敵情報の格納  /// */
	for (i = 0; i < StgMng.ennum; i++)
	{
		memcpy( &GmEmy[ i], p, 1);						/* chr 情報				*/
		p ++;

		memcpy( &GmEmyInfo[ i], p, 9);					/* その他				*/

		/* 奇数アドレスになってしまったのでパッチ・・ */
		GmEmyInfo[ i].point = ((p[ 8] << 8) | p[ 7]);

		p += 9;
	}

}


/* ******************************************************************************
　関　　数	：GmLoadStage
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：ステージに関するデータを全て読み込みます。
		  	：
　履　　歴	：Ver 1.00		2000/12/20		K.Kimura		初版
　			：Ver 2.00		2001/01/28		K.Kimura		引数追加
****************************************************************************** */
void	GmLoadStage( u_char mode)
{
	u_char		i, j, nidx;
	u_char		chr;
	u_short		size, pal;
	u_short		cx, cy;
	u_short		chrno, chrno2;

	static		GMOBJ		*op, *op2;
	static		ENMINFO		*ep, *ep2;


	/* ---------------------------- */
	/* ///  非常駐データの設定  /// */
	/* ---------------------------- */

	/* ///  ★ＢＧデータの読み込み(非常駐 : スルーあり)  /// */
	if ((GameMng.type != StgMng.type) || (mode == 1))
	{
		/* ///  ＢＧデータ格納インデックスからの加算  /// */
		SprSetChracter(( GRP_BG000_FRC + StgMng.type), VRM_BG);
		GameMng.type = StgMng.type;
	}

#if GM_LOADST_DEBUG
	sprintf( buf, "GType,SType::%d,%d\r\n", GameMng.type, StgMng.type);
	DbgPrintPort( buf);
#endif

	/* ///  敵データＶＲＡＭ登録先の初期化  /// */
	GmLoadEnemyCG();

	chrno  = GMPRW_ENEMY;
	chrno2 = GMPRW_SPELL1;

#if GM_LOADST_DEBUG
	sprintf( buf, "-- ENEMY CG NUM :: %d\r\n", StgMng.ennum);
	DbgPrintPort( buf);
#endif

	/* -------------------------- */
	/* ///  常駐データの設定  /// */
	/* -------------------------- */

	/* ///  ★ＡＮＩＭデータの読み込み(常駐 : 強制読み込み)  /// */
	for (i = 0; i < StgMng.ennum; i++)
	{
		op = &GmEmy[ i];
		ep = &GmEmyInfo[ i];

		if (GameMng.enemyDF[ GameMng.fidx] & (0x0001 << i))
		{
			if (ep->dcnt == 0)
				continue;							/* 既に死んでる */
		}

		/*
			パレットは、現在固定だが、アルゴによって、明暗をわける必要あり
		*/
		pal = (GMPAL_ENEMY_01 - 8) + ( ep->algo & 0x01);
		chr = op->chr;

		/* ///  騎士系統：左利きの補正  /// */
		if ((chr >= CHR_KNIGHT1_L) && (chr <= CHR_KNIGHT3_L))
			chr -= 8;

		/*
			AnmChrInit の内部で、このキャラクタの登録先ＶＲＡＭアドレスを
			設定しているため、ここでも騎士系統の”左利き”補正は必要！！
		*/

		if (mode == 0)
		{
			op->aspr = AnmChrInit( chr, pal, chrno);
			op->aspr->useSprNum = GmUseSprChr[ chr];
			chrno += GmUseSprChr[ chr];
		}

		/*
			ここで GmEmy[ i].aspr の返り値が NULL でもどうしようもありません。
			むしろ終了・・というか、ありえないように組め！！
			処理の無駄！！
		*/

		/* ///  アニメ登録（チェックは中でやってる）  /// */
		AnmLoad( op->chr);

		/* ///  とりあえず、制止アニメーションを発行  /// */

		/*
			向きは、プレイヤーの居る方向にする必要あり
			ただし、騎士のみ。

			魔法使いは、最初は非表示。
			スライム＆ウーズは、方向なし。
			ドラゴン、テスタロッサは例外。
		*/

		if (mode == 0)
		{
			ano = 0;

			op->direct = 3;
			op->aspr->speed = 8;

			/* ///  初期座標設定  /// */
			cx  = ep->sx;
			cy  = ep->sy;
			cx -= ((GameMng.fidx % 3) * (GM_SCREEN_AREA_EXC - 2));
			cy -= ((GameMng.fidx / 3) * GM_SCREEN_AREA_EYC);
			cx  = (cx << 3);
			cy  = (cy << 3);
			op->aspr->x = cx;
			op->aspr->y = cy;

			/* ///  魔法使いは”非表示” /// */
			if (op->chr == CHR_MAGICIAN)
			{
				AnmSet( op->aspr, op->chr, ano, 0, 0);

				op->aspr->x = 224;
				op->aspr->y = 144;
				op->aspr->mode |= ANM_MODE_END;

				GmEmyInfo[ i].nscnt = ( GM_MAG_RIGOR_TIME >> 2);	/* しばらく出ない	*/

				/* ///  呪文アニメ用に新規設定  /// */

				/*
					■ マジックナンバー意味合い ■
					(GM_FLOOR_ENEMY_MAX / 2) = 4

					パレットは、明るいパレット強制です。
				*/

				GameMng.splIdx = 4;
				nidx = (i + 4);

				op2 = &GmEmy[ nidx];
				ep2 = &GmEmyInfo[ nidx];

				memcpy( op2, op, sizeof( GMOBJ));
				memcpy( ep2, ep, sizeof( ENMINFO));
				op2->aspr = AnmChrInit( chr, (GMPAL_ENEMY_01 - 8), chrno2);
				op2->aspr->useSprNum = GmUseSprChr[ CHR_SNAKE];
				chrno2 += GmUseSprChr[ CHR_SNAKE];

				ano = EN_D0_20_ANW + op2->direct;						/* 呪文ｱﾆﾒ	*/

				op2->aspr->speed = 8;
				AnmSet( op2->aspr, op2->chr, ano, 0, (ANM_MODE_LOOP | ANM_MODE_NODISP));

				ep2->flag = 0x00;										/* 呪文 OFF		*/
				op2->act = GM_PL_ACT_SPELL;

				ep2->point = 0;
			}
			/* ///  ドラゴン  /// */
			else if (op->chr == CHR_DRAGON)
			{
				AnmSet( op->aspr, op->chr, ano, 0, ANM_MODE_LOOP);

				GameMng.splIdx = 4;

				/* 弾は３発 */
				for (j = 0; j < 3; j++)
				{
					nidx = (( i + GameMng.splIdx) + j);
					op2 = &GmEmy[ nidx];
					ep2 = &GmEmyInfo[ nidx];

					memcpy( op2, op, sizeof( GMOBJ));
					memcpy( ep2, ep, sizeof( ENMINFO));
					op2->aspr = AnmChrInit( chr, (GMPAL_ENEMY_01 - 8), chrno2);
					op2->aspr->useSprNum = GmUseSprChr[ CHR_SNAKE];
					chrno2 += GmUseSprChr[ CHR_SNAKE];

					ano = EN_C0_04_ANW;											/* 弾ｱﾆﾒ	*/

					op2->aspr->speed = 8;
					AnmSet( op2->aspr, op2->chr, ano, 0, (ANM_MODE_LOOP | ANM_MODE_NODISP));

					ep2->flag = 0x00;								/* 弾 OFF	*/
					ep2->ap = 5;
					op2->act = GM_PL_ACT_SPELL;

					ep2->point = 0;
				}
			}
			/* ///  テスタロッサ  /// */
			else if (op->chr == CHR_TESTAROSSA)
			{
				AnmSet( op->aspr, op->chr, ano, 0, ANM_MODE_LOOP);

				/*
					■ マジックナンバー意味合い ■
					(GM_FLOOR_ENEMY_MAX / 2) = 4

					パレットは、明るいパレット強制です。
				*/

				GameMng.splIdx = 1;

#if GM_TESTA_DEBUG
	sprintf( buf, "TESTA_HP::%d\r\n", GmEmyInfo[ i].hp);
	DbgPrintPort( buf);
#endif

				for (j = 0; j < 5; j++)
				{
					nidx = (( i + GameMng.splIdx) + j);
					op2 = &GmEmy[ nidx];
					ep2 = &GmEmyInfo[ nidx];

					memcpy( op2, op, sizeof( GMOBJ));
					memcpy( ep2, ep, sizeof( ENMINFO));
					op2->aspr = AnmChrInit( chr, (GMPAL_ENEMY_01 - 8), chrno2);
					op2->aspr->useSprNum = GmUseSprChr[ CHR_SNAKE];
					chrno2 += GmUseSprChr[ CHR_SNAKE];

					ano = EN_A0_09_ANW;											/* 弾ｱﾆﾒ	*/

					op2->aspr->speed = 8;
					AnmSet( op2->aspr, op2->chr, ano, 0, (ANM_MODE_LOOP | ANM_MODE_NODISP));

					ep2->flag = 0x00;								/* 弾 OFF	*/
					ep2->hp = 1;
					ep2->ap = 5;
					op2->act = GM_PL_ACT_SPELL;

					ep2->point = 0;
				}
			}
			else
			{
				GameMng.splIdx = 4;									/* 基準値を設定		*/
				AnmSet( op->aspr, op->chr, ano, 0, ANM_MODE_LOOP);
			}
		}
	}

#if GM_MAGIC_DEBUG
	for (i = 0; i < GM_FLOOR_ENEMY_MAX; i++)
	{
		sprintf( buf, "-- ASPR_%d::%u\r\n", i, op->aspr->sprNo);
		DbgPrintPort( buf);
	}
#endif

#if GM_LOADST_DEBUG
	DbgPrintPort("-- ENEMY ANIM READ ..OK\r\n");
#endif

	/* ///  ★ＭＡＰデータの読み込み(常駐 : 強制読み込み)  /// */
	StgMng.scr->data = SysGetHeap();
	size = ScrLoadMapData((( GameMng.floor * GM_FLOOR_IDX_NUM) + GameMng.fidx),
							GMPAL_BG, VRM_BG, StgMng.scr->data);
	StgMng.scr->data += 16;								/* ﾍｯﾀﾞ飛ばし		*/
	StgMng.scr->flag = ( StgMng.scr->data + ((SCR_MAP_WIDTH * SCR_MAP_HEIGHT) * 2));
	SysAddHeap( size);

#if GM_LOADST_DEBUG
	DbgPrintPort("-- MAP DATA READ ..OK\r\n");
#endif

	/* ///  サウンド再生(チェックあり)  /// */
	if (GameMng.bgm != StgMng.bgm)
	{
		if (bgm_check())
			bgm_stop();

		SndPlayBGM( StgMng.bgm, PLAY_LOOP);				/* BGM再生			*/
		GameMng.bgm = StgMng.bgm;						/* BGM番号更新		*/
	}

#if GM_LOADST_DEBUG
	sprintf( buf, "GBGM,SBGM::%d,%d\r\n", GameMng.bgm, StgMng.bgm);
	DbgPrintPort( buf);
#endif

	/* ///  ■ＫＯＭＯＮＯ関連■  /// */
	SprSetChracter( GRP_KOMONO_FRC, VRM_ETC);			/* 小物ｸﾞﾗﾌｨｯｸ read		*/
	AnmLoad( ANM_KOMO_FAC);

	if (mode == 0)
	{
		GmInitCursor();										/* ｶｰｿﾙ設定				*/
		GmInitKey();										/* 鍵設定				*/
		GmInitTreasure();									/* 宝箱設定				*/
	}

}


/* ******************************************************************************
　関　　数	：GmMoveMain
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：
				・ステータス画面への切り替え判定
				・自キャラの動作
					−ＭＡＰスクロール or フロア変更判定
				・敵キャラの動作
				・各状態判定（演算込み）
					−自キャラの攻撃判定
					−敵キャラの攻撃判定
					−ダメージ演算
		  	：
　履　　歴	：Ver 1.00		2000/12/23		K.Kimura		初版
****************************************************************************** */
void	GmMoveMain( void *func)
{
	u_char		i;
	char		j;
	static	char	lret;


	lret = 0;

	/* ﾀﾞﾒｰｼﾞ構造体の初期化		*/
	GmDmgNum = 0;
	memset( GmDmgInfo, 0, sizeof( DMGINFO) * GM_DMGINFO_MAX);

#if	GM_EXIT
/* ---------------------------------------------------------------------------- */
	/* ///   画面セーブ（広告用） /// */
	if (PadInfo->pad == (KEY_A | KEY_B))
	{
#if GM_SCREEN_SAVE
		bs_save_screen("testa", 0, 0, 224, 144);
#endif
	}

	/* ///   緊急終了（デバッグ用） /// */
	if (PadInfo->pad == (KEY_START | KEY_A))
	{
		if (bgm_check())
			bgm_stop();

		GmIndex = GMI_OPENING;						/* ｹﾞｰﾑｽﾀｰﾄ					*/
		GmSStepTest = GMT_END;						/* とりあえず終了			*/

		VblkMng.loopExit = 1;						/* LOOP脱出					*/
/*		func = NULL;								/* 関数登録抹消				*/

		return;
	}

	/* ///  デバッグ情報の表示  /// */
	if (PadInfo->padt & KEY_X4)
	{
		GmDispDebug();
	}

/* ---------------------------------------------------------------------------- */
#endif

	/*
		グラフィック更新のため、ここで行う
	*/

	/* ///  生き返りの薬  /// */
	if ((GmPlInfo.hp == 0) && (GmPlInfo.item[0] & GM_ITEM_POTION))
	{
		DbgPrintPort("--< HEAL POTION >--\r\n");

		/* 使用 */
		GmHeal.thp  = GmPlInfo.mhp;						/* MAX HP				*/
		GmHeal.flag = 0;								/* HEAL POTION 演出開始	*/
		GmHeal.cnt  = 0;
		GmHeal.hp   = 0;
		GmPlInfo.hp  = GmPlInfo.mhp;					/* HPはここで回復		*/

		GmPlInfo.item[0] &= ~GM_ITEM_POTION;			/* ﾌﾗｸﾞOFF				*/
	}

	/* ///  ■ステータス・モード判定■  /// */
	if (PadInfo->padt & KEY_X1)
	{
		GmSStepTest = GMT_STATUS;
		VblkMng.loopExit = 1;						/* LOOP脱出					*/
/*		func = NULL;								/* 関数登録抹消				*/

		return;
	}

	/* ///  ■プレイヤー行動■  /// */
	lret = GmMovePlayer();							/* PLAYER 行動			*/

	/* ///  ■画面切り替え判定■  /// */
	if (lret)
	{
		GmChangeFloor( lret);
/*		func = NULL;								/* 関数登録抹消			*/

		return;
	}

	GmMoveEnemy();									/* ENEMY  行動			*/
	GmJudgeAtPlayer();								/* PLAYER 攻撃判定		*/

	if (GameMng.floor == (GM_FLOOR_NUM - 1)) {
		GmMoveSpell2();								/* 呪文処理				*/
		GmCheckRing();
		GmMoveRing();
	} else {
		GmMoveSpell();
	}

	GmJudgeAtEnemy();								/* ENEMY  攻撃判定		*/
	lret = GmCheckDamage();							/* ﾀﾞﾒｰｼﾞ演算			*/

	if (lret)										/* PLAYER ﾀﾞﾒｰｼﾞ?		*/
	{
		GmDispHitPoint( GmPlInfo.hp);				/* HP 表示				*/
		GmHeal.flag ++;								/* HEAL POTION 演出終了	*/
	}

	/* ///  スペクタクル所持判定  /// */
	if ((GmPlInfo.item[ 0] & GM_ITEM_SPECTACLE) == 0)
	{
		/*
			魔法使いは見えません
		*/
		for (i = 0; i < StgMng.ennum; i++)
		{
			if (GmEmy[ i].chr == CHR_MAGICIAN)
				GmEmy[ i].aspr->mode |= (ANM_MODE_NODISP | ANM_MODE_COUNT);
		}
	}

	/* ///  効果アニメーション・チェック  /// */
	GmCheckEffAnm();

#if GM_TEST
	/* ///  宝箱処理  /// */
	if ((GameMng.secondF[(GameMng.floor / 8)] & (0x01 << (GameMng.floor % 8))) == 0)
	{
		GmTrsFloorBase( GMI_TRS_SERACH);
/*		( GmTreasureFunc[ GameMng.floor])( GMI_TRS_SERACH);
*/
	}
#endif
}


/* ******************************************************************************
　関　　数	：GmMovePlayer
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：
		  	：
　履　　歴	：Ver 1.00		2000/12/23		K.Kimura		初版
****************************************************************************** */
char	GmMovePlayer( void)
{
	static	u_char	step, sstep;
	static	u_char	lret;
	static	u_char	tx, ty;
	static	u_char	ox, oy;
	static	short	vx, vy;

	short		kdx, kdy;
	u_short		flag, flag2;



#if	GM_FLOOR_DEBUG
	if (PadInfo->padt & KEY_A)
	{
		if (GameMng.floor < 19)
			return ( 6);
	}

	if (PadInfo->padt & KEY_B)
	{
		if (GameMng.floor > 0)
			return ( -6);
	}
#endif

	if (GameMng.flag & GM_MNGFLAG_ALLCLEAR)
		return ( 0);								/* CLEAR したら動けません	*/

	if (GmPly.act & GM_PL_ACT_DEAD)
		return ( 0);								/* 死んだら動けません		*/

	/* ///  攻撃処理判定  /// */
	ano = GmPly.aspr->anmNo;
	lret = GmCheckSword( ano);

	if (lret)
		return ( 0);								/* 剣振り中					*/

	/* ///  Ｘ４アイテム処理  /// */
	if (PadInfo->padt & KEY_X4)
	{
		lret = GmUseItemX4();

		if (lret)
			return ( 0);								/* ﾊﾝﾏｰ振り中 & ｳｨﾝｸﾞ		*/
	}

	/* ///  キャンセル静止はありえない  /// */
	if ((GmPly.act & GM_PL_ACT_ST2_MASK) != GM_PL_ACT_CANCEL)
	{
		if ((PadInfo->pad & PAD_TRG_DURL_Y) == 0)
		{
			/* ///  ★その方向での停止アニメを表示  /// */
			GmPly.mStep = 0;
			GmPly.aspr->speed = 3;
			ano = GmPly.direct;

			if (GmPly.act & GM_PL_ACT_SPAUSE)
				ano += 8;								/* ｱﾆﾒ配列の関係			*/

			AnmSet( GmPly.aspr, CHR_PLAYER, ano, 0, (ANM_MODE_ACTIVE | ANM_MODE_LOOP));

			GmPly.act &= ~(GM_PL_ACT_ST_MASK | GM_PL_ACT_SWD_MASK);
			GmPly.act |= GM_PL_ACT_NORMAL;				/* 静止ﾌﾗｸﾞ					*/

			return ( 0);
		}
	}

	sstep = GM_PL_WALK_STEP;						/* ﾌﾟﾚｲﾔｰ基本移動ﾄﾞｯﾄ		*/

	/* ///  ダッシュ・ブーツ判定  /// */
	if ((GmPlInfo.item[ 0] & GM_ITEM_JETBOOTS) == 0)	/* Dash Boots	*/
	{
		flag = GmGetFlagMAP(((tx - 7) >> 3), (ty >> 3));

		if (flag & GM_MAPFLAG_SAND)
		{
			sstep = ((sstep * 6) / 10);				/* 移動量 60% に			*/
		}
	}
	else
	{
		sstep = GM_PL_WALK_STEP_JB;
	}

	if (GmPly.act & GM_PL_ACT_SPAUSE)
	{
		sstep = ((sstep * 9) / 10);					/* 移動量 90% に			*/
	}

	step = GmPly.mStep + sstep;						/* ﾌﾟﾚｲﾔｰ基本移動ﾄﾞｯﾄ		*/
	step = (step >> 4);
	tx = GmPly.aspr->x;								/* ﾃﾝﾎﾟﾗﾘに取得				*/
	ty = GmPly.aspr->y;
	ox = tx;
	oy = ty;

	/* ///  移動処理（仮想座標） /// */
	if (PadInfo->pad & KEY_Y3)
	{
		ano = PL_A0_05_ANW;							/* 右	*/
		ty += step;
		GmPly.direct = 1;
	}

	if (PadInfo->pad & KEY_Y1)
	{
		ano = PL_A0_06_ANW;							/* 左	*/
		ty -= step;
		GmPly.direct = 2;
	}

	if (PadInfo->pad & KEY_Y2)
	{
		ano = PL_A0_04_ANW;							/* 上	*/
		tx += step;
		GmPly.direct = 0;
	}

	if (PadInfo->pad & KEY_Y4)
	{
		ano = PL_A0_07_ANW;							/* 下	*/
		tx -= step;
		GmPly.direct = 3;
	}

	if (PadInfo->pad & PAD_TRG_DURL_Y)
	{
		/* 座標チェック */
		if (tx < GM_MOVE_AREA_SX)
		{
			tx = GM_MOVE_AREA_SX;
			return ( -1);							/* ﾌﾛｱ･ｲﾝﾃﾞｯｸｽ加算数値		*/
		}

		if (tx > GM_MOVE_AREA_EX)
		{
			tx = GM_MOVE_AREA_EX;
			return ( 1);							/* ﾌﾛｱ･ｲﾝﾃﾞｯｸｽ加算数値		*/
		}

		if (ty < GM_MOVE_AREA_SY)
		{
			ty = GM_MOVE_AREA_SY;
			return ( -3);							/* ﾌﾛｱ･ｲﾝﾃﾞｯｸｽ加算数値		*/
		}

		if (ty > GM_MOVE_AREA_EY)
		{
			ty = GM_MOVE_AREA_EY;
			return ( 3);							/* ﾌﾛｱ･ｲﾝﾃﾞｯｸｽ加算数値		*/
		}

		/* ///  敵との衝突判定（当たったら即 (ox,oy) に戻す） /// */
		lret = GmCheckCollisionEnemy( &tx, &ty, ox, oy);

		if (!lret)
		{
			vx = tx - ox;								/* ﾍﾞｸﾄﾙ取得				*/
			vy = ty - oy;
			flag = 0;

			/* ///  障害物判定＆補正（キャラクタタイプ：０）  /// */
			if (((ox & 0x07) == 0) & (vx != 0))
				flag |= 0x01;							/* X方向演算				*/

			if (((oy & 0x07) == 0) & (vy != 0))
				flag |= 0x10;							/* Y方向演算				*/

			if ( flag)
			{
				/*
					壁画判定
				*/
				kdx = GmAppTable[ 0][ GmPly.direct].dx;
				kdy = GmAppTable[ 0][ GmPly.direct].dy;
				flag2 = GmGetFlagMAP(((tx >> 3) + kdx), ((ty >> 3) + kdy));

				if (flag2 & GM_MAPFLAG_WALL_CG)
				{
					GmSStepTest = GMT_HINTWALL;
					VblkMng.loopExit = 1;						/* LOOP脱出					*/

					return ( 0);
				}

				/*
					鍵判定
				*/
				if (GameMng.fidx == GmKDTPoinrt[ GameMng.floor].kidx)
				{
					if (GmPlInfo.key == 0)				/* 所持？					*/
					{
						kdx = (tx - GmKey->x);
						kdy = (ty - GmKey->y);

						if ((ABS( kdx) + ABS( kdy)) <= 12)	/* ﾃｷﾄｰな距離	*/
						{
							/* ///  鍵ＧＥＴ！ /// */
							GmKey->mode |= ANM_MODE_NODISP;
							se_play_n( GMSE_KEYGET);	/* SE	*/

							GmPlInfo.key = 1;			/* KEY GET */

							/* 座標変更 for IWIN */
							GmKey->x = ( 3 << 3);
							GmKey->y = (11 << 3);
							GmKey->pal |= 0x2000;
						}
					}
				}

				/*
					扉オープン判定
				*/
				if (GmPlInfo.key)							/* 鍵持ってる？	*/
				{
					/* ///  扉エリア？ /// */
					if (GameMng.fidx == GmKDTPoinrt[ GameMng.floor].didx)
					{
						kdx = (tx - ((GmKDTPoinrt[ GameMng.floor].dx << 3) + 12));
						kdy = (ty - ((GmKDTPoinrt[ GameMng.floor].dy << 3) + 8));

						if ((ABS( kdx) + ABS( kdy)) <= 24)	/* ﾃｷﾄｰな距離	*/
						{
							GmSetDoor( GM_DOOR_OPEN, GmKDTPoinrt[ GameMng.floor].ddir);
							se_play_n( GMSE_DOOR);				/* SE		*/

							GmPlInfo.key = 0;					/* KEY LOST */
							GameMng.openF[ GameMng.floor] = 1;	/* OPEN		*/
						}
					}
				}

				/*
					宝箱判定
				*/
				if ((GmTrs->mode & ANM_MODE_NODISP) == 0)	/* 表示されてる？	*/
				{
					kdx = (tx - (GmKDTPoinrt[ GameMng.floor].tx << 3));
					kdy = (ty - (GmKDTPoinrt[ GameMng.floor].ty << 3));

					if ((ABS( kdx) + ABS( kdy)) <= 12)	/* ﾃｷﾄｰな距離	*/
					{
#if GM_TEST
						GmTrsFloorBase( GMI_TRS_GET);
/*						( GmTreasureFunc[ GameMng.floor])( GMI_TRS_GET);
*/
#endif
					}
				}

				lret = GmCheckPosition( &tx, &ty, ox, oy, CHR_PLAYER, flag);
				flag  = GmGetFlagMAP((tx >> 3), (ty >> 3));
				flag |= GmGetFlagMAP(((tx - 1) >> 3), (ty >> 3));

				/* ///  フロア移動判定  /// */

				if ((flag & GM_MAPFLAG_DW_STAIRS) == GM_MAPFLAG_DW_STAIRS)
					return ( -6);						/* 階下へ					*/

				if (flag & GM_MAPFLAG_UP_STAIRS)
					return (  6);						/* 上階へ					*/
			}
			else
			{
				/* ８の倍数以外 */

				flag  = GmGetFlagMAP((tx >> 3), (ty >> 3));

				/* ///  ■穴チェック■  /// */
				if (GmHolePos.x)							/* 設定＝穴が存在			*/
				{
					/* 穴に落ちましたか？ */
					kdx = ( GmHolePos.x - tx);
					kdy = ( GmHolePos.y - ty);

					if ((ABS( kdx) + ABS( kdy)) <= 4)	/* ﾃｷﾄｰな距離	*/
					{
						/* 落ちました */
						GmPly.act &= ~GM_PL_ACT_ST_MASK;
						GmPly.act |= GM_PL_ACT_HOLEIN;

						return ( -6);						/* 階下へ					*/
					}
				}
				/* ///  ■ひび割れチェック■  /// */
				else if (flag & GM_MAPFLAG_CRFLOOR)
				{
					/* ///  穴にしましょう  /// */
					GmSetHole((tx >> 3), (ty >> 3));
					se_play_n( GMSE_DOOR);					/* SE */
				}
			}
		}

		/* ///  移動ボタンが押されたよ  /// */

		/* 移動ステップ固定小数点補正 */
		GmPly.mStep = ((GmPly.mStep + sstep) & GM_PL_WALK_STEP_MASK);

		/*
			■アニメーション設定
			  − 斜め移動は常に上下方向のグラフィック。
			  − 既に表示中ならば、アニメーションは変更しない。
		*/

		if (GmPly.act & GM_PL_ACT_SPAUSE)
			ano += 8;							/* ｱﾆﾒ配列の関係			*/

		if (GmPly.aspr->anmNo != ano)
		{
			GmPly.aspr->speed = 6;
			AnmSet( GmPly.aspr, CHR_PLAYER, ano, 0, (ANM_MODE_ACTIVE | ANM_MODE_LOOP));

			GmPly.act &= ~(GM_PL_ACT_ST_MASK | GM_PL_ACT_SWD_MASK);
			GmPly.act |= GM_PL_ACT_WALK;			/* 移動ﾌﾗｸﾞ					*/
		}

		GmPly.aspr->x = tx;							/* ﾃﾝﾎﾟﾗﾘに取得				*/
		GmPly.aspr->y = ty;

		/* キャンセル状態の解除 */
		if ((GmPly.act & GM_PL_ACT_ST2_MASK) == GM_PL_ACT_CANCEL)
		{
			GmPly.act &= ~GM_PL_ACT_ST2_MASK;
		}
	}


	return ( 0);
}


/* ******************************************************************************
　関　　数	：GmCheckPosition
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：障害物（当たり判定）がないか判定します。
		  	：キャラクタ補正ドット以内であれば、座標位置を補正します。
			：
　履　　歴	：Ver 1.00		2000/12/23		K.Kimura		初版
****************************************************************************** */
u_char	GmCheckPosition( u_char *tx, u_char *ty, u_char ox, u_char oy, u_char type, u_char flag)
{
	static	u_char			ret;
	static	u_char			csx, csy, cex, cey;
	static	char			vecx, vecy;
	static	u_short			idx, tidx;
	static	SYSRECT			pl;
	static	u_short near	*p;
	static	GMBLKTYPE		*btp;



	p = ( u_short near *)StgMng.scr->flag;		/* ﾌﾗｸﾞﾃﾞｰﾀ･ｱﾄﾞﾚｽ取得		*/
	btp = &GmBlkType[ type];

	/* ///  自キャラの矩形設定  /// */
	pl.l = *tx + btp->rect.l;
	pl.t = *ty + btp->rect.t;
	pl.r = *tx + btp->rect.r;
	pl.b = *ty + btp->rect.b;
	csx = (pl.l >> 3);							/* 判定すべきｾﾙ位置を算出	*/
	csy = (pl.t >> 3);
	cex = (pl.r >> 3);
	cey = (pl.b >> 3);

	vecx = *tx - ox;
	vecy = *ty - oy;
	ret  = 0;

#if	GM_DEBUG
	DbgPrintPort("-------------------------\r\n");
#endif

	idx  = (csy * SCR_MAP_WIDTH) + csx;
	tidx = idx;

	switch ( flag)
	{
		/* ///  Ｘ方向演算  /// */
		case 0x01:
			if (vecx > 0)
				tidx += (cex - csx);

			if (GmCheckBlock( tidx, 0, (cey - csy)))
				ret |= 0x01;

			break;


		/* ///  Ｙ方向演算  /// */
		case 0x10:
			if (vecy > 0)
				tidx += ((cey - csy) * SCR_MAP_WIDTH);

			if (GmCheckBlock( tidx, (cex - csx), 0))
				ret |= 0x10;
			break;


		/* ///  ＸＹ方向演算  /// */
		case 0x11:
			/*
				Ｘを見る
			*/
			tidx  = (idx + (vecx > 0) * (cex - csx));
			tidx += (SCR_MAP_WIDTH * (vecy < 0));

			if (GmCheckBlock( tidx, 0, (cey - csy - 1)))
				ret |= 0x01;

			/*
				Ｙを見る
			*/
			tidx  = (idx + (vecy > 0) * (cey - csy) * SCR_MAP_WIDTH);
			tidx += (vecx < 0);

			if (GmCheckBlock( tidx, (cex - csx - 1), 0))
				ret |= 0x10;

			/* ///  ＸＹ方向に障害物なし  /// */
			if (ret == 0x00)
			{
				/* Ａを見る */
				tidx  = (idx + (vecx > 0) * (cex - csx));
				tidx += ((vecy > 0) * (cey - csy) * SCR_MAP_WIDTH);
#if	GM_DEBUG
	sprintf( buf, "A:tidx::%d\r\n", tidx);
	DbgPrintPort( buf);
#endif
/*				if (StgMng.scr->flag[ tidx] & GM_MAPFLAG_BLOCK)
*/				if (GmCheckBlock( tidx, 0, 0))
					ret = 0x01;
			}
			break;

		default:
			break;
	}

	if (ret & 0x01)
		*tx = ox;

	if (ret & 0x10)
		*ty = oy;


	return ( ret);
}


/* ******************************************************************************
　関　　数	：GmGetBlock
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：
		  	：
			：
　履　　歴	：Ver 1.00		2000/12/27		K.Kimura		初版
****************************************************************************** */
char	GmCheckBlock( u_short idx, u_char w, u_char h)
{
	static	u_short near	*p;
	static	u_char	i, j;


	p = ( u_short near *)StgMng.scr->flag;			/* ﾌﾗｸﾞﾃﾞｰﾀ･ｱﾄﾞﾚｽ取得	*/

	/* ///  ■領域設定■  /// */
	for (i = 0; i <= h; i++)							/* 縦方向の繰り返し数	*/
	{
		for (j = 0; j <= w; j++)						/* 横方向の繰り返し数	*/
		{
			if (p[ idx + j] & GM_MAPFLAG_BLOCK)
			{
				return ( 1);
			}
		}
		idx += SCR_MAP_WIDTH;
	}



	return ( 0);
}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：
			：
　履　　歴	：Ver 1.00		2001/01/07		K.Kimura		初版
****************************************************************************** */
u_short		GmGetFlagMAP( u_char x, u_char y)
{
	static	u_short near	*p;

	p = ( u_short near *)StgMng.scr->flag;			/* ﾌﾗｸﾞﾃﾞｰﾀ･ｱﾄﾞﾚｽ取得	*/
	return ( p[(SCR_MAP_WIDTH * y) + x]);
}


/* ******************************************************************************
　関　　数	：GmCheckRange
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：
			：
　履　　歴	：Ver 1.00		2000/12/27		K.Kimura		初版
****************************************************************************** */
char	GmCheckRange( SYSRECT *blk, SYSRECT *pl)
{
	if (((pl->l - blk->r) & (blk->l - pl->r) & (pl->t - blk->b) & (blk->t - pl->b)) < 0)
		return ( 1);

	return ( 0);
}


/* ******************************************************************************
　関　　数	：GmChangeBGMain
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：ＢＧ変更処理
		  	：
　履　　歴	：Ver 1.00		2000/12/28		K.Kimura		初版
****************************************************************************** */
void	GmChangeBGMain( void *func)
{
	static		GMKDTPOINT 		*p;
	u_char		pal;


	/*
		本来ならカウンターを持ってスクロール処理します。
		現在は（仮）の処理です。
	*/
	switch (StgMng.scr->scrDir)
	{
		/* 左 */
		case -3:
			GmPly.aspr->y = GM_MOVE_AREA_EY;
			ScrDispScreen( 0);
			break;

		/* 下 */
		case -1:
			GmPly.aspr->x = GM_MOVE_AREA_EX;
			ScrDispScreen( 0);
			break;

		/* 上 */
		case 1:
			GmPly.aspr->x = GM_MOVE_AREA_SX;
			ScrDispScreen( 0);
			break;

		/* 右 */
		case 3:
			GmPly.aspr->y = GM_MOVE_AREA_SY;
			ScrDispScreen( 0);
			break;

		/* スクロールなし */
		default:
			/* とりあえず表示 */
			ScrDispScreen( 0);
			break;
	}

	p = &GmKDTPoinrt[ GameMng.floor];

	/* ///  「扉」チェック  /// */
	if ((GameMng.fidx == p->didx) && (p->ddir >= 0))
	{
		/* ”扉”は開けたの？ */
		if (GameMng.openF[ GameMng.floor] == 0)
		{
			/*
				 開けてないので、扉を「スクリーン０に」描画
				 ※ omp に書き込むのは、フラグのみ
			*/
			GmSetDoor( GM_DOOR_CLOSE, p->ddir);
		}
	}

	if ((GameMng.floor + GameMng.fidx) == 0)
	{
		if ((GameMng.flag & GM_MNGFLAG_START) == 0)			/* EVENT 中?		*/
			GmPutDorrCG( 0, 0, 10, 1, 1);					/* STSRT 地点		*/
	}


	/* ///  自キャラクタの表示  /// */
	GmPly.aspr->speed = 3;
	AnmSet( GmPly.aspr, CHR_PLAYER, GmPly.direct, 0, (ANM_MODE_ACTIVE | ANM_MODE_LOOP));

	/* ///  アワーグラスの効力終了  /// */
	GmPlInfo.flag &= ~GM_PIFLAG_HGLASS;
	pal = GMPAL_BG;

	/*
		暗闇チェック
	*/
	if (StgMng.flag & GM_FLAG_DARKROOM)
	{
		if ((GmPlInfo.item[ 0] & GM_ITEM_CANDLE) == 0)
		{
			pal = GMPAL_DARKROOM; 
			palette_set_color( GMPAL_BG, 0x7777); 
		}
	}

	/* フロア移動チェック */
	if (GameMng.flag & GM_MNGFLAG_CHG_FLOOR)
	{
		display_control( 0x0007);				/* ｽﾌﾟﾗｲﾄ ON		*/
		GmFadeInPal( GMPAL_BG, pal, GM_FIOT_FLOOR);

		GameMng.flag &= ~GM_MNGFLAG_CHG_FLOOR;
	}
	else
	{
		palette_set_color( GMPAL_BG, SysPal[ pal]); 
	}


	GmSStepTest = GMT_GAME;						/* GAMEﾒｲﾝへ			*/
	VblkMng.loopExit = 1;						/* LOOP脱出				*/
	StgMng.scr->scrDir = 0;

}


/* ******************************************************************************
　関　　数	：GmCheckSword
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：プレイヤー剣チェック
		  	：
　履　　歴	：Ver 1.00		2001/01/01		K.Kimura		初版
****************************************************************************** */
u_char	GmCheckSword( u_char ano)
{
	static	u_char		ret;
	static	u_char		flag, aflag;



	ret   = 0;
	flag  = 0;						/* ﾌﾟﾚｲﾔｰ行動ﾌﾗｸﾞ		*/
	aflag = 0;						/* ｼｽﾃﾑ的許可ﾌﾗｸﾞ		*/

	if (GmPly.aspr->mode & ANM_MODE_END)
	{
		if (GmPly.act & GM_PL_ACT_SWING_S)
		{
			/* ///  順剣振りが終了  /// */
			GmPly.act &= ~GM_PL_ACT_MASK_ALL;
			GmPly.act |= GM_PL_ACT_NORMAL;				/* 静止ﾌﾗｸﾞ		*/

			if (PadInfo->pad & KEY_X3)
			{
				GmPly.act |= GM_PL_ACT_SPAUSE;			/* 構えﾌﾗｸﾞ		*/
			}
		}
		else
		{
			/* ///  剣振りが終了のため、静止状態に移行  /// */
			GmPly.act &= ~GM_PL_ACT_MASK_ALL;
			GmPly.act |= GM_PL_ACT_NORMAL;				/* 静止ﾌﾗｸﾞ		*/
		}
	}

	if (GmPlInfo.cnt1 > 0)
		GmPlInfo.cnt1 --;

	if (GmPly.act & GM_PL_ACT_SWING_HM)
		return ( 1);									/* ﾊﾝﾏｰ振ってます	*/


	if (PadInfo->padt & KEY_X3)
	{
		flag |= 0x01;				/* 順振りが可能ならば振ってもＯＫ	*/

		if (GmPlInfo.cnt1 == 0)
		{
			GmPlInfo.cnt1 = GM_PL_ISSWORD_TIME;
		}
		else
		{
			if (GmPlInfo.cnt1 > 0)
			{
				flag |= 0x04;		/* 逆振りが可能ならば振ってもＯＫ	*/
				GmPlInfo.cnt1 = 0;	/* 初期化 */
			}
		}
	}
	else if (PadInfo->padt & KEY_X2)
	{
		flag |= 0x02;				/* 縦振りが可能ならば振ってもＯＫ	*/
	}

#if	GM_CANCEL_DEBUG
	DbgPrintPort("0..");
#endif
	/* ///  振る気がなければ終了  /// */
	if ((PadInfo->pad & (KEY_X3 | KEY_X2)) == 0)
	{
#if	GM_CANCEL_DEBUG
	DbgPrintPort("1..");
#endif
		if (GmPly.act & GM_PL_ACT_SPAUSE)
		{
			GmPly.act &= ~GM_PL_ACT_SPAUSE;
			flag |= 0x04;			/* 逆振りを許可 		*/
		}
		/* ///  剣振り中か？  /// */
		else if (GmPly.act & GM_PL_ACT_SWD_MASK)
		{
#if	GM_CANCEL_DEBUG
	DbgPrintPort("2..\r\n");
#endif
			if (GmPly.act & GM_PL_ACT_CANCEL)
			{
				return ( 0);		/* 移動も可能です		*/
			}
			else
			{
				return ( 1);		/* 移動は不可です		*/
			}
		}
		else
		{
#if	GM_CANCEL_DEBUG
	DbgPrintPort("\r\n");
#endif
			return ( 0);			/* 移動ＯＫ				*/
		}
	}
#if	GM_CANCEL_DEBUG
	DbgPrintPort("\r\n");
#endif

	/*	------------------------------------
		現在の振っても良い剣技を設定
	-------------------------------------- */

	/* ///  逆振りをしたいのか？  /// */
	if (flag & 0x04)
	{
		if ((GmPly.act & GM_PL_ACT_SWING_S) && (GmPly.aspr->motNo <= 2))
		{
			/*
				逆サイド振りに移行
				ガントレットがあれば、空キャン２度振りダメージでお得！
			*/
			aflag |= 0x04;			/* 逆振りを許可 */
		}
		else if ((GmPly.act & GM_PL_ACT_ST_MASK) <= GM_PL_ACT_WALK)
		{
			aflag |= 0x04;			/* 逆振りを許可 */
		}
		else if (GmPly.act & GM_PL_ACT_CANCEL)
		{
			aflag |= 0x04;			/* 逆振りを許可 */
		}
	}

	/* ///  順振りをしたいのか？  /// */
	if (flag & 0x01)
	{
		if ((GmPly.act & GM_PL_ACT_ST_MASK) <= GM_PL_ACT_WALK)
		{
			aflag |= 0x01;			/* 順振りを許可 */
		}
		else if (GmPly.act & GM_PL_ACT_CANCEL)
		{
			aflag |= 0x01;			/* 順振りを許可 */
		}
	}

	/* ///  縦振りをしたいのか？  /// */
	if (flag & 0x02)
	{
		if ((GmPly.act & GM_PL_ACT_ST_MASK) <= GM_PL_ACT_WALK)
		{
			aflag |= 0x02;			/* 縦振りを許可 */
		}
		else if (GmPly.act & GM_PL_ACT_CANCEL)
		{
			aflag |= 0x02;			/* 縦振りを許可 */
		}
	}

	/* ///  ★キャンセル可能な攻撃を設定  /// */
	if (GmPly.act & GM_PL_ACT_CANCEL)
	{
		switch (GmPly.act & GM_PL_ACT_SWD_MASK)
		{
			case GM_PL_ACT_SWING_S:
				aflag &= 0x06;						/* 順斬り以外	*/
				break;

			case GM_PL_ACT_SWING_IS:
				aflag &= 0x03;						/* 逆斬り以外	*/
				break;

			case GM_PL_ACT_SWING_VS:
				aflag &= 0x05;						/* 縦斬り以外	*/
				break;
		}
	}
#if	GM_CANCEL_DEBUG
	sprintf( buf, "aflag,flag::%x,%x\r\n", aflag, flag);
	DbgPrintPort( buf);
#endif
	/* ///  剣を振るのか？  /// */
	aflag &= flag;

	if (aflag)
	{
		if (aflag & 0x04)
		{
			/* ///  逆振り発動！！ /// */
			GmSetSwordMotion( PL_A0_28_ANW, GM_PL_ACT_SWING_IS);
		}
		else if (aflag & 0x01)
		{
			/* ///  順振り発動！！  /// */
			GmSetSwordMotion( PL_A0_20_ANW, GM_PL_ACT_SWING_S);
		}
		else
		{
			/* ///  縦振り発動！！  /// */
			GmSetSwordMotion( PL_A0_16_ANW, GM_PL_ACT_SWING_VS);
		}

		ret = 1;				/* 剣振り中のため 行動不能			*/
	}

	/* ///  剣振り中か？  /// */
	if (GmPly.act & GM_PL_ACT_SWD_MASK)
		ret = 1;				/* 移動は不可です		*/


	return ( ret);
}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：剣を振ります
		  	：
　履　　歴	：Ver 1.00		2001/01/04		K.Kimura		初版
****************************************************************************** */
u_char	GmSetSwordMotion( u_char ba, u_short flag)
{
	u_char		speed;


	/* ///  ★アニメーション・ベーススピード設定  /// */
	speed = 9;
	GmTmpVal = ( flag >> 9) + GMSE_SWD_01;

	/* ガントレット処理 */
	if (GmPlInfo.item[ 0] & GM_ITEM_GAUNTLET)
	{
		speed = 4;
		GmTmpVal += 3;								/* SE変更	*/

		if (flag == GM_PL_ACT_SWING_VS)				/* 縦斬りは限度がある	*/
			speed = 5;
	}
	else
	{
		if (flag == GM_PL_ACT_SWING_VS)				/* 縦斬りは速い			*/
			speed = 7;
	}

	/* ＳＥ発音 */
	se_play_n( GmTmpVal);

	GmPly.aspr->speed = speed;

	ano = ba + GmPly.direct;
	AnmSet( GmPly.aspr, CHR_PLAYER, ano, 0, ANM_MODE_ACTIVE);

	/* ///  剣フラグ  サイド・スウィング  /// */
	GmPly.act &= ~GM_PL_ACT_MASK_ALL;
	GmPly.act |= (GM_PL_ACT_SWORD | flag);

#if GM_SWD_DEBUG
	sprintf( buf, "SWORD START!!::ano::%d\r\n", ano);
	DbgPrintPort( buf);
#endif

	/* 宝箱出現用に記憶 */
	GmTrsInfo.swordNum ++;
	GmTrsInfo.swordNumFloor ++;


	return ( ano);
}


/* ******************************************************************************
　関　　数	：GmLoadItemWindowData
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：アイテムウィンドウＣＧ＆データの読み込み＆登録。
			：GameMng.iwin に、データ格納アドレスが設定されます。
			：SysGetHeap() を使用します。
			：
　履　　歴	：Ver 1.00		2001/01/06		K.Kimura		初版
			：Ver 1.10		2001/01/20		K.Kimura		複数回読み込みに対応
****************************************************************************** */
void	GmLoadItemWindowData( void)
{
	u_short		size;
	u_char		flag;


	flag = 0;

	if (GameMng.iwin == NULL)
	{
		/* ＣＧの読み込み＆ＶＲＡＭ転送 */
		SprSetChracter( GRP_I_WIN_FRC, VRM_IWIN);
		GameMng.iwin = SysGetHeap();							/* 展開先ｱﾄﾞﾚｽ		*/

		flag = 1;
	}

	size = ScrLoadMapData( MAP_I_WIN_OMC, GMPAL_IWIN, VRM_IWIN, GameMng.iwin);

	if (flag)
	{
		/*
			flag分切り離す？	size - 1KByte	とか
		*/
		SysAddHeap( size);
	}

}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：アイテムウィンドウを、ＢＧ面に描画します。
			：
　履　　歴	：Ver 1.00		2001/01/06		K.Kimura		初版
****************************************************************************** */
void	GmSetItemWindowBase( u_char scr, u_char x, u_char y, u_char xl, u_char w)
{
	static	u_char		i;
	static	u_char near	*data;


	/* ///  一部描画（中途半端だけど、ゲーム専用ということで・・） /// */
	data = GameMng.iwin + 16;						/* ﾍｯﾀﾞ飛ばし		*/
	data += ( xl * 2);								/* ﾗｲﾝ移動			*/

	for (i = 0; i < SCR_MAP_HEIGHT; i++)
	{
		/* (y + i) が、気がかり・・ */
		screen_set_char( scr, x, (y + i), w, 1, data);
		data += ( SCR_MAP_WIDTH * 2);				/* 2 Byte情報		*/
	}

}


/* ******************************************************************************
　関　　数	：GmInitStatus
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：プレイヤーと敵キャラのアニメを停止します。
			：
　			：[ mode ]	0 .. ｱﾆﾒ STOP
		  	：			1 .. ｱﾆﾒ START
		  	：
　履　　歴	：Ver 1.00		2001/01/07		K.Kimura		初版
****************************************************************************** */
void	GmInitStatus( u_char mode)
{
	static	u_char		i;


	/* ///  アニメーション・カウントＯＮ／ＯＦＦ  /// */

	if (mode)
	{
		/* ///  ■アニメ・ＳＴＡＲＴ■  /// */
		GmPly.aspr->mode &= ~ANM_MODE_STOP;

		/* ///  アワーグラスは？  /// */
		if ((GmPlInfo.flag & GM_PIFLAG_HGLASS) == 0)
		{
			for (i = 0; i < StgMng.ennum; i++)
				GmEmy[ i].aspr->mode &= ~ANM_MODE_STOP;
		}
	}
	else
	{
		/* ///  ■アニメ・ＳＴＯＰ■  /// */
		GmPly.aspr->mode |= ANM_MODE_STOP;

		for (i = 0; i < StgMng.ennum; i++)
			GmEmy[ i].aspr->mode |= ANM_MODE_STOP;

		/* ///  アイテムウィンドウの読み込み＆所持品の設定  /// */
		GmLoadItemWindowData();
		GmSetItemWindowData();

		GmCurIdx = 1;

		/* ///  ■カーソル表示＆座標設定■  /// */

		/*
			スクロール中は、AnmExec() をコールしないので、ここで設定してＯＫ
		*/

		/* (11, 3 + y) */
		GmCur[ 0]->x = (11 << 3);
		GmCur[ 0]->y = ((3 + (GmPlInfo.selItem[ 0] << 2)) << 3);
		GmCur[ 0]->mode &= ~ANM_MODE_NODISP;

		/* ( 6, 3 + y) */
		GmCur[ 1]->x = (6 << 3);
		GmCur[ 1]->y = ((3 + (GmPlInfo.selItem[ 1] << 2)) << 3);
		GmCur[ 1]->mode &= ~ANM_MODE_NODISP;

		/* 鍵所持判定 */
		if (GmPlInfo.key)
		{
			GmKey->mode &= ~ANM_MODE_NODISP;
			
		}
		else
		{
			GmKey->mode |= ANM_MODE_NODISP;
		}
	}

}


/* ******************************************************************************
　関　　数	：GmMoveMain
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：
		  	：
　履　　歴	：Ver 1.00		2000/12/23		K.Kimura		初版
****************************************************************************** */
void	GmMoveStatus( void *func)
{
	static	SPRANM	*p;


	/* ///  ステータス・モード判定  /// */
	if (PadInfo->padt & (KEY_X1 | KEY_X4))
	{
		GmSStepTest = GMT_GAME;
		VblkMng.loopExit = 1;						/* LOOP脱出					*/
/*		func = NULL;								/* 関数登録抹消				*/

		GmCur[ 0]->mode |= ANM_MODE_NODISP;
		GmCur[ 1]->mode |= ANM_MODE_NODISP;

		/* プレイヤーのパラメータ更新 */
		GmCheckParamPlayer();

		/* 鍵所持判定 */
		if (GmPlInfo.key)
		{
			GmKey->mode |= ANM_MODE_NODISP;
		}
		else
		{
			if (GmKDTPoinrt[ GameMng.floor].ddir >= 0)		/* 扉の有無も判定	*/
			{
				/*
					持ってなくて、かつ鍵部屋なら表示
				*/
				if (GameMng.fidx == GmKDTPoinrt[ GameMng.floor].kidx)
					GmKey->mode &= ~ANM_MODE_NODISP;
			}
		}

		return;
	}

	/* ///  カーソル操作＆決定  /// */

	p = GmCur[ GmCurIdx];

	/* ///  カーソル点滅処理  /// */
	if (VblkGetCount() & 0x0010)
	{
		p->mode |= ANM_MODE_NODISP;					/* 消去	*/
	}
	else
	{
		p->mode &= ~ANM_MODE_NODISP;				/* 表示	*/
	}

	switch (PadInfo->padt & PAD_TRG_DURL_Y)
	{
		case KEY_Y1:								/* 右	*/
			if (p->y > 24)
			{
				p->y -= 32;
				GmPlInfo.selItem[ GmCurIdx] --;
				GmDispItemName();				/* 名前表示	*/
			}
			se_play_n( GMSE_CURSOR);				/* SE	*/
			break;

		case KEY_Y2:								/* 上	*/
			GmCurIdx = 0;
			p->mode &= ~ANM_MODE_NODISP;		/* 点滅解除	*/
			se_play_n( GMSE_CURSOR);				/* SE	*/
			break;

		case KEY_Y3:								/* 左	*/
			if (p->y < 120)
			{
				p->y += 32;
				GmPlInfo.selItem[ GmCurIdx] ++;
				GmDispItemName();				/* 名前表示	*/
			}
			se_play_n( GMSE_CURSOR);				/* SE	*/
			break;

		case KEY_Y4:								/* 下	*/
			GmCurIdx = 1;
			p->mode &= ~ANM_MODE_NODISP;		/* 点滅解除	*/
			se_play_n( GMSE_CURSOR);				/* SE	*/
			break;
	}

}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：アイテムウィンドウをスクロールします。
			：
　			：[ mode ]	-1 .. 表示
		  	：			 1 .. 隠蔽
		  	：
　履　　歴	：Ver 1.00		2001/01/08		K.Kimura		初版
****************************************************************************** */
void	GmScrollIWIN( char mode)
{
	static	u_char		i;
	static	u_char		sp, ep, op, lc;
	static	char		vec;

	/*
		ダブルバッファじゃないので、ブロック処理でＯＫ
	*/

	vec  = 16 * mode;
	sp   = 0;
	ep   = GM_IWIN_SX;
	lc   = 2;

	if (mode == -1)
	{
		sp = GM_IWIN_SX;
		ep = 0;
		lc = 0;
	}

	for (i = 0; i < 16; i++)
	{
		screen_set_scroll( 1, 256 - sp, 0);
		sys_wait( 1);

		op = sp;
		sp += vec;

		if ((sp & 0x10) ^ (op & 0x10))					/* 16 Byte境界またぎ？	*/
		{
#if GM_IWIN_DEBUG
	sprintf( buf, "sp,op,lc::%d,%d,%d\r\n", sp, op, lc);
	DbgPrintPort( buf);
#endif
			/* ///  セルデータ転送 or 削除  /// */
			if (mode == -1)
			{
				if ((4 + lc) < 28)
					GmSetItemWindowBase( 1, (4 + lc), 0, (4 + lc), 2);
			}
			else
			{
				if ((28 - lc) >= 4)
					screen_fill_char( 1, (28 - lc), 0, 2, SCR_MAP_HEIGHT, (4 << 9));
			}

			lc += 2;
		}

		if (i >= 11)
			vec = vec >> 1;
	}

	/* 最後は強制で */
	screen_set_scroll( 1, 256 - ep, 0);
	sys_wait( 1);

}


/* ******************************************************************************
　関　　数	：GmDispScore
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：スコアを表示します。
		  	：ちなみに、スコアに１の位はないので、飛ばして表示
		  	：
　履　　歴	：Ver 1.00		2001/01/09		K.Kimura		初版
****************************************************************************** */
void	GmDispScore( u_char x, u_char y, u_short sc)
{
	/* スコア表示 */
	sprintf( buf, "%06u0", sc);
	FntPrint( 1, x, y, buf, 1, FNT_PALETTE_W_NUM);

}


/* ******************************************************************************
　関　　数	：GmDispScore
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：フロアを表示します。
		  	：
　履　　歴	：Ver 1.00		2001/01/09		K.Kimura		初版
****************************************************************************** */
void	GmDispFloor( u_char x, u_char y, u_short floor)
{
	sprintf( buf, "%02d", floor);
	FntPrint( 1, x, y, buf, 1, FNT_PALETTE_W_NUM);
}


/* ******************************************************************************
　関　　数	：GmJudgeAtPlayer
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：プレイヤーの攻撃判定を行います。
		  	：
　履　　歴	：Ver 1.00		2001/01/10		K.Kimura		初版
　			：Ver 1.20		2001/01/17		K.Kimura		ｷｬﾝｾﾙ処理追加
****************************************************************************** */
u_char	GmJudgeAtPlayer( void)
{
	u_char		i;
	u_char		ret;
	u_char		idx1, idx2, dir;
	static	short		nx, ny;
	static	SYSRECT		pl, en, tmp;
	static	GMTRSINFO	*trs;



	trs  = &GmTrsInfo;
	ret  = 0;
	idx1 = ((GmPly.aspr->flag & GM_ANM_FLAG_AT_MASK) >> 8);

	/* ///  現在のアニメが攻撃判定を持っているか？  /// */
	if (idx1)
	{
		/*
			剣の判定＆攻撃判定の変更
		*/
		if ((GmPly.act & GM_PL_ACT_SWORD) != GM_PL_ACT_SWING_HM)
		{
			if (GmPlInfo.selItem[ 0] == 2)
				idx1 += 20;											/* 攻撃判定ｵﾌｾｯﾄ	*/
		}

		memcpy( &tmp, &GmBlkAttack[ idx1], sizeof( SYSRECT));
#if GM_ATTACK_DEBUG
	DbgPrintPort("-----------------------\r\n");
	sprintf( buf, "( IDX )::%d\r\n", idx1);
	DbgPrintPort( buf);
	sprintf( buf, "( TMP )::(%d,%d)-(%d,%d)\r\n", tmp.l, tmp.t, tmp.r, tmp.b);
	DbgPrintPort( buf);
#endif
		/*
			縦画面なので、ＹとＸが逆に加算されます。
			Ｘ方向が＋−逆な点に注意！
			また、(pl.l < pl.r), (pl.t < pl.b) である必要があるので、
			Ｘ方向だけ、計算が特殊になってます。
		*/
		pl.l = GmPly.aspr->x - tmp.b;
		pl.t = GmPly.aspr->y + tmp.l;
		pl.r = GmPly.aspr->x - tmp.t;
		pl.b = GmPly.aspr->y + tmp.r;
#if GM_ATTACK_DEBUG
	sprintf( buf, "( PL_PO )::(%d,%d)\r\n", GmPly.aspr->x, GmPly.aspr->y);
	DbgPrintPort( buf);
	sprintf( buf, "( PL_AF )::(%d,%d)-(%d,%d)\r\n", pl.l, pl.t, pl.r, pl.b);
	DbgPrintPort( buf);
#endif
		/*
			【 全 ENEMY と当たり判定 】
				− ダメージフラグを設定（方向＆攻撃値）
				− 内部的なポイント加算（段位認定）
				− 攻撃フラグの消去（連続で何度も当たらないように）
		*/

#if GM_ATBLK_DEBUG
		sprite_set_char_location( 127, VRM_BG, pl.l, pl.t);
#endif

		/* ///  存在する全敵分ループ  /// */
/*		for (i = 0; i < StgMng.ennum; i++)
*/		for (i = 0; i < GM_FLOOR_ENEMY_MAX; i++)
		{
			if (GmEmy[ i].aspr == NULL)
				continue;

			/*
				ENEMY 生死判定 to continue
			*/
			if (GmEmy[ i].act & GM_PL_ACT_DEAD)
				continue;

			/*
				ENEMY 非表示判定（for MAGICIAN） to continue
			*/
			if (GmEmy[ i].aspr->mode & (ANM_MODE_END | ANM_MODE_END2))
				continue;

			idx2 = 0;

			/* ///  ■剣客判定■  /// */
			switch (GmEmy[ i].chr)
			{
				case CHR_KNIGHT1:
				case CHR_KNIGHT2:
				case CHR_KNIGHT3:
				case CHR_KNIGHT1_L:
				case CHR_KNIGHT2_L:
				case CHR_KNIGHT3_L:
					/* ///  ■あちらさんは剣攻撃？■  /// */
					idx2 = ((GmEmy[ i].aspr->flag & GM_ANM_FLAG_AT_MASK) >> 8);
					break;
			}

			if (idx2)
			{
				/*
					剣の攻撃判定同士の衝突判定
					− 衝突＝キャンセル可能な硬化状態へ
				*/
				memcpy( &tmp, &GmBlkAttack[ idx2], sizeof( SYSRECT));
				en.l = GmEmy[ i].aspr->x - tmp.b;
				en.t = GmEmy[ i].aspr->y + tmp.l;
				en.r = GmEmy[ i].aspr->x - tmp.t;
				en.b = GmEmy[ i].aspr->y + tmp.r;

				if (GmCheckRange( &pl, &en))
				{
					/* ヒット */
#if GM_CANCEL_DEBUG
	DbgPrintPort("<< to CANCEL!! >>""\r\n");
#endif
					/* 双方の攻撃判定を削除 */
					GmPly.aspr->flag &= ~GM_ANM_FLAG_AT_MASK;
					GmEmy[ i].aspr->flag &= ~GM_ANM_FLAG_AT_MASK;

					/* キャンセル状態へ移行：プレイヤー（フラグ＆タイマ設定） */
					GmPly.act &= ~GM_PL_ACT_ST2_MASK;
					GmPly.act |= GM_PL_ACT_CANCEL;
					GmPly.aspr->mode |= ANM_MODE_STOP;			/* ｱﾆﾒ停止		*/
					GmPlInfo.ccnt = GM_CANCEL_TIME;				/* Timer設定	*/

					/* キャンセル状態へ移行：ＥＮＥＭＹ（フラグ＆タイマ設定） */
					GmEmy[ i].act &= ~GM_PL_ACT_ST2_MASK;
					GmEmy[ i].act |= GM_PL_ACT_CANCEL;
					GmEmy[ i].aspr->mode |= ANM_MODE_STOP;		/* ｱﾆﾒ停止		*/
					GmEmyInfo[ i].ccnt = GM_CANCEL_TIME;		/* Timer設定	*/

					trs->lsEidx = i;

					/* ＳＥ発音 */
					se_play_n( GMSE_SWDCOLLI);

					continue;							/* 本体判定には飛ばない	*/
				}
			}

			/* ///  ■純粋な本体判定■  /// */
			idx2 = (GmEmy[ i].aspr->flag & GM_ANM_FLAG_DM_MASK);

			if (idx2 < 7)								/* 7 = 無敵		*/
			{
				memcpy( &tmp, &GmBlkDamage[ idx2], sizeof( SYSRECT));
				en.l = GmEmy[ i].aspr->x - tmp.b;
				en.t = GmEmy[ i].aspr->y + tmp.l;
				en.r = GmEmy[ i].aspr->x - tmp.t;
				en.b = GmEmy[ i].aspr->y + tmp.r;

				if (GmCheckRange( &pl, &en))
				{
					/* ヒット */
					GmPly.aspr->flag &= ~GM_ANM_FLAG_AT_MASK;		/* ﾌﾗｸﾞ消去		*/

					/* ダメージ構造体へ設定 */
					GmDmgInfo[ GmDmgNum].chr  = CHR_PLAYER;			/* 攻撃者			*/
					GmDmgInfo[ GmDmgNum].dchr = i;					/* 受け側ｲﾝﾃﾞｯｸｽ	*/
					GmDmgInfo[ GmDmgNum].acta = GmPly.act;			/* 攻撃act			*/
					GmDmgInfo[ GmDmgNum].actd = GmEmy[ i].act;		/* 受けact			*/
					GmDmgInfo[ GmDmgNum].idx  = 0xff;				/* GmPly = 0xff		*/

					nx = GmPly.aspr->x - GmEmy[ i].aspr->x;
					ny = GmPly.aspr->y - GmEmy[ i].aspr->y;

					/* 受け方向の象限決定 */
					if (nx > ny)
					{
						dir = 3;

						if (nx > -ny)
							dir = 0;
					}
					else
					{
						dir = 2;

						if (nx > -ny)
							dir = 1;
					}

					/* ダメージ受け方向の設定 */
					GmDmgInfo[ GmDmgNum].dir = GmDmgDir[ GmEmy[ i].direct][ dir];
					GmDmgNum++;										/* 加算			*/

#if GM_ATTACK_DEBUG
	DbgPrintPort("< Hit!! >\r\n");
	sprintf( buf, "idx1,idx2::%d,%d\r\n", idx1, idx2);
	DbgPrintPort( buf);
	sprintf( buf, "SRC_DIR::%d,%d\r\n", GmEmy[ i].direct, dir);
	DbgPrintPort( buf);
	sprintf( buf, "DIR::%d\r\n", GmDmgDir[ GmEmy[ i].direct][ dir]);
	DbgPrintPort( buf);
	sprintf( buf, "PLAYER::(%d,%d)-(%d,%d)\r\n", pl.l, pl.t, pl.r, pl.b);
	DbgPrintPort( buf);
	sprintf( buf, "ENEMY ::(%d,%d)-(%d,%d)\r\n", en.l, en.t, en.r, en.b);
	DbgPrintPort( buf);
#endif
				}
			}
		}
	}

#if GM_ATBLK_DEBUG
	if ((GmPly.act & GM_PL_ACT_SWD_MASK) == 0)
	{
		sprite_set_char_location( 127, VRM_BG, 244, 144);
	}
#endif


	return ( ret);
}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：ダメージ演算をします。
		  	：
　履　　歴	：Ver 1.00		2001/01/11		K.Kimura		初版
****************************************************************************** */
u_char	GmCheckDamage( void)
{
	u_char		i, ret;
	char		j, nap;
	u_short		npal;
	u_char		lret;
	u_char		idx, dir;
	short		nx, ny;

	static	DMGINFO		*p;
	static	ENMINFO		*ep;
	static	GMTRSINFO	*trs;



	trs = &GmTrsInfo;
	ret = 0;

	for (i = 0; i < GmDmgNum; i++)
	{
		p = &GmDmgInfo[ i];

		if (p->chr)
		{
			/* ///  ■ ENEMY to PLAYER ■  /// */

			/* ///  正面：1倍、側面：1.5倍、背面：2倍  /// */
/*			nap = (( GmEmyInfo[ p->idx].ap * GmDmgDirRatio[ p->dir]) >> 1);	/* 攻撃力	*/
			nap = GmEmyInfo[ p->idx].ap;

			/*
				盾の防御力＝２
					nap= nap - 2;
				の演算が「必要かどうか」を方向でチェック！
			*/

#if GM_SHIELD_DEBUG
	sprintf( buf, "P_IDX::%d\r\n", p->idx);
	DbgPrintPort( buf);
	sprintf( buf, "E_NAP_BF::%d to %d\r\n", GmEmyInfo[ p->idx].ap, nap);
	DbgPrintPort( buf);
#endif
			/*
				呪文チェック
			*/
			if (p->idx >= GameMng.splIdx)				/* 呪文は GameMng.splIdx 以降	*/
			{
				lret = 1;

				/* ”蛇”判定 */
				if (p->acta != GM_PL_ACT_SNAKE)
				{
					if (p->dir == 0)
					{
						if ((GmPly.act & GM_PL_ACT_ST_MASK) <= GM_PL_ACT_WALK)
						{
							/*
								ダメージを受けても、「防御」は「防御」
							*/
							nap -= GmPlInfo.dp;
							trs->defNum++;
							trs->defSplNum++;

							lret = 0;
						}
					}
				}

				if (lret)
				{
					nap -= GmPlInfo.dp2;

					if (nap <= 0)
						nap = 1;						/* 最低でも１は食らう	*/
				}

				/*
					とりあえず、ヒットしたら消える
				*/
				GmEmy[ p->idx].aspr->mode |= ANM_MODE_END;
				GmEmy[ p->idx].act |= GM_PL_ACT_DEAD;
			}
			else
			{
				/* /// 騎士 or スライム  /// */

				lret = GmCheckShield( p);

				if (lret)
				{
					/*
						ダメージを受けても、「防御」は「防御」
					*/
					nap -= GmPlInfo.dp;
					trs->defNum++;
					trs->defSwdNum++;
				}
				else
				{
					nap -= GmPlInfo.dp2;
				}
			}

			if (nap <= 0)
			{
				/* 攻撃が効いてません！！ */

				/* ＳＥ発音 */
				se_play_n( GMSE_NODAMAGE);
				continue;
			}

#if GM_SHIELD_DEBUG
	sprintf( buf, "E_NAP::%d\r\n", nap);
	DbgPrintPort( buf);
#endif
			GmPlInfo.hp -= nap;									/* HP演算			*/

			if (GmPlInfo.hp < 0)
				GmPlInfo.hp = 0;								/* HP補正			*/

#if GM_DEATHLESS
	/* 擬似無敵(2001/01/20) */
	if ((GmPlInfo.hp == 0) && ((GmPlInfo.item[0] & GM_ITEM_POTION) == 0))
	{
		GmPlInfo.hp = 1;
	}
#endif

			/* 生死判定 */
			if ((GmPlInfo.hp > 0) || (GmPlInfo.item[0] & GM_ITEM_POTION))
			{
				/* ダメージ（パレット判定） */
				GmPlInfo.dcnt = GM_DAMAGE_TIME;
				GmPly.act |= GM_PL_ACT_DAMAGE;

				npal = GmPly.aspr->paln;						/* ﾀﾞﾒｰｼﾞﾊﾟﾚｯﾄ設定	*/
				GmPly.aspr->pal = (0x0800 | ((npal == 0x0800) << 9));

				/* ＳＥ発音 */
				se_play_n( GMSE_DAMAGE);

				ret = 1;

#if GM_DAMAGE_DEBUG
	DbgPrintPort("< GUWA!! >\r\n");
#endif
			}
			else
			{
				/* ///  ダメージ状態のを解除  /// */
				GmPly.aspr->pal = GmPly.aspr->paln;				/* 通常ﾊﾟﾚｯﾄに戻す	*/
				GmPly.act &= ~GM_PL_ACT_DAMAGE;					/* ﾀﾞﾒｰｼﾞ状態解除	*/

				/* 死亡（点滅） */
				GmPlInfo.dcnt = ( GM_DEAD_TIME << 1);
				GmPly.act |= GM_PL_ACT_DEAD;
				GmPly.aspr->mode |= ANM_MODE_STOP;				/* ｱﾆﾒ停止			*/

				/* ///  全敵キャラ表示ＯＦＦ /// */
				for (i = 0; i < GM_FLOOR_ENEMY_MAX; i++)
					GmEmy[ i].aspr->mode |= (ANM_MODE_STOP | ANM_MODE_NODISP);

				/* ＳＥ発音 */
				se_play_n( GMSE_DEAD);

				if (bgm_check())
					bgm_stop();

				GmDispHitPoint( GmPlInfo.hp);
				GmFadeOutPal( GMPAL_BG, 0x04);

				GameMng.flag |= GM_MNGFLAG_GAMEOVER;
#if GM_DAMAGE_DEBUG
	DbgPrintPort("< GAME OVER >\r\n");
#endif
			}
		}
		else
		{
			/* ///  ■ PLAYER to ENEMY ■  /// */

			/*
				１）ＡＰ取得
				２）方向演算によるＡＴ決定
				３）ＨＰ減算
				４）生死判定
				５）各々の処理
					・ダメージ＝パレット反転（タイマー時間）
					・死亡＝点滅（タイマー時間）
			*/

			ep = &GmEmyInfo[ p->dchr];

			/* ///  正面：1倍、側面：1.5倍、背面：2倍  /// */
			nap = (( GmPlInfo.ap * GmDmgDirRatio[ p->dir]) >> 1);

			/* ///  盾判定あり  /// */
			
			/*
				盾の防御力＝２ + algo
					nap= nap - (2 * algo);
				の演算が「必要かどうか」を方向でチェック！
			*/
			lret = GmCheckShield( p);

			if (lret)
				nap -= (GM_SHIELD_POINT + ep->algo);

#if GM_SHIELD_DEBUG
	sprintf( buf, "HP,NAP::%d,%d\r\n", ep->hp, nap);
	DbgPrintPort( buf);
#endif
			if ((GmEmy[ p->dchr].chr == CHR_TESTAROSSA) && (p->dchr < GameMng.splIdx))
			{
#if GM_TESTA_DEBUG
	sprintf( buf, "IROIRO::%d,%2x,%d,%d\r\n", ep->hp, GameMng.floor19, GameMng.fidx, GmEmy[ p->dchr].aspr->anmNo);
	DbgPrintPort( buf);
#endif
				/* ///  リングフラグ判定  /// */
				if ((GameMng.floor19 != 0x05)
					|| ((GameMng.fidx % 3) != 1)
					|| (GmEmy[ p->dchr].aspr->anmNo != EN_A0_05_ANW))
				{
					nap = 0;							/* 効きません		*/

					if (GmEmy[ p->dchr].aspr->anmNo == EN_A0_08_ANW)
					{
						nx = GmEmy[ p->dchr].aspr->x - GmPly.aspr->x;
						ny = GmEmy[ p->dchr].aspr->y - GmPly.aspr->y;

						/* 自分の位置から向きを決定 */
						if (nx > ny)
						{
							dir = 1;						/* ﾌﾟﾚｲﾔｰの左（右を向け）	*/

							if (nx > -ny)
								dir = 3;					/* ﾌﾟﾚｲﾔｰの上（下を向け）	*/
						}
						else
						{
							dir = 0;						/* ﾌﾟﾚｲﾔｰの下（上を向け）	*/

							if (nx > -ny)
								dir = 2;					/* ﾌﾟﾚｲﾔｰの右（左を向け）	*/
						}

						ep->ddir = dir ^ 0x03;
						ep->ccnt = 26;						/* この時間で移動	*/
					}
				}
				else
				{
					nap = 1;
				}
			}

			/* ///  ドラゴンは堅いっす  /// */
			if (GmEmy[ p->dchr].chr == CHR_DRAGON)
				nap = 0;

			if (nap <= 0)
			{
				/* 攻撃が効いてません！！ */

				/* ＳＥ発音 */
				se_play_n( GMSE_NODAMAGE);
				continue;
			}

			ep->hp -= nap;									/* HP減算			*/

			/* 生死判定 */
			if (ep->hp > 0)
			{
				/* ダメージ（パレット判定） */
				ep->dcnt = GM_DAMAGE_TIME;
				GmEmy[ p->dchr].act |= GM_PL_ACT_DAMAGE;

				npal = GmEmy[ p->dchr].aspr->paln;			/* ﾀﾞﾒｰｼﾞﾊﾟﾚｯﾄ設定	*/
				GmEmy[ p->dchr].aspr->pal = (0x0800 | ((npal == 0x0800) << 9));

				/* ＳＥ発音 */
				se_play_n( GMSE_DAMAGE);

#if GM_DAMAGE_DEBUG
	DbgPrintPort("< OUCH!! >\r\n");
#endif
			}
			else
			{
				/* ///  ＥＮＥＭＹ死亡処理  /// */
				GmDeadEnemy( p->dchr, p->acta);

#if GM_DAMAGE_DEBUG
	DbgPrintPort("< DEAD!! >\r\n");
#endif
			}
		}
	}

	return ( ret);
}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：効果アニメーション（ダメージ・パレット反転 etc..）
		  	：のチェック
		  	：
　履　　歴	：Ver 1.00		2001/01/11		K.Kimura		初版
****************************************************************************** */
void	GmCheckEffAnm( void)
{
	static	u_char		i;
	static	GMOBJ		*op;
	static	ENMINFO		*ep;



	/* ///  ■プレイヤー■  /// */
	if (GmPlInfo.dcnt)
		GmPlInfo.dcnt--;

	if (GmPlInfo.ccnt)
		GmPlInfo.ccnt--;

	op = &GmPly;

	if (op->act & GM_PL_ACT_DEAD)
	{
		/* ------------------------ */
		/* 		to GAME OVER		*/
		/* ------------------------ */

		if (GmPlInfo.dcnt)
		{
			op->aspr->mode &= ~ANM_MODE_NODISP;				/* 点滅処理			*/

			if ((GmPlInfo.dcnt >> 2) & 0x01)
				op->aspr->mode |= ANM_MODE_NODISP;			/* 点滅処理			*/
		}
		else
		{
			display_control( 0x0003);						/* ｽﾌﾟﾗｲﾄ OFF		*/

			GmSStepTest = GMT_GAMEOVER;						/* GAME OVER		*/
			VblkMng.loopExit = 1;							/* LOOP脱出			*/

			return;
		}

	}
	else
	{
		/* 死亡以外 */

		/* ///  ■キャンセル可能状態■  /// */
		if ((op->act & GM_PL_ACT_ST2_MASK) == GM_PL_ACT_CANCEL)
		{
			if (GmPlInfo.ccnt & 0x01)
				op->aspr->mode ^= ANM_MODE_NODISP;		/* 点滅処理		*/

			if (GmPlInfo.ccnt == 0)
			{
				/* ///  剣の行動を終了  /// */
				op->aspr->mode &= ~(ANM_MODE_NODISP | ANM_MODE_STOP);
				op->aspr->mode |= ANM_MODE_END;
				op->act &= ~(GM_PL_ACT_ST2_MASK | GM_PL_ACT_SWD_MASK);		/* ｷｬﾝｾﾙ解除	*/
				op->act |= GM_PL_ACT_SWING_VS;			/* 縦斬りを終了したのと同様に修正	*/

				/*
					上で、縦斬り修正状態にしているのは、
					順斬りだと、溜め歩きの状態にもっていけてしまうため。
				*/
			}
		}

		/* ///  ■ダメージ状態■  /// */
		if (op->act & GM_PL_ACT_DAMAGE)
		{
			if (GmPlInfo.dcnt == 0)
			{
				op->aspr->pal = op->aspr->paln;		/* 通常ﾊﾟﾚｯﾄに戻す		*/
				op->act &= ~GM_PL_ACT_DAMAGE;		/* ﾀﾞﾒｰｼﾞ状態解除		*/
			}
		}
		else
		{
			/*
				原因追求するだけ無駄なので、保険処理
			*/
			op->aspr->pal = op->aspr->paln;			/* 通常ﾊﾟﾚｯﾄに戻す		*/
		}
	}


	/* ///  ■敵全部■  /// */
/*	for (i = 0; i < StgMng.ennum; i++)
*/	for (i = 0; i < GM_FLOOR_ENEMY_MAX; i++)
	{

		op = &GmEmy[ i];
		ep = &GmEmyInfo[ i];

		if (op->aspr == NULL)
			continue;

		if (ep->dcnt)
			ep->dcnt--;

		if (ep->ccnt)
			ep->ccnt--;

		if (op->act & GM_PL_ACT_DEAD)
		{
			if (ep->dcnt)
			{
				if (!(ep->dcnt & 0x03))
					op->aspr->mode ^= ANM_MODE_NODISP;		/* 点滅処理		*/
			}
			else
			{
				/* アニメーションＳＴＯＰ＆画面外へ移動 */
				op->aspr->mode |= ANM_MODE_END;

				if (i >= GameMng.splIdx)
					ep->flag = 0x00;						/* 呪文 OFF		*/

				/* ///  ＡＬＬ ＣＬＥＡＲ？  /// */
				if (GameMng.flag & GM_MNGFLAG_ALLCLEAR)
				{
					GmSStepTest = GMT_GAMEEND;
					VblkMng.loopExit = 1;				/* LOOP脱出				*/
				}
			}
		}
		else
		{
			/* 死亡以外 */

			/* ///  ■キャンセル可能状態■  /// */
			if ((op->act & GM_PL_ACT_ST2_MASK) == GM_PL_ACT_CANCEL)
			{
				if (ep->ccnt & 0x01)
					op->aspr->mode ^= ANM_MODE_NODISP;		/* 点滅処理		*/

				if (ep->ccnt == 0)
				{
					/* ///  剣の行動を終了  /// */
					op->aspr->mode &= ~(ANM_MODE_NODISP | ANM_MODE_STOP);
					op->aspr->mode |= ANM_MODE_END;
					op->act &= ~(GM_PL_ACT_ST2_MASK | GM_PL_ACT_SWD_MASK);		/* ｷｬﾝｾﾙ解除	*/

					/* 行動の硬化だよーん */
					ep->nscnt = GM_RIGOR_TIME;
					ep->think = 0;

					ep->cancel = 0;		/* ここかなぁ・・	*/
				}
			}

			if (op->act & GM_PL_ACT_DAMAGE)
			{
				if (op->chr == CHR_MAGICIAN)
					op->aspr->mode &= ~ANM_MODE_NODISP;	/* ﾀﾞﾒｰｼﾞ時は見える		*/

				if (ep->dcnt == 0)
				{
					op->aspr->pal = op->aspr->paln;		/* 通常ﾊﾟﾚｯﾄに戻す		*/
					op->act &= ~GM_PL_ACT_DAMAGE;		/* ﾀﾞﾒｰｼﾞ状態解除		*/
				}
			}
			else
			{
				/*
					原因追求するだけの時間ないので、保険処理
				*/
				op->aspr->pal = op->aspr->paln;			/* 通常ﾊﾟﾚｯﾄに戻す		*/
			}
		}
	}


}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：プレイヤーのパラメータ初期設定です。
		  	：
　履　　歴	：Ver 1.00		2001/01/11		K.Kimura		初版
****************************************************************************** */
void	GmSetParamPlayer( void)
{
	GmPlInfo.mhp = 12;									/* 体力 MAX			*/
	GmPlInfo.hp  = 12;									/* 体力				*/
	GmPlInfo.ap  = 1;									/* base 攻撃力		*/
	GmPlInfo.selItem[ 0] = 0;							/* Light Edge		*/
	GmPlInfo.selItem[ 1] = 0;							/* X4なし			*/

	GmPlInfo.item[ 0] = GM_ITEM_SHIELD_S;				/* Shield			*/
	GmPlInfo.item[ 1] = GM_ITEM_SWORD_00;				/* Light Edge		*/

#if GM_EXIT
	if (PadInfo->pad & KEY_A)
	{
		GmPlInfo.item[ 0] |= GM_ITEM_POTION;
		GmPlInfo.item[ 0] |= GM_ITEM_SPECTACLE;
		GmPlInfo.item[ 0] |= GM_ITEM_JETBOOTS;
		GmPlInfo.item[ 0] |= GM_ITEM_CANDLE;
		GmPlInfo.item[ 0] |= GM_ITEM_GAUNTLET;
		GmPlInfo.item[ 0] |= GM_ITEM_ARMOR;
		GmPlInfo.item[ 0] |= GM_ITEM_HELMET;
		GmPlInfo.item[ 0] |= GM_ITEM_SILVER_RING;
		GmPlInfo.item[ 0] |= GM_ITEM_GOLD_RING;

		GmPlInfo.item[ 1] |= GM_ITEM_SWORD_01;
		GmPlInfo.item[ 1] |= GM_ITEM_SWORD_02;
		GmPlInfo.item[ 1] |= GM_ITEM_SWORD_03;
		GmPlInfo.item[ 1] |= GM_ITEM_HOURGLASS;
		GmPlInfo.item[ 1] |= GM_ITEM_HAMMER;
		GmPlInfo.item[ 1] |= GM_ITEM_WHISTLE;
		GmPlInfo.item[ 1] |= GM_ITEM_WING;
	}
#endif

}


/* ******************************************************************************
　関　　数	：GmMoveEnemy
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：敵の行動ルーチンです。
		  	：キャラ毎に分岐します。
		  	：
　履　　歴	：Ver 1.00		2001/01/15		K.Kimura		初版
****************************************************************************** */
void	GmMoveEnemy( void)
{
	static	u_char		i;


	if (GameMng.flag & GM_MNGFLAG_GAMEOVER)
		return;

	/* ///  アワーグラスは？  /// */
	if (GmPlInfo.flag & GM_PIFLAG_HGLASS)
		return;

	/* ///  ■各キャラクタのアルゴに分岐■  /// */
	for (i = 0; i < StgMng.ennum; i++)
	{
		if (GmEmy[ i].act & GM_PL_ACT_DEAD)
			continue;									/* 死んでます		*/

		( GmMoveEnemyFunc[ GmEmy[ i].chr])( i);
	}
}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：ダミー・ルーチンです。
		  	：
　履　　歴	：Ver 1.00		2001/01/15		K.Kimura		初版
****************************************************************************** */
void	GmMoveENEMY( u_char i)
{
	return;
}


/* ******************************************************************************
　関　　数	：GmMoveKnight
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：騎士系統のルーチンです。
		  	：移動は、回り込みを追加したいよー・
		  	：
　履　　歴	：Ver 1.00		2001/01/15		K.Kimura		初版
****************************************************************************** */
void	GmMoveKnight( u_char i)
{
	static	ENMINFO		*ep;
	static	GMOBJ		*op;
	static	u_char		step, sstep;
	static	u_char		lret;
	static	u_char		dir;
	static	u_short		flag;
	static	short		nx, ny;
	static	u_char		tx, ty;
	static	u_char		ox, oy;
	static	u_char		dis;
	static	short		vx, vy;

	short	kdx, kdy;



	ep = &GmEmyInfo[ i];
	op = &GmEmy[ i];

	/* ///  剣振り中？ /// */

	tx = op->aspr->x;
	ty = op->aspr->y;
	nx = tx - GmPly.aspr->x;
	ny = ty - GmPly.aspr->y;

	dis = 36;	/* 間合い（初期値＝ビビリ） */
	dis -= ( ep->algo << 2);					/* 最強で 24 まで詰める		*/

	if (ep->nscnt)
		ep->nscnt--;							/* 硬化ｶｳﾝﾀ減算		*/

	if (ep->nswd)
		ep->nswd--;								/* 剣禁止ｶｳﾝﾀ減算	*/

	/* ///  思考は決定？ /// */
	if (ep->think == 0)
	{
		/* 自分の位置から向きを決定 */
		if (nx > ny)
		{
			dir = 1;							/* ﾌﾟﾚｲﾔｰの左（右を向け）	*/

			if (nx > -ny)
				dir = 3;						/* ﾌﾟﾚｲﾔｰの上（下を向け）	*/
		}
		else
		{
			dir = 0;							/* ﾌﾟﾚｲﾔｰの下（上を向け）	*/

			if (nx > -ny)
				dir = 2;						/* ﾌﾟﾚｲﾔｰの右（左を向け）	*/
		}

		op->direct = dir;

		if (ep->nscnt)
		{
			/* ///  硬化時間です  ///  */
			ep->think = (GM_EMYTH_THINK | dir);
		}
		/* プレイヤーとの距離は？ */
		else if ((ABS( nx) + ABS( ny)) <= 36)	/* 振り始めは、この距離		*/
		{
			if (ep->nswd == 0)
			{
				/* 攻撃を考えてみようか */
				ep->think = (GM_EMYTH_ATTACK | dir);
			}
			else
			{
				/* /// 進んでちょうだいな /// */
				ep->think = (GM_EMYTH_WALK | dir);
			}
		}
		else
		{
			/* /// 進んでちょうだいな /// */
			ep->think = (GM_EMYTH_WALK | dir);
		}

#if GM_ENEMY_ACT_DEBUG
	DbgPrintPort( "-- thinking time! --\r\n");
	sprintf( buf, "THINK,nx,ny::%2x,%d,%d\r\n", ep->think, nx, ny);
	DbgPrintPort( buf);
#endif
	}

	/* ///  ■各行動分岐■  /// */
	switch (ep->think & GM_EMYTH_ACT_MASK)
	{
		/* ///  ●思考  /// */
		case GM_EMYTH_THINK:					/* 思考（硬化）中	*/
			/* とりあえず静止 */
			ano = EN_E0_00_ANW + op->direct;			/* 静止ｱﾆﾒ			*/
			op->aspr->speed = 3;
			AnmSet( op->aspr, op->chr, ano, 0, ANM_MODE_LOOP);
			op->act &= ~GM_PL_ACT_ST_MASK;
			op->act |= GM_PL_ACT_NORMAL;				/* 静止ﾌﾗｸﾞ			*/

			if (ep->nscnt == 0)
				ep->think = 0;

			break;


		/* ///  ●移動  /// */
		case GM_EMYTH_WALK:
			ano = EN_E0_04_ANW + op->direct;			/* 歩行ｱﾆﾒ					*/

			if (op->aspr->anmNo != ano)
			{
				/* 
					mv パラメータから、アニメスピードを逆算する必要あり！
				*/
				op->aspr->speed = 6;
				AnmSet( op->aspr, op->chr, ano, 0, ANM_MODE_LOOP);

				op->act &= ~(GM_PL_ACT_ST_MASK | GM_PL_ACT_SWD_MASK);
				op->act |= GM_PL_ACT_WALK;						/* 移動ﾌﾗｸﾞ				*/
			}

			/* ///  ある距離以上、近づくな！  /// */
			if ((ABS( nx) + ABS( ny)) < dis)
			{
				ep->think = 0;
				break;
			}

			/* ///  絶対的に剣優先  /// */
			if (((ABS( nx) + ABS( ny)) < 36) && (ep->nswd == 0))
			{
				ep->think = 0;
				break;
			}

			flag = GmGetFlagMAP(((tx - 7) >> 3), (ty >> 3));

			sstep = ep->mv;								/* 基本移動ﾄﾞｯﾄ		*/

			if (flag & GM_MAPFLAG_SAND)
				sstep = ((sstep * 6) / 10);				/* 移動量 60% に			*/

			step = op->mStep + sstep;					/* 移動ﾄﾞｯﾄ					*/
			step = (step >> 4);							/* 固定小数点				*/
			ox = tx;
			oy = ty;

			switch ( op->direct)
			{
				case 0:	tx += step;	break;				/* 上	*/
				case 1:	ty += step;	break;				/* 右	*/
				case 2:	ty -= step;	break;				/* 左	*/
				case 3:	tx -= step;	break;				/* 下	*/
			}

			lret = GmCheckCollisionPlayer( i, &tx, &ty, ox, oy);

			if (lret == 0)
			{
				vx = tx - ox;								/* ﾍﾞｸﾄﾙ取得				*/
				vy = ty - oy;
				flag = 0;

				/* ///  障害物判定＆補正（キャラクタタイプ：０）  /// */
				if (((ox & 0x07) == 0) & (vx != 0))
					flag |= 0x01;								/* X方向演算			*/

				if (((oy & 0x07) == 0) & (vy != 0))
					flag |= 0x10;								/* Y方向演算			*/

				if ( flag)
				{
					lret = GmCheckPosition( &tx, &ty, ox, oy, 1, flag);		/* １を指定	*/
					flag  = GmGetFlagMAP((tx >> 3), (ty >> 3));
/*					flag |= GmGetFlagMAP(((tx - 1) >> 3), (ty >> 3));
*/				}
				else
				{
					/* ///  ■穴チェック■  /// */
					if (GmHolePos.x)							/* 設定＝穴が存在			*/
					{
						/* 穴に落ちましたか？ */
						kdx = ( GmHolePos.x - tx);
						kdy = ( GmHolePos.y - ty);

						if ((ABS( kdx) + ABS( kdy)) <= 6)	/* ﾃｷﾄｰな距離	*/
						{
							/* 落ちました */

							/* ///  ＥＮＥＭＹ死亡処理  /// */
							GmDeadEnemy( i, 0);
							GmTrsInfo.holeNum ++;			/* ここで加算 */
						}
					}
				}

				/* 移動ステップ固定小数点補正 */
				op->mStep = ((op->mStep + sstep) & GM_PL_WALK_STEP_MASK);

				/*
					■アニメーション設定
					  − 斜め移動は常に上下方向のグラフィック。
					  − 既に表示中ならば、アニメーションは変更しない。
				*/
			}

			op->aspr->x = tx;									/* ﾃﾝﾎﾟﾗﾘに取得			*/
			op->aspr->y = ty;

			/*
				軸が近くなったら、その方向への進行をやめる
			*/
			if ((ABS( ny) <= 4) && ((op->direct + 1) & 0x02))
				ep->think = 0;

			if ((ABS( ny) <= 8) && ((ABS( ny) & 0x07) == 0) && ((op->direct + 1) & 0x02))
				ep->think = 0;

			if ((ABS( nx) <= 4) && !((op->direct + 1) & 0x02))
				ep->think = 0;

			if ((ABS( nx) <= 8) && ((ABS( ny) & 0x07) == 0) && !((op->direct + 1) & 0x02))
				ep->think = 0;

			break;


		/* ///  ●攻撃  /// */
		case GM_EMYTH_ATTACK:						/* 攻撃		*/

			if (ep->nswd)
				break;								/* 剣禁止 */

			lret = GmSetSwordMotionE( i);

			switch (lret)
			{
				case 0:
				case 2:
					/* ミスボラシイが、とりあえず静止・・・ */
					ano = EN_E0_00_ANW + op->direct;			/* 静止ｱﾆﾒ			*/
					op->aspr->speed = 3;
					AnmSet( op->aspr, op->chr, ano, 0, ANM_MODE_LOOP);
					op->act &= ~GM_PL_ACT_ST_MASK;
					op->act |= GM_PL_ACT_NORMAL;				/* 静止ﾌﾗｸﾞ			*/

					ep->think = 0;					/* 剣終了 to 思考	*/
					break;
			}
			break;


		default:
			break;
	}

}


/* ******************************************************************************
　関　　数	：GmCheckCollisionEnemy
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：プレイヤーの、敵との衝突判定です。
		  	：
　履　　歴	：Ver 1.00		2001/01/15		K.Kimura		初版
****************************************************************************** */
u_char	GmCheckCollisionEnemy( u_char *tx, u_char *ty, u_char ox, u_char oy)
{
	static	u_char		i;
	static	u_char		lret;
	static	u_char		ex, ey;
	static	SYSRECT		pl, blk, *tmp;


	tmp = &GmBlkColl[ GmBlkType[ 0].cidx];

	pl.l = *tx + tmp->l;
	pl.t = *ty + tmp->t;
	pl.r = *tx + tmp->r;
	pl.b = *ty + tmp->b;

	/* ///  ■各キャラクタのアルゴに分岐■  /// */
	for (i = 0; i < StgMng.ennum; i++)
	{
		if (GmEmy[ i].act & GM_PL_ACT_DEAD)
			continue;									/* 死んでます		*/

		/* 魔法使い用 */
		if ((GmEmy[ i].act & GM_PL_ACT_ST_MASK) >= GM_PL_ACT_APPEAR)
			continue;

		tmp = &GmBlkColl[ GmBlkType[ GmEmy[ i].chr].cidx];
		ex = GmEmy[ i].aspr->x;
		ey = GmEmy[ i].aspr->y;

		blk.l = ex + tmp->l;
		blk.t = ey + tmp->t;
		blk.r = ex + tmp->r;
		blk.b = ey + tmp->b;

		lret = GmCheckRange( &pl, &blk);

		if ( lret)
		{
			*tx = ox;
			*ty = oy;

			return ( 1);
		}
	}

	return ( 0);
}


/* ******************************************************************************
　関　　数	：GmCheckCollisionPlayer
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：敵とプレイヤーの衝突判定です。
		  	：
　履　　歴	：Ver 1.00		2001/01/15		K.Kimura		初版
****************************************************************************** */
u_char	GmCheckCollisionPlayer( u_char idx, u_char *tx, u_char *ty, u_char ox, u_char oy)
{
	static	u_char		i;
	static	u_char		lret;
	static	u_char		ex, ey;
	static	SYSRECT		pl, blk, *tmp;



	tmp = &GmBlkColl[ GmBlkType[ GmEmy[ idx].chr].cidx];
	pl.l = *tx + tmp->l;
	pl.t = *ty + tmp->t;
	pl.r = *tx + tmp->r;
	pl.b = *ty + tmp->b;

	/* ///  ■対プレイヤー■  /// */
	tmp = &GmBlkColl[ GmBlkType[ 0].cidx];
	ex  = GmPly.aspr->x;
	ey  = GmPly.aspr->y;
	blk.l = ex + tmp->l;
	blk.t = ey + tmp->t;
	blk.r = ex + tmp->r;
	blk.b = ey + tmp->b;

	lret = GmCheckRange( &pl, &blk);

	if ( lret)
	{
		*tx = ox;
		*ty = oy;

		return ( 1);
	}

	/* ///  ■対ＥＮＥＭＹ■  /// */
	for (i = 0; i < StgMng.ennum; i++)
	{
		if (i == idx)
			continue;

		if (GmEmy[ i].act & GM_PL_ACT_DEAD)
			continue;									/* 死んでます		*/

		/* 魔法使い用 */
		if ((GmEmy[ i].act & GM_PL_ACT_ST_MASK) >= GM_PL_ACT_APPEAR)
			continue;

		tmp = &GmBlkColl[ GmBlkType[ GmEmy[ i].chr].cidx];
		ex = GmEmy[ i].aspr->x;
		ey = GmEmy[ i].aspr->y;

		blk.l = ex + tmp->l;
		blk.t = ey + tmp->t;
		blk.r = ex + tmp->r;
		blk.b = ey + tmp->b;

		lret = GmCheckRange( &pl, &blk);

		if ( lret)
		{
			*tx = ox;
			*ty = oy;
#if 0
	sprintf( buf, "CHR::%d to %d\r\n", idx, i);
	DbgPrintPort( buf);
	sprintf( buf, "( JIBUN )::(%d,%d)-(%d,%d)\r\n", pl.l, pl.t, pl.r, pl.b);
	DbgPrintPort( buf);
	sprintf( buf, "( AITE  )::(%d,%d)-(%d,%d)\r\n", blk.l, blk.t, blk.r, blk.b);
	DbgPrintPort( buf);
#endif
			return ( 1);
		}
	}

	return ( 0);
}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：剣を振ります
		  	：
　履　　歴	：Ver 1.00		2001/01/04		K.Kimura		初版
****************************************************************************** */
u_char	GmSetSwordMotionE( u_char idx)
{
	static	GMOBJ		*ep;
	static	u_char		ba;
	static	u_short		flag;
	u_char	algo;


	ep = &GmEmy[ idx];
	algo = GmEmyInfo[ idx].algo;

	if (ep->act & GM_PL_ACT_CANCEL)
	{
		/*
			アルゴ２以上は、キャンセルをかけてくる
		*/
		if (algo >= 2)
		{
			/* 1 or 2 回 */
			if (GmEmyInfo[ idx].cancel < (algo - 1))
			{
#if GM_CANCEL_DEBUG
	DbgPrintPort("---- < ENEMY_CANCEL!! >\r\n");
#endif
				/* ///  剣の行動を終了  /// */
				ep->aspr->mode |= ANM_MODE_END;
				ep->act &= ~GM_PL_ACT_MASK_03;			/* ｷｬﾝｾﾙ解除	*/
				ep->act |= GM_PL_ACT_NORMAL;			/* 静止ﾌﾗｸﾞ（形式上）*/

				GmEmyInfo[ idx].nscnt = 25;				/* 25V 待て			*/
				GmEmyInfo[ idx].nswd = 0;				/* 剣禁止時間の設定	*/
				GmEmyInfo[ idx].cancel ++;

				return ( 2);							/* ｷｬﾝｾﾙ		*/
			}
		}
	}

	if (ep->aspr->mode & ANM_MODE_END)
	{
		if (ep->act & GM_PL_ACT_SWORD)
		{
			/* ///  剣振りが終了のため、静止状態に移行  /// */
			ep->act &= ~GM_PL_ACT_MASK_ALL;
			ep->act |= GM_PL_ACT_NORMAL;			/* 静止ﾌﾗｸﾞ		*/

			GmEmyInfo[ idx].nswd = 70 - ((algo + 1) << 3);		/* 剣禁止時間の設定	*/
			GmEmyInfo[ idx].cancel = 0;

			return ( 0);							/* 剣終了		*/
		}
	}

	/* ///  ■剣斬りチェック  /// */
	if (ep->act & GM_PL_ACT_SWORD)
		return ( 1);

	/*
		状況、アルゴリズムにより、剣の振りを分岐。
		ランダムは禁止！！
	*/
	GmTmpVals = ( GmPly.aspr->x - ep->aspr->x);

	if (ABS( GmTmpVals) <= 4)
	{
		switch (GmEmyInfo[ idx].algo)
		{
			case 0:
				/* ///  ■横斬り  /// */
				ba = EN_E0_12_ANW;							/* ofs = 12		*/
				flag = GM_PL_ACT_SWING_S;
				break;

			case 1:
				/* ///  ■弱突き  /// */
				ba = EN_E0_16_ANW;							/* ofs = 16		*/
				flag = GM_PL_ACT_SWING_VS;
				break;

			default:
				if (GmPly.direct != (ep->direct ^ 0x03))
				{
					/*
						正面対峙じゃなければ、強突き
					*/

					/* ///  ■強突き  /// */
					ba = EN_E0_08_ANW;						/* ofs = 8		*/
					flag = GM_PL_ACT_SWING_VS;
				}
				else
				{
					if (GmTmpVals & 0x0002)
					{
						/* ///  ■弱突き  /// */
						ba = EN_E0_16_ANW;						/* ofs = 16		*/
						flag = GM_PL_ACT_SWING_VS;
					}
					else
					{
						/* ///  ■正面＆横斬り  /// */
						ba = EN_E0_12_ANW;							/* ofs = 12		*/
						flag = GM_PL_ACT_SWING_S;
					}
				}
				break;
		}
	}
	else
	{
		GmTmpVals = ( GmPly.aspr->y - ep->aspr->y);

		if (ABS( GmTmpVals) <= 4)
		{
			switch (GmEmyInfo[ idx].algo)
			{
				case 0:
					/* ///  ■横斬り  /// */
					ba = EN_E0_12_ANW;							/* ofs = 12		*/
					flag = GM_PL_ACT_SWING_S;
					break;

				case 1:
					/* ///  ■弱突き  /// */
					ba = EN_E0_16_ANW;							/* ofs = 16		*/
					flag = GM_PL_ACT_SWING_VS;
					break;

				default:
					if (GmPly.direct != (ep->direct ^ 0x03))
					{
						/*
							正面対峙じゃなければ、強突き
						*/

						/* ///  ■強突き  /// */
						ba = EN_E0_08_ANW;						/* ofs = 8		*/
						flag = GM_PL_ACT_SWING_VS;
					}
					else
					{
						if (GmTmpVals & 0x0002)
						{
							/* ///  ■弱突き  /// */
							ba = EN_E0_16_ANW;						/* ofs = 16		*/
							flag = GM_PL_ACT_SWING_VS;
						}
						else
						{
							/* ///  ■正面＆横斬り  /// */
							ba = EN_E0_12_ANW;							/* ofs = 12		*/
							flag = GM_PL_ACT_SWING_S;
						}
					}
					break;
			}
		}
		else
		{
			/* ///  ■横斬り  /// */
			ba = EN_E0_12_ANW;							/* ofs = 12		*/
			flag = GM_PL_ACT_SWING_S;
		}
	}

	if (GmEmyInfo[ idx].cancel)
	{
		/* ///  キャンセル技は、強制で横斬り  /// */
		ba = EN_E0_12_ANW;							/* ofs = 12		*/
		flag = GM_PL_ACT_SWING_S;
	}

	/*
		ベース・スピードは、アルゴリズムにより変更
	*/
	ep->aspr->speed = ( 15 - ( GmEmyInfo[ idx].algo * 3));
	ano = ( ba + ep->direct);

#if GM_ENEMY_ACT_DEBUG
	sprintf( buf, "CHR,ANO::%d,%d\r\n", ep->chr, ano);
	DbgPrintPort( buf);
#endif

	AnmSet( ep->aspr, ep->chr, ano, 0, 0);

	/* ///  剣フラグ  /// */
	ep->act &= ~GM_PL_ACT_MASK_ALL;
	ep->act |= (GM_PL_ACT_SWORD | flag);

	/* ＳＥ発音 */
	GmTmpVal = ( flag >> 9) + GMSE_SWD_01;
	se_play_n( GmTmpVal);


	return ( 1);									/* 剣振り中		*/
}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：ダメージ演算をします。
		  	：to プレイヤーです。
		  	：
　履　　歴	：Ver 1.00		2001/01/17		K.Kimura		初版
****************************************************************************** */
void	GmJudgeAtEnemy( void)
{
	static	u_char		i;
	static	u_char		idx1, idx2, dir;
	static	short		nx, ny;
	static	SYSRECT		pl, en, tmp;
	static	GMOBJ		*op;



	/* ///  アワーグラスは？  /// */
	if (GmPlInfo.flag & GM_PIFLAG_HGLASS)
		return;

	/* ///  存在する全敵分ループ  /// */
/*	for (i = 0; i < StgMng.ennum; i++)
*/	for (i = 0; i < GM_FLOOR_ENEMY_MAX; i++)
	{
		op = &GmEmy[ i];

		if (op->aspr == NULL)
			continue;

		/*
			ENEMY 生死判定 to continue
		*/
		if (op->act & GM_PL_ACT_DEAD)
			continue;

		/* 魔法使い用（イレギュラーな処理）*/
		if (i < GameMng.splIdx)								/* 呪文は splIdx 以降	*/
		{
			if ((GmEmy[ i].act & GM_PL_ACT_ST_MASK) >= GM_PL_ACT_APPEAR)
				continue;
		}
		else
		{
			if ((GmEmyInfo[ i].flag & 0x01) == 0)
				continue;									/* 呪文 OFF		*/
		}

		idx1 = ((op->aspr->flag & GM_ANM_FLAG_AT_MASK) >> 8);

		/* ///  現在のアニメが攻撃判定を持っているか？  /// */
		if (idx1)
		{
#if GM_ENMCDMG_DEBUG
	DbgPrintPort("-- ATTACK! --\r\n");
#endif

			memcpy( &tmp, &GmBlkAttack[ idx1], sizeof( SYSRECT));

#if GM_ENMCDMG_DEBUG
	sprintf( buf, "( IDX )::%d\r\n", idx1);
	DbgPrintPort( buf);
	sprintf( buf, "( TMP )::(%d,%d)-(%d,%d)\r\n", tmp.l, tmp.t, tmp.r, tmp.b);
	DbgPrintPort( buf);
#endif
			pl.l = op->aspr->x - tmp.b;
			pl.t = op->aspr->y + tmp.l;
			pl.r = op->aspr->x - tmp.t;
			pl.b = op->aspr->y + tmp.r;

#if GM_ENMCDMG_DEBUG
	sprintf( buf, "( PL_PO )::(%d,%d)\r\n", op->aspr->x, op->aspr->y);
	DbgPrintPort( buf);
	sprintf( buf, "( PL_AF )::(%d,%d)-(%d,%d)\r\n", pl.l, pl.t, pl.r, pl.b);
	DbgPrintPort( buf);
#endif
			/*
				【 PLAYER と当たり判定 】
					− ダメージフラグを設定（方向＆攻撃値）
					− 内部的なポイント加算（段位認定）
					− 攻撃フラグの消去（連続で何度も当たらないように）
			*/

			idx2 = (GmPly.aspr->flag & GM_ANM_FLAG_DM_MASK);

			if (idx2 < 7)								/* 7 = 無敵		*/
			{
				memcpy( &tmp, &GmBlkDamage[ idx2], sizeof( SYSRECT));
				en.l = GmPly.aspr->x - tmp.b;
				en.t = GmPly.aspr->y + tmp.l;
				en.r = GmPly.aspr->x - tmp.t;
				en.b = GmPly.aspr->y + tmp.r;

				if (GmCheckRange( &pl, &en))
				{
					/* ヒット */
					op->aspr->flag &= ~GM_ANM_FLAG_AT_MASK;		/* ﾌﾗｸﾞ消去			*/

					/* ダメージ構造体へ設定 */
					GmDmgInfo[ GmDmgNum].chr  = op->chr;			/* 攻撃者			*/
					GmDmgInfo[ GmDmgNum].dchr = 0;					/* 受け側ｲﾝﾃﾞｯｸｽ	*/
					GmDmgInfo[ GmDmgNum].acta = op->act;			/* 攻撃act			*/
					GmDmgInfo[ GmDmgNum].actd = GmPly.act;			/* 受けact			*/
					GmDmgInfo[ GmDmgNum].idx  = i;					/* GmEmy ｲﾝﾃﾞｯｸｽ	*/

					/*
						受け側インデックスは、攻撃者が０以上の場合、
						強制的にプレイヤー対象となるので、関係ない。
						よって、０が設定されている。
					*/

					nx = op->aspr->x - GmPly.aspr->x;
					ny = op->aspr->y - GmPly.aspr->y;

					/* 受け方向の象限決定 */
					if (nx > ny)
					{
						dir = 3;

						if (nx > -ny)
							dir = 0;
					}
					else
					{
						dir = 2;

						if (nx > -ny)
							dir = 1;
					}

					/* ダメージ受け方向の設定 */
					GmDmgInfo[ GmDmgNum].dir = GmDmgDir[ GmPly.direct][ dir];
					GmDmgNum++;										/* 加算			*/

#if GM_ENMHIT_DEBUG
	DbgPrintPort("< Hit!! >\r\n");
	sprintf( buf, "i, nscnt, nswd::%d,%d,%d\r\n", i, GmEmyInfo[ i].nscnt, GmEmyInfo[ i].nswd);
	DbgPrintPort( buf);
	sprintf( buf, "idx1,idx2::%d,%d\r\n", idx1, idx2);
	DbgPrintPort( buf);
	sprintf( buf, "SRC_DIR::%d,%d\r\n", GmPly.direct, dir);
	DbgPrintPort( buf);
	sprintf( buf, "DIR::%d\r\n", GmDmgDir[ GmPly.direct][ dir]);
	DbgPrintPort( buf);
	sprintf( buf, "PLAYER::(%d,%d)-(%d,%d)\r\n", pl.l, pl.t, pl.r, pl.b);
	DbgPrintPort( buf);
	sprintf( buf, "ENEMY ::(%d,%d)-(%d,%d)\r\n", en.l, en.t, en.r, en.b);
	DbgPrintPort( buf);
#endif
				}
			}
		}
	}
}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：ダメージ演算をします。
		  	：to プレイヤーです。
		  	：
　履　　歴	：Ver 1.00		2001/01/17		K.Kimura		初版
****************************************************************************** */
u_char	GmCheckShield( DMGINFO	*p)
{
	static	u_char		ret;
	static	u_char		alrh, dlrh;



	ret = 0;

	/* ///  受け側：状態判定  /// */

#if GM_SHIELD_DEBUG
	sprintf( buf, "ACTD::%x\r\n", (p->actd & GM_PL_ACT_ST_MASK));
	DbgPrintPort( buf);
#endif
	/* 相手は、歩きor静止？ */
	if ((p->actd & GM_PL_ACT_ST_MASK) > GM_PL_ACT_WALK)
	{
		return ( 0);				/* HIT !!			*/
	}

	/* ///  攻撃側：利き腕設定  /// */
	switch (p->chr)
	{
		/* ///  盾判定あり  /// */
		case CHR_PLAYER:
			alrh = 0;					/* 右利き			*/

			/* ///  受け側：利き腕設定  /// */
			switch (GmEmy[ p->dchr].chr)
			{
				/* ///  盾判定あり  /// */
				case CHR_KNIGHT1:
				case CHR_KNIGHT2:
				case CHR_KNIGHT3:
					dlrh = 0;					/* 右利き	*/
					break;

				case CHR_KNIGHT1_L:
				case CHR_KNIGHT2_L:
				case CHR_KNIGHT3_L:
					dlrh = 1;					/* 左利き	*/
					break;

				/* ///  騎士系統じゃなければ、ＡＬＬヒット！  /// */
				default:
#if GM_SHIELD_DEBUG
	DbgPrintPort("0..\r\n");
#endif
					return ( 0);				/* HIT!!	*/
			}
			break;

		case CHR_KNIGHT1:
		case CHR_KNIGHT2:
		case CHR_KNIGHT3:
			alrh = 0;					/* 右利き			*/
			dlrh = 0;					/* 右利き（ﾌﾟﾚｲﾔｰ）	*/
			break;

		case CHR_KNIGHT1_L:
		case CHR_KNIGHT2_L:
		case CHR_KNIGHT3_L:
			alrh = 1;					/* 左利き	*/
			dlrh = 0;					/* 右利き（ﾌﾟﾚｲﾔｰ）	*/
			break;

		/* ///  騎士系統じゃなければ、ＡＬＬヒット！  /// */
		default:
#if GM_SHIELD_DEBUG
	DbgPrintPort("1..\r\n");
#endif
			return ( 0);				/* HIT!!	*/
	}

	/*
		攻撃側、受け側の利き腕が設定されている
	*/
	switch (p->acta & GM_PL_ACT_SWD_MASK)
	{
		/* 順斬り */
		case GM_PL_ACT_SWING_S:
			if (alrh == 0)
			{
				if (dlrh == 0)
				{
					/* 右利き */
					if (p->dir == 2)
						ret = 1;				/* 防御	*/
				}
				else
				{
					/* 左利き */
					if (p->dir == 0)
						ret = 1;				/* 防御	*/
				}
				break;
			}

			/*
				順斬りなのに「左利き」なので、逆斬りと同様の処理にスルー
			*/

		/* 逆斬り */
		case GM_PL_ACT_SWING_IS:
			if (dlrh == 0)
			{
				/* 右利き */
				if (p->dir == 0)
					ret = 1;				/* 防御	*/
			}
			else
			{
				/* 左利き */
				if (p->dir == 1)
					ret = 1;				/* 防御	*/
			}
			break;

		/* 縦斬り（突き） */
		case GM_PL_ACT_SWING_VS:
			if (p->dir == 0)
				ret = 1;					/* 防御	*/
			break;
	}

#if GM_SHIELD_DEBUG
	sprintf( buf, "LRH_A,D::%d,%d\r\n", alrh, dlrh);
	DbgPrintPort( buf);
	sprintf( buf, "ACTA::%x\r\n", (p->acta & GM_PL_ACT_SWD_MASK));
	DbgPrintPort( buf);
	sprintf( buf, "DIR::%d\r\n", p->dir);
	DbgPrintPort( buf);
	sprintf( buf, "RET::%d\r\n", ret);
	DbgPrintPort( buf);
#endif

	return ( ret);
}


/* ******************************************************************************
　関　　数	：GmMoveKnight
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：騎士系統のルーチンです。
		  	：移動は、回り込みを追加したいよー・
		  	：
　履　　歴	：Ver 1.00		2001/01/15		K.Kimura		初版
****************************************************************************** */
void	GmMoveMagician( u_char i)
{
	static	ENMINFO		*ep;
	static	GMOBJ		*op;
	static	u_char		dir;
	static	short		nx, ny;
	static	u_char		tx, ty;
	static	u_char		dis;



	ep = &GmEmyInfo[ i];
	op = &GmEmy[ i];

	if (ep->nscnt)
		ep->nscnt--;								/* ｶｳﾝﾀ減算		*/

#if GM_MAGICIAN_DEBUG
/*	sprintf( buf, "THINK,NSCNT::%x,%d\r\n", ep->think, ep->nscnt);
	DbgPrintPort( buf);
*/
#endif

	/* ///  出現中？  /// */
	if ( ep->think == 0)
	{
		/*
			休憩時間？
		*/

		if (ep->nscnt == 0)
		{
			/* ///  「蛇」使いは笛に弱い  /// */
			if (ep->algo & 0x01)
			{
				if (GameMng.flag & GM_MNGFLAG_WHISTLE)
					return;								/* なんだ笛かよ	*/
			}

			/* 出現ＯＫ */

			/*
				プレイヤーの移動がトリガー
			*/
			if ((GmPly.act & GM_PL_ACT_ST_MASK) == GM_PL_ACT_WALK)
			{
				/* 歩行なら出現！ */

				/*
					出現座標の決定
						- 状況による出現位置の設定を行う

					が、今は距離 GM_MAG_APPDIS の適当な位置
				*/
#if GM_MAGICIAN_DEBUG
	DbgPrintPort("< APPEAR!! >\r\n");
#endif
				if (GmSetAppPoint( i, &tx, &ty))
				{
					tx = (tx << 3);
					ty = (ty << 3);
					op->aspr->x = tx;
					op->aspr->y = ty;

					nx = tx - GmPly.aspr->x;
					ny = ty - GmPly.aspr->y;

					/* 自分の位置から向きを決定 */
					if (nx > ny)
					{
						dir = 1;						/* ﾌﾟﾚｲﾔｰの左（右を向け）	*/

						if (nx > -ny)
							dir = 3;					/* ﾌﾟﾚｲﾔｰの上（下を向け）	*/
					}
					else
					{
						dir = 0;						/* ﾌﾟﾚｲﾔｰの下（上を向け）	*/

						if (nx > -ny)
							dir = 2;					/* ﾌﾟﾚｲﾔｰの右（左を向け）	*/
					}

					op->direct = dir;
					ep->think = (GM_EMYTH_APPEAR | dir);		/* 行動：出現		*/

#if GM_MAGICIAN_DEBUG
	sprintf( buf, "TX,TY::(%d,%d)\r\n", tx, ty);
	DbgPrintPort( buf);
#endif
					op->aspr->anmNo = 0xff;
				}
			}
		}
	}

	tx = op->aspr->x;
	ty = op->aspr->y;

	dis = 40;	/* 間合い（初期値＝ビビリ） */


	/* ///  ■各行動分岐■  /// */
	switch (ep->think & GM_EMYTH_ACT_MASK)
	{
		/* ///  ●思考  /// */
		case GM_EMYTH_THINK:					/* 思考（硬化）中	*/
			break;


		/* ///  ●攻撃  /// */
		case GM_EMYTH_ATTACK:					/* 攻撃		*/
			/* アニメ終了チェック */
			if (op->aspr->mode & ANM_MODE_END)
			{
				/* さて、消えましょうか */

				op->aspr->speed = 12;

				op->act &= ~GM_PL_ACT_ST_MASK;
				op->act |= GM_PL_ACT_DISAPPEAR;			/* 消滅ﾌﾗｸﾞ	*/

				ano = EN_D0_12_ANW + op->direct;		/* 隠滅ｱﾆﾒ	*/
				AnmSet( op->aspr, op->chr, ano, 0, 0);

				ep->think = GM_EMYTH_DISAPP;			/* to 消滅	*/
			}
			else
			{
				/* ///  ■ 呪文発射？ ■  /// */
				if ((op->aspr->motNo == 2) && ((GmEmyInfo[i + 4].flag & 0x01) == 0) && (op->aspr->time == 1))
				{
					if (ep->algo & 0x01)
					{
						ano = EN_D0_24_ANW + op->direct;		/* 蛇  ｱﾆﾒ	*/
						GmEmyInfo[ i + 4].flag  = 0x80;			/* 蛇		*/
						GmEmy[ i + 4].act = GM_PL_ACT_SNAKE;

						se_play_n( GMSE_SPELL02);				/* SE		*/
					}
					else
					{
						ano = EN_D0_20_ANW + op->direct;		/* 呪文ｱﾆﾒ	*/
						GmEmyInfo[ i + 4].flag  = 0x00;			/* 呪文		*/
						GmEmy[ i + 4].act = GM_PL_ACT_SPELL;

						se_play_n( GMSE_SPELL01);				/* SE		*/
					}

#if GM_MAGIC_DEBUG
	sprintf( buf, "SPELL!!::%d,%d\r\n", i, ano);
	DbgPrintPort( buf);
#endif
					AnmSet( GmEmy[ i + 4].aspr, op->chr, ano, 0, ANM_MODE_LOOP);
					GmEmy[ i + 4].aspr->x = tx;
					GmEmy[ i + 4].aspr->y = ty;
					GmEmy[ i + 4].direct  = op->direct;

					GmEmyInfo[ i + 4].hp    = 0x01;				/* 蛇用		*/
					GmEmyInfo[ i + 4].flag |= 0x01;				/* 呪文 ON	*/
				}
			}
			break;


		case GM_EMYTH_APPEAR:					/* 出現中			*/
			if (op->aspr->anmNo == 0xff)
			{
				op->aspr->speed = 12;
				ano = EN_D0_08_ANW + op->direct;		/* 出現ｱﾆﾒ	*/
				AnmSet( op->aspr, op->chr, ano, 0, 0);

				op->act &= ~GM_PL_ACT_ST_MASK;
				op->act |= GM_PL_ACT_APPEAR;			/* 出現ﾌﾗｸﾞ	*/
			}
			else
			{
				/* アニメ終了チェック */
				if (op->aspr->mode & ANM_MODE_END)
				{
					op->aspr->speed = 12;
					op->act &= ~GM_PL_ACT_ST_MASK;

					nx = tx - GmPly.aspr->x;
					ny = ty - GmPly.aspr->y;

					/* プレイヤーとの距離は？ */
					if ((ABS( nx) + ABS( ny)) >= dis)
					{
						/* 攻撃してみようか */

						ano = EN_D0_16_ANW + op->direct;		/* 出現ｱﾆﾒ	*/
						op->act |= GM_PL_ACT_ATTACK;			/* 攻撃ﾌﾗｸﾞ	*/
						ep->think = GM_EMYTH_ATTACK;			/* to 攻撃	*/
					}
					else
					{
						/* うわっ近いじゃん！！ */

						ano = EN_D0_12_ANW + op->direct;		/* 隠滅ｱﾆﾒ	*/
						op->act |= GM_PL_ACT_DISAPPEAR;			/* 消滅ﾌﾗｸﾞ	*/
						ep->think = GM_EMYTH_DISAPP;			/* to 消滅	*/
					}

					AnmSet( op->aspr, op->chr, ano, 0, 0);
				}
			}
			break;


		case GM_EMYTH_DISAPP:					/* 消え中			*/
			/* アニメ終了チェック */
			if (op->aspr->mode & ANM_MODE_END)
			{
				op->act &= ~GM_PL_ACT_ST_MASK;
				op->act |= GM_PL_ACT_NODISP;		/* 隠滅ﾌﾗｸﾞ			*/

				ep->think = 0;						/* to 思考			*/
				ep->nscnt = GM_MAG_RIGOR_TIME;
			}
			break;


		default:
			break;
	}

}


/* ******************************************************************************
　関　　数	：GmSetAppPoint
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：魔法使い出現位置決定ーチンです。
		  	：
　履　　歴	：Ver 1.00		2001/01/17		K.Kimura		初版
****************************************************************************** */
u_char	GmSetAppPoint( u_char idx, u_char *tx, u_char *ty)
{
	static	char		i, j, k;
	static	GMOBJ		*op;
	static	short		px, py, ex, ey;
	static	short		abx, aby;
	static	u_short		flag;
	static	GMAPPTABLE	*ptr;


	/* ///  方向別に設定  /// */

	/* ///  背後方向３段階（マス分ね） /// */

	ptr = &GmAppTable[ GmPly.direct][ 0];

	for (k = 3; k >= 0; k--)
	{
		/* ///  ■各攻撃方向における基準座標■  /// */
		px = ( GmPly.aspr->x >> 3) + ( ptr[ k].dx * GM_MAG_APPDIS);
		py = ( GmPly.aspr->y >> 3) + ( ptr[ k].dy * GM_MAG_APPDIS);

#if GM_MAGICIAN_DEBUG
	sprintf( buf, "-- PX,PY::(%d,%d)\r\n", px, py);
	DbgPrintPort( buf);
#endif

		/* ///  距離３マス分検索  /// */
		for (i = 0; i < 3; i++)
		{
			if ((px | py) <= 0)
				continue;

			if (px > (GM_SCREEN_AREA_EXC - 4))
				continue;

			if (py > (GM_SCREEN_AREA_EYC - 2))
				continue;

#if GM_MAGICIAN_DEBUG
	sprintf( buf, "  .. PX,PY::(%d,%d)\r\n", px, py);
	DbgPrintPort( buf);
#endif

/*			flag  = GmGetFlagMAP( px, py);
			flag |= GmGetFlagMAP( px, (py - 1));
*/			flag  = GmGetFlagMAP((px - 1), py);
			flag |= GmGetFlagMAP((px - 1), (py - 1));

#if GM_MAGICIAN_DEBUG
	sprintf( buf, "  .. FLAG::%x\r\n", flag);
	DbgPrintPort( buf);
#endif
			if ((flag & GM_MAPFLAG_BLOCK) == 0)
			{
				/* ///  全敵キャラとの座標判定  /// */
				for (j = 0; j < StgMng.ennum; j++)
				{
					if (j == idx)
						continue;							/* 自分は除外（一応）	*/

					op = &GmEmy[ j];
					ex = (op->aspr->x >> 3);
					ey = (op->aspr->y >> 3);

					abx = (px - ex);
					aby = (py - ey);

#if GM_MAGICIAN_DEBUG
	sprintf( buf, "  .. EX,EY::(%d,%d)\r\n", ex, ey);
	DbgPrintPort( buf);
	sprintf( buf, "  .. ABS::%d\r\n", (ABS(abx) + ABS(aby)));
	DbgPrintPort( buf);
#endif
					if ((ABS(abx) + ABS(aby)) <= 2)
						break;
				}

#if GM_MAGICIAN_DEBUG
	sprintf( buf, "  .. J,ENUM::%d,%d\r\n", j, StgMng.ennum);
	DbgPrintPort( buf);
#endif
				if (j == StgMng.ennum)
				{
					/* ///  ここに決定  /// */
					*tx  = px;
					*ty  = py;

					return ( 1);							/* あったよー	*/
				}
			}

			px += ptr[ k].dx;
			py += ptr[ k].dy;
		}
	}


	return ( 0);									/* もうちょい待ってみて	*/
}


/* ******************************************************************************
　関　　数	：GmMoveSpell
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：スペル動作ルーチンです。
		  	：
　履　　歴	：Ver 1.00		2001/01/17		K.Kimura		初版
****************************************************************************** */
void	GmMoveSpell( void)
{
	static	GMOBJ		*op;
	static	ENMINFO		*ep;
	static	char		dx, dy;
	static	char		i;


	/* ///  ■呪文番号は、これ以外ありえない■  /// */
	for (i = GameMng.splIdx; i < GM_FLOOR_ENEMY_MAX; i++)
	{
		op = &GmEmy[ i];
		ep = &GmEmyInfo[ i];

		if (op->act & GM_PL_ACT_DEAD)
			continue;								/* 蛇用			*/

		if (ep->flag & 0x01)
		{
			/* 呪文機能ＯＮ */

			dx = GmAppTable[ 0][ op->direct].dx;	/* ﾍﾞｸﾄﾙ取得	*/
			dy = GmAppTable[ 0][ op->direct].dy;
			op->aspr->x += ep->mv * dx;				/* 座標更新		*/
			op->aspr->y += ep->mv * dy;

			if (ep->algo < 2)
			{
				/*
					呪文は壁止まりだよ
				*/
				if (GmGetFlagMAP((op->aspr->x >> 3), (op->aspr->y >> 3)) & GM_MAPFLAG_BLOCK)
					ep->flag = 0x00;				/* 呪文 OFF		*/
			}

			if ( dx)
			{
				if ((op->aspr->x < GM_SCREEN_AREA_SX) || (op->aspr->x > GM_SCREEN_AREA_EX))
					ep->flag = 0x00;				/* 呪文 OFF		*/
			}
			else
			{
				if ((op->aspr->y < GM_SCREEN_AREA_SY) || (op->aspr->y > GM_SCREEN_AREA_EY))
					ep->flag = 0x00;				/* 呪文 OFF		*/
			}

			/* ///  アニメの終了  /// */
			if ((ep->flag & 0x01) == 0)
			{
				op->aspr->mode = ANM_MODE_END;
			}
		}
	}

}


/* ******************************************************************************
　関　　数	：GmMoveSlime
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：スライムのルーチンです。
		  	：
　履　　歴	：Ver 1.00		2001/01/18		K.Kimura		初版
****************************************************************************** */
void	GmMoveSlime( u_char i)
{
	static	ENMINFO		*ep;
	static	GMOBJ		*op;
	static	u_char		tx, ty;

	u_char		step, sstep;
	u_char		lret;
	u_char		dir;
	u_short		flag;
	short		nx, ny;
	u_char		ox, oy;
	u_char		dis;
	short		vx, vy;



	ep = &GmEmyInfo[ i];
	op = &GmEmy[ i];

	if (ep->nscnt)
		ep->nscnt--;								/* ｶｳﾝﾀ減算		*/

#if GM_SLIME_DEBUG
#endif

	tx = op->aspr->x;
	ty = op->aspr->y;
	nx = tx - GmPly.aspr->x;
	ny = ty - GmPly.aspr->y;

	dis = 24 - (ep->algo << 1);			/* 間合い（初期値＝ビビリ） */

	/* ///  思考チェック？  /// */
	if ( ep->think == 0)
	{
		/*
			休憩時間？
		*/

		if (ep->nscnt == 0)
		{
			/* 行動ＯＫ */

			/* 自分の位置から向きを決定 */
			if (nx > ny)
			{
				dir = 1;						/* ﾌﾟﾚｲﾔｰの左（右を向け）	*/

				if (nx > -ny)
					dir = 3;					/* ﾌﾟﾚｲﾔｰの上（下を向け）	*/
			}
			else
			{
				dir = 0;						/* ﾌﾟﾚｲﾔｰの下（上を向け）	*/

				if (nx > -ny)
					dir = 2;					/* ﾌﾟﾚｲﾔｰの右（左を向け）	*/
			}

			op->direct = dir;

			/* プレイヤーとの距離は？ */
			if ((ABS( nx) + ABS( ny)) <= dis)
			{
				/* 攻撃を考えてみようか */
				ep->think = (GM_EMYTH_ATTACK | dir);

				ano = EN_B0_01_ANW + op->direct;		/* 攻撃ｱﾆﾒ			*/
				op->aspr->speed = 9;
				AnmSet( op->aspr, op->chr, ano, 0, 0);

				op->act &= ~GM_PL_ACT_ST_MASK;
				op->act |= GM_PL_ACT_ATTACK;			/* 静止ﾌﾗｸﾞ			*/
			}
			else
			{
				/* /// 進んでちょうだいな /// */
				ep->think = (GM_EMYTH_WALK | dir);
				ep->sx = tx;					/* 初期座標を記憶			*/
				ep->sy = ty;

				ep->nscnt = 120;							/* ｶｳﾝﾀ設定		*/
			}
		}
	}

	/* ///  ■各行動分岐■  /// */
	switch (ep->think & GM_EMYTH_ACT_MASK)
	{
		/* ///  ●思考  /// */
		case GM_EMYTH_THINK:							/* 思考（硬化）中	*/
			ano = 0 + op->direct;						/* 静止ｱﾆﾒ			*/

			if (ano != op->aspr->anmNo)
			{
				op->aspr->speed = 14;					/* POYO POYO		*/
				AnmSet( op->aspr, op->chr, ano, 0, ANM_MODE_LOOP);

				op->act &= ~GM_PL_ACT_ST_MASK;
				op->act |= GM_PL_ACT_NORMAL;			/* 静止ﾌﾗｸﾞ			*/
			}
			break;


		/* ///  ●移動  /// */
		case GM_EMYTH_WALK:
			/* ///  ある距離以上、近づくな！  /// */
			if ((ABS( nx) + ABS( ny)) < dis)
			{
				ep->think = 0;
				ep->nscnt = 0;
				break;
			}

			/*
				スライムは、砂漠で移動量が落ちません。
				ちょっと優秀。
			*/

			sstep = ep->mv;								/* 基本移動ﾄﾞｯﾄ		*/
			sstep = 4;									/* 基本移動ﾄﾞｯﾄ		*/
			step = op->mStep + sstep;					/* 移動ﾄﾞｯﾄ			*/
			step = (step >> 4);							/* 固定小数点		*/
			ox = tx;
			oy = ty;

			ano = 4 + op->direct;						/* 歩行ｱﾆﾒ = 4〜	*/

			switch ( op->direct)
			{
				case 0:	tx += step;	break;				/* 上	*/
				case 1:	ty += step;	break;				/* 右	*/
				case 2:	ty -= step;	break;				/* 左	*/
				case 3:	tx -= step;	break;				/* 下	*/
			}

			lret = GmCheckCollisionPlayer( i, &tx, &ty, ox, oy);

			if (lret == 0)
			{
				vx = tx - ox;								/* ﾍﾞｸﾄﾙ取得				*/
				vy = ty - oy;
				flag = 0;

				/* ///  障害物判定＆補正（キャラクタタイプ：０）  /// */
				if (((ox & 0x07) == 0) & (vx != 0))
					flag |= 0x01;								/* X方向演算			*/

				if (((oy & 0x07) == 0) & (vy != 0))
					flag |= 0x10;								/* Y方向演算			*/

				if ( flag)
				{
					lret = GmCheckPosition( &tx, &ty, ox, oy, 1, flag);		/* １を指定	*/
					flag  = GmGetFlagMAP((tx >> 3), (ty >> 3));
/*					flag |= GmGetFlagMAP(((tx - 1) >> 3), (ty >> 3));
*/				}

				/* 移動ステップ固定小数点補正 */
				op->mStep = ((op->mStep + sstep) & GM_PL_WALK_STEP_MASK);

				/*
					■アニメーション設定
					  − 斜め移動は常に上下方向のグラフィック。
					  − 既に表示中ならば、アニメーションは変更しない。
				*/
			}

			/* ///  移動アニメション・チェック  /// */
			if (op->aspr->anmNo != ano)
			{
				op->aspr->speed = 8;							/* ちょっと速い			*/
				AnmSet( op->aspr, op->chr, ano, 0, ANM_MODE_LOOP);

				op->act &= ~(GM_PL_ACT_ST_MASK | GM_PL_ACT_SWD_MASK);
				op->act |= GM_PL_ACT_WALK;						/* 移動ﾌﾗｸﾞ				*/
			}

			op->aspr->x = tx;									/* ﾃﾝﾎﾟﾗﾘに取得			*/
			op->aspr->y = ty;

			if (ep->sx == tx)
			{
				GmTmpVals = ep->sy - ty;
			}
			else
			{
				GmTmpVals = ep->sx - tx;
			}

			/*
				１６回移動したら、もしくは、120V 経過したら移動をやめる
			*/
			if ((ABS(GmTmpVals) >= (16 + (ep->algo << 2))) || (ep->nscnt == 0))
			{
				/*
					アルゴで、行動開始時間までが変化
				*/
				ep->nscnt = (GM_SLM_RIGOR_TIME - (ep->algo << 3));
				ep->think = 0;
			}
			break;


		/* ///  ●攻撃  /// */
		case GM_EMYTH_ATTACK:									/* 攻撃		*/
			/* アニメ終了チェック */
			if (op->aspr->mode & ANM_MODE_END)
			{
				ano = 0 + op->direct;							/* 静止ｱﾆﾒ			*/
				op->aspr->speed = 14;						/* POYO POYO		*/
				AnmSet( op->aspr, op->chr, ano, 0, ANM_MODE_LOOP);

				op->act &= ~GM_PL_ACT_ST_MASK;
				op->act |= GM_PL_ACT_NORMAL;				/* 静止ﾌﾗｸﾞ			*/

				ep->think = 0;								/* to 思考			*/
				ep->nscnt = (GM_SLM_RIGOR_TIME - (ep->algo << 3));
			}
			break;


		default:
			break;
	}

}


/* ******************************************************************************
　関　　数	：GmSetItemWindowData
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：アイテムウィンドウ・データ（ＯＭＰ）の直接変更です。
		  	：ヒープメモリ上にあるデータに対して、直接書き込みます。
		  	：現在プレイヤーが所持しているもののみが残ります。
			：
			：	GmLoadItemWindowData();
			：	GmSetItemWindowData();
		  	：
		  	：１セットで使います。
		  	：
　履　　歴	：Ver 1.00		2001/01/20		K.Kimura		初版
****************************************************************************** */
void	GmSetItemWindowData( void)
{
	static	PLINFO			*p;
	static	u_short near	*data;

	u_char		i;
	u_short		idx;
	short		sx, sy;
	short		cx, cy;
	short		stepx, stepy;



	p = &GmPlInfo;
	data = ( u_short near *)( GameMng.iwin + 16);			/* ﾍｯﾀﾞ飛ばし		*/

	/*
		■アイテム（equipment）
	*/

	/* ///  ( 21, 2)が初期座標  /// */
	sx = 21;
	sy = 2;
	cx = sx;
	cy = sy;
	stepx = -3;
	stepy =  4;

	for (i = 0; i < GM_ITEM_01_NUM; i++)
	{
		if ((i % 4) == 0)
			cy = sy;

		if ((p->item[ 0] & (0x0001 << i)) == 0)
		{
			/* 持ってない */
			cx = (sx + (stepx * (i >> 2)));

			/* 空白描画 */
			idx = ((cy * GM_SCREEN_AREA_EXC)  + cx);

			/* 128, 129 限定 */
			data[ idx] = (( data[ idx] & 0x3e00) | (VRM_IWIN + 128));
			data[ idx + 1]  = (( data[ idx + 1] & 0x3e00) | (VRM_IWIN + 129));

			idx += GM_SCREEN_AREA_EXC;
			data[ idx] = (( data[ idx] & 0x3e00) | (VRM_IWIN + 128));
			data[ idx + 1] = (( data[ idx + 1] & 0x3e00) | (VRM_IWIN + 129));

#if GM_IWIN_DEBUG
	sprintf( buf, "I_WIN_01 (%d) DEL::(%d,%d)\r\n", i, cx, cy);
	DbgPrintPort( buf);
#endif

		}

		cy += stepy;
	}

	/*
		■剣関連
		■Ｘ４特殊アイテム
	*/

	/* ///  ( 10, 2)が初期座標  /// */
	sx = 10;
	sy = 2;
	cx = sx;
	cy = sy;
	stepx = -5;
	stepy =  4;

	for (i = 0; i < GM_ITEM_02_NUM; i++)
	{
		if ((i % 4) == 0)
			cy = sy;

		if ((p->item[ 1] & (0x0001 << i)) == 0)
		{
			/* 持ってない */
			cx = (sx + (stepx * (i >> 2)));

			/* 空白描画 */
			idx = ((cy * GM_SCREEN_AREA_EXC)  + cx);

			/* 128, 129 限定 */
			data[ idx] = (( data[ idx] & 0x3e00) | (VRM_IWIN + 128));
			data[ idx + 1] = (( data[ idx + 1] & 0x3e00) | (VRM_IWIN + 129));

			idx += GM_SCREEN_AREA_EXC;
			data[ idx] = (( data[ idx] & 0x3e00) | (VRM_IWIN + 128));
			data[ idx + 1] = (( data[ idx + 1] & 0x3e00) | (VRM_IWIN + 129));

#if GM_IWIN_DEBUG
	sprintf( buf, "I_WIN_02 (%d) DEL::(%d,%d)\r\n", i, cx, cy);
	DbgPrintPort( buf);
#endif

		}

		cy += stepy;
	}

}


/* ******************************************************************************
　関　　数	：GmSetItemWindowData
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：現在、カーソルが合わされているアイテム名の表示を行います。
		  	：この際、スコア、ハイスコア、フロア数も表示する必要があります。
		  	：フォントルーチンの仕様のためです。
		  	：
　履　　歴	：Ver 1.00		2001/01/20		K.Kimura		初版
****************************************************************************** */
void	GmDispItemName( void)
{

	/* ///  ■ 基本スコア等表示 ■  /// */
	GmDispStatus();

	/* ///  ITEM_01名表示  /// */
	if (GmPlInfo.item[ 1] & (0x0001 << GmPlInfo.selItem[ 0]))		/* 所持 CHECK	*/
	{
		FntPrint( 1, 13, 7, GmItemName[ GmPlInfo.selItem[ 0]], FNT_MODE_ADDY, FNT_PALETTE_NUM);
	}
	else
	{
		FntPrint( 1, 13, 7, "          ", FNT_MODE_ADDY, FNT_PALETTE_NUM);
	}

	/* ///  ITEM_02名表示  /// */
	if (GmPlInfo.item[ 1] & (0x0010 << GmPlInfo.selItem[ 1]))		/* 所持 CHECK	*/
	{
		FntPrint( 1, 8, 7, GmItemName[ GmPlInfo.selItem[ 1] + 4], FNT_MODE_ADDY, FNT_PALETTE_NUM);
		GmDispItemX4( 1);	/* X4 ITEM 描画 */
	}
	else
	{
		FntPrint( 1, 8, 7, "          ", FNT_MODE_ADDY, FNT_PALETTE_NUM);
		GmDispItemX4( 0);	/* X4 ITEM 削除 */
	}

	FntFlush();

}


/* ******************************************************************************
　関　　数	：GmDispHitPoint
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：プレイヤーの体力を表示します。
		  	：
　履　　歴	：Ver 1.00		2001/01/20		K.Kimura		初版
****************************************************************************** */
void	GmDispHitPoint( u_char hp)
{
	char		i;
	char		num, anum;
	u_short		data;



#if GM_CONTINUE_DEBUG
	sprintf( buf, "PLAY_HP::%u\r\n", hp);
	DbgPrintPort( buf);
#endif
	/* ///  ハートをクリア  /// */
	data = (GMPAL_IWIN << 9) + VRM_IWIN;
	screen_fill_char( 1, 0, 11, 1, GM_HIT_POINT_NUM, (data + 104)); 
	screen_fill_char( 1, 0, 11, 1, ( GmPlInfo.mhp / 4), ( data + 143)); 

	num  = ( hp / 4);
	anum = ( hp % 4);

	/* ///  ■ 満タン・ハート表示 ■  /// */
	for (i = 0; i < num; i++)
	{
		screen_fill_char( 1, 0, (11 + i), 1, 1, data + 139);
	}

	/* ///  ■ 欠損ハート表示 ■  /// */
	if (anum > 0)
		screen_fill_char( 1, 0, (11 + i), 1, 1, data + 143 - anum);

}


/* ******************************************************************************
　関　　数	：GmInitCursor
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：カーソルのアニメ設定
		  	：
　履　　歴	：Ver 1.00		2001/01/20		K.Kimura		初版
****************************************************************************** */
void	GmInitCursor( void)
{

	/* ///  アニメの初期化＆設定  /// */
	GmCur[ 0] = AnmChrInit( CHR_KOMONO, GMPAL_EFFECT, GMPRW_CURSOR_01);
	AnmSet( GmCur[ 0], CHR_KOMONO, 0, 0, ANM_MODE_LOOP);	/* ｶｰｿﾙ･ｱﾆﾒ		*/
	GmCur[ 0]->useSprNum = GmUseSprChr[ CHR_KOMONO];

	GmCur[ 1] = AnmChrInit( CHR_KOMONO, GMPAL_EFFECT, GMPRW_CURSOR_02);
	AnmSet( GmCur[ 1], CHR_KOMONO, 0, 0, ANM_MODE_LOOP);
	GmCur[ 1]->useSprNum = GmUseSprChr[ CHR_KOMONO];

	GmCur[ 0]->mode |= ANM_MODE_NODISP;
	GmCur[ 1]->mode |= ANM_MODE_NODISP;
	GmCur[ 0]->pal  |= 0x2000;
	GmCur[ 1]->pal  |= 0x2000;

}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：カーソルのアニメ設定
		  	：
　履　　歴	：Ver 1.00		2001/01/20		K.Kimura		初版
****************************************************************************** */
void	GmDispDebug( void)
{
	u_char			i;
	static	GMOBJ	*p;
	static	SPRANM	*ptr;
	static	GMTRSINFO	*trs;


#if 0
	for (i = 0; i < StgMng.ennum; i++)
	{
		p = &GmEmy[ i];

		sprintf( buf, "--< ENEMY %d >--\r\n", i);
		DbgPrintPort( buf);

		sprintf( buf, "CHR :: %u\r\n", p->chr);
		DbgPrintPort( buf);
		sprintf( buf, "ACT :: %u\r\n", p->act);
		DbgPrintPort( buf);
		sprintf( buf, "ASPR :: %x\r\n", p->aspr);
		DbgPrintPort( buf);
		sprintf( buf, "MSTEP :: %x\r\n", p->mStep);
		DbgPrintPort( buf);
		sprintf( buf, "DIRECT :: %d\r\n", p->direct);
		DbgPrintPort( buf);

		DbgPrintPort("--< ENEMY_01 ASPR >--\r\n");

		sprintf( buf, "X,Y :: %u,%u\r\n", p->aspr->x, p->aspr->y);
		DbgPrintPort( buf);
		sprintf( buf, "BASE :: %u\r\n", p->aspr->base);
		DbgPrintPort( buf);
		sprintf( buf, "PAL :: %x\r\n", p->aspr->pal);
		DbgPrintPort( buf);
		sprintf( buf, "PALN :: %x\r\n", p->aspr->paln);
		DbgPrintPort( buf);
		sprintf( buf, "sprNo :: %d\r\n", p->aspr->sprNo);
		DbgPrintPort( buf);
	}

	DbgPrintPort("---------------( ENEMY END )--<<\r\n");
#endif

#if 0
	ptr = GmCur[ 0];
	sprintf( buf, "X,Y :: %u,%u\r\n", ptr->x, ptr->y);
	DbgPrintPort( buf);
	sprintf( buf, "BASE :: %u\r\n", ptr->base);
	DbgPrintPort( buf);
	sprintf( buf, "PAL :: %x\r\n", ptr->pal);
	DbgPrintPort( buf);
	sprintf( buf, "PALN :: %x\r\n", ptr->paln);
	DbgPrintPort( buf);
	sprintf( buf, "sprNo :: %d\r\n", ptr->sprNo);
	DbgPrintPort( buf);
	sprintf( buf, "mode :: %x\r\n", ptr->mode);
	DbgPrintPort( buf);
#endif

#if 0
	trs = &GmTrsInfo;

	DbgPrintPort("---------------( TREASURE )--<<\r\n");

	sprintf( buf, "DEAD_NUM::%u\r\n", trs->deadNum);
	DbgPrintPort( buf);

	DbgPrintPort("DEAD_CHR(0-7)::");
	for (i = 0; i < 8; i++)
	{
		sprintf( buf, "%u,", trs->deadChr[ i]);
		DbgPrintPort( buf);
	}
	DbgPrintPort("\r\n");

	DbgPrintPort("DEAD_CHR(8-15)::");
	for (i = 8; i < 16; i++)
	{
		sprintf( buf, "%u,", trs->deadChr[ i]);
		DbgPrintPort( buf);
	}
	DbgPrintPort("\r\n");

	sprintf( buf, "LAST_SWD::%u,%u,%u,%u\r\n", trs->lastSwd[ 0],trs->lastSwd[ 1],trs->lastSwd[ 2],trs->lastSwd[ 3]);
	DbgPrintPort( buf);

	sprintf( buf, "CCLNUM::%u\r\n", trs->cclNum);
	DbgPrintPort( buf);
	sprintf( buf, "LDEIDX::%u\r\n", trs->ldEidx);
	DbgPrintPort( buf);
	sprintf( buf, "LSEIDX::%u\r\n", trs->lsEidx);
	DbgPrintPort( buf);
	sprintf( buf, "DOCHR::%u,%u,%u,%u\r\n", trs->doChr[0],trs->doChr[1],trs->doChr[2],trs->doChr[3]);
	DbgPrintPort( buf);
	sprintf( buf, "DEF_NUM::%u\r\n", trs->defNum);
	DbgPrintPort( buf);
	sprintf( buf, "DEF_SWD_NUM::%u\r\n", trs->defSwdNum);
	DbgPrintPort( buf);
	sprintf( buf, "DEF_SPL_NUM::%u\r\n", trs->defSplNum);
	DbgPrintPort( buf);
	sprintf( buf, "SWORD_NUM::%u\r\n", trs->swordNum);
	DbgPrintPort( buf);
	sprintf( buf, "SWORD_NUM_FLOOR::%u\r\n", trs->swordNumFloor);
	DbgPrintPort( buf);
	sprintf( buf, "HOLE_NUM::%u\r\n", trs->holeNum);
	DbgPrintPort( buf);
	sprintf( buf, "WHISTLE::0x%x\r\n", trs->whistle);
	DbgPrintPort( buf);
	sprintf( buf, "ST::%u\r\n", trs->st);
	DbgPrintPort( buf);

	DbgPrintPort("---------------( GAMEMNG )--<<\r\n");

	sprintf( buf, "TRSF::%2x,%2x,%2x\r\n", GameMng.trsF[0],GameMng.trsF[1],GameMng.trsF[2]);
	DbgPrintPort( buf);
	sprintf( buf, "SECF::%2x,%2x,%2x\r\n", GameMng.secondF[0],GameMng.secondF[1],GameMng.secondF[2]);
	DbgPrintPort( buf);
	sprintf( buf, "HFLOOR::%d,%d,%d,%d\r\n", GameMng.hfloor[0],GameMng.hfloor[1],GameMng.hfloor[2],GameMng.hfloor[3]);
	DbgPrintPort( buf);

#endif

#if 0
	DbgPrintPort("---------------( ASprAnm )--<<\r\n");
	sprintf( buf, "GmPly::%4x\r\n", GmPly.aspr);
	DbgPrintPort( buf);

	for (i = 0; i < GM_FLOOR_ENEMY_MAX; i++)
	{
		p = &GmEmy[ i];
		sprintf( buf, "GmEmy[%d]::%4x\r\n", i, p->aspr);
		DbgPrintPort( buf);
	}

	for (i = 0; i < SPR_REG_MAX; i++)
	{
		ptr = &SprAnm[ i];
		sprintf( buf, "ASprAnm[%d]::%4x,%4x\r\n", i, ptr, ptr->fst);
		DbgPrintPort( buf);
	}
#endif


}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：扉ＣＧの描画（スクリーン直描画のため、ＯＭＰは破壊しない）
		  	：ただし、フラグは設定される。
		  	：
		  	：	mode = 0..閉, 1..開
		  	：	dir  = 0..上, 1..下
		  	：
　履　　歴	：Ver 1.00		2001/01/20		K.Kimura		初版
****************************************************************************** */
void	GmSetDoor( u_char mode, char dir)
{
	char		i, j;
	u_char		nmode;
	u_short		data, ndata;

	static	u_short near	*pf, *df;
	static	GMKDTPOINT 		*p;


	nmode = (mode << 1) + dir;
	data  = (GMPAL_BG << 9) + VRM_BG;
	pf    = ( u_short near *)StgMng.scr->flag;			/* ﾌﾗｸﾞﾃﾞｰﾀ･ｱﾄﾞﾚｽ取得	*/
	p	  = &GmKDTPoinrt[ GameMng.floor];

	/* ///  扉描画＆フラグ設定  /// */
	for (i = 0; i < 2; i++)
	{
		for (j = 0; j < 3; j++)
		{
			ndata = data + GmDoorData[ nmode][(i * 3) + j];
			screen_fill_char( 0, (p->dx + j), (p->dy + i), 1, 1, ndata);

			df = &pf[(SCR_MAP_WIDTH * (p->dy + i)) + (p->dx + j)];
/*
			sprintf( buf, "DOOR::%d,%u,%u\r\n", mode, (p->dx + j), (p->dy + i));
			DbgPrintPort( buf);
*/
			/* フラグ再設定 */
			if (mode)
			{
				*df &= ~GM_MAPFLAG_BLOCK;				/* 衝突削除	*/
			}
			else
			{
				*df |= GM_MAPFLAG_BLOCK;				/* 扉に衝突	*/
			}
		}
	}
}


/* ******************************************************************************
　関　　数	：GmInitKey
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：カーソルのアニメ設定
		  	：
　履　　歴	：Ver 1.00		2001/01/20		K.Kimura		初版
****************************************************************************** */
void	GmInitKey( void)
{
	static	GMKDTPOINT 		*p;


	/* ///  アニメの初期化＆設定  /// */
	GmKey = AnmChrInit( CHR_KOMONO, GMPAL_EFFECT, GMPRW_KEY);
	AnmSet( GmKey, CHR_KOMONO, 1, 0, (ANM_MODE_NODISP | ANM_MODE_LOOP));
	GmKey->useSprNum = GmUseSprChr[ CHR_KOMONO];

	if (GmPlInfo.key)
	{
		/* 座標変更 for IWIN */
		GmKey->x = ( 3 << 3);
		GmKey->y = (11 << 3);
		GmKey->pal |= 0x2000;							/* SCR1より手前	*/

		return;											/* 持ってるよ	*/
	}

	if (GameMng.openF[ GameMng.floor] == 0)
	{
		/*
			まだ、鍵で開けてないらしい
		*/

		p = &GmKDTPoinrt[ GameMng.floor];

		if ((GameMng.fidx == p->kidx) && (p->ddir >= 0))	/* 扉の有無も判定	*/
		{
			/*
				鍵アニメを設定
			*/
			GmKey->x = ( p->kx << 3);
			GmKey->y = ( p->ky << 3);
			GmKey->mode &= ~ANM_MODE_NODISP;			/* ＭＡＰに表示	*/
		}
	}

}

#if GM_TEST
/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：■フロア１の宝箱チェック
		  	：	宝		：ポーション
			：	出現条件：スライムを４匹倒す
		  	：
　履　　歴	：Ver 1.00		2001/01/22		K.Kimura		初版
****************************************************************************** */
char	GmTrsFloor01( u_char mode)
{
	static	GMTRSINFO	*trs;


	trs = &GmTrsInfo;

	if (trs->deadChr[ CHR_SLIME] >= 4)
	{
		/* 宝箱出現！！ */
		return ( 1);
	}

	return ( 0);
}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：■フロア２の宝箱チェック
		  	：	宝		：アワーグラス
		  	：  出現条件：スライムのみ全滅させる（１４匹：変更あり）
		  	：
　履　　歴	：Ver 1.00		2001/01/23		K.Kimura		初版
****************************************************************************** */
char	GmTrsFloor02( u_char mode)
{
	static	GMTRSINFO	*trs;
	u_char	num;


	num = 14;
	trs = &GmTrsInfo;

	/*
		トータル１４匹の時に、スライムが１４匹死んでいる
		＝ スライム「のみ」殺す
	*/
	if (trs->deadNum == num)
	{
		if (trs->deadChr[ CHR_SLIME] >= num)
		{
			/* 宝箱出現！！ */
			return ( 1);
		}
	}

	return ( 0);
}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：■フロア３の宝箱チェック
		  	：	宝		：スペクタクル
		  	：  出現条件：「蛇」を３匹倒す
		  	：
　履　　歴	：Ver 1.00		2001/01/23		K.Kimura		初版
****************************************************************************** */
char	GmTrsFloor03( u_char mode)
{
	static	GMTRSINFO	*trs;
	u_char	num;


	num = 3;
	trs = &GmTrsInfo;

	if (trs->deadChr[ CHR_SNAKE] >= num)
	{
		/* 宝箱出現！！ */
		return ( 1);
	}

	return ( 0);
}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：■ フロア４の宝箱チェック
			：宝		： ロングソード（ソード２）
			：出現条件 	： キャンセルをかけて騎士を殺す
		  	：
　履　　歴	：Ver 1.00		2001/01/22		K.Kimura		初版
****************************************************************************** */
char	GmTrsFloor04( u_char mode)
{
	static	GMTRSINFO	*trs;


	trs = &GmTrsInfo;

	if (trs->ldEidx == 0xff)
		return ( 0);

	switch (GmEmy[ trs->ldEidx].chr)
	{
		case CHR_KNIGHT1:
		case CHR_KNIGHT2:
		case CHR_KNIGHT3:
		case CHR_KNIGHT1_L:
		case CHR_KNIGHT2_L:
		case CHR_KNIGHT3_L:
			if (((GmEmyInfo[ trs->ldEidx].nscnt) > 0)
			    || ((GmEmyInfo[ trs->ldEidx].ccnt) > 0))
			{
				/* 宝箱出現！！ */
				return ( 1);
			}
			break;
	}

	return ( 0);
}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：■フロア５の宝箱チェック
			：宝		： ダッシュブーツ
			：出現条件	： 盾で攻撃を５回防御する
			：
　履　　歴	：Ver 1.00		2001/01/20		K.Kimura		初版
****************************************************************************** */
char	GmTrsFloor05( u_char mode)
{
	static	GMTRSINFO	*trs;


	trs = &GmTrsInfo;

	if (trs->defNum >= 5)
	{
		/* 宝箱出現！！ */
		return ( 1);
	}

	return ( 0);
}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：■フロア６の宝箱チェック
			：宝		： タワーシールド
			：出現条件	： KNIGHT3、KNIGHT2、KNIGHT1の順に倒す
		  	：
　履　　歴	：Ver 1.00		2001/01/22		K.Kimura		初版
****************************************************************************** */
char	GmTrsFloor06( u_char mode)
{
	static	GMTRSINFO	*trs;


	trs = &GmTrsInfo;

	if ((trs->doChr[ 0] & 0xf7) == CHR_KNIGHT1)
	{
		if ((trs->doChr[ 1] & 0xf7) == CHR_KNIGHT2)
		{
			if ((trs->doChr[ 2] & 0xf7) == CHR_KNIGHT3)
			{
				/* 宝箱出現！！ */
				return ( 1);
			}
		}
	}

	return ( 0);
}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：■フロア７の宝箱チェック
			：宝		： キャンドル
			：出現条件	： 剣を一度も振らずにその階を「通過」する
		  	：
　履　　歴	：Ver 1.00		2001/01/22		K.Kimura		初版
****************************************************************************** */
char	GmTrsFloor07( u_char mode)
{
	static	GMTRSINFO	*trs;
	static	GAMEMNG		*p;


	trs = &GmTrsInfo;
	p = &GameMng;

	if (p->floor7 == 0)
	{
		if ((p->hfloor[ 1] == 7) && (p->hfloor[ 2] == 6) && (p->hfloor[ 3] == 5))
		{
			/* 宝箱出現！！ */
			return ( 1);
		}
	}

	return ( 0);
}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：■フロア８の宝箱チェック
			：宝		： ウィング
			：出現条件	： ＳＴＡＲＴボタンを押す
			：
　履　　歴	：Ver 1.00		2001/01/23		K.Kimura		初版
****************************************************************************** */
char	GmTrsFloor08( u_char mode)
{
	static	GMTRSINFO	*trs;


	trs = &GmTrsInfo;

	if (PadInfo->padt & KEY_START)
	{
		/* 宝箱出現！！ */
		return ( 1);
	}

	return ( 0);
}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：■フロア９の宝箱チェック
			：宝		： ナイト・ブレード
			：出現条件	： 蛇使いのみ殺す
			：
　履　　歴	：Ver 1.00		2001/01/23		K.Kimura		初版
****************************************************************************** */
char	GmTrsFloor09( u_char mode)
{
	static	GMTRSINFO	*trs;
	u_char	num;


	num = 4;
	trs = &GmTrsInfo;

	if (trs->deadNum == num)
	{
		if ((trs->deadChr[ CHR_MAGICIAN] >> 8) >= num)
		{
			/* 宝箱出現！！ */
			return ( 1);
		}
	}

	return ( 0);
}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：■フロア１０の宝箱チェック
			：宝		： ガントレット
			：出現条件	： 穴に敵２匹を落とす
			：
　履　　歴	：Ver 1.00		2001/01/24		K.Kimura		初版
****************************************************************************** */
char	GmTrsFloor10( u_char mode)
{
	static	GMTRSINFO	*trs;


	trs = &GmTrsInfo;

	if (trs->holeNum >= 2)
	{
		/* 宝箱出現！！ */
		return ( 1);
	}

	return ( 0);
}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：■フロア１１の宝箱チェック
			：宝		： ハンマー
			：出現条件	： 敵の呪文を１回以上、剣の攻撃を２回以上防御後に、
			：			   キャンセルをかけて騎士を倒す。
			：
　履　　歴	：Ver 1.00		2001/01/24		K.Kimura		初版
****************************************************************************** */
char	GmTrsFloor11( u_char mode)
{
	static	GMTRSINFO	*trs;


	trs = &GmTrsInfo;

	if (trs->defSplNum < 1)
		return ( 0);

	if (trs->defSwdNum < 2)
		return ( 0);

	if (trs->ldEidx == 0xff)
		return ( 0);

	switch (GmEmy[ trs->ldEidx].chr)
	{
		case CHR_KNIGHT1:
		case CHR_KNIGHT2:
		case CHR_KNIGHT3:
		case CHR_KNIGHT1_L:
		case CHR_KNIGHT2_L:
		case CHR_KNIGHT3_L:
			if (((GmEmyInfo[ trs->ldEidx].nscnt) > 0)
				|| ((GmEmyInfo[ trs->ldEidx].ccnt) > 0))
			{
				/* 宝箱出現！！ */
				return ( 1);
			}
			break;
	}

	return ( 0);
}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：■フロア１２の宝箱チェック
			：宝		： グレートアーマー
			：出現条件	： 縦斬りで敵を３匹以上殺す
			：
　履　　歴	：Ver 1.00		2001/01/24		K.Kimura		初版
****************************************************************************** */
char	GmTrsFloor12( u_char mode)
{
	static	GMTRSINFO	*trs;


	trs = &GmTrsInfo;

	if (trs->lastSwd[ 2] >= 3)
	{
		/* 宝箱出現！！ */
		return ( 1);
	}

	return ( 0);
}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：■フロア１３の宝箱チェック
			：宝		： 聖なる笛
			：出現条件	： 部屋２で、合計１０回以上、剣を振る
			：
　履　　歴	：Ver 1.00		2001/01/24		K.Kimura		初版
****************************************************************************** */
char	GmTrsFloor13( u_char mode)
{
	static	GMTRSINFO	*trs;


	trs = &GmTrsInfo;

	if (GameMng.fidx != 2)
		return ( 0);

	if (trs->swordNum >= 10)
	{
		/* 宝箱出現！！ */
		return ( 1);
	}

	return ( 0);
}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：■フロア１４の宝箱チェック
			：宝		： ソード・ドラグナー
			：出現条件	： ある位置を通過する
			：
			：72,80
　履　　歴	：Ver 1.00		2001/01/20		K.Kimura		初版
****************************************************************************** */
char	GmTrsFloor14( u_char mode)
{
	static	GMTRSINFO	*trs;
	short	tx, ty;


	trs = &GmTrsInfo;

	if (GameMng.fidx != 5)
		return ( 0);

	tx = ( GmPly.aspr->x - 72);
	ty = ( GmPly.aspr->y - 80);

	if ((ABS( tx) + ABS( ty)) <= 2)		/* ﾃｷﾄｰな距離	*/
	{
		/* 宝箱出現！！ */
		return ( 1);
	}

	return ( 0);
}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：■フロア１５の宝箱チェック
			：宝		： ヘルメット
			：出現条件	： ハンマーで敵を殺す
			：
　履　　歴	：Ver 1.00		2001/01/20		K.Kimura		初版
****************************************************************************** */
char	GmTrsFloor15( u_char mode)
{
	static	GMTRSINFO	*trs;
	short	tx, ty;


	trs = &GmTrsInfo;

	if (trs->lastSwd[ 3] > 0)
	{
		/* 宝箱出現！！ */
		return ( 1);
	}

	return ( 0);
}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：■フロア１６の宝箱チェック
			：宝		： シルバーリング
			：出現条件	： １６Ｆ−４( 10, 6)に重なる。
		  	：
　履　　歴	：Ver 1.00		2001/01/20		K.Kimura		初版
****************************************************************************** */
char	GmTrsFloor16( u_char mode)
{
	static	GMTRSINFO	*trs;
	short	tx, ty;


	trs = &GmTrsInfo;

	if (GameMng.fidx != 4)
		return ( 0);

	tx = ( GmPly.aspr->x - 80);
	ty = ( GmPly.aspr->y - 48);

	if ((ABS( tx) + ABS( ty)) == 0)			/* ｼﾞｬｽﾄ距離	*/
	{
		/* 宝箱出現！！ */
		return ( 1);
	}

	return ( 0);
}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：■フロア１７の宝箱チェック
			：宝		： 空箱
			：出現条件	： 敵を全滅させる
		  	：
　履　　歴	：Ver 1.00		2001/01/24		K.Kimura		初版
****************************************************************************** */
char	GmTrsFloor17( u_char mode)
{
	static	GMTRSINFO	*trs;
	u_char	num;


	num = 18;
	trs = &GmTrsInfo;

	if ((trs->deadNum >= num) && (trs->deadChr[ CHR_SNAKE] == 0))
	{
		/* 宝箱出現！！ */
		return ( 1);
	}

	return ( 0);
}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：■フロア１８の宝箱チェック
			：宝		： 楽典
			：出現条件	： 全ての部屋で笛を吹く
		  	：
　履　　歴	：Ver 1.00		2001/01/24		K.Kimura		初版
****************************************************************************** */
char	GmTrsFloor18( u_char mode)
{
	static	GMTRSINFO	*trs;


	trs = &GmTrsInfo;

	if (GmTrsInfo.whistle == 0x3f)
	{
		/* 宝箱出現！！ */
		return ( 1);
	}

	return ( 0);
}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：■フロア１９の宝箱チェック
			：宝		： ゴールドリング
			：出現条件	： 硬直中の騎士に笛を聞かせる。
		  	：
　履　　歴	：Ver 1.00		2001/01/20		K.Kimura		初版
****************************************************************************** */
char	GmTrsFloor19( u_char mode)
{
	static	GMTRSINFO	*trs;
	u_char	i;


	trs = &GmTrsInfo;

	if (trs->lsEidx == 0xff)
		return ( 0);

	if (((GmEmyInfo[ trs->lsEidx].nscnt) > 0)
		|| ((GmEmyInfo[ trs->lsEidx].ccnt) > 0))
	{
		if (GmPlInfo.selItem[ 1] == 2)			/* 笛 */
		{
			if (PadInfo->padt & KEY_X4)			/* 使用	*/
			{
				/* 宝箱出現！！ */
				return ( 1);
			}
		}
	}

	return ( 0);
}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：■フロア２０の宝箱チェック
			：宝		： なし
			：出現条件	： なし
		  	：
　履　　歴	：Ver 1.00		2001/01/20		K.Kimura		初版
****************************************************************************** */
char	GmTrsFloor20( u_char mode)
{
	return ( 0);
}
#endif

/* ******************************************************************************
　関　　数	：GmInitTreasure
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：宝箱アニメの初期化
		  	：
　履　　歴	：Ver 1.00		2001/01/22		K.Kimura		初版
****************************************************************************** */
void	GmInitTreasure( void)
{
	u_char		idx1, idx2;
	static		GMKDTPOINT 		*p;


	p = &GmKDTPoinrt[ GameMng.floor];

	/* ///  アニメの初期化＆設定  /// */
	GmTrs = AnmChrInit( CHR_KOMONO, GMPAL_EFFECT, GMPRW_TRS);
	AnmSet( GmTrs, CHR_KOMONO, 2, 0, (ANM_MODE_NODISP | ANM_MODE_LOOP));
	GmTrs->x = ( p->tx << 3);
	GmTrs->y = ( p->ty << 3);
	GmTrs->useSprNum = GmUseSprChr[ CHR_KOMONO];

#if 0
	sprintf( buf, "TRS_XY::%u,%u\r\n", GmTrs->x, GmTrs->y);
	DbgPrintPort( buf);
#endif

	/*
		あとは、表示のＯＮ／ＯＦＦだけ
	*/

}


/* ******************************************************************************
　関　　数	：GmDispTreasure
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：宝箱アニメの表示チェック
		  	：というか、表示状態じゃないとコールされないはず。
		  	：
　履　　歴	：Ver 1.00		2001/01/22		K.Kimura		初版
****************************************************************************** */
void	GmDispTreasure( void)
{

	if (GmPlInfo.trs)
		return;										/* 取りました		*/

	/* ///  部屋チェック  /// */
	if (GameMng.fidx == GmKDTPoinrt[ GameMng.floor].tidx)
	{
		GmTrs->mode &= ~ANM_MODE_NODISP;
	}

}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：ヒールポーション使用時
		  	：func の止め方が強引・・（マズイです）
		  	：
　履　　歴	：Ver 1.00		2001/01/22		K.Kimura		初版
****************************************************************************** */
void	GmHealPotion( void *func)
{
	static	GMHEAL	*p;


	p = &GmHeal;

	if (p->flag >= 2)
		return;

#if GM_HEAL_DEBUG
	sprintf( buf, "HEAL_FUNC::%d,%d,%d,%u\r\n", p->thp, p->hp, p->flag, p->cnt);
	DbgPrintPort( buf);
#endif

	if (p->cnt > 0)
		p->cnt--;

	if (p->cnt == 0)
	{
		p->hp++;

		if (p->hp >= p->thp)
		{
#if GM_HEAL_DEBUG
	DbgPrintPort("-- HEAL_END_02 --\r\n");
#endif
			p->hp = p->thp;						/* 最悪な補正だ・・	*/
			p->flag = 2;
		}
		else
		{
#if GM_HEAL_DEBUG
	DbgPrintPort("-- HEAL!! --\r\n");
#endif
			se_play_n( GMSE_HEAL);							/* SE	*/
			p->cnt = 6;
		}

		GmDispHitPoint( p->hp);
	}

}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：ヒールポーション使用時
		  	：func の止め方が強引・・（マズイです）
		  	：
　履　　歴	：Ver 1.00		2001/01/22		K.Kimura		初版
****************************************************************************** */
void	GmDispItemX4( u_char mode)
{
	u_short		data;


	data = (GMPAL_IWIN << 9) + VRM_IWIN;

	if (mode)
	{
		/* Ｘ４アイテムを描画 */

		switch (GmPlInfo.selItem[ 1])
		{
			/* GM_ITEM_HOURGLASS */
			case 0:
				/* ( 0, 8) */
				screen_fill_char( 1, 0, 8, 1, 1, data + 122);
				screen_fill_char( 1, 1, 8, 1, 1, data + 123);
				screen_fill_char( 1, 0, 9, 1, 1, data + 122 + 0x8000);
				screen_fill_char( 1, 1, 9, 1, 1, data + 123 + 0x8000);
				break;

			/* GM_ITEM_HAMMER */
			case 1:
				/* ( 0, 8) */
				screen_fill_char( 1, 0, 8, 1, 1, data + 106);
				screen_fill_char( 1, 1, 8, 1, 1, data + 107);
				screen_fill_char( 1, 0, 9, 1, 1, data + 106 + 0x8000);
				screen_fill_char( 1, 1, 9, 1, 1, data + 107 + 0x8000);
				break;

			/* GM_ITEM_WHISTLE */
			case 2:
				/* ( 0, 8) */
				screen_fill_char( 1, 0, 8, 1, 1, data + 108);
				screen_fill_char( 1, 1, 8, 1, 1, data + 109);
				screen_fill_char( 1, 0, 9, 1, 1, data + 124);
				screen_fill_char( 1, 1, 9, 1, 1, data + 125);
				break;

			/* GM_ITEM_WING */
			case 3:
				/* ( 0, 8) */
				screen_fill_char( 1, 0, 8, 1, 1, data + 110);
				screen_fill_char( 1, 1, 8, 1, 1, data + 111);
				screen_fill_char( 1, 0, 9, 1, 1, data + 126);
				screen_fill_char( 1, 1, 9, 1, 1, data + 127);
				break;
		}
	}
	else
	{
		/* Ｘ４アイテムを削除 */

		screen_fill_char( 1, 0, 8, 1, 2, data + 128);
		screen_fill_char( 1, 1, 8, 1, 2, data + 129);
	}
}


/* ******************************************************************************
　関　　数	：GmUseItemX4
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：Ｘ４アイテム関連
		  	：
　履　　歴	：Ver 1.00		2001/01/22		K.Kimura		初版
****************************************************************************** */
u_char	GmUseItemX4( void)
{
	u_char		i, ret;
	char		floor, lret;

	static	PLINFO	*p;
	static	GMPOS	*pos;


	p = &GmPlInfo;
	ret = 0;

	if ((p->item[ 1] & (GM_ITEM_HOURGLASS << p->selItem[ 1])) == 0)
		return ( 0);									/* 持ってないじゃん	*/

	/* ///  Ｘ４アイテム分岐  /// */
	switch (p->selItem[1])
	{
		/* ///  HOURGLASS  /// */
		case 0:
			if ((p->flag & GM_PIFLAG_HGLASS) == 0)
			{
				if (GameMng.floor == (GM_FLOOR_NUM - 1))
				{
					se_play_n( GMSE_CANSEL);
					break;
				}

				if (p->useItem[0] < GM_HGLASS_USE_MAX)
				{
					/*
						３回までなら使えるよ
					*/

					/* ＢＧパレットチェンジ */
					palette_set_color( GMPAL_BG, SysPal[ GMPAL_HGLASS]); 

					se_play_n( GMSE_DECIDE);				/* SE		*/
					p->flag |= GM_PIFLAG_HGLASS;			/* ﾌﾗｸﾞON	*/
					p->useItem[0]++;						/* 回数加算	*/

					/* 敵アニメーション・全停止 */
					for (i = 0; i < StgMng.ennum; i++)
						GmEmy[ i].aspr->mode |= ANM_MODE_STOP;

					if (p->useItem[0] == GM_HGLASS_USE_MAX)
					{
						/* 壊れたよ */
						p->item[ 1] &= ~GM_ITEM_HOURGLASS;	/* 削除		*/
						GmDispItemX4( 0);					/* ｱﾆﾒ削除	*/
					}
				}
			}
			break;


		/* ///  HAMMER  /// */
		case 1:
			if ((GmPly.act & GM_PL_ACT_ST_MASK) <= GM_PL_ACT_WALK)
			{
				/* ///  ★アニメーション・ベーススピード設定  /// */
				GmPly.aspr->speed = 12;

				ano = PL_A0_24_ANW + GmPly.direct;
				AnmSet( GmPly.aspr, CHR_PLAYER, ano, 0, ANM_MODE_ACTIVE);

				/* ///  ハンマー・スウィング  /// */
				GmPly.act &= ~GM_PL_ACT_MASK_ALL;
				GmPly.act |= (GM_PL_ACT_SWORD | GM_PL_ACT_SWING_HM);

				/* ＳＥ発音 */
				se_play_n( GMSE_SWD_02);

				ret = 1;
			}
			break;


		/* ///  WHISTLE  /// */
		case 2:
			if ((GmPly.act & GM_PL_ACT_ST_MASK) <= GM_PL_ACT_WALK)
			{
				/* ＳＥ発音 */
				se_play_n( GMSE_WHISTLE);

				/* １回だけよ */
				if ((GmTrsInfo.whistle & ( 0x01 << GameMng.fidx)) == 0)
				{
					/* 魔法使い隠蔽フラグ設定 */
					GameMng.flag |= GM_MNGFLAG_WHISTLE;
				}

				GmTrsInfo.whistle |= ( 0x01 << GameMng.fidx);

			}
			break;


		/* ///  WING  /// */
		case 3:
			floor = 0;
			lret = 0;

			switch (GmPly.direct)
			{
				/* 上 */
				case 0:
					floor = ( GameMng.floor + 1);
					lret = 6;
					break;

				/* 下 */
				case 3:
					floor = ( GameMng.floor - 1);
					lret = -6;
					break;

				default:
					break;
			}

			if (lret)
			{
				if (GameMng.visitF[ floor] == 0)
				{
					/* ＳＥ発音 */
					se_play_n( GMSE_CANSEL);
					break;
				}

				if ((floor >= 0) && (floor < (GM_FLOOR_NUM - 1)))
				{
					pos = &GmStartPos[ floor];

					/* 座標再設定 */
					GameMng.fidx = ((pos->y / GM_SCREEN_AREA_EYC) * 3) + (pos->x / (GM_SCREEN_AREA_EXC - 2));
					GmPly.aspr->x = ((pos->x % (GM_SCREEN_AREA_EXC - 2)) << 3);
					GmPly.aspr->y = ((pos->y % GM_SCREEN_AREA_EYC) << 3);

					/* ///  座標補正を回避するための策  /// */
					GmPly.act &= ~GM_PL_ACT_ST_MASK;
					GmPly.act |= GM_PL_ACT_HOLEIN;

					/* フロア移動 */
					GmChangeFloor( lret);

					/* ＳＥ発音 */
					se_play_n( GMSE_DECIDE);
				}
			}
			break;


		default:
			break;
	}

	return ( ret);
}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：プレイヤーのパラメータ設定です。
		  	：アイテムウィンドウ等の後にコールされます。
		  	：主に、攻撃値や、装備品（Ｘ４）の設定です。
		  	：
　履　　歴	：Ver 1.00		2001/01/11		K.Kimura		初版
****************************************************************************** */
void	GmCheckParamPlayer( void)
{
	static	PLINFO		*p;
	char		j;


	p = &GmPlInfo;

	/* ＡＰ設定 */
	if ((p->item[ 1] & (0x0001 << p->selItem[ 0])) == 0)
	{
		/* 嘘つくな！ */
		for (j = 3; j >= 0; j--)
		{
			if (p->item[ 1] & (0x0001 << j))
			{
				p->selItem[ 0] = j;
				break;
			}
		}
	}

	p->ap  = ( GM_PLINFO_AP + p->selItem[ 0]);
	p->dp  = GM_PLINFO_DP;
	p->dp2 = 0;

	/* ＭＨＰ設定 */
	p->mhp = GM_PLINFO_MHP;										/* base HP			*/

	if (p->item[ 0] & GM_ITEM_SHIELD_L)
	{
		p->mhp += 4;
		p->dp ++;
	}

	if (p->item[ 0] & GM_ITEM_ARMOR)
	{
		p->mhp += 4;
		p->dp ++;
		p->dp2 ++;
	}

	if (p->item[ 0] & GM_ITEM_HELMET)
	{
		p->mhp += 4;
		p->dp ++;
		p->dp2 ++;
	}

	/*
		ＢＭＰの差し替えも行う
	*/
	GmChangePlayerCG();

#if GM_PARAM_DEBUG
	sprintf( buf, "SEL_WEAPON::%d\r\n", p->selItem[ 0]);
	DbgPrintPort( buf);
	sprintf( buf, "AP,DP,DP2::%d, %d, %d\r\n", p->ap, p->dp, p->dp2);
	DbgPrintPort( buf);
#endif

}


/* ******************************************************************************
　関　　数	：GmSetHole
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：ひび割れ床を、穴にします。
		  	：
　履　　歴	：Ver 1.00		2001/01/24		K.Kimura		初版
****************************************************************************** */
void	GmSetHole( u_char x, u_char y)
{
	u_char		i, j;
	u_char		sx, sy;
	u_short		idx, data, ndata;

	static	u_short near	*pf;


	sx = (x - 1);
	sy = (y - 1);

	/* ///  ■必ず、この範囲に存在  /// */
	for (i = 0; i < 3; i++)
	{
		for (j = 0; j < 3; j++)
		{
			if (GmGetFlagMAP((sx + j), (sy + i)) & GM_MAPFLAG_CRFLOOR)
			{
				sx += j;
				sy += i;

				i = 3;
				break;
			}
		}
	}

	/* 左上セル座標( sx, sy)が決定 */

	data  = (GMPAL_BG << 9) + VRM_BG;
	pf    = ( u_short near *)StgMng.scr->flag;			/* ﾌﾗｸﾞﾃﾞｰﾀ･ｱﾄﾞﾚｽ取得	*/

	/* 穴描画（to screen0）*/
	screen_fill_char( 0, sx, sy, 1, 1, data + 7);
	screen_fill_char( 0, sx, (sy + 1), 1, 1, data + 23);
	screen_fill_char( 0, (sx + 1), sy, 1, 1, ((data + 7) | 0x4000));
	screen_fill_char( 0, (sx + 1), (sy + 1), 1, 1, ((data + 23) | 0x4000));

	/* フラグ再設定 */
	idx = (SCR_MAP_WIDTH * sy) + sx;
	pf[ idx] = (pf[ idx] | GM_MAPFLAG_HOLE);	idx ++;
	pf[ idx] = (pf[ idx] | GM_MAPFLAG_HOLE);	idx += SCR_MAP_WIDTH;
	pf[ idx] = (pf[ idx] | GM_MAPFLAG_HOLE);	idx ++;
	pf[ idx] = (pf[ idx] | GM_MAPFLAG_HOLE);

	/* 穴座標を待避 */
	GmHolePos.x = ((sx + 1) << 3);
	GmHolePos.y = ((sy + 1) << 3);

}


/* ******************************************************************************
　関　　数	：GmDeadEnemy
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：
		  	：
　履　　歴	：Ver 1.00		2001/01/24		K.Kimura		初版
****************************************************************************** */
void	GmDeadEnemy( u_char idx, u_short acta)
{
	static	ENMINFO		*ep;
	static	GMOBJ		*op;
	static	GMTRSINFO	*trs;
	u_char	fidx;
	char	j;



	op = &GmEmy[ idx];
	ep = &GmEmyInfo[ idx];
	trs = &GmTrsInfo;

	/* ///  ダメージ状態のを解除  /// */
	op->aspr->pal = op->aspr->paln;					/* 通常ﾊﾟﾚｯﾄに戻す	*/
	op->act &= ~GM_PL_ACT_DAMAGE;					/* ﾀﾞﾒｰｼﾞ状態解除	*/

	/* 死亡（点滅） */
	ep->dcnt = GM_DEAD_TIME;
	op->act |= GM_PL_ACT_DEAD;

	op->aspr->mode |= ANM_MODE_STOP;				/* ｱﾆﾒ停止			*/

	/*
		フロア情報に死亡通知を行う
	*/
	GameMng.enemyDF[ GameMng.fidx] |= (0x0001 << idx);			/* 敵死亡ﾌﾗｸﾞ（1ﾌﾛｱ）	*/

	/* ///  得点取得  /// */
	GmGetPoint( idx);

	fidx = (GM_FLOOR_IDX_NUM * GameMng.floor) + GameMng.fidx;
	GameMng.enemyF[ fidx] |= (0x01 << idx);						/* 敵死亡ﾌﾗｸﾞ（全ﾌﾛｱ）	*/

	/* ＳＥ発音 */
	se_play_n( GMSE_DEAD);

	/* ---------------------------- */
	/* 		宝箱フラグの設定	/// */
	/* ---------------------------- */
	trs->deadNum++;									/* 倒した敵数を加算	*/
	trs->ldEidx = idx;								/* ﾗｽﾄ ENEMY		*/

	for (j = 2; j >= 0; j--)
		trs->doChr[ j + 1] = trs->doChr[ j];		/* 順番をｽﾗｲﾄﾞ		*/

	trs->doChr[ 0] = op->chr;						/* 倒した敵			*/

	if (idx < GM_ENEMY_OBJMAX)
	{
		if (op->chr == CHR_MAGICIAN)
		{
			if (ep->algo & 0x01)
			{
				/* 蛇タイプ */
				trs->deadChr[ CHR_MAGICIAN] += 0x0100;	/* 上位に加算		*/
			}
			else
			{
				/* 呪文タイプ */
				trs->deadChr[ CHR_MAGICIAN] ++;			/* 下位に加算		*/
			}
		}
		else
		{
			trs->deadChr[ op->chr] ++;					/* 倒した敵の分類	*/
		}
	}
	else
	{
		trs->deadChr[ CHR_SNAKE] ++;					/* 蛇です			*/
	}

	GmTmpVals = ( acta >> 8);

	for (j = 0; j < 4; j++)
	{
		if (GmTmpVals & ( 0x0001 << j))
			break;
	}

	trs->lastSwd[ j] ++;							/* 攻撃ﾀｲﾌﾟの記憶	*/

}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：
		  	：
　履　　歴	：Ver 1.00		2001/01/24		K.Kimura		初版
****************************************************************************** */
void	GmChangeFloor( char lret)
{
	char		j;


	if ((lret == 6) || (lret == -6))
	{
		GmPlInfo.key = 0;						/* DEBUG用？			*/
		GmPlInfo.trs = 0;						/* 宝箱取得ﾌﾗｸﾞｸﾘｱ		*/

		/* ///  フロア７だけ特殊  /// */
		if (GameMng.floor == 6)
			GameMng.floor7 = GmTrsInfo.swordNumFloor;

		/* 宝箱出現情報構造体の初期化 */
		memset( &GmTrsInfo, 0, sizeof( GMTRSINFO));
		memset( GameMng.enemyDF, 0, GM_FLOOR_IDX_NUM);	/* 敵死亡ﾌﾗｸﾞ（1ﾌﾛｱ）ｸﾘｱ */

		/*
			フロア履歴更新
		*/
		for (j = 2; j >= 0; j--)
			GameMng.hfloor[ j + 1] = GameMng.hfloor[ j];	/* 順番をｽﾗｲﾄﾞ		*/

		/* ///  プレイヤー向き＆座標の補正  /// */
		if ((GmPly.act & GM_PL_ACT_ST_MASK) != GM_PL_ACT_HOLEIN)
		{
			/* 穴じゃなければ、座標補正 */

			GmPly.direct ^= 0x03;

			if (GmPly.direct == 0) {
				GmPly.aspr->x += 8;
			} else {
				GmPly.aspr->x -= 8;
			}
		}

		GmPly.act = GM_PL_ACT_NORMAL;

		/* ///  新フロアに到達？ /// */
		if ((GameMng.healF[ GameMng.floor + (lret / 6)] == 0) && (lret > 0))
		{
			/*
				ご褒美回復（４だけど・・）
			*/
			GmHeal.thp  = (GmPlInfo.hp + 4);	/* 回復					*/

			if (GmHeal.thp > GmPlInfo.mhp)
				GmHeal.thp = GmPlInfo.mhp;		/* 補正					*/

			GmHeal.flag = 0;					/* HEAL POTION 演出開始	*/
			GmHeal.cnt  = 0;
			GmHeal.hp   = GmPlInfo.hp;
			GmPlInfo.hp = GmHeal.thp;			/* HPはここで回復		*/

			/* 一度だけです			*/
			GameMng.healF[ GameMng.floor + (lret / 6)] = 1;
			GameMng.visitF[ GameMng.floor + (lret / 6)] = 1;
		}

		/* フェードアウト */
		display_control( 0x0003);				/* ｽﾌﾟﾗｲﾄ OFF		*/
		GmFadeOutPal( GMPAL_BG, GM_FIOT_FLOOR);

		GameMng.flag |= GM_MNGFLAG_CHG_FLOOR;
	}

	GmTrsInfo.ldEidx = 0xff;
	GmTrsInfo.lsEidx = 0xff;

	GameMng.flag &= ~GM_MNGFLAG_WHISTLE;		/* 笛の使用中ﾌﾗｸﾞOFF	*/

	GmHolePos.x = 0;							/* 穴座標の初期化		*/
	GmTrsInfo.swordNum = 0;						/* これだけ例外			*/

	GmSStepTest = GMT_LOAD;						/* STAGE 変更			*/
	VblkMng.loopExit = 1;						/* LOOP脱出				*/

	/*
		各種パラメータ設定（ GameMng.floor, GameMng.fidx等）
	*/
	GameMng.floor += (lret / 6);				/* ちょっと待って!		*/
	GameMng.fidx  += (lret % 6);				/* ｲﾝﾃﾞｯｸｽ変更			*/
	StgMng.scr->scrDir = lret;					/* ｽｸﾛｰﾙ方向設定		*/

	GameMng.hfloor[ 0] = GameMng.floor;			/* 新ﾌﾛｱ				*/

}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：スライムのルーチンです。
		  	：
　履　　歴	：Ver 1.00		2001/01/18		K.Kimura		初版
****************************************************************************** */
void	GmMoveTestarossa( u_char i)
{
	static	ENMINFO		*ep;
	static	GMOBJ		*op;
	static	u_char		tx, ty;

	u_char		step, sstep;
	u_char		j, lret;
	u_char		dir, nidx;
	u_short		flag;
	short		nx, ny;
	u_char		ox, oy;
	short		vx, vy;
	u_short		time;



	ep = &GmEmyInfo[ i];
	op = &GmEmy[ i];

	if (ep->nscnt)
		ep->nscnt--;								/* ｶｳﾝﾀ減算		*/

	tx = op->aspr->x;
	ty = op->aspr->y;
	nx = tx - GmPly.aspr->x;
	ny = ty - GmPly.aspr->y;

	step = 3;

	GmEmy[ i].aspr->speed = 8;

	/* ///  思考チェック？  /// */
	if ( ep->think == 0)
	{
		/*
			休憩時間？
		*/

		if (ep->nscnt == 0)
		{
			/* ///  強制突進  /// */
			ep->think = GM_EMYTH_WALK;
			ep->nswd = 0;								/* ｽﾃｯﾌﾟとして利用	*/
		}
	}

	/* ///  ダメージ判定  /// */
	if (op->act & GM_PL_ACT_DAMAGE)
	{
#if GM_TESTA_DEBUG
	sprintf( buf, "DAMAGE_ANO::%d\r\n", op->aspr->anmNo);
	DbgPrintPort( buf);
#endif
		if (op->aspr->anmNo == EN_A0_05_ANW)			/* 溜めｱﾆﾒ		*/
		{
			ep->think &= ~GM_EMYTH_ACT_MASK;
			ep->think |=  GM_EMYTH_DAMAGE;
			ep->nswd  = 0;
			ep->nscnt = 0;
		}
	}

	/* ///  ■各行動分岐■  /// */
	switch (ep->think & GM_EMYTH_ACT_MASK)
	{
		/* ---------------- */
		/* ///  ●思考  /// */
		/* ---------------- */
		case GM_EMYTH_THINK:							/* 思考（硬化）中	*/
			ano = EN_A0_00_ANW;							/* 静止ｱﾆﾒ			*/

			if (ano != op->aspr->anmNo)
			{
				AnmSet( op->aspr, op->chr, ano, 0, ANM_MODE_LOOP);
				op->act &= ~GM_PL_ACT_ST_MASK;
				op->act |= GM_PL_ACT_NORMAL;			/* 静止ﾌﾗｸﾞ			*/
			}
			break;


		/* ---------------- */
		/* ///  ●移動  /// */
		/* ---------------- */
		case GM_EMYTH_WALK:
			ox = tx;
			oy = ty;

			switch ( ep->nswd)
			{
				/* ///  横方向突進  /// */
				case 0:
					flag = 0x01;						/* X方向演算		*/

					if (op->aspr->motNo >= 4)
					{

						if ((op->aspr->mode & ANM_MODE_STOP) == 0)
							se_play_n( GMSE_DASH);

						op->aspr->mode |= ANM_MODE_STOP;

					}
					else
					{
						step = 0;						/* 構え中のため		*/
					}

					if (nx > 0)
					{
						op->direct = 3;					/* 下方向			*/
						tx -= step;
					}
					else
					{
						op->direct = 0;					/* 上方向			*/
						tx += step;
					}
					break;


				/* ///  縦方向突進	/// */
				case 1:
					flag = 0x10;						/* Y方向演算		*/

					if (op->aspr->motNo >= 4)
					{
						if ((op->aspr->mode & ANM_MODE_STOP) == 0)
							se_play_n( GMSE_DASH);

						op->aspr->mode |= ANM_MODE_STOP;
					}
					else
					{
						step = 0;						/* 構え中のため		*/
					}

					if (ny > 0)
					{
						op->direct = 2;					/* 左方向			*/
						ty -= step;
					}
					else
					{
						op->direct = 1;					/* 右方向			*/
						ty += step;
					}
					break;


				case 2:									/* ﾌｧﾝﾈﾙ !!			*/
					/* ///  攻撃へ  /// */
					ep->think = GM_EMYTH_ATTACK;
					ep->nswd = 0;						/* ｽﾃｯﾌﾟ初期化		*/
					return;


				default:
					break;
			}

			lret = GmCheckCollisionPlayer( i, &tx, &ty, ox, oy);

			if (lret == 0)
			{
				/*
					プレイヤーとは衝突していない
				*/
				lret = GmCheckPosition( &tx, &ty, ox, oy, CHR_TESTAROSSA, flag);
			}

			if (lret)
			{
				/* ステップＵＰ */
				ep->nswd ++;
			}

			/* ///  突進終了条件  /// */
			switch (op->direct)
			{
				case 0:
					if ((GmPly.aspr->x <= tx) || (tx >= (GM_SCREEN_AREA_EX - 16)))
						ep->nswd ++;
					break;

				case 1:
					if ((GmPly.aspr->y <= ty) || (ty >= (GM_SCREEN_AREA_EY - 16)))
						ep->nswd ++;
					break;

				case 2:
					if ((GmPly.aspr->y >= ty) || (ty <= 16))
						ep->nswd ++;
					break;

				case 3:
					if ((GmPly.aspr->x >= tx) || (tx <= 16))
						ep->nswd ++;
					break;
			}

			ano = EN_A0_01_ANW + op->direct;					/* 突進ｱﾆﾒ				*/

			/* ///  移動アニメ−ション・チェック  /// */
			if (op->aspr->anmNo != ano)
			{
				AnmSet( op->aspr, op->chr, ano, 0, ANM_MODE_LOOP);
				op->act &= ~(GM_PL_ACT_ST_MASK | GM_PL_ACT_SWD_MASK);
				op->act |= GM_PL_ACT_WALK;						/* 移動ﾌﾗｸﾞ				*/
			}

			op->aspr->x = tx;
			op->aspr->y = ty;
			break;


		/* ---------------- */
		/* ///  ●攻撃  /// */
		/* ---------------- */
		case GM_EMYTH_ATTACK:									/* 攻撃		*/
			switch ( ep->nswd)
			{
				/* ///  解放アニメーション  /// */
				case 0:
					ano = EN_A0_06_ANW;							/* 解放ｱﾆﾒ		*/
					op->aspr->pal = op->aspr->paln;				/* ﾊﾟﾚｯﾄ（暗）	*/
					AnmSet( op->aspr, op->chr, ano, 0, 0);

					op->act &= ~GM_PL_ACT_ST_MASK;
					op->act |= GM_PL_ACT_ATTACK;				/* 攻撃ﾌﾗｸﾞ		*/

					ep->nswd ++;
					break;


				/* ///  溜めアニメーション  /// */
				case 1:
					if (op->aspr->mode & ANM_MODE_END)
					{
						ano = EN_A0_05_ANW;							/* 溜めｱﾆﾒ		*/
						op->aspr->pal = ( GMPAL_ENEMY_01 << 9);		/* ﾊﾟﾚｯﾄ（明）	*/
						AnmSet( op->aspr, op->chr, ano, 0, ANM_MODE_LOOP);

						se_play_n( GMSE_POWER);

						ep->nscnt = 90;								/* ｶｳﾝﾀ設定		*/
						ep->nswd ++;
					}
					break;


				/* ///  溜めアニメ終了待ち  /// */
				case 2:
					if (ep->nscnt == 0)
					{
						ano = EN_A0_06_ANW;							/* 解放ｱﾆﾒ		*/
						op->aspr->pal = op->aspr->paln;				/* ﾊﾟﾚｯﾄ（暗）	*/
						GmEmy[ i].aspr->speed = 2;
						AnmSet( op->aspr, op->chr, ano, 0, 0);

						ep->nswd ++;
					}
					break;


				/* ///  解放アニメ終了待ち１  /// */
				case 3:
					if (op->aspr->motNo == 3)
					{
						op->aspr->mode |= ANM_MODE_STOP;
						ep->nscnt = 60;						/* 3秒は呆けよう	*/
						ep->nswd ++;

						memset( GmFPos, 0, ( sizeof( GMPOS) * 5));

						/* ///  ファンネル５発 発射！  /// */
						for (j = 0; j < 5; j++)
						{
							nidx = (( i + GameMng.splIdx) + j);

							ano = EN_A0_09_ANW;							/* 弾ｱﾆﾒ	*/
							GmEmyInfo[ nidx].flag  = 0x00;				/* 呪文		*/
							GmEmy[ nidx].act = GM_PL_ACT_SPELL;

							AnmSet( GmEmy[ nidx].aspr, op->chr, ano, 0, ANM_MODE_LOOP);
							GmEmy[ nidx].aspr->x = tx;
							GmEmy[ nidx].aspr->y = ty;
							GmEmy[ nidx].direct  = 0;

							GmEmyInfo[ nidx].hp    = 0x01;				/* 蛇用		*/
							GmEmyInfo[ nidx].flag |= 0x01;				/* 呪文 ON	*/

							GmEmyInfo[ nidx].nswd  = 0;
							GmEmyInfo[ nidx].nscnt = (7 * j);			/* delay	*/
						}
					}
					break;


				/* ///  解放アニメ終了待ち２  /// */
				case 4:
					if (ep->nscnt == 0)
					{
						ep->think = 0;							/* to 思考			*/
						ep->nswd  = 0;
					}
					break;

			}
			break;


		/* -------------------- */
		/* ///  ●ダメージ  /// */
		/* -------------------- */
		case GM_EMYTH_DAMAGE:
#if GM_TESTA_DEBUG
	sprintf( buf, "STEP,CCNT::%d,%u\r\n", ep->nswd, ep->ccnt);
	DbgPrintPort( buf);
#endif
			switch ( ep->nswd)
			{
				/* ダメージアニメ発行 */
				case 0:
					AnmSet( op->aspr, op->chr, EN_A0_07_ANW, 0, ANM_MODE_LOOP);
					ep->nscnt = GM_DAMAGE_TIME;
					ep->hp ++;									/* HP補正			*/
					ep->nswd ++;
					break;


				/* ダメージアニメ終了チェック */
				case 1:
					if (ep->nscnt == 0)
					{
						/* 死亡アニメ発行 */
						AnmSet( op->aspr, op->chr, EN_A0_08_ANW, 0, 0);
						op->aspr->mode2 |= ANM_MODE2_ENDSTOP;
						ep->nscnt = 255;						/* これくらい？	*/
						ep->nswd ++;
					}
					break;


				/* 硬直終了チェック */
				case 2:
					if (ep->nscnt == 0)
					{
						/* 通常状態に移行 */
						ep->think = 0;							/* to 思考			*/
						ep->nswd  = 0;
					}

					if (ep->ccnt != 0)
					{
						op->mStep ++;

						ox = tx;
						oy = ty;

						if ((ep->ddir % 3) == 0)
						{
							tx += ((op->mStep >> 1) * GmAppTable[ 0][ ep->ddir].dx);
							flag = 0x01;						/* X方向演算		*/
						}
						else
						{
							ty += ((op->mStep >> 1) * GmAppTable[ 0][ ep->ddir].dy);
							flag = 0x10;						/* Y方向演算		*/
						}
#if GM_TESTA_DEBUG
	sprintf( buf, "MSTEP::%2x\r\n", op->mStep);
	DbgPrintPort( buf);
#endif
						GmCheckPosition( &tx, &ty, ox, oy, CHR_TESTAROSSA, flag);

						op->aspr->x = tx;
						op->aspr->y = ty;

						op->mStep &= 0x01;
						ep->ccnt --;
					}
					else
					{
						/* ///  ■チェック座標取得■  /// */
						nx = tx - 176;
						ny = ty - (((GameMng.fidx / 3) << 5) + 56);
#if GM_TESTA_DEBUG
	sprintf( buf, "TESTA_HP::%d\r\n", ep->hp);
	DbgPrintPort( buf);
	sprintf( buf, "nx, ny::%d,%d\r\n", nx, ny);
	DbgPrintPort( buf);
#endif
						/* ///  リング当たり判定  /// */
						if ((ABS(nx) + ABS(ny)) < 20)
						{
							/* 真のダメージ */
							ep->hp -= 40;						/* HP減算			*/

							/* 生死判定 */
							if (ep->hp > 0)
							{
								AnmSet( op->aspr, op->chr, EN_A0_07_ANW, 0, ANM_MODE_LOOP);
								ep->nscnt = GM_DAMAGE_TIME;
								ep->hp ++;						/* HP補正			*/
								ep->nswd ++;
#if GM_TESTA_DEBUG
	sprintf( buf, "DAMAGE_ANO::%d\r\n", op->aspr->anmNo);
	DbgPrintPort( buf);
#endif
								/* ダメージ（パレット判定） */
								ep->dcnt = GM_DAMAGE_TIME;
								op->act |= GM_PL_ACT_DAMAGE;
								op->aspr->pal = ( GMPAL_PLAYER << 9);

								/* ＳＥ発音 */
								se_play_n( GMSE_DAMAGE_T02);
								se_play_n( GMSE_DAMAGE_T01);
#if GM_TESTA_DEBUG
	DbgPrintPort("< T_OUCH!! >\r\n");
#endif
							}
							else
							{
								/* ///  ＥＮＥＭＹ死亡処理  /// */
								GmDeadEnemy( i, GmPly.act);

								GameMng.playNum = 0;
								GameMng.flag |= GM_MNGFLAG_ALLCLEAR;

								GmPly.aspr->mode |= ANM_MODE_STOP;

								if (bgm_check())
									bgm_stop();
#if GM_TESTA_DEBUG
	DbgPrintPort("< T_DEAD!! >\r\n");
#endif
							}
						}
					}
					break;


				/* ダメージアニメ終了チェック */
				case 3:
#if GM_TESTA_DEBUG
	sprintf( buf, "DAMAGE_ANO::%d\r\n", op->aspr->anmNo);
	DbgPrintPort( buf);
#endif
					if (ep->nscnt == 0)
					{
						/* 通常状態に移行 */
						ep->think = 0;							/* to 思考			*/
						ep->nswd  = 0;
					}
					break;

			}
			break;


		default:
			break;
	}

	/* ///  ■テスタロッサ幻影処理■  /// */
	if (((GameMng.fidx % 3) != 1) || (GameMng.floor19 != 0x05))
	{
		time = VblkGetCount();
		op->aspr->flag |= GM_ANM_FLAG_DM_MASK;					/* 無敵	*/

		if (time & 0x01) {
			op->aspr->mode |= ANM_MODE_NODISP;					/* 点滅	*/
		} else {
			op->aspr->mode &= ~ANM_MODE_NODISP;
		}

		op->aspr->flag |= GM_ANM_FLAG_DM_MASK;					/* 無敵	*/
	}
	else
	{
		op->aspr->mode &= ~ANM_MODE_NODISP;						/* 点滅解除	*/
	}

}


/* ******************************************************************************
　関　　数	：GmMoveSpell2
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：スペル動作ルーチン２です。
		  	：テスタロッサ専用です（シクシク・・）
		  	：
　履　　歴	：Ver 1.00		2001/01/26		K.Kimura		初版
****************************************************************************** */
void	GmMoveSpell2( void)
{
	static	GMOBJ		*op;
	static	ENMINFO		*ep;
	static	GMPOS		*p;
	static	GMAPPTABLE	*ap, *ap2;

	short	dx, dy;
	char	i, dir;



	/* ///  ■呪文番号は、これ以外ありえない■  /// */
	for (i = GameMng.splIdx; i < (GameMng.splIdx + 5); i++)
	{
		op = &GmEmy[ i];

		if (op->act & GM_PL_ACT_DEAD)
			continue;

		ep  = &GmEmyInfo[ i];
		p   = &GmFPos[ i - GameMng.splIdx];
		ap  = GmFPosR;
		ap2 = GmFPosR2;

		if (ep->nscnt)
			ep->nscnt --;

		if (ep->flag & 0x01)
		{
			/* 呪文機能ＯＮ */

			switch (ep->nswd)
			{
				/* ///  最初の硬化待ち  /// */
				case 0:
					if (ep->nscnt == 0)
					{
						/*
							第１段階の移動先を設定
						*/
						dx = ( GmPly.aspr->x - op->aspr->x);
						dy = ( GmPly.aspr->y - op->aspr->y);

						dir = GmGetSpellAtDir( dx, dy);
						dir = (( dir + ((i - GameMng.splIdx) + 6)) % 8);

						p->x = op->aspr->x + GmFPosR[ dir].dx;
						p->y = op->aspr->y + GmFPosR[ dir].dy;
						ep->nscnt = 30;								/* ｺﾏ数		*/
						ep->nswd ++;

						se_play_n( GMSE_SWD_01G);
					}
					break;


				/* ///  第１段階の移動終了待ち  /// */
				case 1:
					if (ep->nscnt == 0)
					{
/*						op->aspr->x = p->x;
						op->aspr->y = p->y;
*/
						/* 硬化時間を設定 */
						ep->nscnt = 20;
						ep->nswd ++;
					}
					else
					{
						/* 新座標設定 */
						op->aspr->x = (((op->aspr->x * 3) + p->x) / 4);
						op->aspr->y = (((op->aspr->y * 3) + p->y) / 4);
					}
					break;


				/* ///  第１段階の硬化終了待ち  /// */
				case 2:
					if (ep->nscnt == 0)
					{
						/*
							第２段階の移動先を設定
						*/
						p->x = GmPly.aspr->x + GmFPosR2[ (i - GameMng.splIdx)].dx;
						p->y = GmPly.aspr->y + GmFPosR2[ (i - GameMng.splIdx)].dy;

						se_play_n( GMSE_SWD_02G);

						ep->nscnt = 30;								/* ｺﾏ数		*/
						ep->nswd ++;
					}
					break;


				/* ///  第２段階の移動終了待ち  /// */
				case 3:
					if (ep->nscnt == 0)
					{
/*						op->aspr->x = p->x;
						op->aspr->y = p->y;
*/
						/* 判定復活 */
/*						op->aspr->flag |= 0x3800;
*/
						/* 硬化時間を設定 */
						ep->nscnt = 60;
						ep->nswd ++;
					}
					else
					{
#if GM_TESTA_DEBUG
	sprintf( buf, "i, flag_af::%d,%x\r\n", i, op->aspr->flag);
	DbgPrintPort( buf);
#endif
						/* 移動中は判定なし */

						/*
							ここで毎ターン設定しないと、LOOP 時に判定が復活する
						*/
						op->aspr->flag &= ~GM_ANM_FLAG_AT_MASK;		/* ﾌﾗｸﾞ消去	*/

						/* 新座標設定 */
						op->aspr->x = (((op->aspr->x * 3) + p->x) / 4);
						op->aspr->y = (((op->aspr->y * 3) + p->y) / 4);
					}
					break;


				/* ///  第２段階の硬化終了待ち  /// */
				case 4:
					if (ep->nscnt == 0)
					{
						/*
							第３段階の移動先＆アニメを設定
						*/
						dx = ( GmPly.aspr->x - op->aspr->x);
						dy = ( GmPly.aspr->y - op->aspr->y);
						dir = GmGetSpellAtDir( dx, dy);

						ano = EN_A0_10_ANW + ((dir + 6) % 8);			/* 弾2ｱﾆﾒ	*/
						AnmSet( op->aspr, op->chr, ano, 0, ANM_MODE_LOOP);

						se_play_n( GMSE_SPELL01);

						ep->nswd ++;
					}
					break;


				/* ///  第３段階の行動終了待ち  /// */
				case 5:
					dir = ((( op->aspr->anmNo - EN_A0_10_ANW) + 2) % 8);

					dx = GmFVec[ dir].dx;
					dy = GmFVec[ dir].dy;
					op->aspr->x += dx;
					op->aspr->y += dy;

					/*
						ファンネル終了処理
					*/

					if ((op->aspr->x < GM_SCREEN_AREA_SX) || (op->aspr->x > GM_SCREEN_AREA_EX))
						ep->flag = 0x00;				/* 呪文 OFF		*/

					if ((op->aspr->y < GM_SCREEN_AREA_SY) || (op->aspr->y > GM_SCREEN_AREA_EY))
						ep->flag = 0x00;				/* 呪文 OFF		*/

					if (ep->flag == 0x00)
					{
						op->aspr->mode |= ANM_MODE_NODISP;
						ep->nswd = 0;
					}
					break;

			}
		}
	}

}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：
		  	：
　履　　歴	：Ver 1.00		2001/01/26		K.Kimura		初版
****************************************************************************** */
u_char	GmGetSpellAtDir( short dx, short dy)
{
	u_char		dir;


	/* 象限設定 */
	if (dx >= 0)
	{
		if (dy >= 0){
			if (dy >= dx){
				dir = 3;
			}else{
				dir = 4;
			}
		}else{
			if (dy >= -dx){
				dir = 1;
			}else{
				dir = 0;
			}
		}
	}
	else
	{
		if (dy >= 0){
			if (dy >= -dx){
				dir = 4;
			}else{
				dir = 5;
			}
		}else{
			if (dy >= dx){
				dir = 6;
			}else{
				dir = 7;
			}
		}
	}


	return ( dir);
}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：
		  	：
　履　　歴	：Ver 1.00		2001/01/26		K.Kimura		初版
****************************************************************************** */
void	GmCheckRing( void)
{
	u_char		rx, ry;
	short		nx, ny;
	static		SCRMNG	*scrp;


	/* ＲＩＮＧ設置 */
	if (GameMng.floor19 & GameMng.fidx)
		return;

	/* ///  ■チェック座標取得■  /// */
	switch (GameMng.fidx)
	{
		case 1:
			rx = 176;
			ry = 56;
			break;

		case 4:
			rx = 176;
			ry = 88;
			break;

		default:
			return;
	}

#if GM_RING_DEBUG
	sprintf( buf, "x,y :: rx,ry::%u,%u,  %u,%u\r\n", GmPly.aspr->x, GmPly.aspr->y, rx, ry);
	DbgPrintPort( buf);
#endif

	nx = ( GmPly.aspr->x - rx);
	ny = ( GmPly.aspr->y - ry);

#if GM_RING_DEBUG
	sprintf( buf, "nx,ny::%d,%d\r\n", nx, ny);
	DbgPrintPort( buf);
#endif

	if ((ABS(nx) + ABS(ny)) <= 24)
	{
		se_play_n( GMSE_DECIDE);

		scrp = ScrGetBGInfo( 0);
		scrp->cnt = 30;
		VblkRegEvent( VBLK_MOVE_MODE, ScrScreenFlush);

		/* ＲＩＮＧ設置 */
		GameMng.floor19 |= GameMng.fidx;
	}

}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：リング設置アニメーション
		  	：
　履　　歴	：Ver 1.00		2001/01/27		K.Kimura		初版
****************************************************************************** */
void	GmMoveRing( void)
{
	u_short		time;
	u_short		data;
	u_short		cnum;
	u_char		py;


	if ((GameMng.fidx % 3) != 1)
		return;

	if ((GameMng.floor19 & GameMng.fidx) == 0)
		return;

	/* リングアニメ */
	time = VblkGetCount();
	data = (GMPAL_BG << 9) + VRM_BG;
	cnum = 53;
	py   = 6;

	if (time & 0x04)
		cnum += 2;

	if (GameMng.fidx & 0x04)
		py = 10;


#if GM_RING_DEBUG
	sprintf( buf, "py::%u\r\n", py);
	DbgPrintPort( buf);
#endif

	/* リング表示 */
	screen_fill_char( 0, 23, py, 1, 1, (data + cnum));
	screen_fill_char( 0, 24, py, 1, 1, (data + cnum + 1));
	screen_fill_char( 0, 23, (py + 1), 1, 1, (data + cnum + 16));
	screen_fill_char( 0, 24, (py + 1), 1, 1, (data + cnum + 17));

}



/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：リング設置アニメーション
		  	：
　履　　歴	：Ver 1.00		2001/01/27		K.Kimura		初版
****************************************************************************** */
void	GmGetPoint( u_char idx)
{
	u_char		didx;


	didx = (( GameMng.floor * GM_FLOOR_IDX_NUM) + GameMng.fidx);

	if (GameMng.enemyF[ didx] & (0x01 << idx))
		return;

	GmPlInfo.score += ( GmEmyInfo[ idx].point / 10);

	/* ///  ■ 基本スコア等表示 ■  /// */
	GmDispStatus();

}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：ヒント絵の表示です。
		  	：
　履　　歴	：Ver 1.00		2001/01/28		K.Kimura		初版
****************************************************************************** */
void	GmInitHintWall( void)
{
	u_char		i;
	u_short		data;

	static	char far	*cptr;



	display_control( 0x0003);								/* ｽﾌﾟﾗｲﾄ OFF 	*/
	sys_wait( 1);

	/* ///  ■アニメ・ＳＴＯＰ■  /// */
	GmPly.aspr->mode |= ANM_MODE_STOP;

	for (i = 0; i < StgMng.ennum; i++)
		GmEmy[ i].aspr->mode |= ANM_MODE_STOP;

	GmFadeOutPal( GMPAL_BG, GM_FIOT_WALLCG);
	palette_set_color( GMPAL_WALLCG, 0x7777);

	/* ＣＧの読み込み＆ＶＲＡＭ転送 */
	cptr = FileGetPointer((TFD_WALLG01 + (GameMng.floor / 10)), (GameMng.floor % 10));
	font_set_colordata( VRM_ENEMY, (cptr[ 8] * cptr[ 9]), (cptr + 16));		/* VRAMへ転送	*/

	data = (GMPAL_IWIN << 9) + VRM_IWIN;
	screen_fill_char( 0,  0, 0, 3, 18, (data + 104));			/* 黒ﾍﾞﾀ	*/
	screen_fill_char( 0, 23, 0, 3, 18, (data + 104));			/* 黒ﾍﾞﾀ	*/

	GmDispHintWall( 0, 3);
	sys_wait( 1);

	GmFadeInPal( GMPAL_WALLCG, GMPAL_WALLCG, GM_FIOT_WALLCG);

}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：ヒント絵の表示です。
		  	：
　履　　歴	：Ver 1.00		2001/01/28		K.Kimura		初版
****************************************************************************** */
void	GmMoveHintWall( void *func)
{
	char		i;
	char		chr;
	u_char		pal;
	static		GMOBJ	*ep;


	if (PadInfo->padt & PAD_TRG_DURL_X)
	{
		GmSStepTest = GMT_GAME;
		VblkMng.loopExit = 1;						/* LOOP脱出					*/
/*		func = NULL;								/* 関数登録抹消				*/

		GmFadeOutPal( GMPAL_WALLCG, GM_FIOT_WALLCG);

		SysInitHeap();								/* ﾋｰﾌﾟｱﾄﾞﾚｽ初期化			*/
		SprInit( 1 + 0x80);							/* ｷｬﾗｸﾀ･ﾃﾞｰﾀ内容保持		*/

		/*
			上の 0x80 は、SprAnm は破棄しないの意味
		*/

		/* ＣＧの読み込み＆ＶＲＡＭ転送 */
		SprSetChracter( GRP_I_WIN_FRC, VRM_IWIN);
		GmLoadStage( 1);							/* 全ﾃﾞｰﾀの再読み込み		*/

		ScrDispScreen( 0);							/* BG 描画					*/

/*		GmSetItemWindowBase( 1, 0, 0, 0, 4);		/* 初期設定（一部）			*/
		GmDispHitPoint( GmPlInfo.hp);				/* HP 表示					*/

		/* ///  ■アニメ再ＳＴＡＲＴ（大変）■  /// */
		GmPly.aspr->mode &= ~ANM_MODE_STOP;

/*		for (i = 0; i < StgMng.ennum; i++)
*/		for (i = 0; i < GM_FLOOR_ENEMY_MAX; i++)
		{
			ep = &GmEmy[ i];

			if (ep->aspr == NULL)
				continue;

			ep->aspr->mode &= ~ANM_MODE_NODISP;

			switch (ep->chr)
			{
				case CHR_MAGICIAN:
				case CHR_DRAGON:
				case CHR_TESTAROSSA:
					if (i >= GameMng.splIdx)
					{
						if (GmEmyInfo[ i].flag == 0x00)
							ep->aspr->mode |= ANM_MODE_NODISP;		/* 呪文系統は再設定	*/
					}
					break;
			}

			/* 登録開始ｷｬﾗｸﾀ番号の再設定 */

			chr = ep->chr;

			/* ///  騎士系統：左利きの補正  /// */
			if ((chr >= CHR_KNIGHT1_L) && (chr <= CHR_KNIGHT3_L))
				chr -= 8;

			ep->aspr->base = ASprMng.stChrIdx[ chr];
			AnmSet( ep->aspr, ep->chr, ep->aspr->anmNo, ep->aspr->motNo, ep->aspr->mode);

			/* ///  アワーグラスは？  /// */
			if ((GmPlInfo.flag & GM_PIFLAG_HGLASS) == 0)
				ep->aspr->mode &= ~ANM_MODE_STOP;

		}

		/* ///  アワーグラスは？  /// */
		if ((GmPlInfo.flag & GM_PIFLAG_HGLASS) == 0)
		{
			pal = GMPAL_BG;

			if (StgMng.flag & GM_FLAG_DARKROOM)
			{
				if ((GmPlInfo.item[ 0] & GM_ITEM_CANDLE) == 0)
					pal = GMPAL_DARKROOM;
			}
		}
		else
		{
			pal = GMPAL_HGLASS;
		}

		/* ///  スペクタクル所持判定  /// */
		if ((GmPlInfo.item[ 0] & GM_ITEM_SPECTACLE) == 0)
		{
			/*
				魔法使いは見えません
			*/
			for (i = 0; i < StgMng.ennum; i++)
			{
				if (GmEmy[ i].chr == CHR_MAGICIAN)
					GmEmy[ i].aspr->mode |= (ANM_MODE_NODISP | ANM_MODE_COUNT);
			}
		}

		GmFadeInPal( GMPAL_BG, pal, GM_FIOT_WALLCG);
		display_control( 0x0007);				/* ｽﾌﾟﾗｲﾄ ON		*/
	}

}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：現在の１エリアにおける、全敵キャラクタの読み込みです。
		  	：
　履　　歴	：Ver 1.00		2001/01/28		K.Kimura		初版
****************************************************************************** */
void	GmLoadEnemyCG( void)
{
	char		i;
	u_char		chr;
	u_short		chrno, chrno2;


	/* ///  敵データＶＲＡＭ登録先の初期化  /// */
	GmTmpVal = VRM_ENEMY;

	/* ///  ★ＳＰＲデータの読み込み(非常駐 : スルーなし)  /// */
	for (i = 0; i < StgMng.ennum; i++)
	{
		if (GameMng.enemyDF[ GameMng.fidx] & (0x0001 << i))
		{
			if (GmEmyInfo[ i].dcnt == 0)
			{
				GmEmy[ i].act |= GM_PL_ACT_DEAD;
				continue;
			}
		}

		chr = GmEmy[ i].chr;

		/* ///  騎士系統：左利きの補正  /// */
		if ((chr >= CHR_KNIGHT1_L) && (chr <= CHR_KNIGHT3_L))
			chr -= 8;

		GmTmpVal += SprSetChracter( chr, GmTmpVal);
	}
}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：ヒント絵の表示です。
		  	：
　履　　歴	：Ver 1.00		2001/01/28		K.Kimura		初版
****************************************************************************** */
void	GmDispHintWall( u_char scr, u_char sx)
{
	u_short		data;
	u_short		chr;
	u_char		i, j;


	data = (GMPAL_WALLCG << 9) + VRM_ENEMY;
	chr  = 0;

	for (i = 0; i < GM_WALLCG_HEIGHT; i++)
	{
		for (j = 0; j < GM_WALLCG_WIDTH; j++)
		{
			screen_fill_char( scr, (sx + j), i, 1, 1, (data + chr));
			chr++;
		}
	}

}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：汎用のきかないパレット・フェードアウトです。
		  	：
　履　　歴	：Ver 1.00		2001/01/28		K.Kimura		初版
****************************************************************************** */
char	GmFadeOutPal( u_char pal, u_char step)
{
	char		i, j;
	u_short		cnt, ocnt;
	u_short		opal, npal;
	u_short		mask;


	cnt  = 0;
	ocnt = 0;
/*	opal = SysPal[ pal];
*/	palette_get_color( pal);
	npal = _AX;
	opal = 0x7777;

#if GM_PALETTE_DEBUG
	sprintf( buf, "NPAL::%x\r\n", npal);
	DbgPrintPort( buf);
#endif

	while (cnt < 0x80)
	{
		if ((ocnt & 0xf0) != (cnt & 0xf0))
		{
			for (j = 0; j < 4; j++)
			{
				mask = (0x000f << (j << 2));

				if ((npal & mask) < (opal & mask))
					npal += (0x0001 << (j << 2));
			}

			palette_set_color( pal, npal); 

#if GM_PALETTE_DEBUG
	sprintf( buf, "FOPAL::%x\r\n", npal);
	DbgPrintPort( buf);
#endif
		}

		ocnt = cnt;
		cnt += step;

		sys_wait( 1);
	}


	return ( 0);
}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：汎用のきかないパレット・フェードインです。
		  	：
　履　　歴	：Ver 1.00		2001/01/28		K.Kimura		初版
****************************************************************************** */
char	GmFadeInPal( u_char pal, u_char pnum, u_char step)
{
	char		i, j;
	u_short		cnt, ocnt;
	u_short		opal, npal;
	u_short		mask;


	cnt  = 0;
	ocnt = 0;
	npal = SysPal[ pnum];
	opal = 0x7777;

#if GM_PALETTE_DEBUG
	sprintf( buf, "NPAL::%x\r\n", npal);
	DbgPrintPort( buf);
#endif

	while (cnt < 0x80)
	{
		if ((ocnt & 0xf0) != (cnt & 0xf0))
		{
			for (j = 0; j < 4; j++)
			{
				mask = (0x000f << (j << 2));

				if ((opal & mask) > (npal & mask))
					opal -= (0x0001 << (j << 2));
			}

			palette_set_color( pal, opal); 

#if GM_PALETTE_DEBUG
	sprintf( buf, "FOPAL::%x\r\n", opal);
	DbgPrintPort( buf);
#endif
		}

		ocnt = cnt;
		cnt += step;

		sys_wait( 1);
	}

	return ( 0);

}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：宝箱基本ルーチン
　		  	：
　履　　歴	：Ver 1.00		2001/01/20		K.Kimura		初版
****************************************************************************** */
void	GmTrsFloorBase( u_char mode)
{
	static		GMTRSINFO	*trs;
	static		GMTRSFLAG	*tf;
	u_char		i, ret;
	u_short		idx, idx2;


	trs = &GmTrsInfo;
	tf  = &GmTrsFlag[ GameMng.floor];

	switch ( mode)
	{
		/* ///  宝箱探し状態  /// */
		case GMI_TRS_SERACH:
			switch (trs->st)
			{
				/* 出現チェック */
				case 0:
					/*
						各フロア処理にジャンプ
					*/
					ret = ( GmTreasureFunc[ GameMng.floor])( 0);

					if (ret)
					{
						se_play_n( GMSE_TRSAPP);			/* SE */
						trs->st ++;
					}
					break;

				/* 宝箱表示チェック */
				case 1:
					GmDispTreasure();
					break;

				/* 宝箱取得後だね */
				default:
					break;
			}
			break;


		/* ///  宝箱取得処理  /// */
		case GMI_TRS_GET:
			idx  = ( GameMng.floor >> 3);
			idx2 = ( 0x01 << ( GameMng.floor & 0x07));

/*			if (GameMng.secondF[(ﾌﾛｱ数 / 8)] && (0x0001 << (ﾌﾛｱ数 % 8)))
*/			if ((GameMng.trsF[ idx] & idx2) == 0)
			{
				GmPlInfo.trs = 1;							/* 取りました		*/
				se_play_n( GMSE_TRSGET);					/* SE */
				GameMng.trsF[ idx] |= idx2;					/* ﾌﾗｸﾞ設定			*/

				/* 各アイテムへのフラグ */
				GmPlInfo.item[ tf->idx] |= tf->trs;			/* ITEM GET!!		*/


				/* ///  ● 各アイテムに必要な処理  /// */
				if (tf->flag & 0x01)
				{
					/* ///  所持 CHECK	/// */
					if (GmPlInfo.item[ 1] & (0x0010 << GmPlInfo.selItem[ 1]))
						GmDispItemX4( 1);					/* X4 ITEM 描画		*/
				}

				if (tf->flag & 0x04)
				{
					GmPlInfo.selItem[ 0] = 3;				/* ｵｰﾄ装備			*/
					GmCheckParamPlayer();
				}

				/* ご褒美回復（４だけど・・）*/
				if (tf->flag & 0x08)
				{
					GmPlInfo.hp += 4;

					if (GmPlInfo.hp > GmPlInfo.mhp)
						GmPlInfo.hp = GmPlInfo.mhp;			/* 補正				*/

					GmDispHitPoint( GmPlInfo.hp);
				}

				/* 部屋を明るく */
				if (tf->flag & 0x10)
					palette_set_color( GMPAL_BG, SysPal[ GMPAL_BG]);

				/* ///   ■記録データにセーブ■  /// */
				if (tf->flag & 0x20)
				{
					/* 未対応・・ */
				}

				/* 一時的な代用 */
				if (GmPlInfo.item[ 0] & GM_ITEM_SOUND_DIC)
					GmTmpFlag |= 0x0001;

				/*
					ＧＥＴアニメしたいなぁ・・・
				*/
			}
			else if ((GameMng.secondF[ idx] & idx2) == 0)
			{
				se_play_n( GMSE_TRSGET);					/* SE */
				GameMng.secondF[ idx] |= idx2;				/* ﾌﾗｸﾞ設定			*/

				/*
					体力２回復だよん
				*/
				GmHeal.thp  = (GmPlInfo.hp + 8);	/* 回復					*/

				if (GmHeal.thp > GmPlInfo.mhp)
					GmHeal.thp = GmPlInfo.mhp;		/* 補正					*/

				GmHeal.flag = 0;					/* HEAL POTION 演出開始	*/
				GmHeal.cnt  = 0;
				GmHeal.hp   = GmPlInfo.hp;
				GmPlInfo.hp = GmHeal.thp;			/* HPはここで回復		*/

			}
			GmTrs->mode |= ANM_MODE_NODISP;				/* 宝箱非表示		*/
			trs->st ++;
			break;


		/* ///  例外処理  /// */
		default:
			break;
	}
}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：プレイヤーＣＧの変更
　		  	：
　履　　歴	：Ver 1.00		2001/01/29		K.Kimura		初版
****************************************************************************** */
void	GmChangePlayerCG( void)
{
	short		idx, idx2;


	idx  = 0;
	idx2 = GRP_CHR000_FRB;

	if (GmPlInfo.selItem[ 0] > 1)
	{
		idx = ( GmPlInfo.selItem[ 0] - 1);					/* 0,1 は変化なし	*/
	}

	if (GmPlInfo.item[ 0] & GM_ITEM_SHIELD_L)
		idx += 3;

	if (idx)
	{
		idx2 = (( GRP_CHR100_FRB - 1) + idx);
	}

	GmPly.aspr->cptr = ( FileGetPointer( TFD_GRAPH, idx2) + 16);

}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：プレイヤーＣＧの変更
　		  	：
　履　　歴	：Ver 1.00		2001/01/29		K.Kimura		初版
****************************************************************************** */
void	GmDispTitleSelect( void)
{
	char		i;
	static		GMTITLE		*p;


	p = &GmOP;

	/* ///  ■文字列描画■  /// */
	for (i = 7; i >= p->cex; i--)
	{
		switch (p->select[ 7 - i])
		{
			case GM_SEL_START:
				sprintf( buf, "  START");
				break;

			case GM_SEL_CONTINUE:
				sprintf( buf, "CONTINUE");
				break;

			case GM_SEL_MUSIC_MODE:
				sprintf( buf, "MUSIC %02u", p->sndNum);
				break;

			case GM_SEL_EXIT:
				sprintf( buf, "  EXIT");
				break;

		}

		FntPrint( 1, i, 5, buf, FNT_MODE_ADDY, FNT_PALETTE_NUM);
	}

	/* ///  ■カーソル描画■  /// */
	sprintf( buf, "%c", 0x7f);
	FntPrint( 1, 4, 4, "    ", 0, FNT_PALETTE_NUM);
	FntPrint( 1, p->cx, 4, buf, FNT_MODE_ADDY, FNT_PALETTE_NUM);

}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：ゲームオーバー
　		  	：
　履　　歴	：Ver 1.00		2001/01/30		K.Kimura		初版
****************************************************************************** */
void	GmInitGameOver( void)
{
	GmFadeOutPal( GMPAL_FONT_W, 0x04);
	GmFadeOutPal( GMPAL_FONT, 0x04);
	GmFadeOutPal( GMPAL_IWIN, 0x04);
	sys_wait( 1);

	display_control( 0x0001);						/* BG0 のみ ON		*/
	sys_wait( 1);

	FntPrint( 0, 13, 5, "game over", FNT_MODE_ADDY, GMPAL_FONT_W);
	sprintf( buf, "SCORE : %u", GmPlInfo.score);

	if (GmPlInfo.score)
		strcat( buf, "0");

	FntPrint( 0, 11, 3, buf, FNT_MODE_ADDY, GMPAL_FONT_W);
	FntFlush();
	sys_wait( 1);

	GmFadeInPal( GMPAL_FONT_W, GMPAL_FONT_W, 0x04);


	if (GmTmpHScore < GmPlInfo.score)
		GmTmpHScore = GmPlInfo.score;

}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：ゲームオーバー
　		  	：
　履　　歴	：Ver 1.00		2001/01/30		K.Kimura		初版
****************************************************************************** */
void	GmMoveGameOver( void *func)
{

	if (PadInfo->padt & PAD_TRG_DURL_X)
	{
		GmFadeOutPal( GMPAL_FONT_W, 0x04);

		if (bgm_check())
			bgm_stop();

		GmIndex = GMI_OPENING;						/* ｹﾞｰﾑｽﾀｰﾄ					*/
		GmSStepTest = GMT_END;						/* とりあえず終了			*/

		VblkMng.loopExit = 1;						/* LOOP脱出					*/
/*		func = NULL;								/* 関数登録抹消				*/

		return;
	}

}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：フェードアウトです。
		  	：ブロック処理です・・・。
		  	：
　履　　歴	：Ver 1.00		2001/01/30		K.Kimura		初版
****************************************************************************** */
char	GmFadeOut( u_char step, u_char mode)
{
	char		i, j;
	u_short		cnt, ocnt;
	u_short		mask;
	static	u_short		npal[ 2];


	cnt  = 0;
	ocnt = 0;
	npal[ 0] = 0x6420;
	npal[ 1] = 0xfca8;

	while (cnt < 0xff)
	{
		if ((ocnt & 0xf0) != (cnt & 0xf0))
		{
			for (i = 0; i < 2; i++)
			{
				for (j = 0; j < 4; j++)
				{
					mask = (0x000f << (j << 2));

					if (mode)
					{
						if ((npal[ i] & mask) < (0xffff & mask))
							npal[ i] += (0x0001 << (j << 2));
					}
					else
					{
						if ((npal[ i] & mask) > 0)
							npal[ i] -= (0x0001 << (j << 2));
					}
				}
			}

			lcd_set_color( npal[ 0], npal[ 1]);

#if GM_PALETTE_DEBUG
	sprintf( buf, "LCD_FO::%4x:%4x\r\n", npal[ 0], npal[ 1]);
	DbgPrintPort( buf);
#endif
		}

		ocnt = cnt;
		cnt += step;

		sys_wait( 1);
	}


	return ( 0);
}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：フェードインです。
		  	：ブロック処理です・・・。
		  	：
　履　　歴	：Ver 1.00		2001/01/30		K.Kimura		初版
****************************************************************************** */
char	GmFadeIn( u_char step, u_char mode)
{
	char		i, j;
	u_short		cnt, ocnt;
	u_short		mask;
	static	u_short		opal[ 2], npal[ 2];


	cnt  = 0;
	ocnt = 0;
	opal[ 0] = 0x6420;
	opal[ 1] = 0xfca8;
	npal[ 0] = 0;
	npal[ 1] = 0;

	if (mode )
	{
		npal[ 0] = 0xffff;
		npal[ 1] = 0xffff;
	}

	while (cnt < 0xff)
	{
		if ((ocnt & 0xf0) != (cnt & 0xf0))
		{
			for (i = 0; i < 2; i++)
			{
				for (j = 0; j < 4; j++)
				{
					mask = (0x000f << (j << 2));

					if ( mode)
					{
						if ((npal[ i] & mask) > (opal[ i] & mask))
							npal[ i] -= (0x0001 << (j << 2));
					}
					else
					{
						if ((npal[ i] & mask) < (opal[ i] & mask))
							npal[ i] += (0x0001 << (j << 2));
					}
				}
			}

			lcd_set_color( npal[ 0], npal[ 1]);

#if GM_PALETTE_DEBUG
	sprintf( buf, "LCD_FI::%4x::%4x\r\n", npal[ 0], npal[ 1]);
	DbgPrintPort( buf);
#endif
		}

		ocnt = cnt;
		cnt += step;

		sys_wait( 1);
	}

	return ( 0);
}


/* ******************************************************************************
　関　　数	：GmMoveDragon
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：ドラゴンのルーチンです。
		  	：
　履　　歴	：Ver 1.00		2001/01/31		K.Kimura		初版
****************************************************************************** */
void	GmMoveDragon( u_char i)
{
	static	ENMINFO		*ep, *ep2;
	static	GMOBJ		*op, *op2;
	static	u_char		tx, ty;

	u_char		step, idx;
	u_char		lret;
	u_char		dir;
	u_short		flag;
	short		nx, ny;
	u_char		ox, oy;
	u_char		dis;
	short		vx, vy;



	ep = &GmEmyInfo[ i];
	op = &GmEmy[ i];

	if (ep->nscnt)
		ep->nscnt--;								/* ｶｳﾝﾀ減算		*/

	/* 笛をふかれたよ */
	if (GameMng.flag & GM_MNGFLAG_WHISTLE)
	{
		if (ep->think == GM_EMYTH_SLEEP)
		{
			if (op->aspr->mode & ANM_MODE_END)
			{
				ano = EN_C0_03_ANW;					/* 永久眠りｱﾆﾒ	*/
				op->aspr->speed = 8;
				AnmSet( op->aspr, op->chr, ano, 0, ANM_MODE_LOOP);
			}
		}
	}

	if (op->aspr->anmNo == EN_C0_03_ANW)
		return;

	tx = op->aspr->x;
	ty = op->aspr->y;
	nx = tx - GmPly.aspr->x;
	ny = ty - GmPly.aspr->y;

	dis = 24 - (ep->algo << 1);			/* 間合い（初期値＝ビビリ） */

	/* ///  思考チェック？  /// */
	if ( ep->think == 0)
	{
		/*
			休憩時間？
		*/

		if (ep->nscnt == 0)
		{
			/* 行動ＯＫ */

			/* 攻撃を考えてみようか */
			ep->think = GM_EMYTH_ATTACK;
			op->act &= ~GM_PL_ACT_ST_MASK;
			op->act |= GM_PL_ACT_ATTACK;				/* 攻撃ﾌﾗｸﾞ			*/

			ep->nswd  = 0;
			ep->nscnt = 0;
			GmDFNum   = 3;								/* ３発				*/

#if GM_DRAGON_DEBUG
	sprintf( buf, "EP::(ACT_OK)GmDFNum::%u\r\n", GmDFNum);
	DbgPrintPort( buf);
#endif

		}
	}

	/* 笛だぁ */
	if (GameMng.flag & GM_MNGFLAG_WHISTLE)
	{
		ep->think = GM_EMYTH_SLEEP;
		op->act &= ~GM_PL_ACT_ST_MASK;
		op->act |= GM_PL_ACT_NORMAL;
	}

	/* ///  ■各行動分岐■  /// */
	switch (ep->think & GM_EMYTH_ACT_MASK)
	{
		/* ///  ●思考  /// */
		case GM_EMYTH_THINK:							/* 思考（硬化）中	*/
			ano = EN_C0_00_ANW;							/* 静止ｱﾆﾒ			*/

			if (ano != op->aspr->anmNo)
			{
				op->aspr->speed = 8;
				AnmSet( op->aspr, op->chr, ano, 0, ANM_MODE_LOOP);

				op->act &= ~GM_PL_ACT_ST_MASK;
				op->act |= GM_PL_ACT_NORMAL;			/* 静止ﾌﾗｸﾞ			*/
			}

#if GM_DRAGON_DEBUG
	sprintf( buf, "EP::(THINK)GmDFNum::%u\r\n", GmDFNum);
	DbgPrintPort( buf);
#endif
			break;


		/* ///  ●眠い  /// */
		case GM_EMYTH_SLEEP:								/* 寝てる		*/
			ano = EN_C0_02_ANW;							/* 眠りｱﾆﾒ			*/

			if (ano != op->aspr->anmNo)
			{
				op->aspr->speed = 12;
				AnmSet( op->aspr, op->chr, ano, 0, 0);
			}
			break;


		/* ///  ●攻撃  /// */
		case GM_EMYTH_ATTACK:								/* 攻撃		*/
			switch (ep->nswd)
			{
				/* ///  攻撃アニメ発行  /// */
				case 0:
					if (ep->nscnt)
						break;

					ano = EN_C0_01_ANW;						/* 攻撃ｱﾆﾒ			*/
					op->aspr->speed = (ABS( nx) >> 5) + 2;
					AnmSet( op->aspr, op->chr, ano, 0, 0);

#if GM_DRAGON_DEBUG
	sprintf( buf, "EP::(0)speed::%u\r\n", op->aspr->speed);
	DbgPrintPort( buf);
#endif
					ep->nswd ++;
					break;


				/* ///  弾アニメ発行  /// */
				case 1:
					if (op->aspr->mode & ANM_MODE_END)
					{
						ano = EN_C0_00_ANW;						/* 静止ｱﾆﾒ			*/
						op->aspr->speed = 8;
						AnmSet( op->aspr, op->chr, ano, 0, ANM_MODE_LOOP);

						GmDFNum--;

						if (GmDFNum != 0)
						{
							ep->nscnt = (ABS( nx) >> 2);		/* 発射までの時間	*/
							ep->nswd  = 0;						/* 再攻撃			*/
#if GM_DRAGON_DEBUG
	sprintf( buf, "EP::(1)::%u\r\n", ep->nscnt);
	DbgPrintPort( buf);
#endif
						}
						else
						{
							ep->think = 0;						/* to 思考			*/
							ep->nscnt = 30;
						}

						break;
					}

					idx = GameMng.splIdx + GmDFNum - 1;

					ep2 = &GmEmyInfo[ i + idx];
					op2 = &GmEmy[ i + idx];

					/* ///  ■ 弾発射？ ■  /// */
					if ((op->aspr->motNo == 2)
						 && ((ep2->flag & 0x01) == 0)
						 && (op->aspr->time == 1))
					{
						ano = EN_C0_04_ANW;
						ep2->flag |= 0x01;						/* 呪文 ON	*/
						op2->act = GM_PL_ACT_SPELL;

						se_play_n( GMSE_SPELL02);				/* SE		*/

						AnmSet( op2->aspr, op->chr, ano, 0, ANM_MODE_LOOP);
						ep2->flag |= 0x01;						/* 呪文 ON	*/
						op2->aspr->x = tx;
						ep2->mv = 0x04;							/* 速い！	*/

						op2->direct = 3;

						/* 座標設定 */
						op2->aspr->y = (ty - (GmDFNum << 3) + 16);
					}
					break;

			}
			break;


		default:
			break;
	}

}


/* ******************************************************************************
　関　　数	：GmMoveDragon
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：テスタロッサ死亡（＝クリア）
		  	：
　履　　歴	：Ver 1.00		2001/01/31		K.Kimura		初版
****************************************************************************** */
void	GmInitGameEND( void)
{

	GmFadeInPal( GMPAL_BG, GMPAL_WOUT, 0x02);
	GmFadeOut( 0x04, 0);
	sys_wait( 1);

	display_control( 0x0000);
	lcd_set_color( 0x6420, 0xfca8);

	if (GmTmpHScore < GmPlInfo.score)
		GmTmpHScore = GmPlInfo.score;

}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：
		  	：
　履　　歴	：Ver 1.00		2001/01/31		K.Kimura		初版
****************************************************************************** */
void	GmMoveGameEND( void *func)
{
	GmIndex = GMI_ENDING;
	GmSStepTest = GMT_END;
	VblkMng.loopExit = 1;						/* LOOP脱出					*/
}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：
		  	：
　履　　歴	：Ver 1.00		2001/01/31		K.Kimura		初版
****************************************************************************** */
void	GmDispStatus( void)
{
	/* ///  ■ 基本スコア等表示 ■  /// */
	GmDispScore( 2, 0, GmTmpHScore);					/* HI-SCORE	表示		*/
	GmDispScore( 0, 0, GmPlInfo.score);					/* SCORE	表示		*/
	GmDispFloor( 1, 16, (GameMng.floor + 1));			/* ﾌﾛｱ表示				*/
	GmDispHitPoint( GmPlInfo.hp);						/* HP 表示				*/
}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：オープニング・イベント用扉セット
		  	：
　履　　歴	：Ver 1.00		2001/01/31		K.Kimura		初版
****************************************************************************** */
void	GmPutDorrCG( u_char scr, u_char x, u_char y, u_char dir, u_char mode)
{
	char		i, j;
	u_char		nmode;
	u_short		data, ndata;


	data  = (GMPAL_BG << 9) + VRM_BG;

	if (mode == 0)
	{
		screen_fill_char( scr, x, y, 3, 2, (4 << 9));		/* 抜けのため 4			*/
		return;
	}

	/* ///  扉描画＆フラグ設定  /// */
	for (i = 0; i < 2; i++)
	{
		for (j = 0; j < 3; j++)
		{
			ndata = data + GmDoorData[ dir][(i * 3) + j];
			screen_fill_char( scr, (x + j), (y + i), 1, 1, ndata);
		}
	}

}


/* ******************************************************************************
　関　　数	：
　内　　容	：
　表　　記	：
　引　　数	：
　返　　値	：−
　コメント	：オープニング・イベント
		  	：
　履　　歴	：Ver 1.00		2001/01/31		K.Kimura		初版
****************************************************************************** */
void	GmInitOPEvent( void)
{
	char		i;


	sys_wait( 50);										/* VSyncWait				*/

	GmPutDorrCG( 1, 6, 10, 1, 0);
	se_play_n( GMSE_DOOR);

	sys_wait( 30);										/* VSyncWait				*/

	ano = PL_A0_04_ANW;									/* 上	*/
	GmPly.aspr->speed = 6;
	AnmSet( GmPly.aspr, CHR_PLAYER, ano, 0, (ANM_MODE_ACTIVE | ANM_MODE_LOOP));

	for (i = 0; i <= 32; i++)
	{
		if (i & 0x01)
			GmPly.aspr->x ++;

		AnmExec();										/* ｱﾆﾒｰｼｮﾝ処理				*/

		sys_wait( 1);									/* VSyncWait				*/

		AnmTransfer();									/* ﾃﾞｰﾀ転送処理				*/
		AnmLocateAll();									/* ｽﾌﾟﾗｲﾄ表示処理			*/
	}

	ano = PL_A0_00_ANW;									/* 上	*/
	AnmSet( GmPly.aspr, CHR_PLAYER, ano, 0, (ANM_MODE_ACTIVE | ANM_MODE_LOOP));

	sys_wait( 30);										/* VSyncWait				*/

	GmPutDorrCG( 0, 0, 10, 1, 1);
	se_play_n( GMSE_DOOR);

}