// toril_chacker.cpp : コンソール アプリケーションのエントリ ポイントを定義します。
//

#include "stdafx.h"

const int BLOCK_MAX = 10;
const int STAGE_SIZE_X = 3;
const int STAGE_SIZE_Y = 3;
const int STAGE_SIZE_H = 3;
const int FIGURE_SIZE_X = 16;
const int FIGURE_SIZE_Y = 13;

const int FIG_BASE_X = 4;
const int FIG_BASE_Y = 4;
const int FIG_BLOCK_SIZE_X = 6;
const int FIG_BLOCK_SIZE_Y = 5;

void CopyString( char* dst, const WCHAR* src,const int len )
{
	if( len == 0 ) return;
	WideCharToMultiByte(CP_ACP,		// コードページ
						0,			// 処理速度とマッピング方法を決定するフラグ
						src, // ワイド文字列のアドレス
						-1,			// ワイド文字列の文字数
						dst,		// 新しい文字列を受け取るバッファのアドレス
						len,		// 新しい文字列を受け取るバッファのサイズ
						NULL,		// マップできない文字の既定値のアドレス
						NULL		// 既定の文字を使ったときにセットするフラグのアドレス
	);
	dst[len-1] = 0;
	
	for( int q=0; dst[q] ; q++ ){
		if( ( dst[q+0] == "�@"[0] )&&
			( dst[q+1] == "�@"[1] ) ){
			dst[q+0] = '.';
			dst[q+1] = '-';
		}
		if( ( dst[q+0] == "�C"[0] )&&
			( dst[q+1] == "�C"[1] ) ){
			dst[q+0] = '.';
			dst[q+1] = '-';
		}
		if( ( dst[q+0] == "�D"[0] )&&
			( dst[q+1] == "�D"[1] ) ){
			dst[q+0] = '/';
			dst[q+1] = ' ';
		}
		if( ( dst[q+0] == "�E"[0] )&&
			( dst[q+1] == "�E"[1] ) ){
			dst[q+0] = '-';
			dst[q+1] = ' ';
		}
	}
	
}

struct LOC {
	BYTE	x,y,h,c;
	LOC() {
		x=y=h=c=0;
	}
	bool	IsEqual( const LOC& s ) const {
		return (x==s.x)&&(y==s.y)&&(h==s.h);
	}
	bool	IsContinue() const {
		return h< STAGE_SIZE_H;
	}
	bool	Next() {
		c++;
		x++;
		if( x>=STAGE_SIZE_X ){
			x=0;
			y++;
			if( y>=STAGE_SIZE_Y ){
				y=0;
				h++;
				if( h>=STAGE_SIZE_H ){
					return true;
				}
			}
		}
		return false;
	}
};

const WCHAR* figBlock0 = 
	//0                   1           1
	//0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　�@────────┐"
	L"　　　　　／＃＃＃＃＃＃＃＃／│"
	L"　　　　┌──�E＃＃�C──┐＃�D"
	L"　　　　│＃／＃＃／│＃＃│／　"
	L"　　　　└┌──┐＃�@──┘　　"
	L"　　　　　│＃＃│／　　　　　　"
	L"　　　　　└──┘　　　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　";

const WCHAR* figBlock1 = 
	//0                   1           1
	//0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　�@────────┐"
	L"　　　　　／＃＃＃＃＃＃＃＃／│"
	L"　　　　┌────────┐＃�D"
	L"　　　　│＃＃＃＃＃＃＃＃│／　"
	L"　　　　└────────┘　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　";

const WCHAR* figBlock2 = 
	//0                   1           1
	//0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　�@─────┐　　　"
	L"　　　　　／＃＃＃＃＃／│　　　"
	L"　　　　／＃＃�C──┐＃�D　　　"
	L"　　　／＃＃／│＃＃│／　　　　"
	L"　　┌──┐＃└──┘　　　　　"
	L"　　│＃＃│／　　　　　　　　　"
	L"　　└──┘　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　";

const WCHAR* figBlock3 = 
	//0                   1           1
	//0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　�@──┐　　　　　　"
	L"　　　　　／＃＃／│　　　　　　"
	L"　　　　／＃＃／＃�D　　　　　　"
	L"　　　／＃＃／＃／　　　　　　　"
	L"　　┌──┐＃／　　　　　　　　"
	L"　　│＃＃│／　　　　　　　　　"
	L"　　└──┘　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　";

const WCHAR* figBlock4 = 
	//0                   1           1
	//0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　�@──┐　　　　　　"
	L"　　　　　／＃＃／│　　　　　　"
	L"　　　　┌──┐＃＋　　　　　　"
	L"　　　　│＃＃│＄│　　　　　　"
	L"　　　　＋＃＠＋＃�D　　　　　　"
	L"　　　　│＃＃│／　　　　　　　"
	L"　　　　└──┘　　　　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　";

const WCHAR* figBlock5 = 
	//0                   1           1
	//0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　�@──┐　　　　　　"
	L"　　　　　／＃＃／│　　　　　　"
	L"　　　　┌──┐＃└──┐　　　"
	L"　　　　│＃＃│／＃＃／│　　　"
	L"　　　　＋＃＠└──┐＃�D　　　"
	L"　　　　│＃＃＃＃＃│／　　　　"
	L"　　　　└─────┘　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　";

const WCHAR* figBlock6 = 
	//0                   1           1
	//0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　�@─────┐　　　"
	L"　　　　　／＃＃＃＃＃／│　　　"
	L"　　　　┌─────┐＃＋　　　"
	L"　　　　│＃＃＃＃＃│＄│　　　"
	L"　　　　└──┐＃＠＋＃�D　　　"
	L"　　　　　　　│＃＃│／　　　　"
	L"　　　　　　　└──┘　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　";


const WCHAR* figBlock7 = 
	//0                   1           1
	//0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6
	L"　　　　　　�@──┐　　　　　　"
	L"　　　　　／＃＃／│　　　　　　"
	L"　　　　┌──┐＃＋　　　　　　"
	L"　　　　│＃＃│＄│　　　　　　"
	L"　　　　＋＃＠＋＃＋　　　　　　"
	L"　　　　│＃＃│＄│　　　　　　"
	L"　　　　＋＃＠＋＃�D　　　　　　"
	L"　　　　│＃＃│／　　　　　　　"
	L"　　　　└──┘　　　　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　";

const WCHAR* figBlock8_9 = 
	//0                   1           1
	//0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　�@─────┐　　　"
	L"　　　　　／＃＃＃＃＃／│　　　"
	L"　　　　┌─────┐＃�D　　　"
	L"　　　　│＃＃＃＃＃│／　　　　"
	L"　　　　└─────┘　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　";


#define	NN {{ 0,0,0 },{ 0,0,0 },{ 0,0,0 }}
struct BLOCK {
	const WCHAR* figure;
	BYTE	t[STAGE_SIZE_H][STAGE_SIZE_Y][STAGE_SIZE_H];
	int		sx,sy,sh;
	int		fx,fy,fx2,fy2;
	void	Initialize()
	{
		sx = -1;
		sy = -1;
		sh = -1;
		for( int x=0; x<STAGE_SIZE_X; x++ ){
			for( int y=0; y<STAGE_SIZE_Y; y++ ){
				for( int h=0; h<STAGE_SIZE_H; h++ ){
					if( t[h][y][x] != 0 ){
						if( sx < x ) sx = x;
						if( sy < y ) sy = y;
						if( sh < h ) sh = h;
					}
				}
			}
		}
		sx++;
		sy++;
		sh++;
		fx = 99999;
		fy = 99999;
		fx2 = -99999;
		fy2 = -99999;
		for( int tx=0; tx<FIGURE_SIZE_X; tx++ ){
			for( int ty=0; ty<FIGURE_SIZE_Y; ty++ ){
				if( figure[tx+ty*FIGURE_SIZE_X] != (L"　")[0] ){
					if( fx > tx ) fx = tx;
					if( fy > ty ) fy = ty;
					if( fx2 < tx ) fx2 = tx;
					if( fy2 < ty ) fy2 = ty;
				}
			}
		}
		fx2++;
		fy2++;
	}
} block[BLOCK_MAX] = {
	// ------------------------------------------------------------------
	// 0
	{
		figBlock0,{
			{
				{ 1,1,1 },
				{ 0,1,0 },
				{ 0,0,0 },
			},
			NN,
			NN,
		}
	},
	// ------------------------------------------------------------------
	// 1
	{
		figBlock1,{
			{
				{ 1,1,1 },
				{ 0,0,0 },
				{ 0,0,0 },
			},
			NN,
			NN,
		}
	},
	// ------------------------------------------------------------------
	// 2
	{
		figBlock2,{
			{
				{ 1,1,0 },
				{ 1,0,0 },
				{ 0,0,0 },			
			},
			NN,
			NN,
		}
	},
	// ------------------------------------------------------------------
	// 3
	{
		figBlock3,{
			{
				{ 1,0,0 },
				{ 1,0,0 },
				{ 0,0,0 },			
			},
			NN,
			NN,
		}
	},
	// ------------------------------------------------------------------
	// 4
	{
		figBlock4,{
			{
				{ 1,0,0 },
				{ 0,0,0 },
				{ 0,0,0 },			
			},
			{
				{ 1,0,0 },
				{ 0,0,0 },
				{ 0,0,0 },			
			},
			NN,
		}
	},
	// ------------------------------------------------------------------
	// 5
	{
		figBlock5,{
			{
				{ 1,1,0 },
				{ 0,0,0 },
				{ 0,0,0 },			
			},
			{
				{ 1,0,0 },
				{ 0,0,0 },
				{ 0,0,0 },			
			},
			NN,
		}
	},
	// ------------------------------------------------------------------
	// 6
	{
		figBlock6,{
			{
				{ 0,1,0 },
				{ 0,0,0 },
				{ 0,0,0 },			
			},
			{
				{ 1,1,0 },
				{ 0,0,0 },
				{ 0,0,0 },			
			},
			NN,
		}
	},
	// ------------------------------------------------------------------
	// 7
	{
		figBlock7,{
			{
				{ 1,0,0 },
				{ 0,0,0 },
				{ 0,0,0 },			
			},
			{
				{ 1,0,0 },
				{ 0,0,0 },
				{ 0,0,0 },			
			},
			{
				{ 1,0,0 },
				{ 0,0,0 },
				{ 0,0,0 },			
			},
		}
	},
	// ------------------------------------------------------------------
	// 8
	{
		figBlock8_9,{
			{
				{ 1,1,0 },
				{ 0,0,0 },
				{ 0,0,0 },			
			},
			NN,
			NN,
		}
	},
	// ------------------------------------------------------------------
	// 9
	{
		figBlock8_9,{
			{
				{ 1,1,0 },
				{ 0,0,0 },
				{ 0,0,0 },			
			},
			NN,
			NN,
		}
	},
	
};

// ------------------------------------------------------------------
struct STAGE {
	BYTE	w[STAGE_SIZE_H][STAGE_SIZE_Y][STAGE_SIZE_X];
	bool	Set( const int bi,const LOC* loc ){
		
		// そもそも入らないサイズ？
		if( STAGE_SIZE_X < ( block[bi].sx + loc->x ) ) return true;
		if( STAGE_SIZE_Y < ( block[bi].sy + loc->y ) ) return true;
		if( STAGE_SIZE_H < ( block[bi].sh + loc->h ) ) return true;
		
		for( int xp=0; xp<block[bi].sx; xp++ ){
			int		x = loc->x+xp;
			for( int yp=0; yp<block[bi].sy; yp++ ){
				int		y = loc->y+yp;
				for( int hp=0; hp<block[bi].sh; hp++ ){
					int		h = loc->h+hp;
					if( block[bi].t[hp][yp][xp] == 1 ){
						if( w[h][y][x] != 99 ) return true;
					}
				}
			}
		}
		for( int xp=0; xp<block[bi].sx; xp++ ){
			int		x = loc->x+xp;
			for( int yp=0; yp<block[bi].sy; yp++ ){
				int		y = loc->y+yp;
				for( int hp=0; hp<block[bi].sh; hp++ ){
					int		h = loc->h+hp;
					if( block[bi].t[hp][yp][xp] == 1 ){
						w[h][y][x] = bi;
					}
				}
			}
		}
		return false;
	}
	bool	Check( const LOC* loc0,
				   const LOC* loc1,
				   const LOC* loc2,
				   const LOC* loc3,
				   const LOC* loc4,
				   const LOC* loc5,
				   const LOC* loc6,
				   const LOC* loc7,
				   const LOC* loc8,
				   const LOC* loc9  ) {
		memset( w,99,STAGE_SIZE_H*STAGE_SIZE_Y*STAGE_SIZE_X );
		if( loc0 == NULL ) return true;
		if( Set( 0,loc0 ) ) return false;
		if( loc1 == NULL ) return true;
		if( Set( 1,loc1 ) ) return false;
		if( loc2 == NULL ) return true;
		if( Set( 2,loc2 ) ) return false;
		if( loc3 == NULL ) return true;
		if( Set( 3,loc3 ) ) return false;
		if( loc4 == NULL ) return true;
		if( Set( 4,loc4 ) ) return false;
		if( loc5 == NULL ) return true;
		if( Set( 5,loc5 ) ) return false;
		if( loc6 == NULL ) return true;
		if( Set( 6,loc6 ) ) return false;
		if( loc7 == NULL ) return true;
		if( Set( 7,loc7 ) ) return false;
		if( loc8 == NULL ) return true;
		if( Set( 8,loc8 ) ) return false;
		if( loc9 == NULL ) return true;
		if( Set( 9,loc9 ) ) return false;
		return true;
	}
};
// ------------------------------------------------------------------

	//0                   1           1
	//0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6
const WCHAR* figStageInit =
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　　　　　　　　　　　"
	L"　　　　　　・−−−−−−−−・"
	L"　　　　　／　　　　　　　　／　"
	L"　　　　／　　　　　　　　／　　"
	L"　　　／　　　　　　　　／　　　"
	L"　　／　　　　　　　　／　　　　"
	L"　／　　　　　　　　／　　　　　"
	L"・−−−−−−−−・　　　　　　";


void	figDraw( FILE* fp,const STAGE& stage,const LOC** ploc,const int vi )
{
	WCHAR	wstr[FIGURE_SIZE_X*FIGURE_SIZE_Y] ; 
	BYTE	flag[FIGURE_SIZE_X*FIGURE_SIZE_Y] ; 

	for( int q=0; q<FIGURE_SIZE_X*FIGURE_SIZE_Y; q++ ){
		wstr[q] = figStageInit[q];
		flag[q] = 0;
	}
	
	struct TLB {
		short	x,y,h;
	} tlb[STAGE_SIZE_X*STAGE_SIZE_Y*STAGE_SIZE_H+1] ;
	
	int		ww = 0;
	for( int y=0; y<STAGE_SIZE_Y; y++ ){
		for( int h=0; h<STAGE_SIZE_H; h++ ){
			for( int x=0; x<STAGE_SIZE_X; x++ ){
				tlb[ww].x = x;
				tlb[ww].y = y;
				tlb[ww].h = h;
				ww++;
			}
		}
	}
	tlb[ww].x = 3;
	tlb[ww].y = 3;
	tlb[ww].h = 3;
	
//	for( ww=0; ww<STAGE_SIZE_X*SIZGE_SIZE_Y*STAGE_SIZE_H; ww++ ){
//		for( int ww2=0; ww2<STAGE_SIZE_X*SIZGE_SIZE_Y*STAGE_SIZE_H; ww2++ ){
//			int		a0 = tlb[ww ].x*tlb[ww ].x + tlb[ww ].y*tlb[ww ].y + tlb[ww ].h*tlb[ww ].h ;
//			int		a2 = tlb[ww2].x*tlb[ww2].x + tlb[ww2].y*tlb[ww2].y + tlb[ww2].h*tlb[ww2].h ;
//			if( a0 > a2 ){
//				TLB	t = tlb[ww];
//				tlb[ww ] = tlb[ww2];
//				tlb[ww2] = t;
//			}
//		}	
//	}
	
	for( int ii=0; ii<9999; ii++ ){
		if( tlb[ii].h >= STAGE_SIZE_H ) break;
		
		int		lx = tlb[ii].x;
		int		ly = tlb[ii].y;
		int		lh = tlb[ii].h;
		int		bi = stage.w[lh][ly][lx];
		if( bi == 99 ) continue;

		const WCHAR* pfig = block[bi].figure;

		const char* pbct =  "  *--*"
							" /##/|"
							"*--*#*"
							"|##|/ "
							"*--*  ";

		int		bl_x = lx - ploc[bi]->x;
		int		bl_y = ly - ploc[bi]->y;
		int		bl_h = lh - ploc[bi]->h;

		int		bl_dx = bl_x*3 - bl_y*2 + FIG_BASE_X;
		int		bl_dy = bl_y*2 - bl_h*2 + FIG_BASE_Y;

		int		dw_dx = lx*3 - ly*2 + FIG_BASE_X;
		int		dw_dy = ly*2 - lh*2 + FIG_BASE_Y;

		for( int qy=0; qy<FIG_BLOCK_SIZE_Y; qy++ ){
			for( int qx=0; qx<FIG_BLOCK_SIZE_X; qx++ ){
				if( pbct[qx+qy*FIG_BLOCK_SIZE_X] != ' ' ){
					const WCHAR* pt = &pfig[ ((bl_dx+qx) + (bl_dy+qy)*FIGURE_SIZE_X) ];
					if( *pt != (L"　")[0] ){
						WCHAR*	w  = &wstr[ ((dw_dx+qx) + (dw_dy+qy)*FIGURE_SIZE_X ) ];
						BYTE*	wf = &flag[ ((dw_dx+qx) + (dw_dy+qy)*FIGURE_SIZE_X ) ];
						if( *pt == (L"＄")[0] ){
							if( *w == (L"／")[0] ){
								// 書き込まない
							}else{
								*w = (L"＃")[0];
								*wf = (bi==vi)?1:0;
							}
						}else
						if( *pt == (L"＠")[0] ){
							if( *w == (L"─")[0] ){
								// 書き込まない
							}else{
								*w = (L"＃")[0];
								*wf = (bi==vi)?1:0;
							}
						}else{
							*w = *pt;
							*wf = (bi==vi)?1:0;
						}
					}
				}
			}
		}
	}

	for( int q=0; q<FIGURE_SIZE_Y; q++ ){
		WCHAR	t[FIGURE_SIZE_X+1];
		for( int k=0; k<FIGURE_SIZE_X; k++ ){
			if( ( wstr[q*FIGURE_SIZE_X+k] == (L"＃")[0] )&&		//＃
				( flag[q*FIGURE_SIZE_X+k] == 0    ) ){
				t[k] = (L"　")[0];
			}else
			if( ( wstr[q*FIGURE_SIZE_X+k] == (L"＋")[0] )&&		//＃
				( flag[q*FIGURE_SIZE_X+k] == 0    ) ){
				t[k] = (L"│")[0];
			}else{
				t[k] = wstr[q*FIGURE_SIZE_X+k];
			}
		}
		t[FIGURE_SIZE_X] = 0;
		// 書く必要があるか？
		int		qj;
		for( qj=0; qj<FIGURE_SIZE_X+1; qj++ ){
			if( t[qj] == 0 ) break;
			if( t[qj] != (L"　")[0] ) break;
		}
		if( t[qj] != 0 ){
			char	tm[FIGURE_SIZE_X*2+2];
			CopyString( tm,t,sizeof(tm) );
			fprintf( fp,"      %s\n",tm );
		}
	}
	fprintf( fp,"\n" );
}

void	figCreate( FILE* fp,const int index,const LOC* loc0,const LOC* loc1,const LOC* loc2,const LOC* loc3,const LOC* loc4,const LOC* loc5,const LOC* loc6,const LOC* loc7,const LOC* loc8,const LOC* loc9 )
{
	STAGE	stage;
	const LOC* ploc[BLOCK_MAX];
	const LOC* plocs[BLOCK_MAX];
	ploc[0] = plocs[0] = loc0;
	ploc[1] = plocs[1] = loc1;
	ploc[2] = plocs[2] = loc2;
	ploc[3] = plocs[3] = loc3;
	ploc[4] = plocs[4] = loc4;
	ploc[5] = plocs[5] = loc5;
	ploc[6] = plocs[6] = loc6;
	ploc[7] = plocs[7] = loc7;
	ploc[8] = plocs[8] = loc8;
	ploc[9] = plocs[9] = loc9;
	memset( stage.w,99,STAGE_SIZE_H*STAGE_SIZE_Y*STAGE_SIZE_X );
	int		hand = 1;
	fprintf( fp,"------------------------------------------------------------------\n" );
	fprintf( fp,"answer : %d\n",index+1 );
	while(1)
	{
		int		vi = -1;
		int		vp = 99999;
		for( int q=0; q<BLOCK_MAX; q++ ){
			if( ploc[q] == NULL ) continue;
			int		a = ploc[q]->x*10 + ploc[q]->y*100 + ploc[q]->h * 1000;
			if( vp > a ){
				vp = a;
				vi = q;
			}
		}
		if( vi < 0 ) break;

		//fprintf( fp,"  --------------------\n" );
		fprintf( fp,"  %d:\n",hand++ );
		fprintf( fp,"  \n" );

		// 手牌を書く
		int		bl_x = ploc[vi]->x;
		int		bl_y = ploc[vi]->y;
		int		bl_dx = bl_x*3 - bl_y*2 + FIG_BASE_X;
		for( int qy=block[vi].fy; qy<block[vi].fy2; qy++ ){
			WCHAR	t[FIGURE_SIZE_X+1];
			int		k = 0;
			for( int qx=block[vi].fx; qx<block[vi].fx2; qx++,k++ ){
				if( ( block[vi].figure[qx+qy*FIGURE_SIZE_X] == (L"＃")[0] )||
					( block[vi].figure[qx+qy*FIGURE_SIZE_X] == (L"＠")[0] )||
					( block[vi].figure[qx+qy*FIGURE_SIZE_X] == (L"＄")[0] ) ){	//＃
					t[k] = (L"　")[0];
				}else{
					t[k] = block[vi].figure[qx+qy*FIGURE_SIZE_X];
				}
			}
			t[k] = 0;
			char	tm[FIGURE_SIZE_X*2+2];
			CopyString( tm,t,sizeof(tm) );
			fprintf( fp,"      ",tm );
			for( int q=0; q<bl_dx; q++ ) fprintf( fp,"　" );
			fprintf( fp,"%s\n",tm );
		}
		fprintf( fp,"\n" );
		for( int qq=0; qq<2; qq++ ){
			fprintf( fp,"      " );
			for( int q=0; q<bl_dx; q++ ) fprintf( fp,"　" );
			for( int q=0; q<(block[vi].fx2-block[vi].fx); q++ ){
				fprintf( fp," " );
			}
			fprintf( fp,"↓\n" );
		}
		fprintf( fp,"\n" );

		stage.Set( vi,ploc[vi] );
		ploc[vi] = NULL;
		figDraw( fp,stage,plocs,vi );
	}
	fprintf( fp,"  complete!\n" );
	figDraw( fp,stage,plocs,-1 );
}

// ------------------------------------------------------------------
struct ANSWER {
	static const int ITEM_MAX = 40;
	struct ITEM {
		LOC	loc0;
		LOC	loc1;
		LOC	loc2;
		LOC	loc3;
		LOC	loc4;
		LOC	loc5;
		LOC	loc6;
		LOC	loc7;
		LOC	loc8;
		LOC	loc9;
		STAGE	s;
	} Item[ITEM_MAX];
	int	Count;
	ANSWER() { Count=0; }
	bool	Register( const STAGE& s,const LOC* loc0,
					   const LOC* loc1,
					   const LOC* loc2,
					   const LOC* loc3,
					   const LOC* loc4,
					   const LOC* loc5,
					   const LOC* loc6,
					   const LOC* loc7,
					   const LOC* loc8,
					   const LOC* loc9  ){
		for( int q=0; q<Count; q++ ){
			if( ( Item[q].loc8.IsEqual( *loc9 ) )&&
				( Item[q].loc9.IsEqual( *loc8 ) ) ){
				return false;
			}
		}
		if( Count >= ITEM_MAX ) return false;
		Item[Count].s = s;
		Item[Count].loc0 = *loc0;
		Item[Count].loc1 = *loc1;
		Item[Count].loc2 = *loc2;
		Item[Count].loc3 = *loc3;
		Item[Count].loc4 = *loc4;
		Item[Count].loc5 = *loc5;
		Item[Count].loc6 = *loc6;
		Item[Count].loc7 = *loc7;
		Item[Count].loc8 = *loc8;
		Item[Count].loc9 = *loc9;
		Count++;
		return true;
	}
};

// ------------------------------------------------------------------

int _tmain(int argc, _TCHAR* argv[])
{
	STAGE	stage;
	ANSWER	answer;
	
	int		hitcount = 0;

	for( int q=0; q<BLOCK_MAX; q++ ) block[q].Initialize();

	for( LOC loc0; loc0.IsContinue(); loc0.Next() ){
		for( LOC loc1; loc1.IsContinue(); loc1.Next() ){
			if( !stage.Check( &loc0,&loc1,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL ) ) continue;
			for( LOC loc2; loc2.IsContinue(); loc2.Next() ){
				if( !stage.Check( &loc0,&loc1,&loc2,NULL,NULL,NULL,NULL,NULL,NULL,NULL ) ) continue;
				for( LOC loc3; loc3.IsContinue(); loc3.Next() ){
					if( !stage.Check( &loc0,&loc1,&loc2,&loc3,NULL,NULL,NULL,NULL,NULL,NULL ) ) continue;
					for( LOC loc4; loc4.IsContinue(); loc4.Next() ){
						if( !stage.Check( &loc0,&loc1,&loc2,&loc3,&loc4,NULL,NULL,NULL,NULL,NULL ) ) continue;
						for( LOC loc5; loc5.IsContinue(); loc5.Next() ){
							if( !stage.Check( &loc0,&loc1,&loc2,&loc3,&loc4,&loc5,NULL,NULL,NULL,NULL ) ) continue;
							for( LOC loc6; loc6.IsContinue(); loc6.Next() ){
								if( !stage.Check( &loc0,&loc1,&loc2,&loc3,&loc4,&loc5,&loc6,NULL,NULL,NULL ) ) continue;
								for( LOC loc7; loc7.IsContinue(); loc7.Next() ){
									if( !stage.Check( &loc0,&loc1,&loc2,&loc3,&loc4,&loc5,&loc6,&loc7,NULL,NULL ) ) continue;
									for( LOC loc8; loc8.IsContinue(); loc8.Next() ){
										if( !stage.Check( &loc0,&loc1,&loc2,&loc3,&loc4,&loc5,&loc6,&loc7,&loc8,NULL ) ) continue;
										for( LOC loc9; loc9.IsContinue(); loc9.Next() ){
											if( !stage.Check( &loc0,&loc1,&loc2,&loc3,&loc4,&loc5,&loc6,&loc7,&loc8,&loc9 ) ) continue;
											if( answer.Register( stage,&loc0,&loc1,&loc2,&loc3,&loc4,&loc5,&loc6,&loc7,&loc8,&loc9 ) ){
												//printf( "Hit! %d\n",hitcount );
												//hitcount++;
											}
										}
									}
								}
							}
						}
					}
				}
			}
		}
	}

//	for( int iq=0; iq<answer.Count; iq++ ){
//		const char* ps[] = {
//			"平３┳[%d](%d,%d) ",
//			"平３━[%d](%d,%d) ",
//			"平２┏[%d](%d,%d) ",
//			"平２┃[%d](%d,%d) ",
//			"立２┃[%d](%d,%d) ",
//			"立２┗[%d](%d,%d) ",
//			"立２┓[%d](%d,%d) ",
//			"立３┃[%d](%d,%d) ",
//			"平２━[%d](%d,%d) ",
//			"平２━[%d](%d,%d) ",
//		};
//		printf( "%d :",iq );
//		LOC*	ploc[BLOCK_MAX];
//		ploc[0] = &answer.Item[iq].loc0;
//		ploc[1] = &answer.Item[iq].loc1;
//		ploc[2] = &answer.Item[iq].loc2;
//		ploc[3] = &answer.Item[iq].loc3;
//		ploc[4] = &answer.Item[iq].loc4;
//		ploc[5] = &answer.Item[iq].loc5;
//		ploc[6] = &answer.Item[iq].loc6;
//		ploc[7] = &answer.Item[iq].loc7;
//		ploc[8] = &answer.Item[iq].loc8;
//		ploc[9] = &answer.Item[iq].loc9;
//		for( int hq=0; hq<STAGE_SIZE_H; hq++ ){
//			for( int q=0; q<BLOCK_MAX; q++ ){
//				if( ploc[q] ){
//					if( ploc[q]->h == hq ){
//						printf( ps[q],ploc[q]->h  ,ploc[q]->x,ploc[q]->y );
//					}
//				}
//			}
//		}
//		printf( "\n" );
//	}
	FILE*	fp = fopen( "q.txt","w" );
	for( int iq=0; iq<answer.Count; iq++ ){
		figCreate( fp,iq,&answer.Item[iq].loc0,
					&answer.Item[iq].loc1,
					&answer.Item[iq].loc2,
					&answer.Item[iq].loc3,
					&answer.Item[iq].loc4,
					&answer.Item[iq].loc5,
					&answer.Item[iq].loc6,
					&answer.Item[iq].loc7,
					&answer.Item[iq].loc8,
					&answer.Item[iq].loc9 );
	}
	fclose( fp );
	return 0;
}

// ------------------------------------------------------------------