Added IsLocked property to GridSlot.

RUBIUS\chebanovdd · RUBIUS\chebanovdd · commit ad7e4f865f7e · 2022-04-07T21:47:30.000+07:00
diff --git a/Assets/Plugins/Match3/Core/Models/GridSlot.cs b/Assets/Plugins/Match3/Core/Models/GridSlot.cs
@@ -7,6 +7,7 @@ namespace Match3.Core.Models
 {
     public class GridSlot<TItem> where TItem : IItem
     {
+        public bool IsLocked { get; private set; }
         public TItem Item { get; private set; }
         public GridPosition GridPosition { get; }
         public GridSlotState State { get; private set; }
@@ -17,6 +18,16 @@ internal GridSlot(GridSlotState state, GridPosition gridPosition)
             GridPosition = gridPosition;
         }
 
+        public void Lock()
+        {
+            IsLocked = true;
+        }
+
+        public void Unlock()
+        {
+            IsLocked = false;
+        }
+
         public void SetItem(TItem item)
         {
             EnsureItemIsNotNull(item);
diff --git a/Assets/Prefabs/Tiles/IceTilePrefab.prefab b/Assets/Prefabs/Tiles/IceTilePrefab.prefab
diff --git a/Assets/Prefabs/Tiles/StoneTilePrefab.prefab b/Assets/Prefabs/Tiles/StoneTilePrefab.prefab
diff --git a/Assets/Scenes/MainScene.unity b/Assets/Scenes/MainScene.unity
diff --git a/Assets/Scripts/Common/Extensions/ItemsSequenceExtensions.cs b/Assets/Scripts/Common/Extensions/ItemsSequenceExtensions.cs
@@ -8,14 +8,19 @@ namespace Common.Extensions
     public static class ItemsSequenceExtensions
     {
         public static IEnumerable<GridSlot<TItem>> GetUniqueGridSlots<TItem>(
-            this IEnumerable<ItemSequence<TItem>> sequences) where TItem : IItem
+            this IEnumerable<ItemSequence<TItem>> sequences, bool includeLocked = true) where TItem : IItem
         {
             var solvedGridSlots = new HashSet<GridSlot<TItem>>();
 
             foreach (var sequence in sequences)
             {
                 foreach (var solvedGridSlot in sequence.SolvedGridSlots)
                 {
+                    if (includeLocked == false && solvedGridSlot.IsLocked)
+                    {
+                        continue;
+                    }
+
                     if (solvedGridSlots.Add(solvedGridSlot) == false)
                     {
                         continue;
diff --git a/Assets/Scripts/Common/GameBoardAgreements.cs b/Assets/Scripts/Common/GameBoardAgreements.cs
@@ -13,6 +13,11 @@ public bool CanSetItem(GridSlot<IUnityItem> gridSlot, TileGroup tileGroup)
             return isAvailableTile && gridSlot.State == GridSlotState.Empty;
         }
 
+        public bool IsBlocker(TileGroup tileGroup)
+        {
+            return tileGroup == TileGroup.Ice;
+        }
+
         public bool IsLockedSlot(TileGroup tileGroup)
         {
             return tileGroup != TileGroup.Available;
diff --git a/Assets/Scripts/Common/GridTiles/StatefulGridTile.cs b/Assets/Scripts/Common/GridTiles/StatefulGridTile.cs
@@ -7,27 +7,40 @@ public class StatefulGridTile : SpriteGridTile, IStatefulTile
     {
         [Space]
         [SerializeField] private SpriteRenderer _stateSpriteRenderer;
-        [SerializeField] private string _stateSpriteName;
+        [SerializeField] private string[] _stateSpriteNames;
+
+        private int _currentStateIndex;
 
         protected override void Start()
         {
             base.Start();
-            _stateSpriteRenderer.sprite = GetSprite(_stateSpriteName);
+            _stateSpriteRenderer.sprite = GetStateSprite(_currentStateIndex);
         }
 
         public bool NextState()
         {
-            if (_stateSpriteRenderer.enabled)
+            _currentStateIndex++;
+
+            if (_currentStateIndex >= _stateSpriteNames.Length)
             {
                 _stateSpriteRenderer.enabled = false;
+                return false;
             }
 
-            return false;
+            _stateSpriteRenderer.sprite = GetStateSprite(_currentStateIndex);
+            return true;
         }
 
         public void ResetState()
         {
+            _currentStateIndex = 0;
             _stateSpriteRenderer.enabled = true;
+            _stateSpriteRenderer.sprite = GetStateSprite(0);
+        }
+
+        private Sprite GetStateSprite(int index)
+        {
+            return GetSprite(_stateSpriteNames[index]);
         }
     }
 }
diff --git a/Assets/Scripts/Common/Interfaces/IGameBoardAgreements.cs b/Assets/Scripts/Common/Interfaces/IGameBoardAgreements.cs
@@ -6,6 +6,7 @@ namespace Common.Interfaces
     public interface IGameBoardAgreements
     {
         bool CanSetItem(GridSlot<IUnityItem> gridSlot, TileGroup tileGroup);
+        bool IsBlocker(TileGroup tileGroup);
         bool IsLockedSlot(TileGroup tileGroup);
         bool IsMovableSlot(GridSlot<IUnityItem> gridSlot, TileGroup tileGroup);
         bool IsAvailableSlot(GridSlot<IUnityItem> gridSlot, TileGroup tileGroup);
diff --git a/Assets/Scripts/Common/Interfaces/IUnityGameBoardRenderer.cs b/Assets/Scripts/Common/Interfaces/IUnityGameBoardRenderer.cs
@@ -15,7 +15,7 @@ public interface IUnityGameBoardRenderer : IGameBoardRenderer
         bool IsPositionOnGrid(GridPosition gridPosition);
 
         void SetNextGridTileGroup(GridPosition gridPosition);
-        void TrySetNextTileState(GridPosition gridPosition);
+        bool TrySetNextTileState(GridPosition gridPosition);
         TileGroup GetTileGroup(GridPosition gridPosition);
     }
 }
diff --git a/Assets/Scripts/Common/TileGroupDetectors/IceTileDetector.cs b/Assets/Scripts/Common/TileGroupDetectors/IceTileDetector.cs
@@ -1,3 +1,4 @@
+using Common.Enums;
 using Common.Interfaces;
 using Match3.Core.Models;
 
@@ -14,7 +15,16 @@ public IceTileDetector(IUnityGameBoardRenderer gameBoardRenderer)
 
         public void CheckGridSlot(GridSlot<IUnityItem> gridSlot)
         {
-            _gameBoardRenderer.TrySetNextTileState(gridSlot.GridPosition);
+            if (_gameBoardRenderer.GetTileGroup(gridSlot.GridPosition) != TileGroup.Ice)
+            {
+                return;
+            }
+            
+            var hasNewState = _gameBoardRenderer.TrySetNextTileState(gridSlot.GridPosition);
+            if (hasNewState == false)
+            {
+                gridSlot.Unlock();
+            }
         }
     }
 }
diff --git a/Assets/Scripts/Common/TileGroupDetectors/StoneTileDetector.cs b/Assets/Scripts/Common/TileGroupDetectors/StoneTileDetector.cs
@@ -24,6 +24,11 @@ public StoneTileDetector(IUnityGameBoardRenderer gameBoardRenderer)
 
         public void CheckGridSlot(GridSlot<IUnityItem> gridSlot)
         {
+            if (gridSlot.IsLocked)
+            {
+                return;
+            }
+
             foreach (var lookupDirection in _lookupDirections)
             {
                 var position = gridSlot.GridPosition + lookupDirection;
diff --git a/Assets/Scripts/Common/TileGroupDetectors/TileGroupDetector.cs b/Assets/Scripts/Common/TileGroupDetectors/TileGroupDetector.cs
@@ -14,8 +14,8 @@ public TileGroupDetector(IUnityGameBoardRenderer gameBoardRenderer)
         {
             _tileDetectors = new ITileDetector[]
             {
-                new IceTileDetector(gameBoardRenderer),
-                new StoneTileDetector(gameBoardRenderer)
+                new StoneTileDetector(gameBoardRenderer),
+                new IceTileDetector(gameBoardRenderer)
             };
         }
 
diff --git a/Assets/Scripts/Common/UnityGameBoardRenderer.cs b/Assets/Scripts/Common/UnityGameBoardRenderer.cs
@@ -102,13 +102,15 @@ public void SetNextGridTileGroup(GridPosition gridPosition)
             SetTile(gridPosition.RowIndex, gridPosition.ColumnIndex, GetNextAvailableGroup(tileGroup));
         }
 
-        public void TrySetNextTileState(GridPosition gridPosition)
+        public bool TrySetNextTileState(GridPosition gridPosition)
         {
             var tile = _gridSlotTiles[gridPosition.RowIndex, gridPosition.ColumnIndex];
             if (tile is IStatefulTile statefulTile)
             {
-                SetNextTileState(gridPosition, statefulTile);
+                return SetNextTileState(gridPosition, statefulTile);
             }
+
+            return false;
         }
 
         public TileGroup GetTileGroup(GridPosition gridPosition)
@@ -192,16 +194,18 @@ private void SetTile(int rowIndex, int columnIndex, TileGroup group)
             _gridSlotTiles[rowIndex, columnIndex] = GetTile(rowIndex, columnIndex, group);
         }
 
-        private void SetNextTileState(GridPosition gridPosition, IStatefulTile statefulTile)
+        private bool SetNextTileState(GridPosition gridPosition, IStatefulTile statefulTile)
         {
             var hasNextState = statefulTile.NextState();
             if (hasNextState)
             {
-                return;
+                return true;
             }
 
             SetTile(gridPosition.RowIndex, gridPosition.ColumnIndex, TileGroup.Available);
             statefulTile.ResetState();
+
+            return false;
         }
 
         private TileGroup GetNextAvailableGroup(TileGroup group)
diff --git a/Assets/Scripts/FillStrategies/BaseFillStrategy.cs b/Assets/Scripts/FillStrategies/BaseFillStrategy.cs
@@ -4,7 +4,6 @@
 using FillStrategies.Jobs;
 using Match3.App.Interfaces;
 using Match3.App.Models;
-using Match3.Core.Enums;
 using Match3.Core.Models;
 using Match3.Core.Structs;
 using UnityEngine;
@@ -40,6 +39,11 @@ public virtual IEnumerable<IJob> GetFillJobs(IGameBoard<IUnityItem> gameBoard)
                         continue;
                     }
 
+                    if (IsBlocker(gridSlot))
+                    {
+                        gridSlot.Lock();
+                    }
+
                     var item = GetItemFromPool();
                     item.SetWorldPosition(GetWorldPosition(gridSlot.GridPosition));
 
@@ -60,24 +64,22 @@ protected bool CanSetItem(GridSlot<IUnityItem> gridSlot)
             return _gameBoardAgreements.CanSetItem(gridSlot, tileGroup);
         }
 
-        protected bool IsMovableSlot(GridSlot<IUnityItem> gridSlot)
+        protected bool IsBlocker(GridSlot<IUnityItem> gridSlot)
         {
-            if (_gameBoardRenderer.IsLockedSlot(gridSlot.GridPosition))
-            {
-                return false;
-            }
+            var tileGroup = _gameBoardRenderer.GetTileGroup(gridSlot.GridPosition);
+            return _gameBoardAgreements.IsBlocker(tileGroup);
+        }
 
-            return gridSlot.State == GridSlotState.Occupied;
+        protected bool IsMovableSlot(GridSlot<IUnityItem> gridSlot)
+        {
+            var tileGroup = _gameBoardRenderer.GetTileGroup(gridSlot.GridPosition);
+            return _gameBoardAgreements.IsMovableSlot(gridSlot, tileGroup);
         }
 
         protected bool IsAvailableSlot(GridSlot<IUnityItem> gridSlot)
         {
-            if (_gameBoardRenderer.IsLockedSlot(gridSlot.GridPosition))
-            {
-                return false;
-            }
-
-            return gridSlot.State != GridSlotState.NotAvailable;
+            var tileGroup = _gameBoardRenderer.GetTileGroup(gridSlot.GridPosition);
+            return _gameBoardAgreements.IsAvailableSlot(gridSlot, tileGroup);
         }
 
         protected Vector3 GetWorldPosition(GridPosition gridPosition)
diff --git a/Assets/Scripts/FillStrategies/FallDownFillStrategy.cs b/Assets/Scripts/FillStrategies/FallDownFillStrategy.cs
@@ -25,7 +25,7 @@ public override IEnumerable<IJob> GetSolveJobs(IGameBoard<IUnityItem> gameBoard,
             var jobs = new List<IJob>();
             var itemsToHide = new List<IUnityItem>();
 
-            foreach (var solvedGridSlot in sequences.GetUniqueGridSlots())
+            foreach (var solvedGridSlot in sequences.GetUniqueGridSlots(false))
             {
                 var currentItem = solvedGridSlot.Item;
                 itemsToHide.Add(currentItem);
diff --git a/Assets/Scripts/FillStrategies/SimpleFillStrategy.cs b/Assets/Scripts/FillStrategies/SimpleFillStrategy.cs
@@ -21,7 +21,7 @@ public override IEnumerable<IJob> GetSolveJobs(IGameBoard<IUnityItem> gameBoard,
             var itemsToHide = new List<IUnityItem>();
             var itemsToShow = new List<IUnityItem>();
 
-            foreach (var solvedGridSlot in sequences.GetUniqueGridSlots())
+            foreach (var solvedGridSlot in sequences.GetUniqueGridSlots(false))
             {
                 var newItem = GetItemFromPool();
                 var currentItem = solvedGridSlot.Item;
diff --git a/Assets/Scripts/FillStrategies/SlideDownFillStrategy.cs b/Assets/Scripts/FillStrategies/SlideDownFillStrategy.cs
@@ -30,6 +30,11 @@ public override IEnumerable<IJob> GetSolveJobs(IGameBoard<IUnityItem> gameBoard,
             {
                 foreach (var solvedGridSlot in sequence.SolvedGridSlots)
                 {
+                    if (solvedGridSlot.IsLocked)
+                    {
+                        continue;
+                    }
+
                     if (solvedGridSlots.Add(solvedGridSlot) == false)
                     {
                         continue;

Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,7 @@ namespace Match3.Core.Models`
`7`	`7`	`{`
`8`	`8`	`public class GridSlot<TItem> where TItem : IItem`
`9`	`9`	`{`
	`10`	`+ public bool IsLocked { get; private set; }`
`10`	`11`	`public TItem Item { get; private set; }`
`11`	`12`	`public GridPosition GridPosition { get; }`
`12`	`13`	`public GridSlotState State { get; private set; }`
`@@ -17,6 +18,16 @@ internal GridSlot(GridSlotState state, GridPosition gridPosition)`
`17`	`18`	`GridPosition = gridPosition;`
`18`	`19`	`}`
`19`	`20`
	`21`	`+ public void Lock()`
	`22`	`+ {`
	`23`	`+ IsLocked = true;`
	`24`	`+ }`
	`25`	`+`
	`26`	`+ public void Unlock()`
	`27`	`+ {`
	`28`	`+ IsLocked = false;`
	`29`	`+ }`
	`30`	`+`
`20`	`31`	`public void SetItem(TItem item)`
`21`	`32`	`{`
`22`	`33`	`EnsureItemIsNotNull(item);`
Original file line number	Diff line number	Diff line change
`@@ -8,14 +8,19 @@ namespace Common.Extensions`
`8`	`8`	`public static class ItemsSequenceExtensions`
`9`	`9`	`{`
`10`	`10`	`public static IEnumerable<GridSlot<TItem>> GetUniqueGridSlots<TItem>(`
`11`		`- this IEnumerable<ItemSequence<TItem>> sequences) where TItem : IItem`
	`11`	`+ this IEnumerable<ItemSequence<TItem>> sequences, bool includeLocked = true) where TItem : IItem`
`12`	`12`	`{`
`13`	`13`	`var solvedGridSlots = new HashSet<GridSlot<TItem>>();`
`14`	`14`
`15`	`15`	`foreach (var sequence in sequences)`
`16`	`16`	`{`
`17`	`17`	`foreach (var solvedGridSlot in sequence.SolvedGridSlots)`
`18`	`18`	`{`
	`19`	`+ if (includeLocked == false && solvedGridSlot.IsLocked)`
	`20`	`+ {`
	`21`	`+ continue;`
	`22`	`+ }`
	`23`	`+`
`19`	`24`	`if (solvedGridSlots.Add(solvedGridSlot) == false)`
`20`	`25`	`{`
`21`	`26`	`continue;`
Original file line number	Diff line number	Diff line change
`@@ -13,6 +13,11 @@ public bool CanSetItem(GridSlot<IUnityItem> gridSlot, TileGroup tileGroup)`
`13`	`13`	`return isAvailableTile && gridSlot.State == GridSlotState.Empty;`
`14`	`14`	`}`
`15`	`15`
	`16`	`+ public bool IsBlocker(TileGroup tileGroup)`
	`17`	`+ {`
	`18`	`+ return tileGroup == TileGroup.Ice;`
	`19`	`+ }`
	`20`	`+`
`16`	`21`	`public bool IsLockedSlot(TileGroup tileGroup)`
`17`	`22`	`{`
`18`	`23`	`return tileGroup != TileGroup.Available;`
Original file line number	Diff line number	Diff line change
`@@ -7,27 +7,40 @@ public class StatefulGridTile : SpriteGridTile, IStatefulTile`
`7`	`7`	`{`
`8`	`8`	`[Space]`
`9`	`9`	`[SerializeField] private SpriteRenderer _stateSpriteRenderer;`
`10`		`- [SerializeField] private string _stateSpriteName;`
	`10`	`+ [SerializeField] private string[] _stateSpriteNames;`
	`11`	`+`
	`12`	`+ private int _currentStateIndex;`
`11`	`13`
`12`	`14`	`protected override void Start()`
`13`	`15`	`{`
`14`	`16`	`base.Start();`
`15`		`- _stateSpriteRenderer.sprite = GetSprite(_stateSpriteName);`
	`17`	`+ _stateSpriteRenderer.sprite = GetStateSprite(_currentStateIndex);`
`16`	`18`	`}`
`17`	`19`
`18`	`20`	`public bool NextState()`
`19`	`21`	`{`
`20`		`- if (_stateSpriteRenderer.enabled)`
	`22`	`+ _currentStateIndex++;`
	`23`	`+`
	`24`	`+ if (_currentStateIndex >= _stateSpriteNames.Length)`
`21`	`25`	`{`
`22`	`26`	`_stateSpriteRenderer.enabled = false;`
	`27`	`+ return false;`
`23`	`28`	`}`
`24`	`29`
`25`		`- return false;`
	`30`	`+ _stateSpriteRenderer.sprite = GetStateSprite(_currentStateIndex);`
	`31`	`+ return true;`
`26`	`32`	`}`
`27`	`33`
`28`	`34`	`public void ResetState()`
`29`	`35`	`{`
	`36`	`+ _currentStateIndex = 0;`
`30`	`37`	`_stateSpriteRenderer.enabled = true;`
	`38`	`+ _stateSpriteRenderer.sprite = GetStateSprite(0);`
	`39`	`+ }`
	`40`	`+`
	`41`	`+ private Sprite GetStateSprite(int index)`
	`42`	`+ {`
	`43`	`+ return GetSprite(_stateSpriteNames[index]);`
`31`	`44`	`}`
`32`	`45`	`}`
`33`	`46`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,7 @@ namespace Common.Interfaces`
`6`	`6`	`public interface IGameBoardAgreements`
`7`	`7`	`{`
`8`	`8`	`bool CanSetItem(GridSlot<IUnityItem> gridSlot, TileGroup tileGroup);`
	`9`	`+ bool IsBlocker(TileGroup tileGroup);`
`9`	`10`	`bool IsLockedSlot(TileGroup tileGroup);`
`10`	`11`	`bool IsMovableSlot(GridSlot<IUnityItem> gridSlot, TileGroup tileGroup);`
`11`	`12`	`bool IsAvailableSlot(GridSlot<IUnityItem> gridSlot, TileGroup tileGroup);`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ public interface IUnityGameBoardRenderer : IGameBoardRenderer`
`15`	`15`	`bool IsPositionOnGrid(GridPosition gridPosition);`
`16`	`16`
`17`	`17`	`void SetNextGridTileGroup(GridPosition gridPosition);`
`18`		`- void TrySetNextTileState(GridPosition gridPosition);`
	`18`	`+ bool TrySetNextTileState(GridPosition gridPosition);`
`19`	`19`	`TileGroup GetTileGroup(GridPosition gridPosition);`
`20`	`20`	`}`
`21`	`21`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,4 @@`
	`1`	`+using Common.Enums;`
`1`	`2`	`using Common.Interfaces;`
`2`	`3`	`using Match3.Core.Models;`
`3`	`4`
`@@ -14,7 +15,16 @@ public IceTileDetector(IUnityGameBoardRenderer gameBoardRenderer)`
`14`	`15`
`15`	`16`	`public void CheckGridSlot(GridSlot<IUnityItem> gridSlot)`
`16`	`17`	`{`
`17`		`- _gameBoardRenderer.TrySetNextTileState(gridSlot.GridPosition);`
	`18`	`+ if (_gameBoardRenderer.GetTileGroup(gridSlot.GridPosition) != TileGroup.Ice)`
	`19`	`+ {`
	`20`	`+ return;`
	`21`	`+ }`
	`22`	`+`
	`23`	`+ var hasNewState = _gameBoardRenderer.TrySetNextTileState(gridSlot.GridPosition);`
	`24`	`+ if (hasNewState == false)`
	`25`	`+ {`
	`26`	`+ gridSlot.Unlock();`
	`27`	`+ }`
`18`	`28`	`}`
`19`	`29`	`}`
`20`	`30`	`}`