Merge branch 'Gameplay/main-gameplay' into Gameplay/ashby-gameplay

Fixes for selecting wrong player, switching player.

Assets/Scripts/Gameplay/GameplayManager.cs

@@ -99,6 +99,7 @@ public class GameplayManager : MonoBehaviour, IBase, IBootLoader, IDataLoader
     {
         // TODO :: 2P, 3P, 4P
         allPlayerTypes = new List<PlayerType> { PlayerType.Player1, PlayerType.Player2, PlayerType.Player3, PlayerType.Player4 };
+        // allPlayerTypes = new List<PlayerType> { PlayerType.Player1, PlayerType.Player3 };
 
         playerBaseHandler.InitPlayerTypes(allPlayerTypes);
         InitCurrentGamePlayerInfo();
@@ -258,7 +259,7 @@ public class GameplayManager : MonoBehaviour, IBase, IBootLoader, IDataLoader
     // What happens when you get a 6
     private void SelectPawnFromBotBase()
     {
-        if (availPlayers.Count() < 1 && !CanRollDiceAgain || !botTypesInGame.Contains(currentPlayerTypeTurn)) return; // Have a better check here
+        if (canSwitchPlayer || availPlayers.Count() < 1 && !CanRollDiceAgain || !botTypesInGame.Contains(currentPlayerTypeTurn)) return; // Have a better check here
 
         Debug.Log($"CallTest: SelectPawnFromBotBase: {currentPlayerTypeTurn}");
         var botPawnsDictForCurrentPlayer = botRuntimeMovementData[currentPlayerTypeTurn]; // set the data inside this dict
@@ -289,21 +290,22 @@ public class GameplayManager : MonoBehaviour, IBase, IBootLoader, IDataLoader
         }
         
         // TODO :: Double check
-        // foreach (var key in botPawnsDictForCurrentPlayer.Keys)
-        //     botPawnsDictForCurrentPlayer[key] = BotMove.NoMoves;
+        foreach (var key in botPawnsDictForCurrentPlayer.Keys)
+        {
+            Debug.Log($"b :: botPawnsDictForCurrentPlayer[key]: {botPawnsDictForCurrentPlayer[key]}");
+            // botPawnsDictForCurrentPlayer[key] = BotMove.NoMoves;
+            Debug.Log($"a :: botPawnsDictForCurrentPlayer[key]: {botPawnsDictForCurrentPlayer[key]}");
+        }
 
+
+        Debug.Log($"Before Iterating");
         foreach (var playerPawn in availPlayers)
         {
+            Debug.Log($"Iterating");
             var possibleLandingIndex = playerPawn.CurrentTileIndex + diceRolledValue;
 
-            if (playerPawn.GetPlayerState() == PlayerState.HasFinished)
-            {
-                botPawnsDictForCurrentPlayer.Remove(playerPawn.PlayerId); // TODO :: Double check logic
-                continue;
-            }
-
             int lastIndex = tilesManager.GetGeneralTilesLength() - 1;
-            int index = possibleLandingIndex > lastIndex ? (possibleLandingIndex - lastIndex) - 1 : possibleLandingIndex;
+            int index = possibleLandingIndex > lastIndex ? possibleLandingIndex - lastIndex - 1 : possibleLandingIndex;
             Tile possibleTileData = tilesManager.RetrieveTileBasedOnIndex(index);
 
             Debug.Log($"AI playerPawn :: {playerPawn.name} :: state: {playerPawn.GetPlayerState()}, possibleLandingIndex: {possibleLandingIndex > playerGameDatasDict[currentPlayerTypeTurn].endIndex}");
@@ -312,27 +314,40 @@ public class GameplayManager : MonoBehaviour, IBase, IBootLoader, IDataLoader
 
             if (playerPawn.GetPlayerState() == PlayerState.InFinishingPath || possibleLandingIndex > playerGameDatasDict[currentPlayerTypeTurn].endIndex)
             {
-                botPawnsDictForCurrentPlayer[playerPawn.PlayerId] = BotMove.FinishingPathMove;
-                savedPlayerId = playerPawn.PlayerId;
-                break;
+                Debug.Log($"AI playerPawn :: {playerPawn.name} :: {playerPawn.PlayerId} :: inFinishingPath :: canSelectPlayer: {playerPawn.CanSelectPlayer}");
+                if (playerPawn.CanSelectPlayer)
+                {
+                    botPawnsDictForCurrentPlayer[playerPawn.PlayerId] = BotMove.FinishingPathMove;
+                    savedPlayerId = playerPawn.PlayerId;
+                    break;
+                }
+                else
+                {
+                    botPawnsDictForCurrentPlayer[playerPawn.PlayerId] = BotMove.NoMoves;
+                }
             }
-            else if (possibleTileData.IsSafeZone || playerPawn.GetPlayerState() == PlayerState.InHome)
+            else if (possibleTileData.IsSafeZone)
             {
+                Debug.Log($"AI playerPawn :: {playerPawn.name} :: {playerPawn.PlayerId} :: safeMove");
                 botPawnsDictForCurrentPlayer[playerPawn.PlayerId] = BotMove.SafeMove;
             }
             else if (possibleTileData.PlayerPawn != null)
             {
+                Debug.Log($"AI playerPawn :: {playerPawn.name} :: {playerPawn.PlayerId} :: attackMove");
                 botPawnsDictForCurrentPlayer[playerPawn.PlayerId] = BotMove.AttackMove;
             }
             else
             {
-                Debug.Log($"AI playerPawn :: {playerPawn.name} :: normalMove");
+                Debug.Log($"AI playerPawn :: {playerPawn.name} :: {playerPawn.PlayerId} :: normalMove");
                 botPawnsDictForCurrentPlayer[playerPawn.PlayerId] = BotMove.NormalMove;
             }
         }
 
         List<int> playerIds = new List<int>();
-        if (savedPlayerId != -1 && playerGameDatasDict[currentPlayerTypeTurn].playerPawnsDict[savedPlayerId].CanSelectPlayerFromHome)
+
+        if (savedPlayerId != -1)
+            Debug.Log($"SavedPlayerId: {savedPlayerId}, CanSelectPlayer: {playerGameDatasDict[currentPlayerTypeTurn].playerPawnsDict[savedPlayerId].CanSelectPlayer}");
+        if (savedPlayerId != -1 && playerGameDatasDict[currentPlayerTypeTurn].playerPawnsDict[savedPlayerId].CanSelectPlayer)
         {
             pawn = playerGameDatasDict[currentPlayerTypeTurn].playerPawnsDict[savedPlayerId]; // chances are when one of the character reaches towards the finishing point
         }
@@ -412,13 +427,25 @@ public class GameplayManager : MonoBehaviour, IBase, IBootLoader, IDataLoader
             canSwitchPlayer = false;
             // provide option to select a pawn from the list
             // also play a simple animation before selecting
-            EnablePlayerSelectionStates(true);
             CanRollDiceAgain = true;
+            pointerMeshRend.material = selectMat;
 
+            foreach (var playerPawn in playerGameDatasDict[currentPlayerTypeTurn].playerPawnsDict)
+                if (playerPawn.Value.GetPlayerState() == PlayerState.InFinishingPath)
+                    playerPawn.Value.SetPlayerSelectionState(false);
+
+            Debug.Log($"### AreAllPawnsInFinishingPath");
             if (AreAllPawnsInFinishingPath())
+            {
                 CanRollDice = true;
 
-            pointerMeshRend.material = selectMat;
+                return;
+            }
+
+            Debug.Log($"### EnablePlayerSelectionStates");
+
+            EnablePlayerSelectionStates(true);
+
             // pointerMeshRend.materials[0] = selectMat;
         }
         else // if there are any other pawns that are in safe or moving state
@@ -426,31 +453,36 @@ public class GameplayManager : MonoBehaviour, IBase, IBootLoader, IDataLoader
             // for player's logic
             InitActivePlayers();
 
-            Debug.Log($"availPlayers: {playerGameDatasDict[currentPlayerTypeTurn].playerPawnsDict.Values.Select(pawn => pawn).Where(pawn => pawn.GetPlayerState() == PlayerState.InHome).ToList().Count}");
             int customAvailPlayers = availPlayers.Count();
             Debug.Log($"before CustomAvailablePlayers: {customAvailPlayers}");
+            List<int> indexesToRemove = new List<int>();
 
-            foreach (PlayerPawn playerPawn in availPlayers)
+            for (int i = 0; i < availPlayers.Count; i++)
             {
-                Debug.Log($"## playerPawn.GetPlayerState(): {playerPawn.GetPlayerState()}");
-                if (playerPawn.GetPlayerState() == PlayerState.InFinishingPath)
+                Debug.Log($"## playerPawn.GetPlayerState(): {availPlayers[i].GetPlayerState()}");
+
+                if (availPlayers[i].GetPlayerState() == PlayerState.InFinishingPath)
                 {
-                    Debug.Log($"diceRolledValue: {diceRolledValue}, FinishingDataLen: {tilesManager.GetFinishingTileDataLength(currentPlayerTypeTurn)}, playerPawn.CurrentTileIndex: {playerPawn.CurrentTileIndex}");
-                    if (diceRolledValue <= tilesManager.GetFinishingTileDataLength(currentPlayerTypeTurn) - (playerPawn.CurrentTileIndex + 1))
+                    Debug.Log($"diceRolledValue: {diceRolledValue}, FinishingDataLen: {tilesManager.GetFinishingTileDataLength(currentPlayerTypeTurn)}, playerPawn.CurrentTileIndex: {availPlayers[i].CurrentTileIndex}");
+                    if (diceRolledValue <= tilesManager.GetFinishingTileDataLength(currentPlayerTypeTurn) - (availPlayers[i].CurrentTileIndex + 1))
                     {
-                        playerPawn.SetPlayerSelectionState(true);
+                        availPlayers[i].SetPlayerSelectionState(true);
                     }
                     else
                     {
+                        indexesToRemove.Add(i);
+                        availPlayers[i].SetPlayerSelectionState(false);
                         customAvailPlayers--;
                     }
 
                     continue;
                 }
 
-                playerPawn.SetPlayerSelectionState(true);
+                availPlayers[i].SetPlayerSelectionState(true);
             }
 
+            foreach (int i in indexesToRemove) availPlayers.RemoveAt(i);
+
             // if (availPlayers.Count() < 1)
             Debug.Log($"CustomAvailablePlayers: {customAvailPlayers}");
             canSwitchPlayer = customAvailPlayers < 1;
@@ -473,7 +505,9 @@ public class GameplayManager : MonoBehaviour, IBase, IBootLoader, IDataLoader
         bool areAllPawnsInFinishingPath = false;
         foreach (var pawn in playerGameDatasDict[currentPlayerTypeTurn].playerPawnsDict)
         {
-            if (pawn.Value.GetPlayerState() == PlayerState.InFinishingPath && pawn.Value.GetPlayerState() != PlayerState.HasFinished)
+            if (pawn.Value.GetPlayerState() == PlayerState.HasFinished) continue;
+
+            if (pawn.Value.GetPlayerState() == PlayerState.InFinishingPath)
             {
                 areAllPawnsInFinishingPath = true;
                 continue;

Assets/Scripts/Gameplay/Player/PlayerPawn.cs

@@ -22,10 +22,11 @@ public class PlayerPawn : MonoBehaviour
     [SerializeField] private PlayerState playerState;
     [SerializeField] private Animator animator;
 
-    public bool CanSelectPlayerFromHome
+    public bool CanSelectPlayer
     {
         get; private set;
     }
+
     private GameplayManager gameplayManager;
 
     public int CurrentTileIndex
@@ -60,8 +61,8 @@ public class PlayerPawn : MonoBehaviour
 
     public void SetPlayerSelectionState(bool state)
     {
-        CanSelectPlayerFromHome = state;
-        if (CanSelectPlayerFromHome)
+        CanSelectPlayer = state;
+        if (CanSelectPlayer)
         {
             // TODO :: Play animation for selecting any of the players
         }
@@ -112,7 +113,7 @@ public class PlayerPawn : MonoBehaviour
 
     private void OnMouseDown()
     {
-        if (IsBotPlayer || !CanSelectPlayerFromHome) return;
+        if (IsBotPlayer || !CanSelectPlayer) return;
 
         SetGameplayManager();
         gameplayManager.OnPawnSelected(this);