Changed game board data type to GridSlot.

ChebanovDD · ChebanovDD · commit 4055f9b47fea · 2022-04-09T12:11:42.000+07:00
diff --git a/Assets/Plugins/Match3.Tests/PlayMode/Match3GameTests.cs b/Assets/Plugins/Match3.Tests/PlayMode/Match3GameTests.cs
@@ -46,9 +46,9 @@ public Match3GameTests()
                 .GetLevelGoals(Arg.Any<int>(), Arg.Any<IGameBoard<IItem>>())
                 .Returns(new LevelGoal<IItem>[] { new MockLevelGoal() });
 
-            var gameBoardDataProvider = Substitute.For<IGameBoardDataProvider>();
+            var gameBoardDataProvider = Substitute.For<IGameBoardDataProvider<IItem>>();
             gameBoardDataProvider
-                .GetGameBoardData(Arg.Any<int>());
+                .GetGameBoardSlots(Arg.Any<int>());
                 // .Returns(new[,] { { true, true }, { true, true } });
 
             _gameConfig = new GameConfig<IItem>
@@ -102,7 +102,7 @@ public void InitGameLevel_ShouldCreateGridSlots_WhenAllParamsAreValid(int level,
             int expectedResult)
         {
             // Arrange
-            var gameBoardDataProvider = Substitute.For<IGameBoardDataProvider>();
+            var gameBoardDataProvider = Substitute.For<IGameBoardDataProvider<IItem>>();
             // gameBoardDataProvider.GetGameBoardData(level).Returns(data);
 
             var gameConfig = new GameConfig<IItem>
diff --git a/Assets/Plugins/Match3/App/GameConfig.cs b/Assets/Plugins/Match3/App/GameConfig.cs
@@ -10,8 +10,8 @@ public class GameConfig<TItem> where TItem : IItem
         public IGameBoardRenderer GameBoardRenderer { get; set; }
         public IBoardFillStrategy<TItem> FillStrategy { get; set; }
         public IGameBoardSolver<TItem> GameBoardSolver { get; set; }
-        public IGameBoardDataProvider GameBoardDataProvider { get; set; }
         public ILevelGoalsProvider<TItem> LevelGoalsProvider { get; set; }
+        public IGameBoardDataProvider<TItem> GameBoardDataProvider { get; set; }
         public ISolvedSequencesConsumer<TItem>[] SolvedSequencesConsumers { get; set; }
     }
 }
diff --git a/Assets/Plugins/Match3/App/Interfaces/IGameBoardDataProvider.cs b/Assets/Plugins/Match3/App/Interfaces/IGameBoardDataProvider.cs
@@ -1,9 +1,10 @@
 using Match3.Core.Interfaces;
+using Match3.Core.Models;
 
 namespace Match3.App.Interfaces
 {
-    public interface IGameBoardDataProvider
+    public interface IGameBoardDataProvider<TItem> where TItem : IItem
     {
-        IGridSlotState[,] GetGameBoardData(int level);
+        GridSlot<TItem>[,] GetGameBoardSlots(int level);
     }
 }
diff --git a/Assets/Plugins/Match3/App/Internal/GameBoard.cs b/Assets/Plugins/Match3/App/Internal/GameBoard.cs
@@ -37,28 +37,16 @@ public GameBoard(IItemSwapper<TItem> itemSwapper, IGameBoardSolver<TItem> gameBo
             _gameBoardSolver = gameBoardSolver;
         }
 
-        public void CreateGridSlots(IGridSlotState[,] gameBoardData)
+        public void SetGridSlots(GridSlot<TItem>[,] gridSlots)
         {
             if (_gridSlots != null)
             {
                 throw new InvalidOperationException("Grid slots have already been created.");
             }
 
-            _rowCount = gameBoardData.GetLength(0);
-            _columnCount = gameBoardData.GetLength(1);
-
-            _gridSlots = new GridSlot<TItem>[_rowCount, _columnCount];
-
-            for (var rowIndex = 0; rowIndex < _rowCount; rowIndex++)
-            {
-                for (var columnIndex = 0; columnIndex < _columnCount; columnIndex++)
-                {
-                    var state = gameBoardData[rowIndex, columnIndex];
-
-                    _gridSlots[rowIndex, columnIndex] =
-                        new GridSlot<TItem>(state, new GridPosition(rowIndex, columnIndex));
-                }
-            }
+            _rowCount = gridSlots.GetLength(0);
+            _columnCount = gridSlots.GetLength(1);
+            _gridSlots = gridSlots;
         }
 
         public async UniTask FillAsync(IBoardFillStrategy<TItem> fillStrategy)
@@ -97,7 +85,9 @@ public bool IsPositionOnBoard(GridPosition gridPosition)
 
         public void ResetState()
         {
-            Dispose();
+            _rowCount = 0;
+            _columnCount = 0;
+            _gridSlots = null;
         }
 
         public void Dispose()
@@ -108,10 +98,7 @@ public void Dispose()
             }
 
             Array.Clear(_gridSlots, 0, _gridSlots.Length);
-
-            _rowCount = 0;
-            _columnCount = 0;
-            _gridSlots = null;
+            ResetState();
         }
 
         private async UniTask SwapItems(GridPosition position1, GridPosition position2)
diff --git a/Assets/Plugins/Match3/App/Match3Game.cs b/Assets/Plugins/Match3/App/Match3Game.cs
@@ -16,8 +16,8 @@ public class Match3Game<TItem> : IDisposable where TItem : IItem
         private readonly IInputSystem _inputSystem;
         private readonly GameBoard<TItem> _gameBoard;
         private readonly IGameBoardRenderer _gameBoardRenderer;
-        private readonly IGameBoardDataProvider _gameBoardDataProvider;
         private readonly ILevelGoalsProvider<TItem> _levelGoalsProvider;
+        private readonly IGameBoardDataProvider<TItem> _gameBoardDataProvider;
         private readonly ISolvedSequencesConsumer<TItem>[] _solvedSequencesConsumers;
 
         private bool _isStarted;
@@ -50,7 +50,7 @@ public void InitGameLevel(int level)
                 throw new InvalidOperationException("Can not be initialized while the current game is active.");
             }
 
-            _gameBoard.CreateGridSlots(_gameBoardDataProvider.GetGameBoardData(level));
+            _gameBoard.SetGridSlots(_gameBoardDataProvider.GetGameBoardSlots(level));
             _levelGoals = _levelGoalsProvider.GetLevelGoals(level, _gameBoard);
         }
 
diff --git a/Assets/Plugins/Match3/Core/Models/GridSlot.cs b/Assets/Plugins/Match3/Core/Models/GridSlot.cs
@@ -4,23 +4,28 @@
 
 namespace Match3.Core.Models
 {
-    public class GridSlot<TItem> where TItem : IItem
+    public sealed class GridSlot<TItem> where TItem : IItem
     {
         public bool HasItem => Item != null;
         public bool IsMovable => State.IsLocked == false && HasItem;
         public bool CanSetItem => State.CanContainItem && HasItem == false;
         public bool NotAvailable => State.CanContainItem == false || State.IsLocked;
 
         public TItem Item { get; private set; }
-        public IGridSlotState State { get; }
+        public IGridSlotState State { get; private set; }
         public GridPosition GridPosition { get; }
 
-        internal GridSlot(IGridSlotState state, GridPosition gridPosition)
+        public GridSlot(IGridSlotState state, GridPosition gridPosition)
         {
             State = state;
             GridPosition = gridPosition;
         }
 
+        public void SetState(IGridSlotState state)
+        {
+            State = state;
+        }
+
         public void SetItem(TItem item)
         {
             EnsureItemIsNotNull(item);
diff --git a/Assets/Scripts/AppContext.cs b/Assets/Scripts/AppContext.cs
@@ -31,8 +31,8 @@ public void Construct()
         RegisterInstance<IGameUiCanvas>(_gameUiCanvas);
         RegisterInstance<IItemGenerator>(_itemGenerator);
         RegisterInstance<IItemsPool<IUnityItem>>(_itemGenerator);
-        RegisterInstance<IGameBoardDataProvider>(_gameBoardRenderer);
         RegisterInstance<IUnityGameBoardRenderer>(_gameBoardRenderer);
+        RegisterInstance<IGameBoardDataProvider<IUnityItem>>(_gameBoardRenderer);
         RegisterInstance<Match3Game<IUnityItem>>(GetMatch3Game());
         RegisterInstance<IBoardFillStrategy<IUnityItem>[]>(GetBoardFillStrategies());
     }
diff --git a/Assets/Scripts/Common/AppModes/GameInitMode.cs b/Assets/Scripts/Common/AppModes/GameInitMode.cs
@@ -53,7 +53,7 @@ public void Dispose()
 
         private void Init(int level)
         {
-            var gameBoardData = _appContext.Resolve<IGameBoardDataProvider>().GetGameBoardData(level);
+            var gameBoardData = _appContext.Resolve<IGameBoardDataProvider<IUnityItem>>().GetGameBoardSlots(level);
             var rowCount = gameBoardData.GetLength(0);
             var columnCount = gameBoardData.GetLength(1);
             var itemsPoolCapacity = rowCount * columnCount + Mathf.Max(rowCount, columnCount) * 2;
diff --git a/Assets/Scripts/Common/Extensions/ItemsPoolExtensions.cs b/Assets/Scripts/Common/Extensions/ItemsPoolExtensions.cs
@@ -17,8 +17,9 @@ public static void ReturnAllItems<TItem>(this IItemsPool<TItem> itemsPool,
                     continue;
                 }
 
-                gridSlot.Item.Hide();
                 itemsPool.ReturnItem(gridSlot.Item);
+                gridSlot.Item.Hide();
+                gridSlot.Clear();
             }
         }
     }
diff --git a/Assets/Scripts/Common/Interfaces/IUnityGameBoardRenderer.cs b/Assets/Scripts/Common/Interfaces/IUnityGameBoardRenderer.cs
@@ -11,10 +11,10 @@ public interface IUnityGameBoardRenderer : IGameBoardRenderer
         bool IsTileActive(GridPosition gridPosition);
         void ActivateTile(GridPosition gridPosition);
         void DeactivateTile(GridPosition gridPosition);
+        void SetNextGridTileGroup(GridPosition gridPosition);
 
         bool IsPositionOnGrid(GridPosition gridPosition);
 
-        void SetNextGridTileGroup(GridPosition gridPosition);
         void TrySetNextTileState(GridPosition gridPosition);
         TileGroup GetTileGroup(GridPosition gridPosition);
     }
diff --git a/Assets/Scripts/Common/LevelGoals/CollectRowMaxItems.cs b/Assets/Scripts/Common/LevelGoals/CollectRowMaxItems.cs
@@ -65,7 +65,7 @@ private int GetMaxRowLength(IGameBoard<IUnityItem> gameBoard)
                 }
             }
 
-            return maxRowLength;
+            return 5;
         }
     }
 }
diff --git a/Assets/Scripts/Common/UnityGameBoardRenderer.cs b/Assets/Scripts/Common/UnityGameBoardRenderer.cs
@@ -4,13 +4,13 @@
 using Common.Models;
 using Match3.App.Interfaces;
 using Match3.Core.Helpers;
-using Match3.Core.Interfaces;
+using Match3.Core.Models;
 using Match3.Core.Structs;
 using UnityEngine;
 
 namespace Common
 {
-    public class UnityGameBoardRenderer : MonoBehaviour, IUnityGameBoardRenderer, IGameBoardDataProvider
+    public class UnityGameBoardRenderer : MonoBehaviour, IUnityGameBoardRenderer, IGameBoardDataProvider<IUnityItem>
     {
         [Space]
         [SerializeField] private int _rowCount = 9;
@@ -23,7 +23,7 @@ public class UnityGameBoardRenderer : MonoBehaviour, IUnityGameBoardRenderer, IG
         [SerializeField] private TileModel[] _gridTiles;
 
         private IGridTile[,] _gridSlotTiles;
-        private IGridSlotState[,] _gameBoardData;
+        private GridSlot<IUnityItem>[,] _gameBoardSlots;
 
         private Vector3 _originPosition;
         private TileItemsPool _tileItemsPool;
@@ -33,32 +33,18 @@ private void Awake()
             _tileItemsPool = new TileItemsPool(_gridTiles, transform);
         }
 
-        public IGridSlotState[,] GetGameBoardData(int level)
+        public GridSlot<IUnityItem>[,] GetGameBoardSlots(int level)
         {
-            if (_gameBoardData != null)
-            {
-                return _gameBoardData;
-            }
-
-            _gameBoardData = new IGridSlotState[_rowCount, _columnCount];
-
-            for (var rowIndex = 0; rowIndex < _rowCount; rowIndex++)
-            {
-                for (var columnIndex = 0; columnIndex < _columnCount; columnIndex++)
-                {
-                    _gameBoardData[rowIndex, columnIndex] = _gridSlotTiles[rowIndex, columnIndex];
-                }
-            }
-
-            return _gameBoardData;
+            return _gameBoardSlots;
         }
 
         public void CreateGridTiles()
         {
             _gridSlotTiles = new IGridTile[_rowCount, _columnCount];
+            _gameBoardSlots = new GridSlot<IUnityItem>[_rowCount, _columnCount];
             _originPosition = GetOriginPosition(_rowCount, _columnCount);
 
-            SetTilesGroup(TileGroup.Available);
+            CreateGridTiles(TileGroup.Available);
         }
 
         public bool IsTileActive(GridPosition gridPosition)
@@ -76,6 +62,12 @@ public void DeactivateTile(GridPosition gridPosition)
             SetTile(gridPosition.RowIndex, gridPosition.ColumnIndex, TileGroup.Unavailable);
         }
 
+        public void SetNextGridTileGroup(GridPosition gridPosition)
+        {
+            var tileGroup = GetTileGroup(gridPosition);
+            SetTile(gridPosition.RowIndex, gridPosition.ColumnIndex, GetNextAvailableGroup(tileGroup));
+        }
+
         public bool IsPointerOnGrid(Vector3 worldPointerPosition, out GridPosition gridPosition)
         {
             gridPosition = GetGridPositionByPointer(worldPointerPosition);
@@ -98,12 +90,6 @@ public Vector3 GetWorldPosition(GridPosition gridPosition)
             return GetWorldPosition(gridPosition.RowIndex, gridPosition.ColumnIndex);
         }
 
-        public void SetNextGridTileGroup(GridPosition gridPosition)
-        {
-            var tileGroup = GetTileGroup(gridPosition);
-            SetTile(gridPosition.RowIndex, gridPosition.ColumnIndex, GetNextAvailableGroup(tileGroup));
-        }
-
         public void TrySetNextTileState(GridPosition gridPosition)
         {
             ((IStatefulSlot) _gridSlotTiles[gridPosition.RowIndex, gridPosition.ColumnIndex]).NextState();
@@ -117,7 +103,6 @@ public TileGroup GetTileGroup(GridPosition gridPosition)
         public void ResetState()
         {
             SetTilesGroup(TileGroup.Available);
-            ResetGameBoardData();
         }
 
         public void Dispose()
@@ -152,12 +137,19 @@ private Vector3 GetOriginPosition(int rowCount, int columnCount)
             return new Vector3(-offsetX, offsetY);
         }
 
-        private IGridTile GetTile(int rowIndex, int columnIndex, TileGroup group)
+        private void CreateGridTiles(TileGroup defaultTileGroup)
         {
-            var tile = _tileItemsPool.GetTile(group);
-            tile.SetWorldPosition(GetWorldPosition(rowIndex, columnIndex));
-
-            return tile;
+            for (var rowIndex = 0; rowIndex < _rowCount; rowIndex++)
+            {
+                for (var columnIndex = 0; columnIndex < _columnCount; columnIndex++)
+                {
+                    var gridTile = GetTile(rowIndex, columnIndex, defaultTileGroup);
+                    
+                    _gridSlotTiles[rowIndex, columnIndex] = gridTile;
+                    _gameBoardSlots[rowIndex, columnIndex] =
+                        new GridSlot<IUnityItem>(gridTile, new GridPosition(rowIndex, columnIndex));
+                }
+            }
         }
 
         private void SetTilesGroup(TileGroup group)
@@ -179,7 +171,18 @@ private void SetTile(int rowIndex, int columnIndex, TileGroup group)
                 _tileItemsPool.ReturnTile(currentTile);
             }
 
-            _gridSlotTiles[rowIndex, columnIndex] = GetTile(rowIndex, columnIndex, group);
+            var gridTile = GetTile(rowIndex, columnIndex, group);
+
+            _gridSlotTiles[rowIndex, columnIndex] = gridTile;
+            _gameBoardSlots[rowIndex, columnIndex].SetState(gridTile);
+        }
+
+        private IGridTile GetTile(int rowIndex, int columnIndex, TileGroup group)
+        {
+            var tile = _tileItemsPool.GetTile(group);
+            tile.SetWorldPosition(GetWorldPosition(rowIndex, columnIndex));
+
+            return tile;
         }
 
         private TileGroup GetNextAvailableGroup(TileGroup group)
@@ -214,13 +217,13 @@ private void ResetGridTiles()
 
         private void ResetGameBoardData()
         {
-            if (_gameBoardData == null)
+            if (_gameBoardSlots == null)
             {
                 return;
             }
 
-            Array.Clear(_gameBoardData, 0, _gameBoardData.Length);
-            _gameBoardData = null;
+            Array.Clear(_gameBoardSlots, 0, _gameBoardSlots.Length);
+            _gameBoardSlots = null;
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -10,8 +10,8 @@ public class GameConfig<TItem> where TItem : IItem`
`10`	`10`	`public IGameBoardRenderer GameBoardRenderer { get; set; }`
`11`	`11`	`public IBoardFillStrategy<TItem> FillStrategy { get; set; }`
`12`	`12`	`public IGameBoardSolver<TItem> GameBoardSolver { get; set; }`
`13`		`- public IGameBoardDataProvider GameBoardDataProvider { get; set; }`
`14`	`13`	`public ILevelGoalsProvider<TItem> LevelGoalsProvider { get; set; }`
	`14`	`+ public IGameBoardDataProvider<TItem> GameBoardDataProvider { get; set; }`
`15`	`15`	`public ISolvedSequencesConsumer<TItem>[] SolvedSequencesConsumers { get; set; }`
`16`	`16`	`}`
`17`	`17`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,9 +1,10 @@`
`1`	`1`	`using Match3.Core.Interfaces;`
	`2`	`+using Match3.Core.Models;`
`2`	`3`
`3`	`4`	`namespace Match3.App.Interfaces`
`4`	`5`	`{`
`5`		`- public interface IGameBoardDataProvider`
	`6`	`+ public interface IGameBoardDataProvider<TItem> where TItem : IItem`
`6`	`7`	`{`
`7`		`- IGridSlotState[,] GetGameBoardData(int level);`
	`8`	`+ GridSlot<TItem>[,] GetGameBoardSlots(int level);`
`8`	`9`	`}`
`9`	`10`	`}`
Original file line number	Diff line number	Diff line change
`@@ -37,28 +37,16 @@ public GameBoard(IItemSwapper<TItem> itemSwapper, IGameBoardSolver<TItem> gameBo`
`37`	`37`	`_gameBoardSolver = gameBoardSolver;`
`38`	`38`	`}`
`39`	`39`
`40`		`- public void CreateGridSlots(IGridSlotState[,] gameBoardData)`
	`40`	`+ public void SetGridSlots(GridSlot<TItem>[,] gridSlots)`
`41`	`41`	`{`
`42`	`42`	`if (_gridSlots != null)`
`43`	`43`	`{`
`44`	`44`	`throw new InvalidOperationException("Grid slots have already been created.");`
`45`	`45`	`}`
`46`	`46`
`47`		`- _rowCount = gameBoardData.GetLength(0);`
`48`		`- _columnCount = gameBoardData.GetLength(1);`
`49`		`-`
`50`		`- _gridSlots = new GridSlot<TItem>[_rowCount, _columnCount];`
`51`		`-`
`52`		`- for (var rowIndex = 0; rowIndex < _rowCount; rowIndex++)`
`53`		`- {`
`54`		`- for (var columnIndex = 0; columnIndex < _columnCount; columnIndex++)`
`55`		`- {`
`56`		`- var state = gameBoardData[rowIndex, columnIndex];`
`57`		`-`
`58`		`- _gridSlots[rowIndex, columnIndex] =`
`59`		`- new GridSlot<TItem>(state, new GridPosition(rowIndex, columnIndex));`
`60`		`- }`
`61`		`- }`
	`47`	`+ _rowCount = gridSlots.GetLength(0);`
	`48`	`+ _columnCount = gridSlots.GetLength(1);`
	`49`	`+ _gridSlots = gridSlots;`
`62`	`50`	`}`
`63`	`51`
`64`	`52`	`public async UniTask FillAsync(IBoardFillStrategy<TItem> fillStrategy)`
`@@ -97,7 +85,9 @@ public bool IsPositionOnBoard(GridPosition gridPosition)`
`97`	`85`
`98`	`86`	`public void ResetState()`
`99`	`87`	`{`
`100`		`- Dispose();`
	`88`	`+ _rowCount = 0;`
	`89`	`+ _columnCount = 0;`
	`90`	`+ _gridSlots = null;`
`101`	`91`	`}`
`102`	`92`
`103`	`93`	`public void Dispose()`
`@@ -108,10 +98,7 @@ public void Dispose()`
`108`	`98`	`}`
`109`	`99`
`110`	`100`	`Array.Clear(_gridSlots, 0, _gridSlots.Length);`
`111`		`-`
`112`		`- _rowCount = 0;`
`113`		`- _columnCount = 0;`
`114`		`- _gridSlots = null;`
	`101`	`+ ResetState();`
`115`	`102`	`}`
`116`	`103`
`117`	`104`	`private async UniTask SwapItems(GridPosition position1, GridPosition position2)`
Original file line number	Diff line number	Diff line change
`@@ -4,23 +4,28 @@`
`4`	`4`
`5`	`5`	`namespace Match3.Core.Models`
`6`	`6`	`{`
`7`		`- public class GridSlot<TItem> where TItem : IItem`
	`7`	`+ public sealed class GridSlot<TItem> where TItem : IItem`
`8`	`8`	`{`
`9`	`9`	`public bool HasItem => Item != null;`
`10`	`10`	`public bool IsMovable => State.IsLocked == false && HasItem;`
`11`	`11`	`public bool CanSetItem => State.CanContainItem && HasItem == false;`
`12`	`12`	`public bool NotAvailable => State.CanContainItem == false \|\| State.IsLocked;`
`13`	`13`
`14`	`14`	`public TItem Item { get; private set; }`
`15`		`- public IGridSlotState State { get; }`
	`15`	`+ public IGridSlotState State { get; private set; }`
`16`	`16`	`public GridPosition GridPosition { get; }`
`17`	`17`
`18`		`- internal GridSlot(IGridSlotState state, GridPosition gridPosition)`
	`18`	`+ public GridSlot(IGridSlotState state, GridPosition gridPosition)`
`19`	`19`	`{`
`20`	`20`	`State = state;`
`21`	`21`	`GridPosition = gridPosition;`
`22`	`22`	`}`
`23`	`23`
	`24`	`+ public void SetState(IGridSlotState state)`
	`25`	`+ {`
	`26`	`+ State = state;`
	`27`	`+ }`
	`28`	`+`
`24`	`29`	`public void SetItem(TItem item)`
`25`	`30`	`{`
`26`	`31`	`EnsureItemIsNotNull(item);`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ public void Dispose()`
`53`	`53`
`54`	`54`	`private void Init(int level)`
`55`	`55`	`{`
`56`		`- var gameBoardData = _appContext.Resolve<IGameBoardDataProvider>().GetGameBoardData(level);`
	`56`	`+ var gameBoardData = _appContext.Resolve<IGameBoardDataProvider<IUnityItem>>().GetGameBoardSlots(level);`
`57`	`57`	`var rowCount = gameBoardData.GetLength(0);`
`58`	`58`	`var columnCount = gameBoardData.GetLength(1);`
`59`	`59`	`var itemsPoolCapacity = rowCount * columnCount + Mathf.Max(rowCount, columnCount) * 2;`
Original file line number	Diff line number	Diff line change
`@@ -17,8 +17,9 @@ public static void ReturnAllItems<TItem>(this IItemsPool<TItem> itemsPool,`
`17`	`17`	`continue;`
`18`	`18`	`}`
`19`	`19`
`20`		`- gridSlot.Item.Hide();`
`21`	`20`	`itemsPool.ReturnItem(gridSlot.Item);`
	`21`	`+ gridSlot.Item.Hide();`
	`22`	`+ gridSlot.Clear();`
`22`	`23`	`}`
`23`	`24`	`}`
`24`	`25`	`}`