Esempio n. 1
0
        static void TryMove(int[,] State, clsMove Move)
        {
            Point c = Move.CurPos;
            Point n = Move.NewPos;

            int value = State[c.X, c.Y];

            //Nhập Thành
            if (value / 10 == 6)
            {
                if (Math.Abs(n.X - c.X) == 2)
                {
                    if (n.X == 7)
                    {
                        int tmp = State[8, n.Y];
                        State[8, n.Y] = 0;
                        State[6, n.Y] = tmp;
                    }
                    if (n.X == 3)
                    {
                        int tmp = State[1, n.Y];
                        State[1, n.Y] = 0;
                        State[4, n.Y] = tmp;
                    }
                }
            }


            State[n.X, n.Y] = value;
            State[c.X, c.Y] = 0;
        }
Esempio n. 2
0
        static void TryMove(int[,] State, clsMove Move)
        {
            Vector2 c = Move.CurPos;
            Vector2 n = Move.NewPos;

            int value = State[(int)c.x, (int)c.y];

            //Nhập Thành
            if (value / 10 == 6)
            {
                if (Math.Abs(n.x - c.x) == 2)
                {
                    if (n.x == 7)
                    {
                        int tmp = State[8, (int)n.y];
                        State[8, (int)n.y] = 0;
                        State[6, (int)n.y] = tmp;
                    }
                    if (n.x == 3)
                    {
                        int tmp = State[1, (int)n.y];
                        State[1, (int)n.y] = 0;
                        State[4, (int)n.y] = tmp;
                    }
                }
            }


            State[(int)n.x, (int)n.y] = value;
            State[(int)c.x, (int)c.y] = 0;
        }
Esempio n. 3
0
        //vd: E2E3, E7E8=q
        public void MakeMove(string strMove)
        {
            if (strMove == "")
            {
                return;
            }
            clsMove MyMove = new clsMove(strMove);


            UcChessPiece Piece = this.arrChessCell[MyMove.CurPos.X, MyMove.CurPos.Y].ChessPiece;

            if (Piece == null)
            {
                return;
            }

            arrMove = clsChessEngine.FindAllLegalMove(_BoardState, MyMove.CurPos, Piece.Type);
            DoMove(Piece, MyMove);
        }
Esempio n. 4
0
        //DateTime StartTime, EndTime;

        private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
        {
            try
            {
                IsThinking = true;
                if (IsCancelThinking == true)
                {
                    IsCancelThinking = false;
                    return;
                }
                Point CurPos = new Point();
                Point NewPos = new Point();


                string strFen = clsFEN.GetFENWithoutMoveNumber(this);
                MyMove = clsChessEngine.ReadFromBook(strFen);
                if (MyMove == null)
                {
                    MyMove = new clsMove(CurPos, NewPos);
                    //StartTime = DateTime.Now;
                    arrMove = clsChessEngine.GenerateMove(this._BoardState, this.arrFEN, tmpOppSide, ref MyMove, tmpDifficulty);
                    if (tmpDifficulty == GameDifficulty.Hard)
                    {
                        clsChessEngine.WriteToBook(strFen, MyMove);
                    }
                }
                else
                {
                    //  intOutOfBookCount = 0;
                    ChessPieceType eType = (ChessPieceType)(this._BoardState[MyMove.CurPos.X, MyMove.CurPos.Y] / 10);
                    arrMove = clsChessEngine.FindAllLegalMove(this._BoardState, MyMove.CurPos, eType);
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }
Esempio n. 5
0
        //Code change ngày 30/07/2010
        //Thêm đối số để phục vụ cho việc xác định các nước đi bất biến 3 lần
        public static int AlphaBeta(int[,] BoardState, ArrayList arrFEN, int depth, ChessSide eSide, int Alpha, int Beta)
        {
            //NodeCount++;
            if (depth == 0)
            {
                return(Evaluate(BoardState, arrFEN));
            }

            int       best     = -100000;
            clsMove   bestmove = new clsMove();
            ArrayList arrMoves = Successors(BoardState, eSide);

            if (arrMoves.Count == 0)
            {
                //Quân Vua mình bị chiếu và người hết cờ là mình => trừ điểm mình

                if (clsKing.IsChecked(BoardState, Myside) == true)
                {
                    if (eSide == Myside)
                    {
                        return(-10000 - depth);
                    }
                }
                //Quân Vua đối phươn bị chiếu và người hết cờ là đối phương => trừ điểm đối phương
                if (clsKing.IsChecked(BoardState, OppSide) == true)
                {
                    if (eSide == OppSide)
                    {
                        return(-10000 - depth);
                    }
                }

                return(0);
            }
            //Sắp xếp các nước đi nhằm tăng hiệu quả của hàm Alpha Beta
            int intPromotionType = 2;

            if (depth > 1)
            {
                foreach (clsMove m in arrMoves)
                {
                    int[,] State = new int[10, 10];
                    Array.Copy(BoardState, State, BoardState.Length);

                    Point c = m.CurPos;
                    Point n = m.NewPos;

                    int value = State[c.X, c.Y];

                    if (value / 10 == 1)
                    {
                        if (value % 10 == 1 && n.Y == 1)
                        {
                            value = intPromotionType * 10 + 1;
                            intPromotionType++;
                            State[c.X, c.Y] = value;
                        }
                        if (value % 10 == 2 && n.Y == 8)
                        {
                            value = intPromotionType * 10 + 2;
                            intPromotionType++;
                            State[c.X, c.Y] = value;
                        }
                    }
                    if (intPromotionType == 6)
                    {
                        intPromotionType = 2;
                    }
                    TryMove(State, m);
                    int Score = AlphaBeta(State, arrFEN, 0, eSide, -Beta, -Alpha);
                    m.Score = Score;
                }
                Sort(arrMoves, eSide);
            }
            intPromotionType = 5;


            while (arrMoves.Count > 0 && best < Beta)
            {
                int[,] State = new int[10, 10];
                Array.Copy(BoardState, State, BoardState.Length);


                clsMove Move = (clsMove)arrMoves[arrMoves.Count - 1];

                Point c = Move.CurPos;
                Point n = Move.NewPos;

                int x = State[c.X, c.Y];

                if (x / 10 == 1)
                {
                    if (x % 10 == 1 && n.Y == 1)
                    {
                        x = intPromotionType * 10 + 1;
                        Move.PromoteTo = (ChessPieceType)intPromotionType;
                        intPromotionType--;
                        State[c.X, c.Y] = x;
                    }
                    if (x % 10 == 2 && n.Y == 8)
                    {
                        x = intPromotionType * 10 + 2;
                        Move.PromoteTo = (ChessPieceType)intPromotionType;
                        intPromotionType--;
                        State[c.X, c.Y] = x;
                    }
                    if (intPromotionType == 1)
                    {
                        intPromotionType = 5;
                    }
                }

                TryMove(State, Move);
                arrMoves.RemoveAt(arrMoves.Count - 1);
                //Đã đi thử xong
                ArrayList arrFENNew = new ArrayList();
                arrFENNew.AddRange(arrFEN);
                arrFENNew.Add(clsFEN.GetPiecePlacementString(State));

                ChessSide s;
                if (eSide == ChessSide.White)
                {
                    s = ChessSide.Black;
                }
                else
                {
                    s = ChessSide.White;
                }

                if (best > Alpha)
                {
                    Alpha = best;
                }

                int value = -AlphaBeta(State, arrFENNew, depth - 1, s, -Beta, -Alpha);

                if (value > best)
                {
                    best     = value;
                    bestmove = Move;
                }
            }

            if (depth == MaxDepth)
            {
                bestmove.Score = best;
                MyBestMove     = bestmove;
            }

            return(best);
        }
Esempio n. 6
0
        public void DoMove(UcChessPiece Piece, clsMove move)
        {
            if ((Piece.Side == ChessSide.Black && this._WhiteToMove == true) || (Piece.Side == ChessSide.White && this._WhiteToMove == false))
            {
                return;
            }

            Point CurPos = move.CurPos;
            Point NewPos = move.NewPos;

            UcChessCell ct = (UcChessCell)this.arrChessCell[NewPos.X, NewPos.Y];

            //*********************************Kiểm tra nước đi************************
            //Kiểm tra Xem Quân Cờ có thể di chuyển từ CurPos đến NewPos hay không
            if (clsChessEngine.CanMove(arrMove, NewPos) == true)
            {
                UnHighlightLastMove();
                PushState();
                string strLastCell = Convert.ToChar(CurPos.X + 64) + CurPos.Y.ToString();
                string strNewCell  = Convert.ToChar(NewPos.X + 64) + NewPos.Y.ToString();


                this._BoardState[CurPos.X, CurPos.Y] = 0;//Đánh dấu vị trí cũ không chứa quân cờ
                this._BoardState[NewPos.X, NewPos.Y] = (int)Piece.Type * 10 + (int)Piece.Side;
                //Kiểm tra xem quân vua có bị chiếu không
                //****************Chưa tính trường hợp chiếu bí và Hòa***************


                bool bCapture = false;

                //Lấy vị trí Bắt tôt qua đường nếu có

                if (Piece.Type == ChessPieceType.Pawn)
                {
                    if (Math.Abs(NewPos.Y - CurPos.Y) == 2)
                    {
                        _EnPassantPoint = clsPawn.GetEnPassantPoint(this._BoardState, NewPos);
                    }
                    else if (CurPos.X == NewPos.X)
                    {
                        _EnPassantPoint = new Point();
                    }


                    //Thực hiện nước bắt tốt qua đường
                    if (NewPos == _EnPassantPoint)
                    {
                        Point CapturedPoint;

                        if (Piece.Side == ChessSide.White)
                        {
                            CapturedPoint = new Point(_EnPassantPoint.X, _EnPassantPoint.Y - 1);
                        }
                        else
                        {
                            CapturedPoint = new Point(_EnPassantPoint.X, _EnPassantPoint.Y + 1);
                        }

                        UcChessCell bt = arrChessCell[CapturedPoint.X, CapturedPoint.Y];

                        this._BoardState[CapturedPoint.X, CapturedPoint.Y] = 0;//Đánh dấu vị trí cũ không chứa quân cờ



                        stkCapturedPieces.Push(bt.ChessPiece);

                        bt.ChessPiece.Hide();
                        bt.ChessPiece   = null;
                        _EnPassantPoint = new Point();

                        bCapture = true;
                    }
                }
                else
                {
                    _EnPassantPoint = new Point();
                }

                if (ct.ChessPiece != null && ct.ChessPiece.Side != Piece.Side)//Nếu đã có quân cờ đặt tại ô đến
                {
                    UcChessPiece CapturedPiece = ct.ChessPiece;
                    stkCapturedPieces.Push(CapturedPiece);
                    CapturedPiece.Hide();//Xóa quân cờ tại ô Di chuyển đến

                    if (CapturedPiece.Type == ChessPieceType.Rook)
                    {
                        if (CapturedPiece.Side == ChessSide.White)
                        {
                            if (CapturedPiece.PositionX == 1)
                            {
                                QUEENsideCastling = false;
                            }
                            if (CapturedPiece.PositionX == 8)
                            {
                                KINGsideCastling = false;
                            }
                        }
                        else
                        {
                            if (CapturedPiece.PositionX == 1)
                            {
                                queensideCastling = false;
                            }
                            if (CapturedPiece.PositionX == 8)
                            {
                                kingsideCastling = false;
                            }
                        }
                    }
                    ct.ChessPiece = null;
                    bCapture      = true;
                }

                Piece.UConCell.ChessPiece = null;//Ô cờ trước đó ko còn chứa quân cờ này nữa
                //Dat Quan Co Tai Vi Tri Moi
                ct.ChessPiece  = Piece;
                Piece.UConCell = ct;

                //Gán tọa độ mới cho quân cờ
                Piece.PositionX = NewPos.X;
                Piece.PositionY = NewPos.Y;

                string strPromote = "";
                if (Piece.Type == ChessPieceType.Pawn)
                {
                    if (clsPawn.Promotion(Piece, move.PromoteTo) == true)
                    {
                        this._BoardState[Piece.PositionX, Piece.PositionY] = (int)Piece.Type * 10 + (int)Piece.Side;
                        switch (Piece.Type)
                        {
                        case ChessPieceType.Bishop: strPromote = "=B";
                            break;

                        case ChessPieceType.Knight: strPromote = "=N";
                            break;

                        case ChessPieceType.Rook: strPromote = "=R";
                            break;

                        case ChessPieceType.Queen: strPromote = "=Q";
                            break;
                        }
                        move.PromoteTo = Piece.Type;
                    }
                }

                if (bCapture == true)
                {
                    PushMove(Piece.Side, strLastCell + "X" + strNewCell + strPromote);
                    OnPieceCaptured(EventArgs.Empty);
                    PlayMusic(CapturedSound);
                }
                else
                {
                    PushMove(Piece.Side, strLastCell + "-" + strNewCell + strPromote);
                    PlayMusic(MovedSound);
                }

                //Cập Nhật trạng thái nhập thành
                if (Piece.Type == ChessPieceType.Rook)
                {
                    if (Piece.Side == ChessSide.White)
                    {
                        if (Piece.PositionX == 1)
                        {
                            QUEENsideCastling = false;
                        }
                        if (Piece.PositionX == 8)
                        {
                            KINGsideCastling = false;
                        }
                    }
                    else
                    {
                        if (Piece.PositionX == 1)
                        {
                            queensideCastling = false;
                        }
                        if (Piece.PositionX == 8)
                        {
                            kingsideCastling = false;
                        }
                    }
                }
                if (Piece.Type == ChessPieceType.King)
                {
                    if (Piece.Side == ChessSide.White)
                    {
                        QUEENsideCastling = false;
                        KINGsideCastling  = false;
                    }
                    else
                    {
                        queensideCastling = false;
                        kingsideCastling  = false;
                    }

                    if (Math.Abs(NewPos.X - CurPos.X) == 2)//Nhập Thành
                    {
                        if (NewPos.X == 3)
                        {
                            UcChessCell OldRookCell = (UcChessCell)this.arrChessCell[1, NewPos.Y];
                            UcChessCell NewRookCell = (UcChessCell)this.arrChessCell[4, NewPos.Y];

                            this._BoardState[1, NewPos.Y] = 0;                    //Đánh dấu quân xe không còn ở vị trí cũ
                            this._BoardState[4, NewPos.Y] = 40 + (int)Piece.Side; //Đặt quân xe tại vị trí mới

                            NewRookCell.ChessPiece = OldRookCell.ChessPiece;
                            OldRookCell.ChessPiece = null;

                            NewRookCell.ChessPiece.UConCell  = NewRookCell;
                            NewRookCell.ChessPiece.PositionX = NewRookCell.PositionX;
                            NewRookCell.ChessPiece.PositionY = NewRookCell.PositionY;
                        }
                        else
                        {
                            UcChessCell OldRookCell = (UcChessCell)this.arrChessCell[8, NewPos.Y];
                            UcChessCell NewRookCell = (UcChessCell)this.arrChessCell[6, NewPos.Y];

                            this._BoardState[8, NewPos.Y] = 0;                    //Đánh dấu quân xe không còn ở vị trí cũ
                            this._BoardState[6, NewPos.Y] = 40 + (int)Piece.Side; //Đặt quân xe tại vị trí mới

                            NewRookCell.ChessPiece = OldRookCell.ChessPiece;
                            OldRookCell.ChessPiece = null;

                            NewRookCell.ChessPiece.UConCell  = NewRookCell;
                            NewRookCell.ChessPiece.PositionX = NewRookCell.PositionX;
                            NewRookCell.ChessPiece.PositionY = NewRookCell.PositionY;
                        }
                    }
                }
                arrFEN.Add(clsFEN.GetPiecePlacementString(this._BoardState));
                //********Play Sound, Hiển thị thông báo*************
                this._GameStatus = clsChessEngine.GetGameStatus(this._BoardState, arrFEN, Piece.Side);

                if (this._GameStatus == GameStatus.BlackWin)
                {
                    PlayMusic(CheckMatedSound);
                    DisplayMessage("Quân Đen Thắng !");
                }
                if (this._GameStatus == GameStatus.WhiteWin)
                {
                    PlayMusic(CheckMatedSound);
                    DisplayMessage("Quân Trắng Thắng !");
                }
                if (this._GameStatus == GameStatus.Draw)
                {
                    if (clsChessEngine.CheckThreefoldRepetition(arrFEN))
                    {
                        DisplayMessage("Ván cờ Hòa do \"Bất Biến 3 Lần\"");
                    }
                    else if (clsChessEngine.CheckInsufficientMaterial(this._BoardState, Piece.Side))
                    {
                        DisplayMessage("Ván cờ Hòa do cả 2 bên không đủ quân chiếu bí đối phương");
                    }
                    else
                    {
                        DisplayMessage("Ván cờ Hòa do không còn nước đi hợp lệ");
                    }
                }

                if (this._GameStatus == GameStatus.NowPlaying && (clsKing.IsChecked(this._BoardState, ChessSide.Black) == true || clsKing.IsChecked(this._BoardState, ChessSide.White) == true))
                {
                    PlayMusic(CheckedSound);
                    if ((this._OwnSide == ChessSide.White && this._WhiteToMove == false) || (this._OwnSide == ChessSide.Black && this._WhiteToMove == true))
                    {
                        DisplayMessage("Chiếu !");
                    }
                }


                if (Piece.Side == this._OwnSide)
                {
                    AlreadyMakeMove = true;
                }

                //Chuyển lượt đi cho đối phương
                if (Piece.Side == ChessSide.Black)
                {
                    this.WhiteToMove = true;
                }
                else
                {
                    this.WhiteToMove = false;
                }


                //Cho máy đi
                if (Piece.Side == this.OwnSide && this.GameMode == GameMode.VsComputer)
                {
                    IsThinking = true;
                    timerComputerMove.Enabled = true;
                }

                LastMove = move;

                HighlightLastMove();


                OnMoveMaked(EventArgs.Empty);
            }
            else
            {
                Piece.UConCell.ChessPiece = Piece;// tra về ô cũ
            }
        }