Exemplo n.º 1
0
        private (bool winningState, Mark?winningMark, List <Point> positions) CheckWinningState(Mark[,] gameField)
        {
            for (int i = 0; i < gameField.GetLength(0); i++)
            {
                Mark[] row = gameField.GetRow(i);
                if (row.ToList().FindAll(e => e == Mark.O).Count == GameField.ColumnDefinitions.Count ||
                    row.ToList().FindAll(e => e == Mark.X).Count == GameField.ColumnDefinitions.Count)
                {
                    return(true, row[0], new List <Point>()
                    {
                        new Point(0, i), new Point(GameField.ColumnDefinitions.Count - 1, i)
                    });
                }
            }

            for (int i = 0; i < gameField.GetLength(1); i++)
            {
                Mark[] column = gameField.GetColumn(i);
                if (column.ToList().FindAll(e => e == Mark.O).Count == GameField.RowDefinitions.Count ||
                    column.ToList().FindAll(e => e == Mark.X).Count == GameField.RowDefinitions.Count)
                {
                    return(true, column[0], new List <Point>()
                    {
                        new Point(i, 0), new Point(i, GameField.RowDefinitions.Count - 1)
                    });
                }
            }

            var diagonals = new List <Mark[]>()
            {
                gameField.GetDiagonal(DiagonalType.Left), gameField.GetDiagonal(DiagonalType.Right)
            };

            foreach (var diagonal in diagonals)
            {
                if (diagonal.ToList().FindAll(e => e == Mark.O).Count == GameField.RowDefinitions.Count ||
                    diagonal.ToList().FindAll(e => e == Mark.X).Count == GameField.RowDefinitions.Count)
                {
                    return(true, diagonal[0], (diagonals.IndexOf(diagonal) == 0) ?
                           new List <Point>()
                    {
                        new Point(0, 0), new Point(GameField.ColumnDefinitions.Count - 1, GameField.RowDefinitions.Count - 1)
                    }
                       : new List <Point>()
                    {
                        new Point(GameField.ColumnDefinitions.Count - 1, 0), new Point(0, GameField.RowDefinitions.Count - 1)
                    });
                }
            }

            return(false, null, null);
        }
        private (List <int> features, double summary) Summarize(Mark[,] gameField)
        {
            int completedSequences_Self         = 0;
            int completedSequences_Opponent     = 0;
            int sequencesToBeCompleted_Self     = 0;
            int sequencesToBeComplited_Opponent = 0;
            int singleMarks_Self     = 0;
            int singleMarks_Opponent = 0;

            List <Mark[]> rows      = new List <Mark[]>();
            List <Mark[]> columns   = new List <Mark[]>();
            List <Mark[]> diagonals = new List <Mark[]>();

            for (int i = 0; i < gameField.GetLength(0); i++)
            {
                rows.Add(gameField.GetRow(i));
            }
            for (int i = 0; i < gameField.GetLength(1); i++)
            {
                columns.Add(gameField.GetColumn(i));
            }
            diagonals.Add(gameField.GetDiagonal(DiagonalType.Left));
            diagonals.Add(gameField.GetDiagonal(DiagonalType.Right));

            foreach (var line in rows.Concat(columns).Concat(diagonals))
            {
                if (!line.ToList().Exists(m => m != InstanceRole))
                {
                    completedSequences_Self++;
                }
                if (!line.ToList().Exists(m => m != _opponentRole))
                {
                    completedSequences_Opponent++;
                }

                if (line.Where(m => m == InstanceRole).Count() > 1 && !line.Contains(_opponentRole))
                {
                    sequencesToBeCompleted_Self++;
                }
                if (line.Where(m => m == _opponentRole).Count() > 1 && !line.Contains(InstanceRole))
                {
                    sequencesToBeComplited_Opponent++;
                }

                if (line.Where(m => m == InstanceRole).Count() == 1 && !line.Contains(_opponentRole))
                {
                    singleMarks_Self++;
                }
                if (line.Where(m => m == _opponentRole).Count() == 1 && !line.Contains(InstanceRole))
                {
                    singleMarks_Opponent++;
                }
            }

            return(new List <int>
            {
                completedSequences_Self,
                completedSequences_Opponent,
                sequencesToBeCompleted_Self,
                sequencesToBeComplited_Opponent,
                singleMarks_Self,
                singleMarks_Opponent
            },

                   _weights[0] + _weights[1] * completedSequences_Self
                   + _weights[2] * completedSequences_Opponent
                   + _weights[3] * sequencesToBeCompleted_Self
                   + _weights[4] * sequencesToBeComplited_Opponent
                   + _weights[5] * singleMarks_Self
                   + _weights[6] * singleMarks_Opponent);
        }