Refactoring + fixes for game over.

Assets/Scripts/Gameplay/GameplayManager.cs

@@ -51,7 +51,10 @@ public class GameplayManager : MonoBehaviour, IBase, IBootLoader, IDataLoader
     private Dictionary<PlayerType, PlayerGameData> playerGameDatasDict = new Dictionary<PlayerType, PlayerGameData>();
     private Dictionary<PlayerType, Dictionary<int, BotMove>> botRuntimeMovementData = new Dictionary<PlayerType, Dictionary<int, BotMove>>();
 
-    private TilesManager tilesManager;
+    public TilesManager TilesManager
+    {
+        get; private set;
+    }
     private UIManager uIManager;
     private GameManager gameManager;
     private GameModeHandler gameModeHandler;
@@ -85,7 +88,7 @@ public class GameplayManager : MonoBehaviour, IBase, IBootLoader, IDataLoader
 
     public void InitializeData()
     {
-        tilesManager = InterfaceManager.Instance.GetInterfaceInstance<TilesManager>();
+        TilesManager = InterfaceManager.Instance.GetInterfaceInstance<TilesManager>();
         uIManager = InterfaceManager.Instance.GetInterfaceInstance<UIManager>();
         gameManager = InterfaceManager.Instance.GetInterfaceInstance<GameManager>();
         gameModeHandler = InterfaceManager.Instance.GetInterfaceInstance<GameModeHandler>();
@@ -107,7 +110,7 @@ public class GameplayManager : MonoBehaviour, IBase, IBootLoader, IDataLoader
             });  
         }
 
-        tilesManager.InitTilesData();
+        TilesManager.InitTilesData();
 
         playerBaseHandler.InitPlayerTypes(allPlayerTypes);
         InitCurrentGamePlayerInfo();
@@ -138,7 +141,7 @@ public class GameplayManager : MonoBehaviour, IBase, IBootLoader, IDataLoader
             }
         }
 
-        tilesManager.InitTilesData();
+        TilesManager.InitTilesData();
         playerBaseHandler.InitPlayerTypes(allPlayerTypes);
         InitCurrentGamePlayerInfo();
         InitBotRuntimeData();
@@ -462,10 +465,10 @@ public class GameplayManager : MonoBehaviour, IBase, IBootLoader, IDataLoader
 
     private void FindPossibleTileData(PlayerPawn playerPawn, out int possibleSteps, out Tile possibleTileData)
     {
-        int lastStepGenTile = totalStepsForCharacter - tilesManager.GetFinishingTileDataLength(playerPawn.PlayerType);//playerGameDatasDict[playerPawn.PlayerType].endIndex;
+        int lastStepGenTile = totalStepsForCharacter - TilesManager.GetFinishingTileDataLength(playerPawn.PlayerType);//playerGameDatasDict[playerPawn.PlayerType].endIndex;
         int possibleTileIndex = playerPawn.CurrentTileIndex + diceRolledValue;
 
-        int lastTileIndex = tilesManager.GetGeneralTilesLength() - 1;
+        int lastTileIndex = TilesManager.GetGeneralTilesLength() - 1;
         bool canGoingInsideFinishingPath = IsGoingInsideFinishingPath(playerPawn, out possibleSteps);
 
         int index = canGoingInsideFinishingPath ? possibleSteps - lastStepGenTile - 1
@@ -473,13 +476,13 @@ public class GameplayManager : MonoBehaviour, IBase, IBootLoader, IDataLoader
 
         Debug.Log($"possibleTileIndex: {possibleTileIndex}, lastStepGenTileIdx: {lastStepGenTile}");
         Debug.Log($"index: {index}");
-        possibleTileData = canGoingInsideFinishingPath ? tilesManager.RetrieveFinishingTileBasedOnIndex(playerPawn.PlayerType, index) : tilesManager.RetrieveTileBasedOnIndex(index);
+        possibleTileData = canGoingInsideFinishingPath ? TilesManager.RetrieveFinishingTileBasedOnIndex(playerPawn.PlayerType, index) : TilesManager.RetrieveTileBasedOnIndex(index);
     }
 
     public bool IsGoingInsideFinishingPath(PlayerPawn playerPawn, out int possibleSteps)
     {
         possibleSteps = playerGameDatasDict[playerPawn.PlayerType].playerPawnsDict[playerPawn.PlayerId].StepsTaken + diceRolledValue;
-        return possibleSteps > tilesManager.GetGeneralTilesLength() - 1;
+        return possibleSteps > TilesManager.GetGeneralTilesLength() - 1;
     }
 
     public void OnDiceRolled(int rolledVal)
@@ -534,8 +537,8 @@ public class GameplayManager : MonoBehaviour, IBase, IBootLoader, IDataLoader
 
                 if (availPlayers[i].GetPlayerState() == PlayerState.InFinishingPath)
                 {
-                    Debug.Log($"diceRolledValue: {diceRolledValue}, FinishingDataLen: {tilesManager.GetFinishingTileDataLength(currentPlayerTypeTurn)}, playerPawn.CurrentTileIndex: {availPlayers[i].CurrentTileIndex}");
+                    Debug.Log($"diceRolledValue: {diceRolledValue}, FinishingDataLen: {TilesManager.GetFinishingTileDataLength(currentPlayerTypeTurn)}, playerPawn.CurrentTileIndex: {availPlayers[i].CurrentTileIndex}");
-                    if (diceRolledValue <= tilesManager.GetFinishingTileDataLength(currentPlayerTypeTurn) - (availPlayers[i].CurrentTileIndex + 1))
+                    if (diceRolledValue <= TilesManager.GetFinishingTileDataLength(currentPlayerTypeTurn) - (availPlayers[i].CurrentTileIndex + 1))
                     {
                         availPlayers[i].SetPlayerSelectionState(true);
                     }
@@ -628,11 +631,11 @@ public class GameplayManager : MonoBehaviour, IBase, IBootLoader, IDataLoader
 
         if (selectedPawn.GetPlayerState() == PlayerState.InHome)
         {
-            Tile targetTile = tilesManager.RetrieveTileBasedOnIndex(playerGameData.startIndex);
+            Tile targetTile = TilesManager.RetrieveTileBasedOnIndex(playerGameData.startIndex);
 
             selectedPawn.ShowPlayerCountCanvas(false);
             selectedPawn.MoveToTile(
-                GetAndInitPositionInsideSafeZone(selectedPawn, targetTile),
+                TilesManager.GetAndInitPositionInsideSafeZone(selectedPawn, targetTile, currentPlayerTypeTurn),
                 onComplete: () =>
                 {
                     playerGameDatasDict[playerGameData.playerType].totalPawnsInHome--;
@@ -654,7 +657,7 @@ public class GameplayManager : MonoBehaviour, IBase, IBootLoader, IDataLoader
         }
         else if (selectedPawn.GetPlayerState() == PlayerState.InFinishingPath)
         {
-            Tile currentSittingTile = tilesManager.RetrieveFinishingTileBasedOnIndex(selectedPawn.PlayerType, selectedPawn.CurrentTileIndex);
+            Tile currentSittingTile = TilesManager.RetrieveFinishingTileBasedOnIndex(selectedPawn.PlayerType, selectedPawn.CurrentTileIndex);
             currentSittingTile.ResetPlayerPawn(selectedPawn);
 
             if (currentSittingTile.HasPawnsAvailable)
@@ -668,20 +671,20 @@ public class GameplayManager : MonoBehaviour, IBase, IBootLoader, IDataLoader
         }
         else if (selectedPawn.CurrentTileIndex == playerGameDatasDict[currentPlayerTypeTurn].endIndex)
         {
-            tilesManager.RetrieveTileBasedOnIndex(selectedPawn.CurrentTileIndex).ResetPlayerPawn(selectedPawn);
+            TilesManager.RetrieveTileBasedOnIndex(selectedPawn.CurrentTileIndex).ResetPlayerPawn(selectedPawn);
             ApplyFinishingPathLogic(selectedPawn);
         }
         else if (selectedPawn.GetPlayerState() == PlayerState.InSafeZone || selectedPawn.GetPlayerState() == PlayerState.Moving)
         {
             // move based on the dice value
             Debug.Log($"Tile Index :: currentTileIndex: {selectedPawn.CurrentTileIndex}");
-            int nextTileIdx = GetNextGeneralTileIndex(selectedPawn);
+            int nextTileIdx = TilesManager.GetNextGeneralTileIndex(selectedPawn.CurrentTileIndex);
             int targetIdx = selectedPawn.CurrentTileIndex + diceRolledValue;
 
             if (nextTileIdx == 0)
                 targetIdx = (targetIdx - selectedPawn.CurrentTileIndex) - 1;
 
-            Tile currentSittingTile = tilesManager.RetrieveTileBasedOnIndex(selectedPawn.CurrentTileIndex);
+            Tile currentSittingTile = TilesManager.RetrieveTileBasedOnIndex(selectedPawn.CurrentTileIndex);
             if (currentSittingTile.IsSafeZone)
             {
                 SafeTile safeTile = (SafeTile)currentSittingTile;
@@ -722,9 +725,9 @@ public class GameplayManager : MonoBehaviour, IBase, IBootLoader, IDataLoader
 
     private void ApplyFinishingPathLogic(PlayerPawn playerPawn)
     {
-        int finishingPathIndex = GetNextFinishingTileIndex(playerPawn);
+        int finishingPathIndex = TilesManager.GetNextFinishingTileIndex(playerPawn.CurrentTileIndex, playerPawn.PlayerType);
-        int targetIdx = finishingPathIndex + diceRolledValue > tilesManager.GetFinishingTileDataLength(currentPlayerTypeTurn) - 1 ?
+        int targetIdx = finishingPathIndex + diceRolledValue > TilesManager.GetFinishingTileDataLength(currentPlayerTypeTurn) - 1 ?
-                            tilesManager.GetFinishingTileDataLength(currentPlayerTypeTurn) - 1 : finishingPathIndex + diceRolledValue;
+                            TilesManager.GetFinishingTileDataLength(currentPlayerTypeTurn) - 1 : finishingPathIndex + diceRolledValue;
 
         Debug.Log($"TargetIdx: {targetIdx}, finishingPathIndex: {finishingPathIndex}");
 
@@ -732,22 +735,14 @@ public class GameplayManager : MonoBehaviour, IBase, IBootLoader, IDataLoader
         MoveThroughFinishingPath(playerPawn, finishingPathIndex, targetIdx);
     }
 
-
+    // TODO :: move to tiles manager
-    public int GetNextGeneralTileIndex(PlayerPawn playerPawn)
+    
-    {
-        return playerPawn.CurrentTileIndex == tilesManager.GetGeneralTilesLength() - 1 ? 0 : playerPawn.CurrentTileIndex + 1;
-    }
-
-    private int GetNextFinishingTileIndex(PlayerPawn playerPawn)
-    {
-        return playerPawn.CurrentTileIndex > tilesManager.GetFinishingTileDataLength(currentPlayerTypeTurn) - 1 ? 0 : playerPawn.CurrentTileIndex + 1;
-    }
 
     private void SwitchPlayer(PlayerPawn playerPawn = null)
     {
         Debug.Log($"CallTest: SwitchPlayer");
         if (playerPawn)
-            UpdatePlayerState(playerPawn, tilesManager.RetrieveTileBasedOnIndex(playerPawn.CurrentTileIndex).IsSafeZone ? PlayerState.InSafeZone : PlayerState.Moving);
+            UpdatePlayerState(playerPawn, TilesManager.RetrieveTileBasedOnIndex(playerPawn.CurrentTileIndex).IsSafeZone ? PlayerState.InSafeZone : PlayerState.Moving);
 
         if (!CanRollDiceAgain)
         {
@@ -759,7 +754,7 @@ public class GameplayManager : MonoBehaviour, IBase, IBootLoader, IDataLoader
             UpdateActivePlayersAndSetDisplay(false);
             Debug.Log($"after SwitchPlayer availPlayers: {availPlayers.Count}, playerPawn: {playerPawn}");
 
-            if (allPlayerTypes.Count == 1)
+            if (allPlayerTypes.Count == 0)
             {
                 Debug.LogError($"GAME IS OVER");
                 return;
@@ -788,10 +783,12 @@ public class GameplayManager : MonoBehaviour, IBase, IBootLoader, IDataLoader
         
         Debug.Log($"CurrentPlayerTurn: {currentPlayerTypeTurn}");
         SetCanRollDiceForUser(gameModeHandler.CurrentGameModeType != GameModeType.Bot || !botTypesInGame.Contains(currentPlayerTypeTurn));    
-        SetCurrentSelectedPointer();
 
+#if UNITY_EDITOR
+        SetCurrentSelectedPointer();
         pointerMeshRend.material = turnMat;
         // pointerMeshRend.materials[0] = turnMat;
+#endif
 
         // Debug.Log($"botTypesInGame.Contains(currentPlayerTypeTurn): {botTypesInGame.Contains(currentPlayerTypeTurn)}");
 
@@ -802,11 +799,13 @@ public class GameplayManager : MonoBehaviour, IBase, IBootLoader, IDataLoader
         }
     }
 
+#if UNITY_EDITOR
     private void SetCurrentSelectedPointer()
     {
         var tempPos = playerBaseHandler.GetPlayerBase(currentPlayerTypeTurn).transform.position;
         pointerDebug.position = new Vector3(tempPos.x, 3f, tempPos.z);
     }
+#endif
 
     public void SetDisplayCountForAllAvailPlayers(bool state)
     {
@@ -822,17 +821,17 @@ public class GameplayManager : MonoBehaviour, IBase, IBootLoader, IDataLoader
 
     private void MoveThroughTiles(PlayerPawn playerPawn, int index, int targetIndex)
     {
-        Tile nextTile = tilesManager.RetrieveTileBasedOnIndex(index);
+        Tile nextTile = TilesManager.RetrieveTileBasedOnIndex(index);
         Vector3 targetPosition = nextTile.CenterPlacementPosition;
 
         Debug.Log($"Tile Index :: nextIndex: {index}, targetIndex: {targetIndex}, nextTileName: {nextTile.name}");
 
         if (index == targetIndex) // if the target index is the safe zone only then apply the logic for rearranging pawns
         {
-            Tile targetTile = tilesManager.RetrieveTileBasedOnIndex(targetIndex);
+            Tile targetTile = TilesManager.RetrieveTileBasedOnIndex(targetIndex);
             if (targetTile.IsSafeZone)
             {
-                targetPosition = GetAndInitPositionInsideSafeZone(playerPawn, targetTile);
+                targetPosition = TilesManager.GetAndInitPositionInsideSafeZone(playerPawn, targetTile, currentPlayerTypeTurn);
             }
         }
 
@@ -847,7 +846,7 @@ public class GameplayManager : MonoBehaviour, IBase, IBootLoader, IDataLoader
                 Debug.Log($"DiceRolledValue: {diceRolledValue}");
                 if (diceRolledValue > 0)
                 {
-                    int nextTileIndex = GetNextGeneralTileIndex(playerPawn);
+                    int nextTileIndex = TilesManager.GetNextGeneralTileIndex(playerPawn.CurrentTileIndex);
                     Debug.Log($"currentTileIndex: {playerPawn.CurrentTileIndex}, nextTileIndex: {nextTileIndex}, targetIndex: {targetIndex}");
 
                     if (playerPawn.GetPlayerState() == PlayerState.InFinishingPath || index == playerGameDatasDict[currentPlayerTypeTurn].endIndex)
@@ -925,69 +924,12 @@ public class GameplayManager : MonoBehaviour, IBase, IBootLoader, IDataLoader
             index);
     }
 
-    private Vector3 GetAndInitPositionInsideSafeZone(PlayerPawn playerPawn, Tile targetTile)
-    {
-        Vector3 targetPosition;
-        SafeTile targetSafeTile = (SafeTile)targetTile;
-        Debug.Log($"targetSafeTile.PlayerTypesCount: {targetSafeTile.PlayerTypesCount}");
-        if (targetSafeTile.PlayerTypesCount == 1)
-        {
-            Debug.Log($"targetSafeTile.ContainsPlayerType(currentPlayerTypeTurn): {targetSafeTile.ContainsPlayerType(currentPlayerTypeTurn)}");
-            if (!targetSafeTile.ContainsPlayerType(currentPlayerTypeTurn)) // means it is a new player type, the second one
-            {
-                PlayerType initialPlayerType = targetSafeTile.GetFirstPlayerType();
-
-                // rearrange already existing player from center position to it's saved transform
-                var playerPawns = targetSafeTile.GetPlayerPawns(initialPlayerType);
-                foreach (var pawn in playerPawns)
-                {
-                    var placementPoint = targetSafeTile.GetPlacementPoint(initialPlayerType);
-                    pawn.MoveToCustomTilePosition(placementPoint.position);
-                }
-
-                targetSafeTile.InitPlayerPawn(playerPawn, currentPlayerTypeTurn);
-                targetPosition = targetSafeTile.GetPlacementPoint(currentPlayerTypeTurn).position;
-            }
-            else
-            {
-                targetSafeTile.InitPlayerPawn(playerPawn, currentPlayerTypeTurn);
-                targetPosition = targetTile.CenterPlacementPosition;
-            }
-        }
-        else
-        {
-            // TODO :: Check the data if it's consistent
-            Debug.Log($"targetSafeTile.ContainsPlayerType(currentPlayerTypeTurn): {targetSafeTile.ContainsPlayerType(currentPlayerTypeTurn)}");
-            if (!targetSafeTile.ContainsPlayerType(currentPlayerTypeTurn))
-            {
-                Debug.Log($"targetSafeTile.PlayerTypesCount: {targetSafeTile.PlayerTypesCount}");
-                if (targetSafeTile.PlayerTypesCount < 1) // he is the only player that is being added to the safe zone
-                {
-                    targetSafeTile.InitPlayerPawn(playerPawn, currentPlayerTypeTurn);
-                    targetPosition = targetTile.CenterPlacementPosition;
-                }
-                else
-                {
-                    targetSafeTile.InitPlayerPawn(playerPawn, currentPlayerTypeTurn);
-                    targetPosition = targetSafeTile.GetPlacementPoint(currentPlayerTypeTurn).position;
-                }
-            }
-            else
-            {
-                targetSafeTile.InitPlayerPawn(playerPawn, currentPlayerTypeTurn);
-                targetPosition = targetSafeTile.GetPlacementPoint(currentPlayerTypeTurn).position;
-            }
-        }
-
-        return targetPosition;
-    }
-
     private void MoveThroughFinishingPath(PlayerPawn playerPawn, int index, int targetIndex)
     {
         UpdatePlayerState(playerPawn, PlayerState.InFinishingPath);
 
         playerPawn.MoveToTile(
-            tilesManager.RetrieveFinishingTileBasedOnIndex(currentPlayerTypeTurn, index).transform.position,
+            TilesManager.RetrieveFinishingTileBasedOnIndex(currentPlayerTypeTurn, index).transform.position,
             onComplete: () =>
             {
                 diceRolledValue--;
@@ -995,7 +937,7 @@ public class GameplayManager : MonoBehaviour, IBase, IBootLoader, IDataLoader
                 Debug.Log($"DiceRolledValue: {diceRolledValue}");
                 if (diceRolledValue > 0)
                 {
-                    int tileIndex = GetNextFinishingTileIndex(playerPawn);
+                    int tileIndex = TilesManager.GetNextFinishingTileIndex(playerPawn.CurrentTileIndex, playerPawn.PlayerType);
                     Debug.Log($"tileIndex: {tileIndex}, targetIndex: {targetIndex}");
                     if (tileIndex <= targetIndex)
                     {
@@ -1005,9 +947,9 @@ public class GameplayManager : MonoBehaviour, IBase, IBootLoader, IDataLoader
                 }
                 else
                 {
-                    if (playerPawn.CurrentTileIndex == tilesManager.GetFinishingTileDataLength(currentPlayerTypeTurn) - 1)
+                    if (playerPawn.CurrentTileIndex == TilesManager.GetFinishingTileDataLength(currentPlayerTypeTurn) - 1)
                     {
-                        Tile tile = tilesManager.RetrieveFinishingTileBasedOnIndex(playerPawn.PlayerType, playerPawn.CurrentTileIndex);
+                        Tile tile = TilesManager.RetrieveFinishingTileBasedOnIndex(playerPawn.PlayerType, playerPawn.CurrentTileIndex);
                         tile.InitPlayerPawn(playerPawn, playerPawn.PlayerType);
                         ShowUpdatedPlayerCountOnTile(playerPawn);
                         
@@ -1052,7 +994,7 @@ public class GameplayManager : MonoBehaviour, IBase, IBootLoader, IDataLoader
                     else
                     {
                         // activate here
-                        tilesManager.RetrieveFinishingTileBasedOnIndex(currentPlayerTypeTurn, playerPawn.CurrentTileIndex).InitPlayerPawn(playerPawn, currentPlayerTypeTurn);
+                        TilesManager.RetrieveFinishingTileBasedOnIndex(currentPlayerTypeTurn, playerPawn.CurrentTileIndex).InitPlayerPawn(playerPawn, currentPlayerTypeTurn);
 
                         if (CheckForMaxDiceRollAttempt())
                         {
@@ -1078,8 +1020,8 @@ public class GameplayManager : MonoBehaviour, IBase, IBootLoader, IDataLoader
     private void ShowUpdatedPlayerCountOnTile(PlayerPawn playerPawn)
     {
         Tile tile = playerPawn.GetPlayerState() == PlayerState.InFinishingPath ? 
-                            tilesManager.RetrieveFinishingTileBasedOnIndex(playerPawn.PlayerType, playerPawn.CurrentTileIndex) 
+                            TilesManager.RetrieveFinishingTileBasedOnIndex(playerPawn.PlayerType, playerPawn.CurrentTileIndex) 
-                            : tilesManager.RetrieveTileBasedOnIndex(playerPawn.CurrentTileIndex);
+                            : TilesManager.RetrieveTileBasedOnIndex(playerPawn.CurrentTileIndex);
 
         playerPawn.ShowPlayerCountCanvas(true);
 
@@ -1108,7 +1050,7 @@ public class GameplayManager : MonoBehaviour, IBase, IBootLoader, IDataLoader
             {
                 if (pawn.GetPlayerState() == PlayerState.InHome) continue;
                 
-                tilesManager.ResetTileData(pawn.PlayerType, pawn.CurrentTileIndex, pawn.GetPlayerState());
+                TilesManager.ResetTileData(pawn.PlayerType, pawn.CurrentTileIndex, pawn.GetPlayerState());
             }
         }
     }

Assets/Scripts/Gameplay/Player/PlayerPawn.cs

@@ -106,7 +106,7 @@ public class PlayerPawn : MonoBehaviour
                 }
                 else
                 {
-                    int nextIndex = gameplayManager.GetNextGeneralTileIndex(this);
+                    int nextIndex = gameplayManager.TilesManager.GetNextGeneralTileIndex(CurrentTileIndex);
                     Debug.Log($"nextIndex :: {nextIndex}, currentIndex: {CurrentTileIndex}");
                     lookDirection = tilesManager.RetrieveTileBasedOnIndex(nextIndex).transform.position - transform.position;
                 }

Assets/Scripts/Tile/TilesManager.cs

@@ -62,6 +62,16 @@ public class TilesManager : MonoBehaviour, IBootLoader, IDataLoader, IBase
         return finishingTileDataPairs[playerType][index];
     }
 
+    public int GetNextGeneralTileIndex(int currentTileIndex)
+    {
+        return currentTileIndex == GetGeneralTilesLength() - 1 ? 0 : currentTileIndex + 1;
+    }
+
+    public int GetNextFinishingTileIndex(int currentTileIndex, PlayerType currentPlayerTypeTurn)
+    {
+        return currentTileIndex > GetFinishingTileDataLength(currentPlayerTypeTurn) - 1 ? 0 : currentTileIndex + 1;
+    }
+
     public void ResetData()
     {
         finishingTileDataPairs.Clear();
@@ -85,4 +95,61 @@ public class TilesManager : MonoBehaviour, IBootLoader, IDataLoader, IBase
             tile.ResetTileData();
         }
     }
+
+    public Vector3 GetAndInitPositionInsideSafeZone(PlayerPawn playerPawn, Tile targetTile, PlayerType currentPlayerTypeTurn)
+    {
+        Vector3 targetPosition;
+        SafeTile targetSafeTile = (SafeTile)targetTile;
+        Debug.Log($"targetSafeTile.PlayerTypesCount: {targetSafeTile.PlayerTypesCount}");
+        if (targetSafeTile.PlayerTypesCount == 1)
+        {
+            Debug.Log($"targetSafeTile.ContainsPlayerType(currentPlayerTypeTurn): {targetSafeTile.ContainsPlayerType(currentPlayerTypeTurn)}");
+            if (!targetSafeTile.ContainsPlayerType(currentPlayerTypeTurn)) // means it is a new player type, the second one
+            {
+                PlayerType initialPlayerType = targetSafeTile.GetFirstPlayerType();
+
+                // rearrange already existing player from center position to it's saved transform
+                var playerPawns = targetSafeTile.GetPlayerPawns(initialPlayerType);
+                foreach (var pawn in playerPawns)
+                {
+                    var placementPoint = targetSafeTile.GetPlacementPoint(initialPlayerType);
+                    pawn.MoveToCustomTilePosition(placementPoint.position);
+                }
+
+                targetSafeTile.InitPlayerPawn(playerPawn, currentPlayerTypeTurn);
+                targetPosition = targetSafeTile.GetPlacementPoint(currentPlayerTypeTurn).position;
+            }
+            else
+            {
+                targetSafeTile.InitPlayerPawn(playerPawn, currentPlayerTypeTurn);
+                targetPosition = targetTile.CenterPlacementPosition;
+            }
+        }
+        else
+        {
+            // TODO :: Check the data if it's consistent
+            Debug.Log($"targetSafeTile.ContainsPlayerType(currentPlayerTypeTurn): {targetSafeTile.ContainsPlayerType(currentPlayerTypeTurn)}");
+            if (!targetSafeTile.ContainsPlayerType(currentPlayerTypeTurn))
+            {
+                Debug.Log($"targetSafeTile.PlayerTypesCount: {targetSafeTile.PlayerTypesCount}");
+                if (targetSafeTile.PlayerTypesCount < 1) // he is the only player that is being added to the safe zone
+                {
+                    targetSafeTile.InitPlayerPawn(playerPawn, currentPlayerTypeTurn);
+                    targetPosition = targetTile.CenterPlacementPosition;
+                }
+                else
+                {
+                    targetSafeTile.InitPlayerPawn(playerPawn, currentPlayerTypeTurn);
+                    targetPosition = targetSafeTile.GetPlacementPoint(currentPlayerTypeTurn).position;
+                }
+            }
+            else
+            {
+                targetSafeTile.InitPlayerPawn(playerPawn, currentPlayerTypeTurn);
+                targetPosition = targetSafeTile.GetPlacementPoint(currentPlayerTypeTurn).position;
+            }
+        }
+
+        return targetPosition;
+    }
 }