Esempio n. 1
0
        static void Main(string[] args)
        {
            using (StreamReader reader = File.OpenText(@"c:\Work\PGN\sample.txt"))
            {
                Dictionary <string, string> c = new Dictionary <string, string>();
                c.Add("Nam", "Val1");
                c.Add("A", "B");
                c["B"] = "C";
                c["A"] = "B2";

                foreach (var k in c)
                {
                    string key = k.Key;
                    string val = k.Value;
                }

                PGNFormatter parser = new PGNFormatter();
                Game         game   = parser.Parse(reader);

                Move m = game.Moves[2];
                //game.Moves[3] = m;

                Coordinate cr = new Coordinate("a2");
                int[]      a  = new int[64];
                a[cr] = 100;

                //Coordinate t = 64;

                IReadOnlyPosition rp = game.GetCurrentPosition();

                //Position p2 = rp as Position;
                //p2.SetInitial();
            }
        }
Esempio n. 2
0
 public IChessboardArray CreateChessboardArray(IReadOnlyPosition position)
 {
     // TODO - using memory pools for such objects?
     Debug.Assert(position is Position.Position);
     var result = new ChessboardArray();
     result.Reset(position as Position.Position);
     return result;
 }
Esempio n. 3
0
        public Position(IReadOnlyPosition p)
        {
            _fields = new Piece[64];
            for (byte i = 0; i < 64; i++)
            {
                _fields[i] = p[i];
            }

            EPFile = p.EPFile;
            CanWhiteCastlingKingSide  = p.CanWhiteCastlingKingSide;
            CanWhiteCastlingQueenSide = p.CanWhiteCastlingQueenSide;
            CanBlackCastlingKingSide  = p.CanBlackCastlingKingSide;
            CanBlackCastlingQueenSide = p.CanBlackCastlingQueenSide;
            SideToMove = p.SideToMove;
            State      = p.State;
        }
Esempio n. 4
0
        private void SetCurrentPosition(IReadOnlyPosition position)
        {
            // TODO
            // Check a lot of conditions here, stop the engine, etc
            if (position is Position.Position)
            {
                m_analyzer.SetCurrentPosition((Position.Position)position);
            }
            else
            {
                // TODO
                throw new NotImplementedException();
            }

            if (m_log.IsDebugEnabled)
            {
                m_log.Debug("Engine got new current position");
            }
        }
Esempio n. 5
0
        public static string Encode(IReadOnlyPosition position,
            EncodingOptions options = EncodingOptions.None)
        {
            Debug.Assert(position != null);
            var s = new StringBuilder(80);
            // Encode the chessboard
            var board = Factory.Instance.CreateChessboardArray(position);
            for (int row = Chessboard.ROW_MAX; row >= Chessboard.ROW_MIN; --row)
            {
                int empty_cells = 0;
                for (int column = Chessboard.COLUMN_MIN;
                    column <= Chessboard.COLUMN_MAX; ++column)
                {
                    var cur_cell = new ChessboardCell(row, column);
                    Players player;
                    Pieces piece;
                    if (board.IsPieceAt(cur_cell, out player, out piece))
                    {
                        if (empty_cells != 0)
                        {
                            s.Append(empty_cells);
                            empty_cells = 0;
                        }
                        s.Append(PieceToChar(player, piece));
                    }
                    else
                    {
                        ++empty_cells;
                    }
                }
                if (empty_cells != 0)
                {
                    s.Append(empty_cells);
                    empty_cells = 0;
                }
                if (row != Chessboard.ROW_MIN)
                {
                    s.Append(ROWS_SEPARATOR);
                }
            }

            // Encode player to move
            s.Append(' ');
            s.Append(position.IsWhiteToMove ? FEN_WHITE_TO_MOVE : FEN_BLACK_TO_MOVE);

            // Encode castling availability
            s.Append(' ');
            if (!position.IsCanCastleShort(Players.White)
                && !position.IsCanCastleLong(Players.White)
                && !position.IsCanCastleShort(Players.Black)
                && !position.IsCanCastleLong(Players.Black))
            {
                s.Append(FEN_NO_ONE_CAN_CASTLE);
            }
            else
            {
                if (position.IsCanCastleShort(Players.White))
                {
                    s.Append(FEN_WHITE_CAN_CASTLE_SHORT);
                }
                if (position.IsCanCastleLong(Players.White))
                {
                    s.Append(FEN_WHITE_CAN_CASTLE_LONG);
                }
                if (position.IsCanCastleShort(Players.Black))
                {
                    s.Append(FEN_BLACK_CAN_CASTLE_SHORT);
                }
                if (position.IsCanCastleLong(Players.Black))
                {
                    s.Append(FEN_BLACK_CAN_CASTLE_LONG);
                }
            }

            // Encode en passant caputre possibility
            s.Append(' ');
            int? capture_en_passant_column = position.CaptureEnPassantColumn;
            if (capture_en_passant_column.HasValue)
            {
                var cell = new ChessboardCell(position.IsWhiteToMove ? 5 : 2,
                    capture_en_passant_column.Value);
                s.Append(cell.ToString());
            }
            else
            {
                s.Append(FEN_CANNOT_CAPTURE_EN_PASSANT);
            }

            s.Append(' ').Append(position.HalfmoveClock);

            s.Append(' ').Append(options.HasFlag(EncodingOptions.SetMovesCountToOne)
                ? 1 : position.FullmoveNumber);

            return s.ToString();
        }