public void SanityCheck_GivenInsaneDataDueToWrongNumberOfBlackAndWhiteSquares_ReturnsFalse()
        {
            // Arrange
            var board = new Board(TestBoardSize);
            var solver = new Solver();
            var bogusPieceD = new Piece(
                new[]
                    {
                        //  B
                        //  W
                        // WW
                        new Square(0, 0, Colour.White),
                        new Square(1, 0, Colour.White),
                        new Square(1, 1, Colour.White),
                        new Square(1, 2, Colour.Black)
                    },
                'D');
            var pieceFeeder = new PieceFeeder(Piece.TestPieceA, Piece.TestPieceB, Piece.TestPieceC, bogusPieceD);

            // Act
            var actual = solver.SanityCheck(board, pieceFeeder);

            // Assert
            Assert.That(actual, Is.False);
        }

        public void TestExplosions()
        {
            Piece[][] board = new Piece[8][]
            {
                new Piece[8] { o, o, o, o, kb, o, o, o },
                new Piece[8] { o, o, o, o, o, o, o, o },
                new Piece[8] { o, o, o, o, o, o, o, o },
                new Piece[8] { o, o, o, pw, qb, o, o, o },
                new Piece[8] { o, o, o, bw, pb, o, o, o },
                new Piece[8] { o, o, o, o, o, o, nw, o },
                new Piece[8] { o, o, o, o, o, o, o, o },
                new Piece[8] { o, o, o, o, kw, o, o, o }
            };

            AtomicChessGame game = new AtomicChessGame(board, Player.White);
            Assert.AreEqual(game.ApplyMove(new Move("G3", "E4", Player.White), true), MoveType.Move | MoveType.Capture);

            Piece[][] expected = new Piece[8][]
            {
                new Piece[8] { o, o, o, o, kb, o, o, o },
                new Piece[8] { o, o, o, o, o, o, o, o },
                new Piece[8] { o, o, o, o, o, o, o, o },
                new Piece[8] { o, o, o, pw, o, o, o, o },
                new Piece[8] { o, o, o, o, o, o, o, o },
                new Piece[8] { o, o, o, o, o, o, o, o },
                new Piece[8] { o, o, o, o, o, o, o, o },
                new Piece[8] { o, o, o, o, kw, o, o, o }
            };
            Piece[][] actual = game.GetBoard();
            Assert.AreEqual(expected, actual);
        }

 void Start()
 {
     piece = gameObject.GetComponent<Piece>();
     piece.moveDirections = directions;
     piece.isRepetitive = false;
     piece.isKing = true;
 }

 /// <summary>
 /// Storage class for row and column, does not restric the value of the input,
 /// expects consuming class to validate appropriate row/column value
 /// </summary>
 /// <param name="row"></param>
 /// <param name="column"></param>
 /// <param name="piece"></param>
 public BoardPosition(int row, int column, Piece piece)
 {
     this.Row = row;
     this.Column = column;
     this.Piece = piece;
     this.Piece.SetPosition(this.Row, this.Column);
 }

 public HordeChessGame() : base()
 {
     WhoseTurn = Player.White;
     Moves = new ReadOnlyCollection<DetailedMove>(new List<DetailedMove>());
     Board = new Piece[8][];
     Piece kb = FenMappings['k'];
     Piece qb = FenMappings['q'];
     Piece rb = FenMappings['r'];
     Piece nb = FenMappings['n'];
     Piece bb = FenMappings['b'];
     Piece pw = FenMappings['P'];
     Piece pb = FenMappings['p'];
     Piece o = null;
     Board = new Piece[8][]
     {
         new[] { rb, nb, bb, qb, kb, bb, nb, rb },
         new[] { pb, pb, pb, pb, pb, pb, pb, pb },
         new[] { o, o, o, o, o, o, o, o },
         new[] { o, pw, pw, o, o, pw, pw, o },
         new[] { pw, pw, pw, pw, pw, pw, pw, pw },
         new[] { pw, pw, pw, pw, pw, pw, pw, pw },
         new[] { pw, pw, pw, pw, pw, pw, pw, pw },
         new[] { pw, pw, pw, pw, pw, pw, pw, pw }
     };
     CanBlackCastleKingSide = CanBlackCastleQueenSide = CastlingCanBeLegal;
     CanWhiteCastleKingSide = CanWhiteCastleQueenSide = false;
 }

 private void CreateRandomPieceAtStartPoint()
 {
     int randomType = UnityEngine.Random.Range(0, PieceTypes.Count);
     switch (randomType)
     {
         case 0:
             PlayerControlledPiece = Piece.Create<Bar>();
             break;
         case 1:
             PlayerControlledPiece = Piece.Create<InverseL>();
             break;
         case 2:
             PlayerControlledPiece = Piece.Create<L>();
             break;
         case 3:
             PlayerControlledPiece = Piece.Create<S>();
             break;
         case 4:
             PlayerControlledPiece = Piece.Create<Square>();
             break;
         case 5:
             PlayerControlledPiece = Piece.Create<Tri>();
             break;
         case 6:
             PlayerControlledPiece = Piece.Create<Z>();
             break;
     }
 }

 public Move(Position originalPosition, Position newPosition, Player player, Piece promotion)
 {
     OriginalPosition = originalPosition;
     NewPosition = newPosition;
     Player = player;
     Promotion = promotion;
 }

 public static void addPiece(Piece [] pieces)
 {
     foreach (Piece p in pieces)
     {
         positions.Add(p);
     }
 }

    public bool CheckTileHeightDiffFromOutsidePlayerZone(Piece selectedPiece,int numPlayers)
    {
        if(numPlayers <=2 ){
            if(selectedPiece.tile.posOnBoard == 2 || selectedPiece.tile.posOnBoard == 7)
            {
                diff1 = Math.Abs(selectedPiece.tile.tileHeight - (this.tiles[0].tileHeight));
                return (diff1 < 3);
            }

            else if(selectedPiece.tile.posOnBoard == 1)
            {
                diff1 = Math.Abs(selectedPiece.tile.tileHeight - (this.tiles[1].tileHeight));
                diff2 = Math.Abs(selectedPiece.tile.tileHeight - this.tiles[6].tileHeight);
                diff3 = Math.Abs(selectedPiece.tile.tileHeight - this.tiles[36].tileHeight);
                return (diff1 < 3 && diff2 < 3 && diff3 < 3);
            }
            else if(selectedPiece.tile.posOnBoard == 37){
                diff1 = Math.Abs(selectedPiece.tile.tileHeight - (this.tiles[0].tileHeight));
                return (diff1 < 3);
            }
            else{
                return true;
            }

        }
        return true;
    }

	public void DetachPiece(){
		if (attachedPiece!=null){
			attachedPiece.transform.parent = null;
			attachedPiece = null;
			state = TileState.empty;
		}
	}

  public bool startTurn()
  {
    iteration++;
    int count = 0;
    count = Client.getMoveCount(connection);
    moves = new Move[count];
    for(int i = 0; i < count; i++)
    {
      moves[i] = new Move(Client.getMove(connection, i));
    }
    count = Client.getPieceCount(connection);
    pieces = new Piece[count];
    for(int i = 0; i < count; i++)
    {
      pieces[i] = new Piece(Client.getPiece(connection, i));
    }
    count = Client.getPlayerCount(connection);
    players = new Player[count];
    for(int i = 0; i < count; i++)
    {
      players[i] = new Player(Client.getPlayer(connection, i));
    }

    if(!initialized)
    {
      initialized = true;
      init();
    }
    return run();
  }

	public void Reset(){
		state = TileState.empty;
		if(attachedPiece!=null){
			attachedPiece.Fall(attachedPiece.transform.position.normalized * 4 + new Vector3(0,8,0));
			attachedPiece=null;
		}
	}

        //returns a list of pieces on the current opening
        public static Pieces GetPieces(int pageNumber)
        {
            var pieces = new Pieces();
            try
            {
                //gets the xelements representing the two pages of the opening (e.g. 1r, 2v)
                XElement root = SurfaceWindow1.xOldFr.Root;
                string verso = "#" + (pageNumber-2).ToString() + "v";
                string recto = "#" + (pageNumber-1).ToString() + "r";
                IEnumerable<XElement> pages =
                    from el in root.Descendants("pb")
                    where ((string)el.Attribute("facs") ==  verso || el.Attribute("facs").Value == recto)
                    select el;
                //adds the pieces on each page to the pieceList
                foreach (XElement page in pages)
                {
                    //var foo = page.Attribute("facs");
                    IEnumerable<XElement> pieceElements =
                    from el in page.Elements("p")
                    select el; //.Attribute("id").Value;

                    foreach (XElement p in pieceElements)
                    {
                        var piece = new Piece(p);
                        pieces.Add(piece.ID,piece);
                    }
                }

            }
            catch (Exception e)
            {
                MessageBox.Show(e.Message);
            }
            return pieces;
        }

    public Board(int d)
    {
        PossibleMovesNum = 1;
        needsRefreshModel = false;
        AlphaBetaMaxDepth = Constants.MAXDEPTH;
        pieceMatrix = new List<List<Piece>>();
        CurrentTurn = 0;
        for (int i = 0; i < d; i++)
        {
            List<Piece> temp = new List<Piece>();
            for (int j = 0; j < d; j++)
            {
                Piece tempPiece = new Piece(new Vector2(i, j));
                temp.Add(tempPiece);
            }
            pieceMatrix.Add(temp);
        }

        StartingMoves = new List<Vector2>();
        StartingMoves.Add(new Vector2(1, 1));
        StartingMoves.Add(new Vector2(1, boardSize - 2));
        StartingMoves.Add(new Vector2(boardSize - 2, 1));
        StartingMoves.Add(new Vector2(boardSize - 2, boardSize - 2));
        StartingMoves.Add(new Vector2((boardSize - 1) / 2, (boardSize - 1) / 2));
    }

 private void AnimateMovement(Piece toMove,  float time)
 {
     //animate it
     //Lerp could also be used, but I prefer the MoveTowards approach :)
     toMove.GameObject.transform.position = Vector2.MoveTowards(toMove.GameObject.transform.position,
       screenPositionToAnimate , time * AnimSpeed);
 }

        public void Print_GivenBoardContainingASinglePiece_PrintsRowDataCorrectly()
        {
            // Arrange
            var squares =
                new[]
                    {
                        // WBW
                        new Square(0, 0, Colour.White),
                        new Square(1, 0, Colour.Black),
                        new Square(2, 0, Colour.White)
                    };
            var piece = new Piece(squares, 'A');
            _board.PlacePieceAt(piece, 0, 0);

            var expectedLineForEmptyRow = CreateExpectedLineForEmptyRow();

            var expectedLastLine = "| Aw | Ab | Aw ";
            for (int i = 3; i < _board.BoardSize; i++) {
                expectedLastLine += "|";
                expectedLastLine += new string(' ', 4);
            }
            expectedLastLine += "|";

            // Act
            _boardPrinter.Print(_board);

            // Assert
            Assert.That(_mockPrintTarget.Lines, Has.Length.EqualTo(_expectedNumberOfOutputLines));

            Assert.That(_mockPrintTarget.Lines[1], Is.EqualTo(expectedLineForEmptyRow));
            Assert.That(_mockPrintTarget.Lines[3], Is.EqualTo(expectedLineForEmptyRow));
            Assert.That(_mockPrintTarget.Lines[5], Is.EqualTo(expectedLineForEmptyRow));
            Assert.That(_mockPrintTarget.Lines[7], Is.EqualTo(expectedLastLine));
        }

    public void Occupy(Piece piece)
    {
        occupied = true;
        currentPiece = piece;

        // TODO: set sprite based on type
    }

 public Move(Piece promoteTo, Coordinate from, Coordinate to)
 {
     m_moveType = MoveType.Promotion;
     m_promoteTo = promoteTo;
     m_from = from;
     m_to = to;
 }

    public void Add(Piece piece, List<Piece> same)
    {
        //Debug.LogWarning ("History Add");
        //string kanji = piece.Kanji;
        //Vector2 pos = piece.Tile;

        if (max > 0)
            return;

        bool isFirst = piece.Owner.IsFirst;

        string addition = "";

        if (same != null) {
            if(same.Count == 1) {
                if(same[0].Tile.x < piece.Tile.x) {
                    addition += isFirst ? "左" : "右";
                }
                if(same[0].Tile.x > piece.Tile.x) {
                    addition += !isFirst ? "左" : "右";
                }
            }
        }

        HistoryInfo info = new HistoryInfo (index++, piece, addition);
        //HistoryInfo info = new HistoryInfo (index++, kanji, pos, isFirst, addition);
        moves.Add (info);
    }

 public DetailedMove(Position originalPosition, Position newPosition, Player player, char? promotion, Piece piece, bool isCapture, CastlingType castling) : 
     base(originalPosition, newPosition, player, promotion)
 {
     Piece = piece;
     IsCapture = isCapture;
     Castling = castling;
 }