A basic implementation of the IMinefield interface, using a two-dimensional array to store the matrix.
Inheritance: IMinefield
        /// <summary>
        /// Convert minefields array to result type array.
        /// </summary>
        /// <param name="result"></param>
        /// <param name="neighborMines"></param>
        public void ConvertMinefield(Minefield field)
        {
            //returns a two dimensional array defines neighbor mines
            int[,] neighborMines = field.CalculateNeighborMines();

            //returns a two dimensional array defines cell type - mine or number
            var result = field.ConvertToResult <ICell, CellResult>(field.Cells, field.ColumnsCount, c => field.ConvertCellToTypeResult(c));

            for (int row = 0; row < result.GetLength(0); row++)
            {
                for (int column = 0; column < result.GetLength(1); column++)
                {
                    string text       = string.Empty;
                    var    symbolType = result[row, column];
                    if (symbolType == CellResult.Number)
                    {
                        int number = neighborMines[row, column];
                        text = number.ToString();
                    }
                    else if (symbolType == CellResult.Mine)
                    {
                        text = CellValidator.validMineChar.ToString();
                    }
                    output.Append(text);
                }
                output.Append(Environment.NewLine);
            }
        }
        public IEnumerable<IMinefield> Load()
        {
            IList<IMinefield> minefields = new List<IMinefield>();

            var regex = new Regex(@"^(?<rows>\d+),(?<cols>\d+);(?<data>[*.]+)$", RegexOptions.Compiled);
            string[] lines = File.ReadAllLines(m_path);

            // Each line in the field yields a unique minefield
            foreach (string line in lines)
            {
                var match = regex.Match(line);

                if (match.Success)
                {
                    int rows = int.Parse(match.Groups["rows"].Value);
                    int cols = int.Parse(match.Groups["cols"].Value);
                    string data = match.Groups["data"].Value;

                    Minefield field = new Minefield(cols, rows);

                    // Enumerate mine areas and mine data
                    IEnumerator<IMineArea> areaEnum = field.AreasByRow().GetEnumerator();
                    IEnumerator<char> dataEnum = data.GetEnumerator();

                    while (areaEnum.MoveNext() && dataEnum.MoveNext())
                        areaEnum.Current.ContainsMine = HasMine(dataEnum.Current);

                    minefields.Add(field);
                }
            }

            return minefields;
        }
Exemplo n.º 3
0
        /// <summary>
        /// Implements the Factory pattern to create new minefield
        /// </summary>
        public static Minefield Create(int id, string input)
        {
            string[] value = input.Split(' ');

            int rows = int.Parse(value[0].ToString());
            int cols = int.Parse(value[1].ToString());

            Minefield field = new Minefield();

            field.RowsCount    = rows;
            field.ColumnsCount = cols;
            field.Id           = id;
            return(field);
        }