/*!

	鮫亀駒部分

*/
#if defined KOMA_INCLUDED___
  #endinput
#endif
#define KOMA_INCLUDED___

#include "types.inc"

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

#define KOMA_PIPE_TEXNUM		(16)			//くっつきコマの通常・選択のテクスチャ枚数
#define KOMA_PIPE_VOID_TEXNUM	(6)
#define KOMA_TEXTUREARRAYSIZE	(200)			//ばらばらの駒は6+6+1 * 5種類で65
#define KOMA_TEXNUM				(KOMA_PIPE_TEXNUM * 2 + KOMA_PIPE_VOID_TEXNUM)

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

stock KomaCheckAround(const index);

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

static g_Koma[MAX_ARRAY][tagObjectData];
static g_KomaIndex[MAX_ARRAY];					//駒の配置情報
static g_KomaAnimSeq[10][tagAnimSeqData];		//駒の配置情報

static g_KomaStoreType[MAX_ARRAY];				//駒の配置情報

static g_KomaAnimFrame;							//フレーム数
static g_KomaAnimWait;							//１フレームのコマ数
static g_KomaAnimWaitCount;						//１フレーム内のカウンタ
static g_KomaAnimStartIndex;
static g_KomaAnimEndIndex;
static g_KomaAnimTermFlag;

static g_StageHeight;
static g_StageWidth;
static g_KomaMaxSize;							//駒の最大数

static bool:g_IsSelected;						//駒が今選択されているか。
static bool:g_bTextureLoaded = false;
//static SelectPosX, SelectPosY;					//選択をしたカーソルの座標

static texture:g_TextureKoma[KOMA_TEXTUREARRAYSIZE];	//

static g_KomaID = -1;							//駒の種類
static g_KomaAttr = -1;							//駒の属性（くっつくか、ばらばらか）

static float:g_KomaSize;						//駒の大きさ
static float:g_KomaHalfSize;					//駒の半分の大きさ

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

//一こまのテクスチャ枚数
//KOMA_PIPE_TEXNUMが二つと消失パターンが最大なので…。
//const KOMA_TEXNUM = (KOMA_PIPE_TEXNUM * 2 + 6);

//////////////////////////////////////////////////////////////////////////////////
/*!
	駒を読み込む
*/
stock KomaAnimLoad(const id[]) {

//	printf("%s\n", id);

	new xmltag:parent = domFindTag(domRoot(), "KOMAANIM", id);
	for (new xmltag: child = domFirstChild(parent) ; child ; child = domNext(child)) {

		new koma_no = GetNumericData(child, "no");
		new type = GetNumericData(child, "type");

		new array_index = (koma_no * 2) + type;

		g_KomaAnimSeq[array_index][No]			 = koma_no;
		g_KomaAnimSeq[array_index][Action]		 = type;
		g_KomaAnimSeq[array_index][StartIndex]	 = GetNumericData(child, "start");
		g_KomaAnimSeq[array_index][EndIndex]	 = GetNumericData(child, "end");
		g_KomaAnimSeq[array_index][Time]		 = GetNumericData(child, "frame");
		g_KomaAnimSeq[array_index][Term]		 = GetNumericData(child, "term");
	}

}
//////////////////////////////////////////////////////////////////////////////////
/*!
	駒のデータを読み込む
*/
stock KomaDataLoad(const koma_id) {

	if (g_bTextureLoaded) {
		KomaTextureDestroyAll();
	}

	new xmltag:parent = domFindTag(domRoot(), "KOMA", "koma_data");
	new xmltag:child = domFirstChild(parent);
	for (new i = 0; i < koma_id;i++) child = domNext(child);

	//駒のテクスチャパスを取得して読み込む
	new tmp_value[128];
	domGetData(child, "koma_path", tmp_value);

	imgDecStart(tmp_value, _, _, _, _, IMGDEC_FLAG_INDIRECT);
	imgDecWait();

	domGetData(child, "attr", tmp_value);
	if (strcmp(tmp_value, "combine") == 0) {
		//くっつく１６枚　選択１６枚　消去６枚　の順番でならんでいます。
		//くっつくタイプ
		TrimingTextureFromXml(domRoot(), "TEXTURE", "bind_koma", g_TextureKoma);
		g_KomaAttr = KOMAATTR_COMBINE;
	} else {
		//ばらばらのタイプ
		TrimingTextureFromXml(domRoot(), "TEXTURE", "bara_koma", g_TextureKoma);
		TrimingTextureFromXml(domRoot(), "TEXTURE", "bara_koma", g_TextureKoma, KOMA_TEXNUM ,    _, 64);
		TrimingTextureFromXml(domRoot(), "TEXTURE", "bara_koma", g_TextureKoma, KOMA_TEXNUM * 2, _, 128);
		TrimingTextureFromXml(domRoot(), "TEXTURE", "bara_koma", g_TextureKoma, KOMA_TEXNUM * 3, _, 192);
		TrimingTextureFromXml(domRoot(), "TEXTURE", "bara_koma", g_TextureKoma, KOMA_TEXNUM * 4, _, 256);

		g_KomaAttr = KOMAATTR_SEPARATE;

	}

//	printf("%d : %d\n", g_KomaID, koma_id);

	g_KomaID = koma_id;

	domGetData(child, "anim", tmp_value);

//	printf("%s\n", tmp_value);
	g_bTextureLoaded = true;

	KomaAnimLoad(tmp_value);
}

//////////////////////////////////////////////////////////////////////////////////
/*!
	駒の初期化をする
*/
stock KomaInitialize(const game_level, const koma_id, obj:parent, bool: retry = false) {

	listRemoveAll();

	g_IsSelected = false;

	g_StageWidth = KOMA_LENGTH[game_level];
	g_StageHeight = KOMA_LENGTH[game_level];

	g_KomaMaxSize = g_StageWidth * g_StageHeight;

//	printf("komaid %d : %d\n", g_KomaID, koma_id);
	if (koma_id != g_KomaID) {
		KomaDataLoad(koma_id);
	}

	g_KomaSize = KOMA_SIZE[game_level];
	g_KomaHalfSize = g_KomaSize / 2.0;

	new index = 0;
	for (new y = 0;y < g_StageHeight;y++) {
		for (new x = 0;x < g_StageWidth;x++) {

			new komatype;
			//リトライするときは同じ配置です。
			if (retry) {
				komatype = g_KomaStoreType[index];
			} else {
				komatype = random(5 - ((game_level == 0) ? 1 : 0));
//				komatype = 0;
				g_KomaStoreType[index] = komatype;
			}

			//コマの種類によって設定するテクスチャIDを決める
			//くっつきコマは白のテクスチャの色合いを変化させる。
			//ただしここで設定してもKomaTextureAssignで変更されます。
			new tex_id;
			if (g_KomaAttr == KOMAATTR_SEPARATE) {
				tex_id = KOMA_TEXNUM * komatype;
			} else {
				tex_id = 0;
			}

			g_Koma[index][Object] = CreateCharacterObject(
										x * g_KomaSize, y * g_KomaSize,
										g_KomaSize, g_KomaSize,
										g_TextureKoma[tex_id], parent,
										ZSORT_NORMAL, 10.0
									);
			if (g_KomaAttr == KOMAATTR_COMBINE) {
				new float: color[5][] = {
					{ 0.9,  0.4, 0.3},
					{ 1.0,  1.0, 1.0},
					{ 0.0,  0.9, 0.9},
					{ 0.9,  0.9, 0.0},
					{ 0.0,  0.9, 0.3}
				};
				SetColor(obj: g_Koma[index][Object], color[komatype][0], color[komatype][1], color[komatype][2], 1.0);
			}
			Hide(obj:g_Koma[index][Object]);

			g_Koma[index][Type] = komatype;
			g_Koma[index][PointX] = x;
			g_Koma[index][PointY] = y;
			g_Koma[index][Selected] = 0;

			g_KomaIndex[index] = index;

			index++;
		}
	}

}
//////////////////////////////////////////////////////////////////////////////////
/*!
	駒を全削除する。
*/
stock KomaObjectDestroyAll() {

	for (new index = 0;index < g_KomaMaxSize; index++) {

		g_Koma[index][PointX] = 0;
		g_Koma[index][PointY] = 0;
		g_Koma[index][Type] = 0;

		new obj: target = obj:g_Koma[index][Object];
		SafeDestroyObject(target);

	}
	listRemoveAll();

}
//////////////////////////////////////////////////////////////////////////////////
/*!
	駒テクスチャを全削除する。
*/
stock KomaTextureDestroyAll() {

	ArrayReleaseTexture(g_TextureKoma);
	g_bTextureLoaded = false;

}
//////////////////////////////////////////////////////////////////////////////////
/*!
	駒データもろもろの全削除
*/
stock KomaUnInitialize() {

	g_KomaID = -1;
	g_KomaAttr = -1;

	KomaObjectDestroyAll();
	KomaTextureDestroyAll();

}

//////////////////////////////////////////////////////////////////////////////////
/*!
	駒を隠す
*/
stock KomaHideAll() {

	for (new i = 0;i < MAX_ARRAY;i++) {

		new obj: target = obj:g_Koma[i][Object];
		if (IsValidObject(target)) {
			Hide(target);
		}
	}

}
//////////////////////////////////////////////////////////////////////////////////
/*!
	駒を表示する
*/
stock KomaShowAll() {

	for (new i = 0;i < MAX_ARRAY;i++) {

		new obj: target = obj:g_Koma[i][Object];
		if (IsValidObject(target)) {
			Show(target);
		}
	}

}

//////////////////////////////////////////////////////////////////////////////////
/*!
	駒の描画をする
*/
stock KomaDraw() {

	new index = 0;

	for (new y = 0;y < g_StageHeight;y++) {
		for (new x = 0;x < g_StageWidth;x++) {

			if (g_KomaIndex[index] != -1) {
				new obj_index = g_KomaIndex[index];

				new float: new_x = x * g_KomaSize;
				new float: new_y = y * g_KomaSize;
				new obj: target = obj:g_Koma[obj_index][Object];

				if (IsValidObject(target)) {
					SetPos(target, new_x + g_KomaHalfSize, new_y + g_KomaHalfSize, 1.0);
				}
			}
			index++;
		}
	}

	//くっつきコマのテクスチャ再設定
	if (g_KomaAttr == KOMAATTR_COMBINE) {
		KomaTextureAllAssign();
	}

}
//////////////////////////////////////////////////////////////////////////////////
/*!
	駒の描画をする
*/
stock KomaDropDraw() {

	new index = 0;
	new float:max_wait = 0.0;

	for (new y = 0;y < g_StageHeight;y++) {
		for (new x = 0;x < g_StageWidth;x++) {

			if (g_KomaIndex[index] != -1) {
				new obj_index = g_KomaIndex[index];

				new float: new_x = x * g_KomaSize;
				new float: new_y = y * g_KomaSize;
				new obj: target = obj:g_Koma[obj_index][Object];

				if (IsValidObject(target)) {
					new float: tmp_x, float: tmp_y, float: tmp_z;
					GetPos(target, tmp_x, tmp_y, tmp_z);

					new float:time_mul;

					//アニメーションして落下をする。
					//この辺は落下の高さによって最大の待ち時間を計算している。
					if (tmp_y < new_y) {
						time_mul = (new_y - tmp_y) / g_KomaSize;
					} else {
						time_mul = (tmp_x - new_x) / g_KomaSize;
					}
					new float:tmp_wait = float(floatround(75.0 * time_mul));

					if (max_wait < tmp_wait) {
						max_wait = tmp_wait;
					}

					AnimMoveLine(target, new_x + g_KomaHalfSize, new_y + g_KomaHalfSize, 1.0, tmp_wait);
//					SetPos(target, new_x + g_KomaHalfSize, new_y + g_KomaHalfSize, 1.0);
				}
			}
			index++;
		}
	}

	wait(floatround(max_wait));

}
//////////////////////////////////////////////////////////////////////////////////
/*!
	駒を消した時のスコアを計算
	得点を返します。
*/
stock KomaScoreCalc(const x, const y) {

	if (listSize()) {
		for (new i = 0;i < listSize(); i++) {
			g_Koma[g_KomaIndex[listGetAt(i)]][Selected] = 0;
		}
		listRemoveAll();
	}

	//選択できるかをチェックする。
	new start_index = y * g_StageWidth + x;
	if (g_KomaIndex[start_index] != -1) {

		KomaCheckAround(start_index);

		//二駒以上つながっているので、チェック
		if (listSize()) {
//			g_IsSelected = true;

			listAddLast(start_index);
			g_Koma[g_KomaIndex[start_index]][Selected] = 1;

			for (new i = 0;i < listSize();i++) {
				new check_index = listGetAt(i);
				KomaCheckAround(check_index);
				g_Koma[g_KomaIndex[check_index]][Selected] = 1;
			}
		}
	}


	new num = listSize();

//	printf("num : %d\n",num);
	if (num) {
		num = ((num - 1) * (num - 1));
//		printf("score : %d( %d )\n", num, listSize());
	}

	return num;

}
//////////////////////////////////////////////////////////////////////////////////
/*!
	駒の選択をキャンセル
*/
/*
stock KomaCancel() {

	if (listSize()) {
		for (new i = 0;i < listSize(); i++) {
			g_Koma[g_KomaIndex[listGetAt(i)]][Selected] = 0;
		}
		listRemoveAll();
	
		printf("Cancel.\n");
	}

}
*/
//////////////////////////////////////////////////////////////////////////////////
/*!
	駒の選択をキャンセル
*/
stock KomaSelectCancel() {

	if (g_IsSelected) {

		SEPlay(SE_KOMA_CANCEL);

		//くっつきコマのテクスチャ再設定
		if (g_KomaAttr == KOMAATTR_COMBINE) {
			KomaTextureAllAssign();
		} else {

			new type = g_Koma[g_KomaIndex[listGetAt(0)]][Type];
			new texture: tex = g_TextureKoma[type * KOMA_TEXNUM];
			for (new i = 0;i < listSize();i++) {

				new obj_index = listGetAt(i);
				new koma_index = g_KomaIndex[obj_index];
				new obj:target = obj:g_Koma[koma_index][Object];

				SetTexture(target, tex);
			}
		}
	}

	g_IsSelected = false;

}
//////////////////////////////////////////////////////////////////////////////////
/*!
	駒の周りをチェックします
*/
stock KomaCheckAround(const index) {

	//消去済みのところは見に行かない。
	if (g_KomaIndex[index] == -1) {
		return;
	}
	new select_type = g_Koma[g_KomaIndex[index]][Type];

	new x = index % g_StageWidth;
	new y = index / g_StageWidth;

	//上方向をチェック
	if (y != 0) {
		new tmp_index = (y - 1) * g_StageWidth + x;
		new koma_index = g_KomaIndex[tmp_index];

		if (koma_index != -1) {
			if ((select_type == g_Koma[koma_index][Type]) && (!g_Koma[koma_index][Selected])) {
				g_Koma[koma_index][Selected] = 1;
				listAddLast(tmp_index);
			}
		}
	}

	//下方向をチェック
	if (y != (g_StageHeight - 1)) {
		new tmp_index = (y + 1) * g_StageWidth + x;
		new koma_index = g_KomaIndex[tmp_index];

		if (koma_index != -1) {
			if ((select_type == g_Koma[koma_index][Type]) && (!g_Koma[koma_index][Selected])) {
				g_Koma[koma_index][Selected] = 1;
				listAddLast(tmp_index);
			}
		}
	}

	//左方向をチェック
	if (x != 0) {
		new tmp_index = y * g_StageWidth + (x - 1);
		new koma_index = g_KomaIndex[tmp_index];

		if (koma_index != -1) {
			if ((select_type == g_Koma[koma_index][Type]) && (!g_Koma[koma_index][Selected])) {
				g_Koma[koma_index][Selected] = 1;
				listAddLast(tmp_index);
			}
		}
	}

	//右方向をチェック
	if (x != (g_StageWidth - 1)) {
		new tmp_index = y * g_StageWidth + (x + 1);
		new koma_index = g_KomaIndex[tmp_index];

		if (koma_index != -1) {
			if ((select_type == g_Koma[koma_index][Type]) && (!g_Koma[koma_index][Selected])) {
				g_Koma[koma_index][Selected] = 1;
				listAddLast(tmp_index);
			}
		}
	}

}

//////////////////////////////////////////////////////////////////////////////////
/*!
	駒が落ちます。
*/
stock KomaVerticalDrop() {


	//下から上に向かって検索をします。
	for (new x = 0;x < g_StageWidth;x++) {
		for (new y = (g_StageHeight - 1);y > -1; y--) {

			new check_index = y * g_StageWidth + x;

			if (g_KomaIndex[check_index] == -1) {
				//空白を発見
				//そこから上を検索する。
				for (new tmp_y = (y - 1); tmp_y > -1; tmp_y--) {

					new tmp_index = tmp_y * g_StageWidth + x;

					if (g_KomaIndex[tmp_index] != -1) {
						//空白じゃないところを発見したので、詰める
//						printf("%d(%d) <= %d(%d)\n", check_index, g_KomaIndex[check_index], tmp_index, g_KomaIndex[tmp_index]);
						g_KomaIndex[check_index] = g_KomaIndex[tmp_index];
						g_KomaIndex[tmp_index] = -1;

						break;

					}
				}
			}
		}
	}

}
//////////////////////////////////////////////////////////////////////////////////
/*!
	駒が横方向に落ちます。
*/
stock KomaHorizontalDrop() {


	for (new x = 0; x < g_StageWidth; x++) {
		new check_index = (g_StageHeight - 1) * g_StageWidth + x;
		//縦一列なくなっているかチェック
		if (g_KomaIndex[check_index] == -1) {
			//なくなっているので横方向を詰める

			for (new tmp_x = (x + 1); tmp_x < g_StageWidth; tmp_x++) {
				new tmp_index = (g_StageHeight - 1) * g_StageWidth + tmp_x;
				if (g_KomaIndex[tmp_index] != -1) {

					for (new tmp_y = 0; tmp_y < g_StageHeight; tmp_y++) {
						tmp_index = tmp_y * g_StageWidth + tmp_x;
						check_index = tmp_y * g_StageWidth + x;

//						printf("%d(%d) <= %d(%d)\n", check_index, g_KomaIndex[check_index], tmp_index, g_KomaIndex[tmp_index]);

						g_KomaIndex[check_index] = g_KomaIndex[tmp_index];
						g_KomaIndex[tmp_index] = -1;
					}

					break;

				}
			}

		}
	}

}
//////////////////////////////////////////////////////////////////////////////////
/*!
	駒の選択します。
*/
//stock KomaSelect(const x, const y) {
stock KomaSelect() {

	//既に選択されている時は消去作業
	if (g_IsSelected) {

		SEPlay(SE_KOMA_VOID);

		KomaDeleteAnimation();

		LeftSub(listSize());
		ScoreAdd();

		for (new i = 0;i < listSize();i++) {
			new obj_index = listGetAt(i);
			new koma_index = g_KomaIndex[obj_index];
			g_Koma[koma_index][Selected] = 0;
			g_Koma[koma_index][Type] = -1;
			SafeDestroyObject(obj:g_Koma[koma_index][Object]);

			g_KomaIndex[obj_index] = -1;

		}
		listRemoveAll();
		printf("Deleted.\n");

		KomaVerticalDrop();
		KomaDropDraw();
		KomaHorizontalDrop();
		KomaDropDraw();

		//くっつきコマのテクスチャ再設定
		if (g_KomaAttr == KOMAATTR_COMBINE) {
			KomaTextureAllAssign();
		}

		g_IsSelected = false;


	} else {
		//選択できるかをチェックする。
		if (listSize()) {

			SEPlay(SE_KOMA_SELECT);

			g_IsSelected = true;

			g_KomaAnimFrame = 0;
			new koma_index = g_KomaIndex[listGetAt(0)];
			new koma_type = g_Koma[koma_index][Type];

			koma_type *= 2;

//			printf("koma_type : %d\n", koma_type);

			g_KomaAnimWait = g_KomaAnimSeq[koma_type][Time];
			g_KomaAnimWaitCount = 0;

			g_KomaAnimStartIndex = g_KomaAnimSeq[koma_type][StartIndex];
			g_KomaAnimEndIndex = g_KomaAnimSeq[koma_type][EndIndex];
			g_KomaAnimTermFlag = g_KomaAnimSeq[koma_type][Term];
		}
	}

}

//////////////////////////////////////////////////////////////////////////////////
/*!
	駒の選択アニメーションをします。
*/
stock KomaSelectAnimation() {

	if (g_IsSelected) {

		if (g_KomaAttr == KOMAATTR_COMBINE) {
			//くっつきこま
			KomaTextureSelectedAssign();
		} else {

			g_KomaAnimWaitCount++;
			if (g_KomaAnimWaitCount == g_KomaAnimWait) {
				g_KomaAnimWaitCount = 0;
				if ((g_KomaAnimEndIndex - g_KomaAnimStartIndex) < (g_KomaAnimFrame + 1)) {
					switch (g_KomaAnimTermFlag) {
						case 0:	{		//ループなし
							g_KomaAnimWaitCount = 0;
						}
						case 1: {		//ループ
							g_KomaAnimWaitCount = 0;
							g_KomaAnimFrame = 0;
						}
					}
				} else {
					g_KomaAnimFrame++;
				}
			}

			//ばらばらこま
			new texture: tex = g_TextureKoma[g_KomaAnimStartIndex + g_KomaAnimFrame];
			for (new i = 0;i < listSize();i++) {
	
				new obj_index = listGetAt(i);
				new koma_index = g_KomaIndex[obj_index];
				new obj:target = obj:g_Koma[koma_index][Object];
	
				SetTexture(target, tex);
			}
		}
	}
}
//////////////////////////////////////////////////////////////////////////////////
/*!
	駒の削除アニメーションをします。
*/
stock KomaDeleteAnimation() {

	if (g_IsSelected) {

		g_KomaAnimFrame = 0;
		new koma_index = g_KomaIndex[listGetAt(0)];
		new koma_type = g_Koma[koma_index][Type];

		koma_type = (koma_type * 2) + 1;

		g_KomaAnimWait = g_KomaAnimSeq[koma_type][Time];
		g_KomaAnimWaitCount = 0;

		g_KomaAnimStartIndex = g_KomaAnimSeq[koma_type][StartIndex];
		g_KomaAnimEndIndex = g_KomaAnimSeq[koma_type][EndIndex];
		g_KomaAnimTermFlag = g_KomaAnimSeq[koma_type][Term];


		new loop = 0;

		for (;;) {

			g_KomaAnimWaitCount++;
			if (g_KomaAnimWaitCount == g_KomaAnimWait) {
				g_KomaAnimFrame++;
				g_KomaAnimWaitCount = 0;
				if ((g_KomaAnimEndIndex - g_KomaAnimStartIndex) < g_KomaAnimFrame) {

					switch (g_KomaAnimTermFlag) {
						case 0:	break;
						case 1: {
							g_KomaAnimWaitCount = 0;
							g_KomaAnimFrame = 0;

							loop++;
							if (loop == 2) {
								break;
							}
						}
					}
				}
			}
	
//			printf("texture : %d\n", g_KomaAnimStartIndex + g_KomaAnimFrame);
	
			new texture: tex = g_TextureKoma[g_KomaAnimStartIndex + g_KomaAnimFrame];
			for (new i = 0;i < listSize();i++) {
	
				new obj_index = listGetAt(i);
				koma_index = g_KomaIndex[obj_index];
				new obj:target = obj:g_Koma[koma_index][Object];

				SetTexture(target, tex);

				if ((g_KomaAnimTermFlag == 1) && (loop == 0)) {
					//termフラグが1の時は縮小する。
					AnimScale(target, 0.0, 0.0, 1.0, 1000.0);
				}
			}
			sleep;
		}
	}
}

/*!
	もうとれなくなったかを調べます。
*/
stock KomaCheckEnd() {

	new koma_count = 0;

	for (new y = 0;y < g_StageHeight;y++) {
		for (new x = 0;x < g_StageWidth;x++) {

			new index = y * g_StageWidth + x;

			//消去済みのところは見に行かない。
			if (g_KomaIndex[index] == -1) {
				continue;
			}

			koma_count++;

			new select_type = g_Koma[g_KomaIndex[index]][Type];
			//上方向をチェック
			if (y != 0) {
				new tmp_index = (y - 1) * g_StageWidth + x;
				new koma_index = g_KomaIndex[tmp_index];

				if (koma_index != -1) {
					if (select_type == g_Koma[koma_index][Type]) {
						return ENDCHECK_CONTINUE;
					}
				}
			}

			//下方向をチェック
			if (y != (g_StageHeight - 1)) {
				new tmp_index = (y + 1) * g_StageWidth + x;
				new koma_index = g_KomaIndex[tmp_index];

				if (koma_index != -1) {
					if (select_type == g_Koma[koma_index][Type]) {
						return ENDCHECK_CONTINUE;
					}
				}
			}

			//左方向をチェック
			if (x != 0) {
				new tmp_index = y * g_StageWidth + (x - 1);
				new koma_index = g_KomaIndex[tmp_index];

				if (koma_index != -1) {
					if (select_type == g_Koma[koma_index][Type]) {
						return ENDCHECK_CONTINUE;
					}
				}
			}

			//右方向をチェック
			if (x != (g_StageWidth - 1)) {
				new tmp_index = y * g_StageWidth + (x + 1);
				new koma_index = g_KomaIndex[tmp_index];

				if (koma_index != -1) {
					if (select_type == g_Koma[koma_index][Type]) {
						return ENDCHECK_CONTINUE;
					}
				}
			}
		}
	}

	if (koma_count) {
		//とれるものがなくなった。
		return ENDCHECK_NOGET;
	}

	//クリア
	return ENDCHECK_CLEAR;
}
stock bool:IsKomaSelectEnable() {
	return (listSize() != 0) ? true : false;
}

stock KomaTextureSelectedAssign() {

	for (new i = 0;i < listSize();i++) {
		new index = listGetAt(i);

		new y = index / g_StageWidth;
		new x = index % g_StageWidth;

		new obj:koma = obj:g_Koma[g_KomaIndex[index]][Object];
		SetTexture(koma, KomaTextureAssign(x, y, true));
	}

}

stock KomaTextureAllAssign() {
	for (new y = 0;y < g_StageHeight;y++) {
		for (new x = 0;x < g_StageWidth;x++) {

			new index = y * g_StageWidth + x;

			//消去済みのところは見に行かない。
			if (g_KomaIndex[index] == -1) {
				continue;
			}

			new obj:koma = obj:g_Koma[g_KomaIndex[index]][Object];
			SetTexture(koma, KomaTextureAssign(x, y));

		}
	}
}

stock texture:KomaTextureAssign(const x, const y, bool:tex_flag = false) {
//	for (new y = 0;y < g_StageHeight;y++) {
//		for (new x = 0;x < g_StageWidth;x++) {

			new side = 0;			//全部つながっている
			new index = y * g_StageWidth + x;

			//消去済みのところは見に行かない。
//			if (g_KomaIndex[index] == -1) {
//				continue;
//			}

			new select_type = g_Koma[g_KomaIndex[index]][Type];

			//上方向をチェック
			if (y == 0) {
				side |= SIDE_TOP;
			} else {
				new tmp_index = (y - 1) * g_StageWidth + x;
				new koma_index = g_KomaIndex[tmp_index];

				if (koma_index == -1) {
					side |= SIDE_TOP;
				} else {
					if (select_type != g_Koma[koma_index][Type]) {
						side |= SIDE_TOP;
					}
				}
			}

			//下方向をチェック
			if (y == (g_StageHeight - 1)) {
				side |= SIDE_BOTTOM;
			} else {
				new tmp_index = (y + 1) * g_StageWidth + x;
				new koma_index = g_KomaIndex[tmp_index];

				if (koma_index == -1) {
					side |= SIDE_BOTTOM;
				} else {
					if (select_type != g_Koma[koma_index][Type]) {
						side |= SIDE_BOTTOM;
					}
				}
			}

			//左方向をチェック
			if (x == 0) {
				side |= SIDE_LEFT;
			} else {
				new tmp_index = y * g_StageWidth + (x - 1);
				new koma_index = g_KomaIndex[tmp_index];

				if (koma_index == -1) {
					side |= SIDE_LEFT;
				} else {
					if (select_type != g_Koma[koma_index][Type]) {
						side |= SIDE_LEFT;
					}
				}
			}

			//右方向をチェック
			if (x == (g_StageWidth - 1)) {
				side |= SIDE_RIGHT;
			} else {
				new tmp_index = y * g_StageWidth + (x + 1);
				new koma_index = g_KomaIndex[tmp_index];

				if (koma_index == -1) {
					side |= SIDE_RIGHT;
				} else {
					if (select_type != g_Koma[koma_index][Type]) {
						side |= SIDE_RIGHT;
					}
				}
			}

//			new obj:koma = obj:g_Koma[g_KomaIndex[index]][Object];
			new tex_index;
			switch (side) {
				case 0:													tex_index = TEXTURE_KOMA_TOPBOTTOMLEFTRIGHT;
				case SIDE_TOP:											tex_index = TEXTURE_KOMA_BOTTOMLEFTRIGHT;
				case SIDE_BOTTOM:										tex_index = TEXTURE_KOMA_TOPLEFTRIGHT;
				case SIDE_TOP | SIDE_BOTTOM:							tex_index = TEXTURE_KOMA_LEFTRIGHT;
				case SIDE_TOP | SIDE_LEFT:								tex_index = TEXTURE_KOMA_BOTTOMRIGHT;
				case SIDE_TOP | SIDE_RIGHT:								tex_index = TEXTURE_KOMA_BOTTOMLEFT;
				case SIDE_TOP | SIDE_BOTTOM | SIDE_LEFT:				tex_index = TEXTURE_KOMA_RIGHT;
				case SIDE_TOP | SIDE_BOTTOM | SIDE_RIGHT:				tex_index = TEXTURE_KOMA_LEFT;
				case SIDE_BOTTOM | SIDE_LEFT:							tex_index = TEXTURE_KOMA_TOPRIGHT;
				case SIDE_BOTTOM | SIDE_RIGHT:							tex_index = TEXTURE_KOMA_TOPLEFT;
				case SIDE_TOP | SIDE_LEFT | SIDE_RIGHT:					tex_index = TEXTURE_KOMA_BOTTOM;
				case SIDE_BOTTOM | SIDE_LEFT | SIDE_RIGHT:				tex_index = TEXTURE_KOMA_TOP;
				case SIDE_LEFT:											tex_index = TEXTURE_KOMA_TOPBOTTOMRIGHT;
				case SIDE_RIGHT:										tex_index = TEXTURE_KOMA_TOPBOTTOMLEFT;
				case SIDE_LEFT | SIDE_RIGHT:							tex_index = TEXTURE_KOMA_TOPBOTTOM;
				case SIDE_TOP | SIDE_BOTTOM | SIDE_LEFT | SIDE_RIGHT:	tex_index = TEXTURE_KOMA_NONE_V;
			}
//			SetTexture(koma, g_TextureKoma[tex_index + select_type * KOMA_TEXNUM]);
			if (tex_flag) {
				tex_index += KOMA_PIPE_TEXNUM;	//パイプのテクスチャ枚数 
			}
//			return g_TextureKoma[tex_index + select_type * KOMA_TEXNUM];
			return g_TextureKoma[tex_index];

//		}
//	}
}
