public void SendInitializeCommonPiece(BoardPosition position, PieceColor color)
 {
     foreach (var subscriber in this._subscribers)
     {
         subscriber.InitializeCommonPiece(position, color);
     }
 }

        // returns all the available moves for a given color
        public List<MoveResult> GetAllAvailableMoves(PieceColor color)
        {
            var availables = new List<MoveResult>();
            var listToCheck = color == PieceColor.Black ? Pieces.AlivePlayerOnePieces : Pieces.AlivePlayerTwoPieces;

            bool anyJumps;
            //for every living piece of said color
            for (var i = 0; i < listToCheck.Count; i++)
            {
                var piece = listToCheck[i];
                anyJumps = false;
                for (var j = 0; j < availables.Count; j++)
                {
                    //if any current available moves are a jump, then all future moves are invalid unless they are a jump - force only jump moves
                    var m = availables[j];
                    if (m.Type == MoveType.Jump) //if the
                    {
                        anyJumps = true;
                        break;
                    }
                }

                //append the available moves onto the list
                availables.AddRange(GetAvailableMovesForPiece(piece, anyJumps));
            }

            // if there are any jumps, you must take a jump
            if(availables.Any(m => m.Type == MoveType.Jump))
               availables.RemoveAll(m => m.Type != MoveType.Jump);

            return availables;
        }

        private void CheckForCapture(char leftX, char rightX, char y, PieceColor color)
        {
            if (this.Board.IsOccupiedSquare(leftX, y, color))
            {
                this.AddValidMove(leftX, y, true);
            }

            if (this.Board.IsOccupiedSquare(rightX, y, color))
            {
                this.AddValidMove(rightX, y, true);
            }

            // En Passant
            if (this.Board.EnPassantSquare != null)
            {
                if (this.Board.EnPassantSquare.X == leftX && this.Board.EnPassantSquare.Y == y)
                {
                    this.AddValidMove(leftX, y, true, this.Board[leftX, this.Square.Y].Piece);
                }

                if (this.Board.EnPassantSquare.X == rightX && this.Board.EnPassantSquare.Y == y)
                {
                    this.AddValidMove(rightX, y, true, this.Board[rightX, this.Square.Y].Piece);
                }
            }
        }

        public Move(PieceColor color, BoardPosition initialPosition, BoardPosition endingPosition, bool pieceJumped = false, bool pieceCaptured = false)
        {
            if (initialPosition.ContainsPiece())
            {
                throw new ArgumentException("Move initial posiiton must not contain a piece");
            }

            if (endingPosition.ContainsPiece())
            {
                throw new ArgumentException("Move ending posiiton must not contain a piece");
            }

            if (pieceCaptured && !pieceJumped)
            {
                throw new ArgumentException("Capture moves are required to be configured as a jump move");
            }

            if (!ValidateMove(initialPosition, endingPosition, pieceJumped, pieceCaptured))
            {
                throw new ArgumentException("Invalid move requested");
            }

            this.PieceColor = color;
            this.PieceJumped = pieceJumped;
            this.PieceCaptured = pieceCaptured;
            this.InitialPosition = initialPosition;
            this.EndingPosition = endingPosition;
        }

        public Piece(PieceType type, PieceColor color, int col, int row, Board board)
        {
            this.Col = col;
            this.Row = row;
            this.X = col * Game.TILESIZE;
            this.Y =  row * Game.TILESIZE;
            this.Color = color;
            this.Board = board;
            FirstMove = true;
            SetType(type);

            this.MouseDown += delegate(object s, MouseButtonEventArgs ev) {
                if (!Game.GameOver && ((!Game.IsConnected && Game.MyTurn(Color)) ||
                    (Game.IsConnected && Game.MainColor == Color && Game.MyTurn())))
                {
                    dragging = true;
                    this.Cursor = Cursors.Hand;
                    System.Windows.Controls.Canvas.SetZIndex(this, 1000);
                }
            };

            this.MouseUp += new MouseButtonEventHandler(image_MouseUp);

            this.MouseMove += new MouseEventHandler(image_MouseMove);

            this.MouseLeave += new MouseEventHandler(image_MouseMove);
        }

 private void AssertPieceLoaded(IEngine engine, string coord, Type type, PieceColor color)
 {
     var piece = engine.Board[coord].Piece;
     Assert.IsNotNull(piece);
     Assert.AreEqual(color, piece.Color);
     Assert.IsInstanceOfType(piece, type);
 }

        /// <summary>
        /// Initializes a new instance of the Pawn class.
        /// </summary>
        /// <param name="color">Color, white or black, the piece represents.</param>
        public Pawn(PieceColor color)
        {
            m_iterator = new BoardIterator(null, Square.None, Direction.NoDirection);

              if (color == PieceColor.White)
              {
            m_color = PieceColor.White;
            m_opponentColor = PieceColor.Black;

            m_directions[0] = Direction.Up;
            m_directions[1] = Direction.UpLeft;
            m_directions[2] = Direction.UpRight;

            moveAgainRow = 2;
              }

              if (color == PieceColor.Black)
              {
            m_color = PieceColor.Black;
            m_opponentColor = PieceColor.White;

            m_directions[0] = Direction.Down;
            m_directions[1] = Direction.DownLeft;
            m_directions[2] = Direction.DownRight;

            moveAgainRow = 5;
              }
        }

        private static Lines GetConsecutiveLines(Connect4Board b, PieceColor color, int col, Connect4Column move)
        {
            int horizontal = 1, vertical = 1, mainDiagonal = 1, antiDiagonal = 1;
            int nextX, nextY;

            for (nextX = col + 1, nextY = move.LastDropRow; nextX < Connect4Board.COLUMNS && b.GetPiece(nextY, nextX) == color; nextX++)
                horizontal++;
            for (nextX = col - 1; nextX >= 0 && b.GetPiece(nextY, nextX) == color; nextX--)
                horizontal++;

            for (nextX = col, nextY = move.LastDropRow + 1; nextY < Connect4Board.ROWS && b.GetPiece(nextY, nextX) == color; nextY++)
                vertical++;
            for (nextX = col, nextY = move.LastDropRow - 1; nextY >= 0 && b.GetPiece(nextY, nextX) == color; nextY--)
                vertical++;

            for (nextX = col + 1, nextY = move.LastDropRow + 1; nextX < Connect4Board.COLUMNS && nextY < Connect4Board.ROWS && b.GetPiece(nextY, nextX) == color; nextX++, nextY++)
                mainDiagonal++;
            for (nextX = col - 1, nextY = move.LastDropRow - 1; nextX >= 0 && nextY >= 0 && b.GetPiece(nextY, nextX) == color; nextX--, nextY--)
                mainDiagonal++;

            for (nextX = col + 1, nextY = move.LastDropRow - 1; nextX < Connect4Board.COLUMNS && nextY >= 0 && b.GetPiece(nextY, nextX) == color; nextX++, nextY--)
                antiDiagonal++;
            for (nextX = col - 1, nextY = move.LastDropRow + 1; nextX >= 0 && nextY < Connect4Board.ROWS && b.GetPiece(nextY, nextX) == color; nextX--, nextY++)
                antiDiagonal++;

            return new Lines(horizontal, vertical, mainDiagonal, antiDiagonal);
        }

        public double Eval(CheckersBoard board, int level, PieceColor playerColor)
        {
            {
                double eval = 0;

                for (int x = 0; x < board.Width; x++)
                    for (int y = 0; y < board.Height; y++)
                    {
                        var piece = board.GetPieceAt(x, y) as CheckersPiece;
                        if (piece != null)
                        {
                            if (piece.Color == playerColor)
                            {
                                if (piece is Pawn) eval += _ownPawnStrength;
                                else if (piece is Queen) eval += _ownQueenStrength;
                            }
                            else
                            {
                                if (piece is Pawn) eval -= _ownPawnStrength;
                                else if (piece is Queen) eval -= _ownQueenStrength;
                            }
                        }
                    }

                return eval;
            }
        }

 public ChessPieceViewModel(ChessPiece i_ChessPiece, PieceColor i_PieceColor, PieceSide i_PieceSide, int i_File, int i_Rank)
 {
     ChessCoord tempChessCoord = new ChessCoord();
     tempChessCoord.File = i_File;
     tempChessCoord.Rank = i_Rank;
     m_ChessPieceModel = new ChessPieceModel(i_ChessPiece, i_PieceColor, i_PieceSide, tempChessCoord);
 }

        /// <summary>
        /// Instantiate <see cref="Piece"/>
        /// </summary>
        /// <param name="type"><see cref="Type"/></param>
        /// <param name="color"><see cref="Color"/></param>
        public Piece(PieceType type, PieceColor color)
        {
            _type = type;
            _color = color;

            Moves = new List<Move>();
            Attacked = new List<Square>();
        }

        public Piece(Square position, Board board, PieceColor color)
        {
            this.position = position;
            this.board = board;
            this.color = color;

            this.board.Squares[position] = this;
        }

        public void Whether_Rook_CantJumpOverAnotherPiece_On_CanMoveTo(PieceColor pieceColor)
        {
            var board = new Board();
            var rook = new Rook(new Square(4, 4), board, PieceColor.White);
            var knight = new Knight(new Square(4, 5), board, pieceColor);

            Assert.That(rook.CanMoveTo(new Square(4, 6)), Is.False);
        }

 public Piece(bool belongsToPlayerTwo, Point position, PieceColor color, int sumoness)
 {
     BelongsToPlayerTwo = belongsToPlayerTwo;
     Position = position;
     Color = color;
     MaxMoveLength = 7 - 2 * sumoness;
     Sumoness = sumoness;
 }

 public FixedDepthPlayer(PieceColor c, int depth)
     : base(c)
 {
     if (depth >= 0)
         maxDepth = depth;
     else
         throw new ArgumentException("Depth must be at least 0");
 }

 public FixedTimePlayer(PieceColor c, int thinkTimeSeconds)
     : base(c)
 {
     if (thinkTimeSeconds > 0)
         this.thinkTimeSeconds = thinkTimeSeconds;
     else
         throw new ArgumentException("Think time must be greater than 0");
 }

        public void Whether_Queen_CantJumpOverAnotherPiece_On_CanMoveTo(PieceColor pieceColor)
        {
            var board = new Board();
            var queen = new Queen(new Square(4, 4), board, PieceColor.White);
            var knight = new Knight(new Square(5, 5), board, pieceColor);

            Assert.That(queen.CanMoveTo(new Square(6, 6)), Is.False);
        }

        public PgnMove(string pgnString)
        {
            Match m = r.Match(pgnString);

              if (m.Groups["Move"].Value == "")
              {
            ColorToPlay = PieceColor.Black;
              }
              else
              {
            ColorToPlay = PieceColor.White;
              }

              if (m.Groups["Castling"].Value == "")
              {
            PieceToPlay = StringToPiece(m.Groups["Piece"].Value, ColorToPlay);
            FromFile = StringToFile(m.Groups["File"].Value);
            FromRank = StringToRank(m.Groups["Rank"].Value);
            DestinationSquare = StringToSquare(m.Groups["Destination"].Value);
            PromotionPiece = StringToPromotion(m.Groups["Promotion"].Value);
              }
              else if (m.Groups["Castling"].Value == "O-O")
              {
            if (ColorToPlay == PieceColor.White)
            {
              DestinationSquare = Square.G1;
              PieceToPlay = Piece.WhiteKing;
              FromFile = 4;
              FromRank = 0;
            }

            if (ColorToPlay == PieceColor.Black)
            {
              DestinationSquare = Square.G8;
              PieceToPlay = Piece.BlackKing;
              FromFile = 4;
              FromRank = 7;
            }
              }
              else if (m.Groups["Castling"].Value == "O-O-O")
              {
            if (ColorToPlay == PieceColor.White)
            {
              DestinationSquare = Square.C1;
              PieceToPlay = Piece.WhiteKing;
              FromFile = 4;
              FromRank = 0;
            }

            if (ColorToPlay == PieceColor.Black)
            {
              DestinationSquare = Square.C8;
              PieceToPlay = Piece.BlackKing;
              FromFile = 4;
              FromRank = 7;
            }
              }
        }

        public double Eval(CheckersBoard board, int level, PieceColor playerColor)
        {
            {
                double myval = 0;
                double enemyval = 0;
                for (int x = 0; x < board.Width; x++)
                    for (int y = 0; y < board.Height; y++)
                    {
                        CheckersPiece piece = board.GetPieceAt(x, y) as CheckersPiece;
                        if (piece != null)
                        {
                            int factor = (piece.Color == PieceColor.White) ? (7 - y) : (y);
                            if (piece.Color == playerColor)
                            {
                                if (piece is Pawn) myval += 100 + (factor * factor);
                                else
                                {

                                    myval += 200;
                                    if (y == 0)
                                    {
                                        if (x == 0) myval -= 40;
                                        else myval -= 20;
                                    }
                                    else if (y == 7)
                                    {
                                        if (x == 7) myval -= 40;
                                        else myval -= 20;
                                    }
                                }
                            }
                            else
                            {
                                if (piece is Pawn) enemyval += 100 + (factor * factor);
                                else
                                {
                                    enemyval += 200;
                                    if (y == 0)
                                    {
                                        if (x == 0) enemyval -= 40;
                                        else enemyval -= 20;
                                    }
                                    else if (y == 7)
                                    {
                                        if (x == 7) enemyval -= 40;
                                        else enemyval -= 20;
                                    }
                                }
                            }
                        }
                    }

                if (enemyval == 0) return 100000 + level * level;
                else if (myval == 0) return -100000 - level * level;
                return (myval - enemyval);
            }
        }

 public void CalculateValidMoves(PieceColor playerColor)
 {
     // TODO: Parallel.ForEach<PieceBase>(this.Pieces, p => p.CalculateValidMoves());
     foreach (PieceBase piece in this.Pieces)
     {
         if (piece.Color == playerColor)
             piece.CalculateValidMoves();
     }
 }