[Add] Field and mine generation

Assets/Minesweeper/Runtime/Core/BoardCellData.cs

@@ -0,0 +1,23 @@
+namespace Minesweeper.Core
+{
+    public readonly struct BoardCellData
+    {
+        public BoardCellData(int x, int y, bool isMine, bool isOpened, bool isFlagged, int neighborMines)
+        {
+            X = x;
+            Y = y;
+            IsMine = isMine;
+            IsOpened = isOpened;
+            IsFlagged = isFlagged;
+            NeighborMines = neighborMines;
+        }
+
+        public int X { get; }
+        public int Y { get; }
+        public bool IsMine { get; }
+        public bool IsOpened { get; }
+        public bool IsFlagged { get; }
+        public int NeighborMines { get; }
+        public string DisplayValue => IsMine ? "M" : NeighborMines.ToString();
+    }
+}

Assets/Minesweeper/Runtime/Core/BoardCellData.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 832de90f32c3d7d4d8526f82eb203866

Assets/Minesweeper/Runtime/Core/BoardService.cs

@@ -0,0 +1,219 @@
+using System;
+using System.Collections.Generic;
+using Minesweeper.Config;
+
+namespace Minesweeper.Core
+{
+    public sealed class BoardService : IBoardService
+    {
+        private const int DefaultWidth = 9;
+        private const int DefaultHeight = 9;
+        private const int DefaultMinesCount = 10;
+
+        private readonly MinesweeperGameConfig config;
+        private readonly Random random = new Random();
+        private CellData[,] cells;
+
+        public BoardService(MinesweeperGameConfig config)
+        {
+            this.config = config;
+        }
+
+        public int Width { get; private set; }
+        public int Height { get; private set; }
+        public int MinesCount { get; private set; }
+        public bool IsGenerated { get; private set; }
+
+        public void InitializeEmptyBoard()
+        {
+            ResolveConfig(out var width, out var height, out var minesCount);
+
+            Width = width;
+            Height = height;
+            MinesCount = minesCount;
+            IsGenerated = false;
+            cells = new CellData[Width, Height];
+
+            for (var x = 0; x < Width; x++)
+            {
+                for (var y = 0; y < Height; y++)
+                {
+                    cells[x, y] = new CellData(x, y);
+                }
+            }
+        }
+
+        public bool GenerateAfterFirstClick(int safeX, int safeY)
+        {
+            EnsureInitialized();
+
+            if (IsGenerated || !IsInside(safeX, safeY))
+            {
+                return false;
+            }
+
+            PlaceMines(safeX, safeY);
+            CalculateNeighborMines();
+
+            cells[safeX, safeY].IsOpened = true;
+            IsGenerated = true;
+            return true;
+        }
+
+        public bool IsInside(int x, int y)
+        {
+            return cells != null && x >= 0 && y >= 0 && x < Width && y < Height;
+        }
+
+        public bool TryGetCell(int x, int y, out BoardCellData cell)
+        {
+            if (!IsInside(x, y))
+            {
+                cell = default;
+                return false;
+            }
+
+            cell = ToData(cells[x, y]);
+            return true;
+        }
+
+        public IReadOnlyList<BoardCellData> GetCells()
+        {
+            EnsureInitialized();
+
+            var result = new List<BoardCellData>(Width * Height);
+            for (var y = 0; y < Height; y++)
+            {
+                for (var x = 0; x < Width; x++)
+                {
+                    result.Add(ToData(cells[x, y]));
+                }
+            }
+
+            return result;
+        }
+
+        private void ResolveConfig(out int width, out int height, out int minesCount)
+        {
+            width = config.Width;
+            height = config.Height;
+            minesCount = config.MinesCount;
+
+            if (width <= 0 || height <= 0 || minesCount <= 0 || minesCount >= width * height)
+            {
+                width = DefaultWidth;
+                height = DefaultHeight;
+                minesCount = DefaultMinesCount;
+            }
+        }
+
+        private void EnsureInitialized()
+        {
+            if (cells == null)
+            {
+                InitializeEmptyBoard();
+            }
+        }
+
+        private void PlaceMines(int safeX, int safeY)
+        {
+            var positions = new List<int>(Width * Height - 1);
+            for (var x = 0; x < Width; x++)
+            {
+                for (var y = 0; y < Height; y++)
+                {
+                    if (x == safeX && y == safeY)
+                    {
+                        continue;
+                    }
+
+                    positions.Add(ToIndex(x, y));
+                }
+            }
+
+            Shuffle(positions);
+
+            for (var i = 0; i < MinesCount; i++)
+            {
+                var index = positions[i];
+                var x = index % Width;
+                var y = index / Width;
+                cells[x, y].IsMine = true;
+            }
+        }
+
+        private void Shuffle(List<int> values)
+        {
+            for (var i = values.Count - 1; i > 0; i--)
+            {
+                var j = random.Next(i + 1);
+                (values[i], values[j]) = (values[j], values[i]);
+            }
+        }
+
+        private void CalculateNeighborMines()
+        {
+            for (var x = 0; x < Width; x++)
+            {
+                for (var y = 0; y < Height; y++)
+                {
+                    if (cells[x, y].IsMine)
+                    {
+                        cells[x, y].NeighborMines = 0;
+                        continue;
+                    }
+
+                    cells[x, y].NeighborMines = CountNeighborMines(x, y);
+                }
+            }
+        }
+
+        private int CountNeighborMines(int centerX, int centerY)
+        {
+            var count = 0;
+            for (var x = centerX - 1; x <= centerX + 1; x++)
+            {
+                for (var y = centerY - 1; y <= centerY + 1; y++)
+                {
+                    if (x == centerX && y == centerY)
+                    {
+                        continue;
+                    }
+
+                    if (IsInside(x, y) && cells[x, y].IsMine)
+                    {
+                        count++;
+                    }
+                }
+            }
+
+            return count;
+        }
+
+        private int ToIndex(int x, int y)
+        {
+            return y * Width + x;
+        }
+
+        private static BoardCellData ToData(CellData cell)
+        {
+            return new BoardCellData(cell.X, cell.Y, cell.IsMine, cell.IsOpened, cell.IsFlagged, cell.NeighborMines);
+        }
+
+        private sealed class CellData
+        {
+            public CellData(int x, int y)
+            {
+                X = x;
+                Y = y;
+            }
+
+            public int X { get; }
+            public int Y { get; }
+            public bool IsMine { get; set; }
+            public bool IsOpened { get; set; }
+            public bool IsFlagged { get; set; }
+            public int NeighborMines { get; set; }
+        }
+    }
+}

Assets/Minesweeper/Runtime/Core/BoardService.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 11dec36e720c3e745b9dc11d588b5794

Assets/Minesweeper/Runtime/Core/IBoardService.cs

@@ -0,0 +1,18 @@
+using System.Collections.Generic;
+
+namespace Minesweeper.Core
+{
+    public interface IBoardService
+    {
+        int Width { get; }
+        int Height { get; }
+        int MinesCount { get; }
+        bool IsGenerated { get; }
+
+        void InitializeEmptyBoard();
+        bool GenerateAfterFirstClick(int safeX, int safeY);
+        bool IsInside(int x, int y);
+        bool TryGetCell(int x, int y, out BoardCellData cell);
+        IReadOnlyList<BoardCellData> GetCells();
+    }
+}

Assets/Minesweeper/Runtime/Core/IBoardService.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 1339a8a92f1f56d4fa786ce011294737