Fixed Data reset issues.

Assets/Scripts/Gameplay/GameModeHandler.cs

@@ -75,15 +75,16 @@ public class GameModeHandler : MonoBehaviour, IBase, IBootLoader, IDataLoader
     public void OnGameRestarted()
     {
         GameManager.OnGameStateChanged(GameState.InGame);
-        gameplayManager.ResetGameRestartData();
+        GameManager.ResetGameDatas();
+
         switch (CurrentGameModeType)
         {
             case GameModeType.PVP:
                 InitPVPModeData(pvpModeData.types, pvpModeData.names);
-            break;
+                break;
             case GameModeType.Bot:
                 InitBotModeData(botModeData.playerData, botModeData.botCount);
-            break;
+                break;
         }
     }
 }

Assets/Scripts/Gameplay/GameplayManager.cs

@@ -36,8 +36,10 @@ public class GameplayManager : MonoBehaviour, IBase, IBootLoader, IDataLoader
     [SerializeField] private PlayerGameData[] playerGameDatas;
     [SerializeField] private PlayerBaseHandler playerBaseHandler;
 
-    private PlayerType currentPlayerTypeTurn;
     public PlayerType CurrentPlayerTypeTurn => currentPlayerTypeTurn;
+    public PlayerBaseHandler PlayerBaseHandler => playerBaseHandler;
+
+    private PlayerType currentPlayerTypeTurn;
     private int currentPlayerTurnIndex = 0;
 
     private List<PlayerType> allPlayerTypes = new List<PlayerType>();
@@ -885,14 +887,8 @@ public class GameplayManager : MonoBehaviour, IBase, IBootLoader, IDataLoader
                             for (int i = counter; i > 0; i--)
                             {
                                 var pawn = nextTile.GetPlayerPawn();
-                                Debug.Log($"pawn: {pawn}");
-                                Debug.Log($"playerBase: {playerBaseHandler}");
-
-                                var playerBasePos = playerBaseHandler.GetPlayerBase(pawn.PlayerType).GetBasePlacementDataPosition(pawn.PlayerId - 1);
-                                Debug.Log($"playerBasePos: {playerBasePos}");
-
                                 playerGameDatasDict[pawn.PlayerType].totalPawnsInHome++;
-                                pawn.MoveBackToHome(playerBasePos);
+                                playerBaseHandler.SendPlayerToHome(pawn);
                             }
 
                             if (CheckForMaxDiceRollAttempt())
@@ -1012,7 +1008,10 @@ public class GameplayManager : MonoBehaviour, IBase, IBootLoader, IDataLoader
                 {
                     if (playerPawn.CurrentTileIndex == tilesManager.GetFinishingTileDataLength(currentPlayerTypeTurn) - 1)
                     {
-                        playerPawn.ShowPlayerCountCanvas(false);
+                        Tile tile = tilesManager.RetrieveFinishingTileBasedOnIndex(playerPawn.PlayerType, playerPawn.CurrentTileIndex);
+                        tile.InitPlayerPawn(playerPawn, playerPawn.PlayerType);
+                        ShowUpdatedPlayerCountOnTile(playerPawn);
+                        
                         UpdatePlayerState(playerPawn, PlayerState.HasFinished);
                         playerGameDatasDict[currentPlayerTypeTurn].totalPawnsFinished++;
 
@@ -1100,6 +1099,21 @@ public class GameplayManager : MonoBehaviour, IBase, IBootLoader, IDataLoader
         playerPawn.PlayerCountCanvas.SetPlayerCount(count);
     }
 
+    public void ResetTileDatasForPlayers()
+    {
+        foreach (PlayerData data in playerDatas)
+        {
+            var pawns = playerGameDatasDict[data.playerType].playerPawnsDict.Values;
+
+            foreach (var pawn in pawns)
+            {
+                if (pawn.GetPlayerState() == PlayerState.InHome || pawn.GetPlayerState() == PlayerState.HasFinished) continue;
+                
+                tilesManager.ResetTileData(pawn.PlayerType, pawn.CurrentTileIndex, pawn.GetPlayerState());
+            }
+        }
+    }
+
     public void ResetData()
     {
         ResetGameRestartData();

Assets/Scripts/Gameplay/Player/PlayerBase.cs

@@ -42,4 +42,12 @@ public class PlayerBase : MonoBehaviour
         Debug.Log($"Index: {idx}, basePlacementDatas[idx]: {basePlacementDatas[idx]}");
         return basePlacementDatas[idx].placementTransform;
     }
+
+    public void ResetPlayerDatas()
+    {
+        for (int idx = 0; idx < playerPawns.Length; idx++)
+        {
+            playerPawns[idx].ResetData();
+        }
+    }
 }

Assets/Scripts/Gameplay/Player/PlayerBaseHandler.cs

@@ -40,4 +40,18 @@ public class PlayerBaseHandler : MonoBehaviour
     {
         return playerBasesDict[playerType];
     }
+
+    public void ResetPlayerBaseData()
+    {
+        foreach (var playerBasePair in playerBasesDict)
+        {
+            playerBasePair.Value.ResetPlayerDatas();
+        }
+    }
+
+    public void SendPlayerToHome(PlayerPawn pawn)
+    {
+        var playerBasePos = GetPlayerBase(pawn.PlayerType).GetBasePlacementDataPosition(pawn.PlayerId - 1);
+        pawn.MoveBackToHome(playerBasePos);
+    }
 }

Assets/Scripts/Gameplay/Player/PlayerPawn.cs

@@ -65,10 +65,6 @@ public class PlayerPawn : MonoBehaviour
     public void SetPlayerSelectionState(bool state)
     {
         CanSelectPlayer = state;
-        if (CanSelectPlayer)
-        {
-            // TODO :: Play animation for selecting any of the players
-        }
     }
 
     public void MoveToTile(Vector3 startingPoint, Action onComplete, int tileIndex)
@@ -91,6 +87,7 @@ public class PlayerPawn : MonoBehaviour
 
             Vector3 lookDirection = Vector3.zero;
 
+            Debug.Log($"nextIndex :: playerState: {playerState}");
             if (playerState == PlayerState.InFinishingPath)
             {
                 int nextIndex = CurrentTileIndex + 1;
@@ -105,18 +102,22 @@ public class PlayerPawn : MonoBehaviour
             {
                 if (gameplayManager.IsGoingInsideFinishingPath(this, out int possibleSteps))
                 {
-                    lookDirection =tilesManager.RetrieveFinishingTileBasedOnIndex(PlayerType, 0).transform.position - transform.position;
+                    lookDirection = tilesManager.RetrieveFinishingTileBasedOnIndex(PlayerType, 0).transform.position - transform.position;
                 }
                 else
                 {
                     int nextIndex = gameplayManager.GetNextGeneralTileIndex(this);
+                    Debug.Log($"nextIndex :: {nextIndex}, currentIndex: {CurrentTileIndex}");
                     lookDirection = tilesManager.RetrieveTileBasedOnIndex(nextIndex).transform.position - transform.position;
                 }
             }
 
+            lookDirection = lookDirection.normalized;
             lookDirection.y = 0;
+            
             if (lookDirection != Vector3.zero)
             {
+                // transform.LookAt(transform.position + lookDirection);
                 transform.DOLookAt(transform.position + lookDirection, 0.2f);
             }
 
@@ -171,4 +172,14 @@ public class PlayerPawn : MonoBehaviour
     {
         playerCountCanvas.gameObject.SetActive(show);
     }
+
+    public void ResetData()
+    {
+        SetPlayerState(PlayerState.InHome);
+        StepsTaken = 0;
+        PlayerId = 0;
+        if (playerCountCanvas.gameObject.activeInHierarchy)
+            ShowPlayerCountCanvas(false);
+            
+    }
 }

Assets/Scripts/State/GameManager.cs

@@ -18,6 +18,8 @@ public class GameManager : MonoBehaviour, IBase, IBootLoader, IDataLoader
         get; private set;
     }
 
+    private GameState PrevGameState;
+
     public void Initialize()
     {
         InterfaceManager.Instance.RegisterInterface<GameManager>(this);
@@ -34,15 +36,15 @@ public class GameManager : MonoBehaviour, IBase, IBootLoader, IDataLoader
 
     public void OnGameStateChanged(GameState gameState)
     {
+        PrevGameState = GameState;
         GameState = gameState;
         Debug.Log($"OnGameStateChanged: {gameState}");
         switch (gameState)
         {
             case GameState.InMenu:
-                gameplayManager.ResetData();
+                CheckPrevGameState();
-                tilesManager.ResetData();
                 uiManager.OnInMenuScreen();
-            break;
+                break;
             case GameState.InGame:
                 uiManager.OnInGameScreen();
             break;
@@ -51,4 +53,20 @@ public class GameManager : MonoBehaviour, IBase, IBootLoader, IDataLoader
             break;
         }
     }
+
+    private void CheckPrevGameState()
+    {
+        if (PrevGameState == GameState.InGame) // returning to menu from in-game
+        {
+            ResetGameDatas();
+        }
+    }
+
+    public void ResetGameDatas()
+    {
+        gameplayManager.ResetTileDatasForPlayers();
+        gameplayManager.ResetData();
+        tilesManager.ResetData();
+        gameplayManager.PlayerBaseHandler.ResetPlayerBaseData();
+    }
 }

Assets/Scripts/Tile/SafeTile.cs

@@ -86,4 +86,12 @@ public class SafeTile : Tile
     {
         return playerTypesDict[playerType].commonPlacementTransform;
     }
+
+    public override void ResetTileData()
+    {
+        if (playerTypesDict != null && playerTypesDict.Count > 0)
+        {
+            playerTypesDict.Clear();
+        }
+    }
 }

Assets/Scripts/Tile/Tile.cs

@@ -53,4 +53,10 @@ public class Tile : MonoBehaviour
         Debug.Log($"Resetting new PlayerPawn {movingPawn.name} {name}");
         Debug.Log($"Resetting new PlayerPawn {PlayerPawns.Count} {name}");
     }
+
+    public virtual void ResetTileData()
+    {
+        if (HasPawnsAvailable)
+            PlayerPawns.Clear();
+    }
 }

Assets/Scripts/Tile/TilesManager.cs

@@ -66,4 +66,23 @@ public class TilesManager : MonoBehaviour, IBootLoader, IDataLoader, IBase
     {
         finishingTileDataPairs.Clear();
     }
+
+    public void ResetTileData(PlayerType playerType, int currentTileIndex, PlayerState playerState)
+    {
+        if (playerState == PlayerState.InFinishingPath)
+        {
+            Tile tile = RetrieveFinishingTileBasedOnIndex(playerType, currentTileIndex);
+            tile.ResetTileData();
+        }
+        else if (playerState == PlayerState.Moving)
+        {
+            Tile tile = RetrieveTileBasedOnIndex(currentTileIndex);
+            tile.ResetTileData();
+        }
+        else if (playerState == PlayerState.InSafeZone)
+        {
+            SafeTile tile = (SafeTile)RetrieveTileBasedOnIndex(currentTileIndex);
+            tile.ResetTileData();
+        }
+    }
 }