//----------------------------------------------------------------------
//	フラワーパズル		テンヨーのプラパズルNo.○
//
//	組み合わせ総数	１６４１通り
//	組み合わせ総数	１７９７通り（私の計算）
//
//	制作開始	１９９６年３月１２日
//	制作凍結	１９９６年３月１４日
//	全面変更	１９９６年４月３０日
//	汎用化開始	１９９６年６月２４日
//
//	Copyright(C) 1996 Hirofumi Fujiwara 
//	本プログラムは、改造も含め、その商用利用は禁止します。
//------------------------------------------------------------------------
// 	制作途中のぐちゃぐちゃ故、目の毒でしょう。
//----------------------------------------------------------------------

import java.awt.*;
import java.applet.*;
import java.lang.*;
import java.io.*;
import java.util.*;
import java.net.*;

public class Flower extends Applet implements Runnable {
	int	PuzzleType   = 0;
	int	BoardOffset  = 190;
	int	PieceOffset  = 310;
	int	RadiusB      = 38;
	int	RadiusP      = 22;
	int	SleepingTime = 2000;

	final	int	MijinkoIndex = 6;
	final	int	MijinkoMaxRotation[] = { 3, 6 };

	FillBoard	board;
	ChoiceBoard	choice;
	Solver		solver;
	PiecePolygon	polygon;

	Dimension	app_size;

	Font	panelFont = new java.awt.Font( "Helvetica", 0, 20 );
	Panel	controlPanel;
	Label	counterPanel;
	ControlButton	solvebutton;
	boolean		possible = true;

	Color	backcolor;
	boolean	mouselock = false;

	Thread  mainThread;

	//------------------------------------------------------------------------
	//	初期化
	public	void	init() {
		app_size = this.size();
		String	param = null;

		param = getParameter("PuzzleType");
		if( param!=null ) PuzzleType = Integer.valueOf(param).intValue();

		param = getParameter("BoardOffset");
		if( param!=null ) BoardOffset = Integer.valueOf(param).intValue();
		param = getParameter("PieceOffset");
		if( param!=null ) PieceOffset = Integer.valueOf(param).intValue();

		param = getParameter("RadiusB");
		if( param!=null ) RadiusB = Integer.valueOf(param).intValue();

		param = getParameter("RadiusP");
		if( param!=null ) RadiusP = Integer.valueOf(param).intValue();

		param = getParameter("SleepingTime");
		if( param!=null ) SleepingTime = Integer.valueOf(param).intValue();

		setLayout( new BorderLayout() );
		controlPanel = new Panel();
		controlPanel.setLayout(new FlowLayout());

		counterPanel = new Label( " No. 0          " );
		counterPanel.setFont( panelFont );
		controlPanel.add( counterPanel );

		solvebutton =     new ControlButton( this, "Solve", "  Solve  " );
		controlPanel.add( solvebutton );
		controlPanel.add( new ControlButton( this, "Next",  "  Next   " ) );
		controlPanel.add( new ControlButton( this, "Reset", "  Reset  " ) );
		add( "North", controlPanel );

		Label  copyright = new Label("Flower Puzzle V0.3" + "  " + 
						"Copyright(C)1996 Hirofumi Fujiwara.",
					Label.CENTER );
		add( "South", copyright );

		polygon  = new PiecePolygon( 7 );
		board    = new FillBoard( this, BoardOffset, PuzzleType, RadiusB,  app_size.width );
		choice   = new ChoiceBoard( this, RadiusP, app_size.width, PieceOffset );

		//				// ミジンコの対称数
		solver   = new Solver( this, MijinkoMaxRotation[PuzzleType] );

		backcolor = getBackground();
	}

	//------------------------------------------------------------------------
	//	初期状態にする
	public	void	Reset() {
		board.Reset();
		choice.Reset();
		solver.Reset();
		paint( getGraphics() );
	}

	//------------------------------------------------------------------------
	public void start() {
		if( mainThread == null ) {
			mainThread = new Thread( this );
		}
	}

	public void run() {
		try { mainThread.sleep( 50 ); } catch( InterruptedException e ) {}

		possible = false;
		while( solver.Findnext() ) {
			possible = true;
			if( solver.mode != 2 )
				break;
			try {
				possible = true;
				mainThread.sleep( SleepingTime );	// お休みタイム
				possible = false;
			} catch( InterruptedException e ) {

				break;
			}
		}

		mainThread.stop();
		mainThread = null;
		possible = true;
	}

	//------------------------------------------------------------------------
	//	マウスＵＰ
	public boolean mouseUp( Event e, int x, int y ) {
		if( mouselock )
			return true;
		mouselock = true;
		if( board.mouseUp( x, y ) || choice.mouseUp( x, y ) ) {
			solver.mode = 0;
		}
		mouselock = false;
		return	true;
	}

	//------------------------------------------------------------------------
	//	描画
	public void repaint( Graphics g ) {
		paint( g );
	}

	public void paint( Graphics g ) {
		Dimension r = size();
		g.clearRect( 0, 0, r.width, r.height );

		board.paintAll( g );
		choice.paintAll( g );
		solver.DrawCounter();
	}
}

//--------------------------------------------------------------------------------
//	制御ボタンクラス
//
//		"Solve"   "Stop"
//--------------------------------------------------------------------------------
class  ControlButton extends Button {
	Flower		app;
	String		name;

	// 構築子
	ControlButton( Flower f, String str, String label ) {
		super();
		app  = f;
		name = str;
		setLabel( label );
		setFont( app.panelFont );
	}

	public boolean action( Event evt, Object obj ) {
		if( ! app.possible )
			return	false;

		if( app.mainThread != null ) {
			app.mainThread.stop();
			app.mainThread = null;
		}

		if( name.equals("Solve") ) {
			switch ( app.solver.mode ) {
			case 0:
				app.Reset();
				app.solver.StartInit();
				app.solvebutton.setLabel( "Stop" );
				app.solver.mode = 2;	// 実行
				app.start();
				app.mainThread.start();
				break;
			case 2:
				app.solvebutton.setLabel( "Continue" );
				app.solver.mode = 1;	// 一時中断
				break;
			case 1:
				app.solvebutton.setLabel( "Stop" );
				app.solver.mode = 2;	// 続行
				app.start();
				app.mainThread.start();
			}
			return true;
		}

		if( app.solver.mode > 0 ) {
			app.solvebutton.setLabel( "  Solve  " );
		}

		if( name.equals("Next") ) {
			app.solvebutton.setLabel( "Continue" );

			if( app.solver.mode == 0 )
				app.solver.StartInit();
			app.solver.mode = 1;	// 一時中断
			app.start();
			app.mainThread.start();
		}
		if( name.equals("Reset") ) {
			app.Reset();
		}
		return true;
	}
}

//--------------------------------------------------------------------------------
//	詰め込みボードデータ
//--------------------------------------------------------------------------------
class FillBoard {
	Flower	app;
	int xys0[][] = {		// 盤の形状データ
		        { -2, -1 }, { -1, -1 }, { 0, -1 }, { 1, -1 },
		  { -2,  0 }, { -1,  0 }, { 0,  0 }, { 1,  0 }, { 2, 0 },
		        { -1,  1 }, { 0,  1 }, { 1,  1 }, { 2, 1 }
		};
	int xys1[][] = {		// 盤の形状データ
		                          { -1, -2 },
		                   { -1, -1 }, { 0, -1 },
		              { -1,  0 }, { 0,  0 }, { 1,  0 },
		        { -1,  1 }, { 0,  1 }, { 1,  1 }, { 2, 1 },
		              {  0,  2 }, { 1,  2 }, { 2,  2 }
		};
	int xys[][];

	public	PickOnBoard	picks[];
	public	int		pickn;

	public	PieceOnBoard	pieces[];

	public	int	R;			// 駒の半径
	public	int	width;			// 横幅
	public	Point	boardCenter;		// 盤の原点位置
	public	Point	deltaX, deltaY;		// 各軸方向の単位ベクトル

	public	int	current	= -1;		// 現在の○の添字
	public	PieceOnBoard	currentpiece;	// 現在の○

		Point		mp;

	//------------------------------------------------------------------------
	//	構築子
	public	FillBoard( Flower f, int boardoffset, int puztype, int r, int w ) {
		app   = f;
		picks = new PickOnBoard[40];
		pickn = 0;

		xys = xys0;
		switch( puztype ) {
		case 1:
			xys = xys1;
			break;
		case 0:
			xys = xys0;
			break;
		}		
						// 盤面の幾何データ初期化
		R     = r;
		width = w;
		boardCenter = new Point( width/2, boardoffset );
		deltaX = new Point( R*2, 0 );
		deltaY = new Point(  -R, (int)Math.round( R * 1.732 ) );
		mp     = new Point( 0, 0 );

					// ピースデータの初期化
		pieces = new PieceOnBoard[xys.length];
		for( int i=0; i<pieces.length; ++i )
			pieces[i] = new PieceOnBoard( this, xys[i][0], xys[i][1], i );
	}

	//------------------------------------------------------------------------
	//	刺を捜す
	public	PickOnBoard	FindPick( int i, int j ) {
		PickOnBoard  p;
		for( int k=0; k<pickn; ++k ) {
			p = picks[k];
			if( p.i3 == i && p.j3 == j )
				return	p;
		}
		picks[pickn] = p = new PickOnBoard( this, i, j );
		++pickn;

		return	p;
	}

	//------------------------------------------------------------------------
	//	初期状態にする
	public	void	Reset() {
		for( int i=0; i<pickn; ++i )
			picks[i].Reset();

		for( int j=0; j<pieces.length; ++j )
			pieces[j].Reset();		
	}

	//------------------------------------------------------------------------
	// アプレット上の座標に変換する
	public void toAppPos( int i, int j, Point P ) {
		P.x = boardCenter.x + i * deltaX.x + j * deltaY.x;
		P.y = boardCenter.y                + j * deltaY.y;
	}

	//------------------------------------------------------------------------
	//	置く
	public void setPiece( int no ) {
		if( no == -1 || current == -1 )
			return;
		currentpiece.setPiece( no, app.choice.pds[no] );
	}

	//------------------------------------------------------------------------
	//	マウスが押された位置番号を返す。エラーは -1
	public int  pickedPiece( int x, int y ) {
		int cx = x - boardCenter.x;
		int cy = y - boardCenter.y;
		double dy = (double)cy/deltaY.y;
		double dx = (cx - dy*deltaY.x)/deltaX.x;

		int	rx = (int)Math.round(dx);
		int	ry = (int)Math.round(dy);
		int	no = -1;
		for( int i=0; i<xys.length; ++i ) {
			if( rx==xys[i][0] && ry==xys[i][1] ) {
				no = i;
				break;
			}
		}
		if( no == -1 )
			return	no;

		toAppPos( rx, ry, mp );

		if( (x-mp.x)*(x-mp.x)+(y-mp.y)*(y-mp.y) >= R*R )
			return	-1;

		return	no;
	}

	//------------------------------------------------------------------------
	//	マウスＵＰ
	public boolean mouseUp( int x, int y ) {
		int no = pickedPiece( x, y );
		if( no == -1 )
			return false;
		SetCurrent( no, true );
		return	true;
	}

	public void SetCurrent( int no, boolean draw ) {
		if( current != -1 && draw ) {
			currentpiece.paintMark( app.getGraphics(), false );
		}

		if( pieces[no].pc != -1 ) {	// 入っているピースをクリック
			current = no;
			currentpiece = pieces[current];
			currentpiece.unsetPiece();
			current = -1;
		} else {			// ブランク個所をクリック
			if( current == no ) {	// 反転のため解除
				current = -1;
			} else {		// 新しい場所
				current = no;
				currentpiece = pieces[current];	
				if( draw )
					currentpiece.paintMark( app.getGraphics(), true );
			}
		}
	}

	//------------------------------------------------------------------------
	//	全てを表示
	public void paintAll( Graphics g ) {
		for( int i=0; i<xys.length; ++i ) {
			PieceOnBoard p = pieces[i];
			p.blankPaint( g );
			if( p.pc != -1 ) {	// 詰まっている
				p.dispPiece( p.pc );
			}
		}

		if( current != -1 ) {	// マークの表示
			pieces[current].paintMark( g, true );
		}
	}
}

//--------------------------------------------------------------------------------
//	ボード上の刺データ
//
//	座標値は、駒の位置データの1/3が単位である
//--------------------------------------------------------------------------------
class PickOnBoard {
	FillBoard	bd;
	int		id;
	public	int	i3, j3;		// 座標値（３倍値）
	public	boolean	empty;		// 使用済チェック用
	public	PieceOnBoard  pcs[] = new PieceOnBoard[3];	// 隣接の３ピース
	public	int	      pcn;				// 隣接数

	//------------------------------------------------------------------------
	//	構築子
	public	PickOnBoard( FillBoard b, int i, int j ) {
		bd = b;
		i3 = i;
		j3 = j;
		for( int k=0; k<pcs.length; ++k )
			pcs[k] = null;
		pcn = 0;
		Reset();
	}

	//------------------------------------------------------------------------
	//	ピースへのリンクを張る
	public	void	LinkPiece( PieceOnBoard pc ) {
		for( int k=0; k<pcs.length; ++k ) {
			if( pcs[k] == null ) {
				pcs[k] = pc;
				++pcn;
				break;
			}
		}
	}

	//------------------------------------------------------------------------
	//	初期状態にする
	public	void	Reset() {
		empty = true;
	}
}

//--------------------------------------------------------------------------------
//	ボード上のピースのデータ
//
//			 *-----* i 方向
//		        /
//		       /
//		      *  j 方向
//
//	中央の○の座標が (0,0)であり、整数値のところに各円の中心が位置する	
//	xys[][]		各位置の座標値
//	pieces[]	１３個のピース位置データの配列
//--------------------------------------------------------------------------------
class PieceOnBoard {
	FillBoard	bd;
	public	Point	C;	// ピースの中心座標
	public	int	posid;
	public	int	pc;	// 入れられたピース番号	
	public	PickOnBoard	picks[];	// ピースの６つの隣接刺
		int	pis[];

	//------------------------------------------------------------------------
	//	構築子
	public PieceOnBoard( FillBoard b, int i, int j, int id ) {
		C = new Point( 0, 0 );
		bd    = b;
		posid = id;
		bd.toAppPos( i, j, C );
		pis   = new int[6];

		// ６つの刺の設定
		picks = new PickOnBoard[6];
		picks[0] = bd.FindPick( i*3-1, j*3-2 );
		picks[1] = bd.FindPick( i*3-2, j*3-1 );
		picks[2] = bd.FindPick( i*3-1, j*3+1 );
		picks[3] = bd.FindPick( i*3+1, j*3+2 );
		picks[4] = bd.FindPick( i*3+2, j*3+1 );
		picks[5] = bd.FindPick( i*3+1, j*3-1 );

		// 刺からピースへのリンクを張る
		for( int k=0; k<picks.length; ++k )
			picks[k].LinkPiece( this );

		Reset();
	}

	//------------------------------------------------------------------------
	//	空き状態にする
	public	void	Reset() {
		pc    = -1;
	}

	//------------------------------------------------------------------------
	//	マークの表示／非表示
	public void paintMark( Graphics g, boolean t ) {
		int	r = bd.R * 4 / 8;
		if( t ) {
			g.setColor( Color.lightGray );
			g.fillOval( C.x-r, C.y-r, r*2, r*2 );
		} else {
			g.setColor( Color.gray );
			g.fillOval( C.x-r, C.y-r, r*2, r*2 );
		}
	}

	//------------------------------------------------------------------------
	//	ブランク表示
	public void blankPaint( Graphics g ) {
		for( int i=0; i<6; ++i ) {
			pis[i] = picks[i].empty ? 1 : 0;
		}

		PiecePolygon p = bd.app.polygon;
		p.Set( bd.R, pis );

		p.move( C.x, C.y );

		g.setColor( Color.gray );
		g.fillPolygon( p );
		g.setColor( Color.black );
		g.drawPolygon( p );
		g.drawOval( C.x-bd.R, C.y-bd.R, bd.R*2, bd.R*2 );
	}

	//------------------------------------------------------------------------
	//	表示
	public void dispPiece( int no ) {
		if( no == -1 )
			return;
		dispPiece( bd.app.choice.pds[no] );
	}

	public void dispPiece( PieceChoice pc ) {
		Graphics g = bd.app.getGraphics();
		PiecePolygon p = bd.app.polygon;
		p.Set( bd.R, pc.picks );
		p.move( C.x, C.y );

		g.setColor( pc.col );
		g.fillPolygon( p );
		g.setColor( Color.black );
		g.drawPolygon( p );
	}

	//------------------------------------------------------------------------
	//	置くことができるか
	public boolean isOK( PieceChoice pc ) {
		for( int i=0; i<6; ++i ) {
			if( pc.picks[i] == 0 )
				continue;
			if( ! picks[i].empty )
				return	false;
		}
		return	true;
	}

	//------------------------------------------------------------------------
	//	置く／刺の処理
	void setPicks( PieceChoice pc ) {
		for( int i=0; i<6; ++i ) {
			if( pc.picks[i] == 0 )
				continue;
			// 刺があった
			picks[i].empty = false;
		}
	}

	//------------------------------------------------------------------------
	//	取り除く／刺の処理
	void unsetPicks( PieceChoice pc ) {
		for( int i=0; i<6; ++i ) {
			if( pc.picks[i] == 0 )
				continue;
			// 刺があった
			picks[i].empty = true;
		}
	}

	//------------------------------------------------------------------------
	//	置く
	public void setPiece( int no, PieceChoice ch ) {
		if( ! isOK( ch ) )		// 置けるか
			return;
		pc = no;
		dispPiece( ch );		// 置いた絵
		setPicks( ch );			// 刺の処理

		ch.usedPaint( bd.app.getGraphics() );	// 使用済のピースを描く
		ch.used = true;
		bd.current = -1;
	}
	
	//------------------------------------------------------------------------
	//	取り除く
	public void unsetPiece() {
		if( pc == -1 )
			return;

		Graphics  g = bd.app.getGraphics();

		PieceChoice q = bd.app.choice.pds[pc];
		unsetPicks( q );		// 刺の処理
		blankPaint( g );

		q.piecePaint( g, true );	// 使用可能のピースを描く
		q.used = false;

		pc = -1;
	}

	//------------------------------------------------------------------------
	//	側面の刺のうち、空きの数
	public int  SidePickCount() {
		int	n = 0;
		for( int i=0; i<picks.length; ++i ) {
			PickOnBoard  px = picks[i];
			if( px.pcn == 3 )	// 中央部の刺は無視
				continue;
			if( px.empty )
				++n;
		}

		return	n;
	}	

	//------------------------------------------------------------------------
	//	側面の刺に孤立したものが無いかをチェックする
	//		sn 以上の側面の刺を使う必要がある。
	public boolean  SideCheck( PieceChoice pc, int sn ) {

		int	tn = 0;
		for( int i=0; i<picks.length; ++i ) {	// ６つの刺について調べる
			PickOnBoard  px = picks[i];

			if( ! px.empty ) {	// 刺が詰まっている
				if( pc.picks[i] != 0 ) {  // でも、刺がある
					return	false;
				}
				continue;
			}

			if( pc.picks[i] != 0 ) {	// 刺を詰める
				if( px.pcn <3 ) {
					++tn;
				}
				continue;
			}
							// 刺を詰めない

			int	n = 0;			// その刺の隣接空き数
			for( int j=0; j<px.pcn; ++j ) {
				if( px.pcs[j].pc == -1 )
					++n;
			}
			if( n <= 1 ) {			// 孤立した刺
				return	false;
			}

		}

		return	( tn >= sn );
	}	
}
	
//--------------------------------------------------------------------------------
//	選択ボードデータ
//--------------------------------------------------------------------------------
class ChoiceBoard {
	public	Flower	app;

	final  int xys[][] = {
			     {0,0,0}, {2,0,1}, {4,0,2}, {6,0,3},
			{0,2,4}, {2,2,5}, {4,2,6}, {6,2,7}, {8,2,8},
			     {2,4,9}, {4,4,10},{6,4,11},{8,4,11},
		};

	final	Color colors[] = {
			Color.green, Color.green, Color.green, Color.magenta, 
			Color.magenta, Color.magenta, Color.cyan, Color.cyan, Color.cyan,
			Color.yellow, Color.yellow, Color.yellow, Color.yellow,
		};

	public int picks[][] = {		// ピースの突起データ
				{ 1, 1, 1, 1, 1, 1,  1 },
				{ 1, 1, 1, 1, 1, 0,  6 },
				{ 1, 1, 1, 1, 0, 0,  6 },
				{ 1, 1, 1, 0, 1, 0,  6 },
				{ 1, 1, 0, 1, 1, 0,  3 },
				{ 1, 1, 1, 0, 0, 0,  6 },
				{ 1, 1, 0, 1, 0, 0, 12 },	// ミジンコ
				{ 1, 1, 0, 0, 0, 0,  6 },
				{ 1, 0, 1, 0, 1, 0,  2 },
				{ 1, 0, 1, 0, 0, 0,  6 },
				{ 1, 0, 0, 1, 0, 0,  3 },
				{ 1, 0, 0, 0, 0, 0,  6 },
			};

	public	PieceChoice pds[];	// 選択されるピースの配列
	public	int	R;		// 半径
	public	int	width;
	public	int	offset;
	public	Point	org;
	public	Point	deltaX, deltaY;
	public	int	picked = -1;	// ピックされてまだ未処理のピース番号

		Point	mp;

	//------------------------------------------------------------------------
	//	初期化
	public ChoiceBoard( Flower a, int r, int w, int off ) {
		app    = a;
		R      = r;
		width  = w;
		offset = off;
		org = new Point( (width - R * 12)/2, offset + R * 3 );
		deltaX = new Point(  R*2, 0 );
		deltaY = new Point( -R,  (int)Math.round(R * 1.732) );
		mp     = new Point( 0, 0 );

		pds = new PieceChoice[xys.length];
		for( int i=0; i<xys.length; ++i )
			pds[i] = new PieceChoice( this, xys[i][0], xys[i][1],xys[i][2], i, colors[i] );
	}	

	//------------------------------------------------------------------------
	//	初期状態にする
	public	void	Reset() {
		for( int i=0; i<pds.length; ++i )
			pds[i].Reset();
	}

	//------------------------------------------------------------------------
	//	アプレット上の座標に変換する
	public	void toAppPos( int i, int j, Point P ) {
		P.x = org.x + i * deltaX.x + j * deltaY.x;
		P.y = org.y                + j * deltaY.y;
	}

	//------------------------------------------------------------------------
	//	マウスが押された位置番号を返す。エラーは -1
	public int  pickedPiece( int x, int y ) {
		int cx = x - org.x;
		int cy = y - org.y;
		double dy = (double)cy/deltaY.y;
		double dx = (cx - dy*deltaY.x)/deltaX.x;

		int	rx = (int)Math.round(dx);
		int	ry = (int)Math.round(dy);
		int	no = -1;
		for( int i=0; i<xys.length; ++i ) {
			if( rx==xys[i][0] && ry==xys[i][1] ) {
				no = i;
				break;
			}
		}
		if( no == -1 )
			return	no;

		toAppPos( rx, ry, mp );

		if( (x-mp.x)*(x-mp.x)+(y-mp.y)*(y-mp.y) >= R*R )
			return	-1;

		return	no;
	}

	//------------------------------------------------------------------------
	//	マウスＵＰ
	public boolean mouseUp( int x, int y ) {
		int no = pickedPiece( x, y );
		if( no == -1 )
			return	false;
		if( app.board.current != -1 ) {	// 詰める
			app.board.setPiece( no );
		} else {				// 回転する
			picked = no;
			repaint( app.getGraphics() );
		}
		return	true;
	}

	//------------------------------------------------------------------------
	//	再描画
	public void repaint( Graphics g ) {
		if( picked == -1 )
			return;
		// 指定ピースを回転する
		PieceChoice p = pds[picked];
		p.piecePaint( g, false );
		p.rotate();
		p.piecePaint( g, true );

		picked = -1;
	}

	//------------------------------------------------------------------------
	//	全てを表示
	public void paintAll( Graphics g ) {
		for( int i=0; i<pds.length; ++i ) {
			PieceChoice p = pds[i];
			if( p.used ) {
				p.usedPaint( g );
			} else {
				p.piecePaint( g, true );
			}
		}
	}
}

//--------------------------------------------------------------------------------
//	下に表示しているピースのデータ（選択子）
//--------------------------------------------------------------------------------
class PieceChoice {
	ChoiceBoard	cb;
		Point	C;		// ピースの中心
		int	id;
		int	figid;		// 形状識別番号（０〜１１）
		Color	col;		// 色
	public	int	picks[];
		int	maxangle;	// angleの個数
		int	angle;		// 0〜1、2、5、11 まで変化する
	public	boolean	used;

	//------------------------------------------------------------------------
	//	構築子
	public PieceChoice( ChoiceBoard b, int i, int j, int fid, int pid, Color c ) {
		C = new Point( 0, 0 );
		cb    = b;
		cb.toAppPos( i, j, C );

		id    = pid;
		figid = fid;
		col   = c;

		picks = new int[6];
		for( int k=0; k<6; ++k )
			picks[k] = cb.picks[figid][k];
		maxangle = cb.picks[figid][6];

		Reset();
	}

	//------------------------------------------------------------------------
	//	初期位置
	public	void	Reset() {
		used  = false;		
		angle = 0;
	}

	//------------------------------------------------------------------------
	//	回転する
	void rotate() {
		angle = (angle+1) % maxangle;
		rotate( angle );
	}

	void rotate( int ang ) {
		boolean rev = (ang >= 6);
		for( int k=0; k<6; ++k ) {
			picks[(k+ang)%6] = cb.picks[figid][rev ? 5-k : k];
		}
	}

	//------------------------------------------------------------------------
	//	ピースを塗る
	void piecePaint( Graphics g, Color fc, Color ec ) {
		PiecePolygon p = cb.app.polygon;
		p.Set( cb.R, picks );
		p.move( C.x, C.y );

		g.setColor( fc );	// 内部塗りつぶし
		g.fillPolygon( p );
		g.setColor( ec );	// 輪郭
		g.drawPolygon( p );
	}

	public void piecePaint( Graphics g, boolean t ) {
		if( t ) {	// 描く
			piecePaint( g, col, Color.black );
		} else {	// 消す
			Color bc = cb.app.backcolor;
			piecePaint( g, bc, bc );
		}
	}

	public void usedPaint( Graphics g ) {
		piecePaint( g, Color.lightGray, Color.black );
	}
}

//--------------------------------------------------------------------------------
//	外周ポリゴン作成クラス（表示のために用いられるのみ）
//--------------------------------------------------------------------------------
class PiecePolygon extends Polygon {
	int	divn;			// 1/6円の分割数
	double	delta;
	double	th;
	int	ithorn[] = new int[6];	// 刺データ

	//------------------------------------------------------------------------
	//	構築子
	public PiecePolygon( int n ) {
		divn    = n;
		delta   = Math.PI/3.0/divn;
		xpoints = new int[divn*13];
		ypoints = new int[divn*13];
		npoints = 0;
	}

	//------------------------------------------------------------------------
	//	設定
	public void Set( int r, PickOnBoard thorn[] ) {
		for( int i=0; i<ithorn.length; ++i )
			ithorn[i] = thorn[i].empty ? 1 : 0; 		

		make( r, ithorn );
	}

	public void Set( int r, int thorn[] ) {
		make( r, thorn );
	}

	void make( int r, int thorn[] ) {
		npoints = 0;

		for( int i=0; i<6; ++i ) {
			if( thorn[i] == 0 ) {	// ツメ無し
				th = Math.PI/3.0 * (i + 1.0);
				for( int j=0; j<divn; ++j ) {
					addPoint(  (int)Math.round(Math.cos(th)*r),
						  -(int)Math.round(Math.sin(th)*r) );
					th += delta;
				}
			} else {		// ツメ有り
				th = Math.PI/3.0 * (i + 1);
				int  p1x =   (int)Math.round(Math.cos(th)*r*2.0);
				int  p1y = - (int)Math.round(Math.sin(th)*r*2.0); 
				th += Math.PI;
				for( int j=0; j<divn; ++j ) {
					addPoint(  (int)Math.round(Math.cos(th)*r) + p1x,
						  -(int)Math.round(Math.sin(th)*r) + p1y );
					th -= delta;
				}
				th = Math.PI/3.0 * (i + 2);
				int  p2x =   (int)Math.round(Math.cos(th)*r*2.0);
				int  p2y = - (int)Math.round(Math.sin(th)*r*2.0); 
				th = Math.PI/3.0 * i;
				for( int j=0; j<divn; ++j ) {
					addPoint(  (int)Math.round(Math.cos(th)*r) + p2x,
						  -(int)Math.round(Math.sin(th)*r) + p2y );
					th -= delta;
				}
			}
		}
		th = Math.PI/3.0;
		addPoint( (int)Math.round(Math.cos(th)*r), - (int)Math.round(Math.sin(th)*r) );
	}

	//------------------------------------------------------------------------
	//	移動
	public void move( int x, int y ) {
		for( int i=0; i<npoints; ++i ) {
			xpoints[i] += x;
			ypoints[i] += y;
		}
	}
}

//================================================================================
//	解法アルゴリズム
//================================================================================
//--------------------------------------------------------------------------------
//	解法
class Solver {
	Flower	app;
	SolveTable  solvetable;
	SolveStack  solvestack;
	int	counter;
	public	int	mode;		// 0:hand, 1: next, 2:auto, 
	Font	counterfont = new Font( "Helvetica", Font.BOLD, 20 );

	//------------------------------------------------------------------------
	//	構築子
	Solver( Flower f, int mizcount ) {
		app = f;
		solvetable = new SolveTable( f.MijinkoIndex, mizcount );
		Reset();
	}

	//------------------------------------------------------------------------
	//	初期状態にする
	public	void Reset() {
		mode = 0;
		counter = 0;
	}

	//------------------------------------------------------------------------
	//	カウンタの描画
	public void DrawCounter() {
		app.counterPanel.setText( " No. "+counter+" " );
	}

	//------------------------------------------------------------------------
	//	初期化する
	void StartInit() {
		app.Reset();
		solvestack = new SolveStack( this, 13 );
		counter = 0;
	}

	//------------------------------------------------------------------------
	//	次の答えを求める
	boolean Findnext() {
		return	solvestack.Solve();
	}
}

//--------------------------------------------------------------------------------
//	解法スタック
class SolveStack {
	Flower	app;
	Solver	solver;
	int	no;	// = スタックポインタ
	int	depth;
	int	pns[];	// ピース番号
	int	nns[];	// 同一ピースの使用回数
	int	poss[];	// 位置
	int	angs[];	// 回転

	//------------------------------------------------------------------------
	//	構築子
	public	SolveStack( Solver s, int n ) {
		solver = s;
		app    = solver.app;
		depth  = n;
		pns    = new int[depth];
		nns    = new int[depth];
		poss   = new int[depth];
		angs   = new int[depth];

		no = 0;
		pns[0] = nns[0] = poss[0] = angs[0] = 0;		
	}

	//------------------------------------------------------------------------
	//	解く
	public boolean	Solve() {
		int	poscount = app.board.pieces.length;
		Graphics      g  = app.getGraphics();

		if( no >= depth ) {	// 答えの次
			--no;
			app.board.pieces[poss[no]].unsetPiece();	// 外す
			--no;
			app.board.pieces[poss[no]].unsetPiece();	// 外す
			++angs[no];
		}

	    loop:
		while( true ) {
			int	pn = pns[no];
			SolvePiece   pc	  = solver.solvetable.table[pn];
			PieceChoice  ch   = app.choice.pds[no]; 	// 選択されたピース
			for( ; poss[no]<poscount; ++poss[no], angs[no]=0 ) {
				int pos = poss[no];
				PieceOnBoard pob = app.board.pieces[pos];	// 盤の位置
				if( pob.pc != -1 )			// 空きチェック	
					continue;
				int	nside = pc.side;		// 側面を使う量
				int	fside = pob.SidePickCount();	// 側面の空いている刺の数
				if( fside < nside ) {
					continue;
				}
				app.board.pieces[pos].unsetPiece();	// ピースを外す
				for( ; angs[no]<pc.maxrot; ++angs[no] ) {
					// ピースを回転
					ch.piecePaint( g, false );
					ch.rotate(angs[no]);
					ch.piecePaint( g, true );

					if( pob.SideCheck( ch, pc.side ) ) {
						pob.setPiece( no, app.choice.pds[no] );
						// 単独の刺がなければ……
						int n = nns[no];
						++no;
						if( n+1 < pc.count ) {		// 同一形状ピース
							pns[no]  = pns[no-1];
							nns[no]  = n+1;
							poss[no] = pos+1;
							angs[no] = 0;
						} else if( no < pns.length ) {	// 別形状のピース
							pns[no]  = pns[no-1]+1;
							nns[no]  = 0;
							poss[no] = 0;
							angs[no] = 0;
						} else {			// 解が得られた
							++solver.counter;
							solver.DrawCounter();
							return true;
						}
						continue loop;
					}
					app.board.pieces[pos].unsetPiece();	// ピースを外す
				}
			}

			if( --no < 0 ) {		// ＰＯＰ
				return	false;		// 調べ終えた
			}
			app.board.pieces[poss[no]].unsetPiece();	// ピースを外す
			++angs[no];
		}
	}
}

//--------------------------------------------------------------------------------
//	解法テーブル
class SolveTable {
	int table_0[][] = {
			{1,4,1}, {1,4,6}, {1,4,6}, {1,3,6}, {1,2,3}, {1,3,6}, 
			{1,2,3}, {1,2,6}, {1,0,2}, {1,0,6}, {1,0,3}, {2,0,6}
		};
	public SolvePiece table[] = new SolvePiece[table_0.length];

	public	SolveTable( int mizindex, int mizcount ) {
		// パズルタイプ毎の「ミジンコ」の置き方の数の設定
		table_0[mizindex][2] = mizcount;

		// 解析テーブルのセットアップ
		for( int i=0; i<table_0.length; ++i ) {
			int	t[] = table_0[i];
			table[i] = new SolvePiece( t[0], t[1], t[2] );
		}
	}
}

//--------------------------------------------------------------------------------
//	解くための配置可能データ
//--------------------------------------------------------------------------------
class SolvePiece {
	public	int	count;
	public	int	side;
	public	int	maxrot;

	public	SolvePiece( int n, int s, int r ) {
		count  = n;
		side   = s;
		maxrot = r;
	}
}

//--------------------------------------------------------------------------------
//		end of "Flower.java",  by Hirofumi Fujiwara
//--------------------------------------------------------------------------------