C# Board.MakeMove方法代码示例

        public void GetRowValues_Setting7And9_Returns7And9()
        {
            // arrange
            var v = new Board();
            v.MakeMove(new Move(Columns.A, Rows.One, Values.One));
            v.MakeMove(new Move(Columns.G, Rows.One, Values.Nine));

            // act
            var result = v.GetRowValues(Rows.One);

            // assert
            Assert.AreEqual(Values.One | Values.Nine, result);
        }

 public void GetCellValue_SettingCellTo9_Returns9()
 {
     // arrange
     var b = new Board();
     b.MakeMove(new Move(Columns.A, Rows.Seven, Values.Nine));
     // act
     var result = b.GetCellValue(Columns.A, Rows.Seven);
     // assert
     Assert.AreEqual(Values.Nine, result);
 }

        public override SearchResult Search(Board board, int color,int depth)
        {
            SearchResult searchResult = new SearchResult();
            //board.CurrentColor = color;
            //PrepareToSolve(board);
            int alpha = -MaxScore - 1;
            int beta = MaxScore + 1;
            int opp =  color.Opp();

            Clock clock = new Clock();
            clock.Start();
            //Roulette roulette = new Roulette();
            //board.RefreshHash();

            int score = -MaxScore;
            int eval;
            //是否调用零窗口的标志
            bool foundPv = false;

            var moves = rule.FindFlips(board, color).ToList();

            if (moves.Count == 0) {
                return new SearchResult() { Move = -1 };
            }

            //if (moves.Count == 1) {
            //    return new SearchResult() { Move = moves.First().Pos };
            //}

            for (int i = 0; i < moves.Count; i++) {
                var pos = moves[i].Pos;
                //下棋
                //---------------------------
                int flipCount = board.MakeMove(pos, color);

                searchResult.Nodes++;
                //检测
                if (foundPv) {
                    //调用零窗口
                    eval = -FastestFirstSolve(board, -alpha - 1, -alpha, depth - 1, searchResult, opp, color);
                    if ((eval > alpha) && (eval < beta)) {
                        eval = -FastestFirstSolve(board, -beta, -eval, depth - 1, searchResult, opp, color);
                        //eval = -FastestFirstMidSolve( -beta, -alpha, oppcolor, depth - 1);
                    }
                }
                else {
                    eval = -FastestFirstSolve(board, -beta, -alpha, depth - 1, searchResult, opp, color);
                }

                //em.ReLink();
                //---------------------------
                //Eval.StepsPop(color);
                //恢复到上一步
                board.Reback(pos, flipCount, opp);

                searchResult.Message += string.Format("({0}:{1})", pos, eval);
                if (eval > score) {
                    score = eval;
                    //更新位置
                    searchResult.Move = pos;
                    searchResult.Score = score;

                    if (eval > alpha) {
                        if (eval >= beta) {
                            //剪枝
                            break;
                        }
                        alpha = eval;
                        foundPv = true;
                    }
                }
            }

            clock.Stop();

            searchResult.TimeSpan = clock.Elapsed;

            return searchResult;
        }

        /// <summary>
        /// 最快优先搜索
        /// </summary> 
        private int FastestFirstSolve(Board board, int alpha, int beta, int depth, SearchResult searchResult, int cur, int opp, bool prevmove = true)
        {
            lock (this) {
                //计算搜索的结点数
                searchResult.Nodes++;
                /*
                //尝试置换表裁剪，并得到置换表走法
                HashResult hashResult = board.ReadHash(alpha, beta, depth);
                if (hashResult != null) {
                    Message.Hits++;
                    return hashResult.Score;
                }
                */

                if (board.EmptyCount == 0) {//游戏结束
                    return EndEval(board,cur);
                }

                //叶子节点，局面估分
                if (depth == 0) {
                    return Eval(board, cur);
                }

                int mvBest = 0;
                int score = -MaxScore;
                //是否调用零窗口的标志
                bool foundPv = false;
                int eval;

                #region hash code
                /*
                //int mvHash = hashResult.Move;
                //初始化最佳值和最佳走法

                HashType hashType = HashType.LOWER_BOUND;

                //初始化走法排序结构
                board.InitMoves(); //board.InitMoves(mvHash);

                int quickMove = board.GetQuickMove();

                //            if (moveDefend > Evalation.Defend_FreeThree)
                //                return moveDefend;
                //if (board.MoveHash != 0)
                //    quickMove = board.MoveHash;
                //else if ((board.MoveKiller1 != board.MoveHash) && (board.MoveKiller1 != 0) && board.CanMove(board.MoveKiller1))
                //    quickMove = board.MoveKiller1;
                //else if ((board.MoveKiller2 != board.MoveHash) && (board.MoveKiller2 != 0) && board.CanMove(board.MoveKiller2))
                //    quickMove = board.MoveKiller2;

                if (quickMove != 0) {
                    //---------------------------
                    board.MakeMove(quickMove);
                    eval = -FastestFirstSolve(board, -beta, -alpha, depth - 1);
                    //恢复到上一步
                    board.Reback(quickMove);

                    if (eval > alpha) {
                        if (eval >= beta) {
                            //----------------------
                            hashType = HashType.UPPER_BOUND;
                            // 记录到置换表
                            board.StoreHash(hashType, eval, depth, quickMove);
                            //TODO:有点怀疑是否需要这个条件
                            if (mvBest != 0) {
                                // 如果不是Alpha走法，就将最佳走法保存到历史表
                                board.StoreBestMove(quickMove, depth);
                            }
                            //剪枝
                            return eval;
                        }
                        //----------------
                        hashType = HashType.EXACT;

                        alpha = eval;
                        foundPv = true;
                    }
                }

                Roulette roulette = new Roulette();
                int gness;
                int moves = roulette.CalculateGoodness(out gness);

                if (gness == Evalation.InfScore) {
                    return gness;
                }
                */

                #endregion

                var moves = rule.FindFlips(board, cur).ToList();

                if (moves.Count == 0) {
                    if (!prevmove) {//游戏结束
                        return EndEval(board,cur);
                        /*
                        if (discdiff > 0)//自己赢
//.........这里部分代码省略.........

 public void TestMove( string boardStr, Move move, bool expectedValid, string expected )
 {
     var board = new Board();
      board.Load( boardStr );
      bool valid = board.MakeMove( move );
      Assert.AreEqual( expectedValid, valid );
      if ( valid )
      {
     Assert.AreEqual( expected, board.ToString() );
      }
      else
      {
     // Make sure it hasn't changed
     Assert.AreEqual( boardStr, board.ToString() );
      }
 }

 public void TestCantMoveOnSolvedBoard( string boardStr, Move move )
 {
     var board = new Board();
      board.Load( boardStr );
      Assert.IsFalse( board.MakeMove( move ) );
 }

 private static Board PlaybackMoves( string boardStr, Move[] moveList )
 {
     var board = new Board();
      board.Load( boardStr );
      foreach ( Move move in moveList )
      {
     bool valid = board.MakeMove( move );
     Assert.IsTrue( valid );
      }
      return board;
 }

        public void MakeMove_MovingKingE1E2()
        {
            // arrange
            var board = new Board(
                new Side(
                    "E1",
                    new PieceSet<Queen>(Bitboard.Empty),
                    new PieceSet<Bishop>(Bitboard.Empty),
                    new PieceSet<Knight>(Bitboard.Empty),
                    new PieceSet<Rook>(Bitboard.Empty),
                    new WhitePawns(Bitboard.Empty)
                    ),
                new Side(
                    "E8",
                    new PieceSet<Queen>(Bitboard.Empty),
                    new PieceSet<Bishop>(Bitboard.Empty),
                    new PieceSet<Knight>(Bitboard.Empty),
                    new PieceSet<Rook>(Bitboard.Empty),
                    new WhitePawns(Bitboard.Empty)
                    ));

            // act
            Board result = board.MakeMove("E1", "E2");

            // assert
            result.White.KingLocation.Should().Be(
                new Square("E2")
                );
        }

        public void MakeMove_NumberRepetitionInColumn_ThrowsInvalidOperationException()
        {
            // arrange
            Board b = new Board();

            // act
            b.MakeMove(new Move(Columns.A, Rows.One, Values.Nine));
            b.MakeMove(new Move(Columns.A, Rows.Seven, Values.Nine));

            // assert
        }

        public void UnmakeMove_MakeAndUnmake9InA1_EmptyA1()
        {
            Board b = new Board();

            b.MakeMove(new Move(Columns.A, Rows.One, Values.Nine));
            b.UnmakeMove(new Move(Columns.A, Rows.One, Values.Nine));

            Assert.AreEqual(Values.None, b.GetCellValue(Columns.A, Rows.One));
            Assert.AreEqual(Values.None, b.GetColumnValues(Columns.A));
            Assert.AreEqual(Values.None, b.GetRowValues(Rows.One));
        }

 public void TestMove(string startFen, string endFen, bool valid, string from, string to, string description)
 {
     var board = new Board(startFen);
     var move = board.MakeMove(from, to);
     Assert.AreEqual(valid, move.Valid, description);
     Assert.AreEqual(endFen, board.FEN, description);
 }

        private void Gen(TextWriter writer, Board board, int color, bool prevmove = true)
        {
            if (Records >= Limit) {
                return;
            }

            if (board.EmptyCount == EndGameDepth) {
                var searchResult = Engine.Search(board.Copy(), color, this.SearchDepth);
                WriteRecord(writer, board, searchResult.Score, searchResult.Move, color);

                Records++;

                //每1000条记录就Flush一次
                if (Records % 1000 == 0) {
                    Console.WriteLine("Write Records: {0}", Records);
                    writer.Flush();
                }

                return;
            }

            int opp = color.Opp();
            var moves = rule.FindFlips(board, color).ToList();

            if (moves.Count == 0) {
                if (prevmove) {
                    Gen(writer, board, opp, false);
                }

                return;
            }

            foreach (var move in moves) {
                int flipCount = board.MakeMove(move.Pos, color);

                Gen(writer, board, opp);

                board.Reback(move.Pos, flipCount, opp);
            }
        }

        private FightResult Fight(IEngine engineA, IEngine engineB, Board board, int color = StoneType.Black)
        {
            Clock clock = new Clock();
            clock.Start();

            IEngine[] engines = new[] { engineA, engineB };
            int[] stoneTypes = new[] { StoneType.Black, StoneType.White };
            int turn = color - 1; //0;
            Console.WriteLine(board);

            while (true) {
                //board.CurrentColor = stoneTypes[turn];
                var searchResult = engines[turn].Search(board.Copy(), stoneTypes[turn], (Constants.StoneCount - 4) / 2);
                Console.WriteLine("[{0}] {1}", engines[turn].Name, searchResult);
                Console.Out.Flush();

                if (searchResult.Move < 0 ||
                    searchResult.Move >= Constants.StoneCount ||
                    !rule.CanFlip(board[searchResult.Move], stoneTypes[turn])) {
                    clock.Stop();
                    //下棋异常
                    Console.WriteLine(board);

                    return new FightResult() {
                        WinnerName = engines[1 - turn].Name,
                        LoserName = engines[turn].Name,
                        WinnerStoneType = (turn == 0 ? StoneType.Black : StoneType.White),
                        Score = 1,
                        TimeSpan = clock.TotalMilliseconds
                    };
                }
                else {
                    board.MakeMove(searchResult.Move, stoneTypes[turn]);
                    Console.WriteLine(board);
                }

                turn = 1 ^ turn;

                var canFlip = rule.CanFlip(board, stoneTypes[turn]);

                if (!canFlip) {
                    //对方无棋可下，轮换
                    turn = 1 ^ turn;
                    canFlip = rule.CanFlip(board, stoneTypes[turn]);

                    if (!canFlip) {
                        //双方都无棋可下，结束
                        break;
                    }
                }
            }

            clock.Stop();
            //Console.WriteLine(board);

            return new FightResult(board, engines) {
                TimeSpan = clock.TotalMilliseconds
            };
        }