コード例 #1
0
ファイル: PgnMove.cs プロジェクト: prezz/Firoz-Chess
        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;
            }
              }
        }
コード例 #2
0
ファイル: EventArgs.cs プロジェクト: prezz/Firoz-Chess
 /// <summary>
 /// Initializes a new instance of BoardChangedEventArgs.
 /// </summary>
 /// <param name="move">Move that has chenged the board. Can be null if the move has been changed in some other way.</param>
 internal BoardChangedEventArgs(Move move)
 {
     if (move == null)
       {
     m_from = Square.None;
     m_to = Square.None;
       }
       else
       {
     m_from = move.From;
     m_to = move.To;
       }
 }
コード例 #3
0
        public static Square[] GetDiagonals(Square CurrentPosition, PieceColor FriendlyColor)
        {
            GetColAndRowFromName(CurrentPosition.Name, out int column, out int row);
            var ValidSquares = new List <Square>();

            bool FoundSW = false, FoundSE = false, FoundNW = false, FoundNE = false;

            for (int i = row - 1; i >= 0; --i)
            {
                if (column - Math.Abs(row - i) >= 0 && !FoundSW)
                {
                    Square SW = GetSquareFromName(GetSquareNameFromColAndRow(column - Math.Abs(row - i), i));
                    if (SW.Piece == null)
                    {
                        ValidSquares.Add(SW);
                    }
                    else
                    {
                        FoundSW = true;
                        if (SW.Piece.Color != FriendlyColor)
                        {
                            ValidSquares.Add(SW);
                        }
                    }
                }

                if (column + Math.Abs(row - i) < 8 && !FoundSE)
                {
                    Square SE = GetSquareFromName(GetSquareNameFromColAndRow(column + Math.Abs(row - i), i));
                    if (SE.Piece == null)
                    {
                        ValidSquares.Add(SE);
                    }
                    else
                    {
                        FoundSE = true;
                        if (SE.Piece.Color != FriendlyColor)
                        {
                            ValidSquares.Add(SE);
                        }
                    }
                }
            }

            for (int i = row + 1; i < 8; ++i)
            {
                if (column - Math.Abs(row - i) >= 0 && !FoundNW)
                {
                    Square NW = GetSquareFromName(GetSquareNameFromColAndRow(column - Math.Abs(row - i), i));
                    if (NW.Piece == null)
                    {
                        ValidSquares.Add(NW);
                    }
                    else
                    {
                        FoundNW = true;
                        if (NW.Piece.Color != FriendlyColor)
                        {
                            ValidSquares.Add(NW);
                        }
                    }
                }

                if (column + Math.Abs(row - i) < 8 && !FoundNE)
                {
                    Square NE = GetSquareFromName(GetSquareNameFromColAndRow(column + Math.Abs(row - i), i));
                    if (NE.Piece == null)
                    {
                        ValidSquares.Add(NE);
                    }
                    else
                    {
                        FoundNE = true;
                        if (NE.Piece.Color != FriendlyColor)
                        {
                            ValidSquares.Add(NE);
                        }
                    }
                }
            }
            return(ValidSquares.ToArray());
        }
コード例 #4
0
 private void RaisePieceTaken(Square square, ChessPiece pieceTaken)
 {
     var handler = this.PieceTaken;
     if (handler != null) {
         var eventArgs = new PieceTakenEventArgs(square, pieceTaken);
         handler(this, eventArgs);
     }
 }
コード例 #5
0
ファイル: ChessFacade.cs プロジェクト: prezz/Firoz-Chess
        /// <summary>
        /// Creates a key that can be used to return an actual "Move" from the "MoveOrganizer"
        /// This method is also responsible for raising the Pawn promotion events.
        /// </summary>
        /// <param name="from">Where to move from.</param>
        /// <param name="to">Where to move to.</param>
        /// <returns>Key matching the requested move.</returns>
        private MoveIdentifier CreateMoveIdentifier(Square from, Square to)
        {
            MoveIdentifier result;
              result.From = from;
              result.To = to;
              result.PromotionPiece = Piece.None;

              if (Board.Rank(to) == 7 && m_currentGame.Board[from] == Piece.WhitePawn)
              {
            result.PromotionPiece = Piece.WhiteQueen;
            if (m_currentGame.Moves.Find(result) == null)
            {
              result.PromotionPiece = Piece.None;
            }
            else if (WhitePawnPromoted != null)
            {
              PromotionEventArgs promotionArgs = new PromotionEventArgs(PromotionPiece.Queen);
              WhitePawnPromoted(this, promotionArgs);
              switch (promotionArgs.PromotionPiece)
              {
            case PromotionPiece.Bishop:
              result.PromotionPiece = Piece.WhiteBishop;
              break;

            case PromotionPiece.Knight:
              result.PromotionPiece = Piece.WhiteKnight;
              break;

            case PromotionPiece.Rook:
              result.PromotionPiece = Piece.WhiteRook;
              break;
              }
            }
              }

              if (Board.Rank(to) == 0 && m_currentGame.Board[from] == Piece.BlackPawn)
              {
            result.PromotionPiece = Piece.BlackQueen;
            if (m_currentGame.Moves.Find(result) == null)
            {
              result.PromotionPiece = Piece.None;
            }
            else if (BlackPawnPromoted != null)
            {
              PromotionEventArgs promotionArgs = new PromotionEventArgs(PromotionPiece.Queen);
              BlackPawnPromoted(this, promotionArgs);
              switch (promotionArgs.PromotionPiece)
              {
            case PromotionPiece.Bishop:
              result.PromotionPiece = Piece.BlackBishop;
              break;

            case PromotionPiece.Knight:
              result.PromotionPiece = Piece.BlackKnight;
              break;

            case PromotionPiece.Rook:
              result.PromotionPiece = Piece.BlackRook;
              break;
              }
            }
              }

              return result;
        }
コード例 #6
0
ファイル: ChessFacade.cs プロジェクト: prezz/Firoz-Chess
 /// <summary>
 /// Returns the piece on a specefic square.
 /// </summary>
 /// <param name="square"></param>
 /// <returns></returns>
 public Piece PieceAt(Square square)
 {
     return m_boardCopy[square];
 }
コード例 #7
0
ファイル: ChessFacade.cs プロジェクト: prezz/Firoz-Chess
 /// <summary>
 /// Performs a single move.
 /// </summary>
 /// <param name="from">Where to move from.</param>
 /// <param name="to">Where to move to.</param>
 /// <returns>True if the move was possible. False otherwise.</returns>
 /// <exception cref="Chess.Model.ChessModelException"></exception>"
 public bool PerformMove(Square from, Square to)
 {
     if (!m_engineManager.Thinking)
       {
     Move move = m_currentGame.Moves.Find(CreateMoveIdentifier(from, to));
     if (move != null)
     {
       m_currentGame.MakeMove(move);
       HandleChangedGameState(move, m_engineConfiguration.EngineAutoPlay, true);
       return true;
     }
       }
       return false;
 }
コード例 #8
0
ファイル: GraphicHandler.cs プロジェクト: prezz/Firoz-Chess
        public void DrawPiece(Square square, Piece piece)
        {
            if (square != Square.None && piece != Piece.None)
              {
            Image image = PieceImage(piece);

            switch (m_viewFromBlack)
            {
              case true:
            m_picturePainter.DrawImage(image, ((7 - ChessFacade.File(square)) * SquareSize) + EdgeSize, (ChessFacade.Rank(square) * SquareSize) + EdgeSize, SquareSize, SquareSize);
            break;

              case false:
            m_picturePainter.DrawImage(image, (ChessFacade.File(square) * SquareSize) + EdgeSize, ((7 - ChessFacade.Rank(square)) * SquareSize) + EdgeSize, SquareSize, SquareSize);
            break;
            }
              }
        }
コード例 #9
0
ファイル: ChessFacade.cs プロジェクト: prezz/Firoz-Chess
 /// <summary>
 /// Returns the rank (or row) the square is located on.
 /// </summary>
 /// <param name="square">Valid arguments are all squares except Square.NoSquare.</param>
 /// <returns>The rank [0..7], viewed from white player, where square is located on the board.</returns>
 public static int Rank(Square square)
 {
     return Board.Rank(square);
 }
コード例 #10
0
ファイル: ChessFacade.cs プロジェクト: prezz/Firoz-Chess
 /// <summary>
 /// Returns the file (or column) the square is located on.
 /// </summary>
 /// <param name="square">Valid arguments are all squares except Square.NoSquare.</param>
 /// <returns>The rank [0..7], left to right viewed from white player, where square is located on the board.</returns>
 public static int File(Square square)
 {
     return Board.File(square);
 }
コード例 #11
0
 public PieceTakenEventArgs(Square square, ChessPiece pieceTaken)
 {
     this.Square = square;
     this.PieceTaken = pieceTaken;
 }
コード例 #12
0
ファイル: PositionEditor.cs プロジェクト: prezz/Firoz-Chess
        /// <summary>
        /// Gets or sets the piece on a specific square.
        /// </summary>
        /// <param name="square">Location of ppiece to get or set.</param>
        /// <returns>Square at a specefic location.</returns>
        public Piece this[Square square]
        {
            get { return m_editBoard[square]; }

              set
              {
            m_editBoard.PlacePiece(square, value);

            if (BoardChanged != null)
              BoardChanged(this, new BoardChangedEventArgs(null));
              }
        }
コード例 #13
0
ファイル: GraphicHandler.cs プロジェクト: prezz/Firoz-Chess
        public void HighlightSquare(Square square)
        {
            if (square != Square.None)
              {
            switch (m_viewFromBlack)
            {
              case true:
            m_picturePainter.DrawRectangle(m_highlightPen, ((7 - ChessFacade.File(square)) * SquareSize) + EdgeSize, (ChessFacade.Rank(square) * SquareSize) + EdgeSize, SquareSize, SquareSize);
            break;

              case false:
            m_picturePainter.DrawRectangle(m_highlightPen, (ChessFacade.File(square) * SquareSize) + EdgeSize, ((7 - ChessFacade.Rank(square)) * SquareSize) + EdgeSize, SquareSize, SquareSize);
            break;
            }
              }
        }
コード例 #14
0
        public static Square[] GetStraights(Square CurrentPosition, PieceColor FriendlyColor)
        {
            var validSquares = new List <Square>();

            var i = CurrentPosition.Row - 1;

            while (true)
            {
                if (i < 0)
                {
                    break;
                }
                var square = GetSquareFromName(GetSquareNameFromColAndRow(CurrentPosition.Column, i));
                if (!AddOnFriendlyCondition(square, validSquares, FriendlyColor))
                {
                    break;
                }
                --i;
            }

            i = CurrentPosition.Row + 1;
            while (true)
            {
                if (i > 7)
                {
                    break;
                }
                var square = GetSquareFromName(GetSquareNameFromColAndRow(CurrentPosition.Column, i));
                if (!AddOnFriendlyCondition(square, validSquares, FriendlyColor))
                {
                    break;
                }
                ++i;
            }

            i = CurrentPosition.Column - 1;
            while (true)
            {
                if (i < 0)
                {
                    break;
                }
                var square = GetSquareFromName(GetSquareNameFromColAndRow(i, CurrentPosition.Row));
                if (!AddOnFriendlyCondition(square, validSquares, FriendlyColor))
                {
                    break;
                }
                --i;
            }

            i = CurrentPosition.Column + 1;
            while (true)
            {
                if (i > 7)
                {
                    break;
                }
                var square = GetSquareFromName(GetSquareNameFromColAndRow(i, CurrentPosition.Row));
                if (!AddOnFriendlyCondition(square, validSquares, FriendlyColor))
                {
                    break;
                }
                ++i;
            }

            return(validSquares.ToArray());
        }
コード例 #15
0
ファイル: ChessFacade.cs プロジェクト: prezz/Firoz-Chess
        /// <summary>
        /// Returns the valid squares a piece can move to.
        /// </summary>
        /// <param name="from">Location of the piece valid destination squares are returned for.</param>
        /// <returns>Array of valid destination squares.</returns>
        public Square[] GetValidSquaresForPiece(Square from)
        {
            List<Square> buffer = new List<Square>();

              if (!m_engineManager.Thinking)
            foreach (Move move in m_currentGame.Moves)
              if (move.From == from)
            buffer.Add(move.To);

              return buffer.ToArray();
        }
コード例 #16
0
 public static Square[] GetKnightSquares(Square CurrentPosition)
 {
     throw new NotImplementedException();
 }
コード例 #17
0
ファイル: MainForm.cs プロジェクト: prezz/Firoz-Chess
        private void boardPicture_MouseDown(object sender, MouseEventArgs e)
        {
            m_movingFrom = m_graphicHandler.CoordinateToSquare(e.X, e.Y);

              m_graphicHandler.SwipeBoard();
              for (Square square = Square.A1; square <= Square.H8; ++square)
            m_graphicHandler.DrawPiece(square, m_chessFacade.PieceAt(square));

              Square[] squares = m_chessFacade.GetValidSquaresForPiece(m_movingFrom);
              foreach (Square square in squares)
            m_graphicHandler.HighlightSquare(square);

              m_graphicHandler.Refresh();
        }