コード例 #1
0
        private void pictureBox1_Click(object sender, EventArgs e)
        {
            MouseEventArgs me          = (MouseEventArgs)e;
            Point          coordinates = me.Location;

            labelMouseLocation.Text = "Clicked at x: " + coordinates.X / 60 + " y: " + (7 - coordinates.Y / 60);

            x = (coordinates.Y / 60);
            y = (7 - coordinates.X / 60);
            selectedTargetCoords = Coordinate.GetInstance.GetCoord(x, y);

            Move attemptedMove = new Move(selectedPieceCoords, selectedTargetCoords);

            try
            {
                if (HelperMaths.ContainsObjectMove(availableMoves, attemptedMove))
                {
                    GameState.UpdateLayout(attemptedMove);
                    selectedPieceCoords = Tuple.Create(-1, -1);
                    availableMoves.Clear();
                }
                else
                {
                    selectedPieceCoords = Coordinate.GetInstance.GetCoord(x, y);
                    availableMoves      = Referee.GetAvailableMoves(selectedPieceCoords);
                }

                Draw();
            }
            catch (Exception)
            {
            }
        }
コード例 #2
0
        private void exitToolStripMenuItem_Click(object sender, EventArgs e)
        {
            int          size = -1;
            string       file;
            DialogResult result = openFileDialog1.ShowDialog();

            if (result == DialogResult.OK) // Test result.
            {
                file = openFileDialog1.FileName;
                try
                {
                    HelperMaths.LoadSerializedObj <Dictionary <int, Dictionary <int, ChessPiece> > >(file);
                }
                catch (Exception)
                {
                }
            }
        }
コード例 #3
0
 private void saveToolStripMenuItem_Click(object sender, EventArgs e)
 {
     HelperMaths.SaveObj(GameState.GetGameState(), "tempName");
 }
コード例 #4
0
        public override List <Move> GetAvailableMoves(Tuple <int, int> coords)
        {
            List <Move> availableMoves = new List <Move>();
            var         Layout         = GameState.GetGameState();

            for (int i = 1; i < 8; i++)
            {
                if (HelperMaths.IsInRange(coords.Item1 - i, 0, 7) && HelperMaths.IsInRange(coords.Item2 - i, 0, 7))
                {
                    if (Layout[coords.Item1 - i][coords.Item2 - i] == null)
                    {
                        availableMoves.Add(new Move(coords, Tuple.Create(coords.Item1 - i, coords.Item2 - i)));
                    }
                    else
                    {
                        if (Layout[coords.Item1 - i][coords.Item2 - i].PieceColor == this.PieceColor)
                        {
                            break;
                        }
                        availableMoves.Add(new Move(coords, Tuple.Create(coords.Item1 - i, coords.Item2 - i)));

                        if (Layout[coords.Item1 - i][coords.Item2 - i].PieceColor != this.PieceColor)
                        {
                            break;
                        }
                    }
                }
                else
                {
                    break;
                }
            }

            for (int i = 1; i < 8; i++)
            {
                if (HelperMaths.IsInRange(coords.Item1 - i, 0, 7) && HelperMaths.IsInRange(coords.Item2 + i, 0, 7))
                {
                    if (Layout[coords.Item1 - i][coords.Item2 + i] == null)
                    {
                        availableMoves.Add(new Move(coords, Tuple.Create(coords.Item1 - i, coords.Item2 + i)));
                    }
                    else
                    {
                        if (Layout[coords.Item1 - i][coords.Item2 + i].PieceColor == this.PieceColor)
                        {
                            break;
                        }
                        availableMoves.Add(new Move(coords, Tuple.Create(coords.Item1 - i, coords.Item2 + i)));

                        if (Layout[coords.Item1 - i][coords.Item2 + i].PieceColor != this.PieceColor)
                        {
                            break;
                        }
                    }
                }
                else
                {
                    break;
                }
            }

            for (int i = 1; i < 8; i++)
            {
                if (HelperMaths.IsInRange(coords.Item1 + i, 0, 7) && HelperMaths.IsInRange(coords.Item2 - i, 0, 7))
                {
                    if (Layout[coords.Item1 + i][coords.Item2 - i] == null)
                    {
                        availableMoves.Add(new Move(coords, Tuple.Create(coords.Item1 + i, coords.Item2 - i)));
                    }
                    else
                    {
                        if (Layout[coords.Item1 + i][coords.Item2 - i].PieceColor == this.PieceColor)
                        {
                            break;
                        }
                        availableMoves.Add(new Move(coords, Tuple.Create(coords.Item1 + i, coords.Item2 - i)));

                        if (Layout[coords.Item1 + i][coords.Item2 - i].PieceColor != this.PieceColor)
                        {
                            break;
                        }
                    }
                }
                else
                {
                    break;
                }
            }

            for (int i = 1; i < 8; i++)
            {
                if (HelperMaths.IsInRange(coords.Item1 + i, 0, 7) && HelperMaths.IsInRange(coords.Item2 + i, 0, 7))
                {
                    if (Layout[coords.Item1 + i][coords.Item2 + i] == null)
                    {
                        availableMoves.Add(new Move(coords, Tuple.Create(coords.Item1 + i, coords.Item2 + i)));
                    }
                    else
                    {
                        if (Layout[coords.Item1 + i][coords.Item2 + i].PieceColor == this.PieceColor)
                        {
                            break;
                        }
                        availableMoves.Add(new Move(coords, Tuple.Create(coords.Item1 + i, coords.Item2 + i)));

                        if (Layout[coords.Item1 + i][coords.Item2 + i].PieceColor != this.PieceColor)
                        {
                            break;
                        }
                    }
                }
                else
                {
                    break;
                }
            }

            return(availableMoves);
        }
コード例 #5
0
        public override List <Move> GetAvailableMoves(Tuple <int, int> coords)
        {
            List <Move> availableMoves = new List <Move>();
            var         Layout         = GameState.GetGameState();

            if (HelperMaths.IsInRange(coords.Item1 - 1, 0, 7) && HelperMaths.IsInRange(coords.Item2 - 2, 0, 7))
            {
                if (Layout[coords.Item1 - 1][coords.Item2 - 2] == null)
                {
                    availableMoves.Add(new Move(coords, Tuple.Create(coords.Item1 - 1, coords.Item2 - 2)));
                }
                else if (Layout[coords.Item1 - 1][coords.Item2 - 2].PieceColor != this.PieceColor)
                {
                    availableMoves.Add(new Move(coords, Tuple.Create(coords.Item1 - 1, coords.Item2 - 2)));
                }
            }

            if (HelperMaths.IsInRange(coords.Item1 - 1, 0, 7) && HelperMaths.IsInRange(coords.Item2 + 2, 0, 7))
            {
                if (Layout[coords.Item1 - 1][coords.Item2 + 2] == null)
                {
                    availableMoves.Add(new Move(coords, Tuple.Create(coords.Item1 - 1, coords.Item2 + 2)));
                }
                else if (Layout[coords.Item1 - 1][coords.Item2 + 2].PieceColor != this.PieceColor)
                {
                    availableMoves.Add(new Move(coords, Tuple.Create(coords.Item1 - 1, coords.Item2 + 2)));
                }
            }

            if (HelperMaths.IsInRange(coords.Item1 + 1, 0, 7) && HelperMaths.IsInRange(coords.Item2 - 2, 0, 7))
            {
                if (Layout[coords.Item1 + 1][coords.Item2 - 2] == null)
                {
                    availableMoves.Add(new Move(coords, Tuple.Create(coords.Item1 + 1, coords.Item2 - 2)));
                }
                else if (Layout[coords.Item1 + 1][coords.Item2 - 2].PieceColor != this.PieceColor)
                {
                    availableMoves.Add(new Move(coords, Tuple.Create(coords.Item1 + 1, coords.Item2 - 2)));
                }
            }

            if (HelperMaths.IsInRange(coords.Item1 + 1, 0, 7) && HelperMaths.IsInRange(coords.Item2 + 2, 0, 7))
            {
                if (Layout[coords.Item1 + 1][coords.Item2 + 2] == null)
                {
                    availableMoves.Add(new Move(coords, Tuple.Create(coords.Item1 + 1, coords.Item2 + 2)));
                }
                else if (Layout[coords.Item1 + 1][coords.Item2 + 2].PieceColor != this.PieceColor)
                {
                    availableMoves.Add(new Move(coords, Tuple.Create(coords.Item1 + 1, coords.Item2 + 2)));
                }
            }

            //--------------------

            if (HelperMaths.IsInRange(coords.Item1 - 2, 0, 7) && HelperMaths.IsInRange(coords.Item2 - 1, 0, 7))
            {
                if (Layout[coords.Item1 - 2][coords.Item2 - 1] == null)
                {
                    availableMoves.Add(new Move(coords, Tuple.Create(coords.Item1 - 2, coords.Item2 - 1)));
                }
                else if (Layout[coords.Item1 - 2][coords.Item2 - 1].PieceColor != this.PieceColor)
                {
                    availableMoves.Add(new Move(coords, Tuple.Create(coords.Item1 - 2, coords.Item2 - 1)));
                }
            }

            if (HelperMaths.IsInRange(coords.Item1 + 2, 0, 7) && HelperMaths.IsInRange(coords.Item2 - 1, 0, 7))
            {
                if (Layout[coords.Item1 + 2][coords.Item2 - 1] == null)
                {
                    availableMoves.Add(new Move(coords, Tuple.Create(coords.Item1 + 2, coords.Item2 - 1)));
                }
                else if (Layout[coords.Item1 + 2][coords.Item2 - 1].PieceColor != this.PieceColor)
                {
                    availableMoves.Add(new Move(coords, Tuple.Create(coords.Item1 + 2, coords.Item2 - 1)));
                }
            }

            if (HelperMaths.IsInRange(coords.Item1 - 2, 0, 7) && HelperMaths.IsInRange(coords.Item2 + 1, 0, 7))
            {
                if (Layout[coords.Item1 - 2][coords.Item2 + 1] == null)
                {
                    availableMoves.Add(new Move(coords, Tuple.Create(coords.Item1 - 2, coords.Item2 + 1)));
                }
                else if (Layout[coords.Item1 - 2][coords.Item2 + 1].PieceColor != this.PieceColor)
                {
                    availableMoves.Add(new Move(coords, Tuple.Create(coords.Item1 - 2, coords.Item2 + 1)));
                }
            }

            if (HelperMaths.IsInRange(coords.Item1 + 2, 0, 7) && HelperMaths.IsInRange(coords.Item2 + 1, 0, 7))
            {
                if (Layout[coords.Item1 + 2][coords.Item2 + 1] == null)
                {
                    availableMoves.Add(new Move(coords, Tuple.Create(coords.Item1 + 2, coords.Item2 + 1)));
                }
                else if (Layout[coords.Item1 + 2][coords.Item2 + 1].PieceColor != this.PieceColor)
                {
                    availableMoves.Add(new Move(coords, Tuple.Create(coords.Item1 + 2, coords.Item2 + 1)));
                }
            }



            return(availableMoves);
        }
コード例 #6
0
ファイル: Pawn.cs プロジェクト: tiboriandrei/ChessWinFormsApp
        public override List <Move> GetAvailableMoves(Tuple <int, int> coords)
        {
            List <Move> availableMoves = new List <Move>();
            var         Layout         = GameState.GetGameState();

            if (this.PieceColor.ToString() == "White")
            {
                if (HelperMaths.IsInRange(coords.Item1 - 1, 0, 7))
                {
                    if (Layout[coords.Item1 - 1][coords.Item2] == null)
                    {
                        availableMoves.Add(new Move(coords, Tuple.Create(coords.Item1 - 1, coords.Item2)));
                    }
                }

                if (HelperMaths.IsInRange(coords.Item1 - 2, 0, 7) && HelperMaths.IsInRange(coords.Item1 - 1, 0, 7))
                {
                    if (Layout[coords.Item1 - 2][coords.Item2] == null && Layout[coords.Item1 - 1][coords.Item2] == null && coords.Item1 == 6)
                    {
                        availableMoves.Add(new Move(coords, Tuple.Create(coords.Item1 - 2, coords.Item2)));
                    }
                }

                if (HelperMaths.IsInRange(coords.Item1 - 1, 0, 7) && HelperMaths.IsInRange(coords.Item2 - 1, 0, 7))
                {
                    if (Layout[coords.Item1 - 1][coords.Item2 - 1] != null)
                    {
                        if (Layout[coords.Item1 - 1][coords.Item2 - 1].PieceColor != this.PieceColor)
                        {
                            availableMoves.Add(new Move(coords, Tuple.Create(coords.Item1 - 1, coords.Item2 - 1)));
                        }
                    }
                }

                if (HelperMaths.IsInRange(coords.Item1 - 1, 0, 7) && HelperMaths.IsInRange(coords.Item2 + 1, 0, 7))
                {
                    if (Layout[coords.Item1 - 1][coords.Item2 + 1] != null)
                    {
                        if (Layout[coords.Item1 - 1][coords.Item2 + 1].PieceColor != this.PieceColor)
                        {
                            availableMoves.Add(new Move(coords, Tuple.Create(coords.Item1 - 1, coords.Item2 + 1)));
                        }
                    }
                }
            }

            if (this.PieceColor.ToString() == "Black")
            {
                if (HelperMaths.IsInRange(coords.Item1 + 1, 0, 7))
                {
                    if (Layout[coords.Item1 + 1][coords.Item2] == null)
                    {
                        availableMoves.Add(new Move(coords, Tuple.Create(coords.Item1 + 1, coords.Item2)));
                    }
                }

                if (HelperMaths.IsInRange(coords.Item1 + 2, 0, 7) && HelperMaths.IsInRange(coords.Item1 + 1, 0, 7))
                {
                    if (Layout[coords.Item1 + 2][coords.Item2] == null && Layout[coords.Item1 + 1][coords.Item2] == null && coords.Item1 == 1)
                    {
                        availableMoves.Add(new Move(coords, Tuple.Create(coords.Item1 + 2, coords.Item2)));
                    }
                }

                if (HelperMaths.IsInRange(coords.Item1 + 1, 0, 7) && HelperMaths.IsInRange(coords.Item2 + 1, 0, 7))
                {
                    if (Layout[coords.Item1 + 1][coords.Item2 + 1] != null)
                    {
                        if (Layout[coords.Item1 + 1][coords.Item2 + 1].PieceColor != this.PieceColor)
                        {
                            availableMoves.Add(new Move(coords, Tuple.Create(coords.Item1 + 1, coords.Item2 + 1)));
                        }
                    }
                }

                if (HelperMaths.IsInRange(coords.Item1 + 1, 0, 7) && HelperMaths.IsInRange(coords.Item2 - 1, 0, 7))
                {
                    if (Layout[coords.Item1 + 1][coords.Item2 - 1] != null)
                    {
                        if (Layout[coords.Item1 + 1][coords.Item2 - 1].PieceColor != this.PieceColor)
                        {
                            availableMoves.Add(new Move(coords, Tuple.Create(coords.Item1 + 1, coords.Item2 - 1)));
                        }
                    }
                }
            }

            return(availableMoves);
        }