import java.util.*;

class BoardNode
{
	Board board;
	Move move;
	Vector children;

	public BoardNode()
	{
		children = new Vector();
	}

	public BoardNode(Board b)
	{
		board = b.clone();
		children = new Vector();
	}

	public Board getBoard()
	{
		return board;
	}

	public void setMove(Move m)
	{
		move = m;
	}

	public Move getMove()
	{
		return move;
	}

	public void addChild(BoardNode bn)
	{
		children.addElement(bn);
	}

	public void removeChild(BoardNode bn)
	{
		children.removeElement(bn);
	}

	public int size()
	{
		return children.size();
	}

	public BoardNode child(int i)
	{
		return (BoardNode)(children.elementAt(i));
	}

	public void createTree(int depth, int player)
	{
		BoardNode bn;

		for(int j = 0; j < Board.BOARD_SIZE; j++)
		{
			for(int k = 0; k < Board.BOARD_SIZE; k++)
			{
				if(board.moveResults(j, k) != 0)
				{
					bn = new BoardNode(board);
					bn.getBoard().place(j, k);
					bn.setMove(new Move(j, k));
					addChild(bn);

					if(bn.getBoard().playerTurn() == player)
					{
						if(depth > 1) bn.createTree(depth - 1, player);
					}
					else
					{
						bn.createTree(depth, player);
					}
				}
			}
		}
	}

	public int[] considerTree(int player)
	{
		int score[];

		/* Are we a leaf? */
		if(children.size() == 0)
		{
			score = new int[1];
			score[0] = board.weightedRelativeScore(player);
			return score;
		}
		else
		{
			score = new int[children.size()];
		}

		/* Is it my turn in this node? */
		boolean myTurn = board.playerTurn() == player;

		for(int i = 0; i < children.size(); i++)
		{
			int temp[] = child(i).considerTree(player);

			/* Find the best or worst result */
			score[i] = temp[0];

			for(int j = 1; j < temp.length; j++)
			{
				if(myTurn && temp[j] < score[i])
					score[i] = temp[j];
				else if(!myTurn && temp[j] > score[i])
					score[i] = temp[j];
			}
		}

		return score;
	}
}