Next Phase Button and Mulligan Changes

Assets/Scripts/Script/MainPhaseAction/PassAction.cs

@@ -0,0 +1,28 @@
+using ExitGames.Client.Photon;
+
+public class PassAction : MainPhaseAction
+{
+    
+    public PassAction()
+    {
+    }
+
+    public PassAction(byte[] bytes)
+    {
+        Deserialize(bytes);
+    }
+
+    public override void Execute(TurnStateMachine stateMachine)
+    {
+        stateMachine.PassTurn();
+    }
+
+    public override void Deserialize(byte[] bytes)
+    {
+    }
+
+    public override byte[] Serialize()
+    {
+        return null;
+    }
+}

Assets/Scripts/Script/Networking/GamePacketRegistration.cs

@@ -10,5 +10,6 @@ public static class PacketRegistration
         GamePacketFactory.Register((btyes) => new ActivatePermanentAction(btyes));
         GamePacketFactory.Register((btyes) => new CheatAction(btyes));
         GamePacketFactory.Register((btyes) => new PlayCardAction(btyes));
+        GamePacketFactory.Register((btyes) => new PassAction(btyes));
     }
 }

Assets/Scripts/Script/NextPhaseButton.cs

@@ -1,12 +1,13 @@
-using System.Collections;
-using System.Collections.Generic;
-using UnityEngine;
-using UnityEngine.UI;
-using UnityEngine.Events;
+using Photon;
 using Photon.Pun;
 using System;
-using Photon;
+using System.Collections;
+using System.Collections.Generic;
 using TMPro;
+using UnityEngine;
+using UnityEngine.Events;
+using UnityEngine.TextCore.Text;
+using UnityEngine.UI;
 
 public class NextPhaseButton : MonoBehaviourPunCallbacks
 {
@@ -40,14 +41,26 @@ public class NextPhaseButton : MonoBehaviourPunCallbacks
 
     public void OnClick()
     {
-        if (!GManager.instance.turnStateMachine.isSync && !GManager.instance.turnStateMachine.IsSelecting && !GManager.instance.turnStateMachine.isExecuting && !GManager.instance.turnStateMachine.isSecurityCehck)
+        TurnStateMachine turnStateMachine = GManager.instance.turnStateMachine;
+
+        if (!turnStateMachine.isSync && !turnStateMachine.IsSelecting && !turnStateMachine.isExecuting && !turnStateMachine.isSecurityCehck)
         {
-            if (GManager.instance.turnStateMachine.gameContext.TurnPlayer.isYou)
+            if (turnStateMachine.gameContext.TurnPlayer.isYou)
             {
-                if (GManager.instance.turnStateMachine.gameContext.TurnPhase == GameContext.phase.Breeding || GManager.instance.turnStateMachine.gameContext.TurnPhase == GameContext.phase.Main)
+                if (turnStateMachine.gameContext.TurnPhase == GameContext.phase.Breeding || turnStateMachine.gameContext.TurnPhase == GameContext.phase.Main)
                 {
                     GManager.instance.turnStateMachine.isSync = true;
-                    photonView.RPC("NextPhase", RpcTarget.All);
+
+                    switch (turnStateMachine.gameContext.TurnPhase)
+                    {
+                        case GameContext.phase.Breeding:
+                            turnStateMachine.SendShouldHatch(false);
+                            break;
+                        case GameContext.phase.Main:
+                            turnStateMachine.QueueMainPhaseAction(turnStateMachine.gameContext.TurnPlayer, new PassAction());
+                            break;
+                    }
+
                     StartCoroutine(CoverCoroutine(1.5f));
 
                     Button.interactable = false;
@@ -163,12 +176,6 @@ public class NextPhaseButton : MonoBehaviourPunCallbacks
         }
     }
 
-    [PunRPC]
-    public void NextPhase()
-    {
-        GManager.instance.turnStateMachine.NextPhase();
-    }
-
     public void SwitchTurnSprite()
     {
         if (GManager.instance.turnStateMachine.gameContext.TurnPlayer.isYou)

Assets/Scripts/Script/TurnStateMachine.cs

@@ -342,7 +342,6 @@ public class TurnStateMachine : MonoBehaviourPunCallbacks
     public bool DoneStartGame { get; set; } = false;
 
     bool _isRedraw = false;
-    bool _endSelect = false;
     IEnumerator StartGame()
     {
 #if UNITY_EDITOR
@@ -385,7 +384,6 @@ public class TurnStateMachine : MonoBehaviourPunCallbacks
         foreach (Player player in gameContext.Players_ForNonTurnPlayer)
         {
             _isRedraw = false;
-            _endSelect = false;
 
             yield return GManager.instance.photonWaitController.StartWait($"Mulligan");
 
@@ -398,7 +396,7 @@ public class TurnStateMachine : MonoBehaviourPunCallbacks
             {
                 if (GManager.instance.isAuto && GManager.instance.IsAI)
                 {
-                    SetRedraw(RandomUtility.IsSucceedProbability(0.5f));
+                    SetRedraw(player.PlayerID, RandomUtility.IsSucceedProbability(0.5f));
                 }
 
                 else
@@ -419,8 +417,8 @@ public class TurnStateMachine : MonoBehaviourPunCallbacks
                         Message: message,
                         NotSelectButtonMessage: "Keep Hand",
                         EndSelectButtonMessage: "Mulligan",
-                        _OnClickNotSelectButtonAction: () => SetRedraw_RPC(false),
-                        _OnClickEndSelectButtonAction: () => SetRedraw_RPC(true),
+                        _OnClickNotSelectButtonAction: () => SetRedraw_RPC(player.PlayerID, false),
+                        _OnClickEndSelectButtonAction: () => SetRedraw_RPC(player.PlayerID, true),
                         RootCardSources: player.HandCards,
                         _CanTargetCondition: (cardSource) => false,
                         _CanTargetCondition_ByPreSelecetedList: null,
@@ -432,9 +430,9 @@ public class TurnStateMachine : MonoBehaviourPunCallbacks
                         skillInfos: null,
                         root: SelectCardEffect.Root.None));
 
-                    void SetRedraw_RPC(bool _isDraw)
+                    void SetRedraw_RPC(int playerId, bool _isDraw)
                     {
-                        photonView.RPC("SetRedraw", RpcTarget.All, _isDraw);
+                        photonView.RPC("SetRedraw", RpcTarget.All, playerId, _isDraw);
                     }
                 }
             }
@@ -451,13 +449,14 @@ public class TurnStateMachine : MonoBehaviourPunCallbacks
                         doRedraw = true;
                     }
 
-                    SetRedraw(doRedraw);
+                    SetRedraw(player.PlayerID, doRedraw);
                 }
                 #endregion
             }
 
-            yield return new WaitWhile(() => !_endSelect);
-            _endSelect = false;
+            yield return new WaitUntil(() => player.HasPlayerSelection());
+            ValueSelection valueSeletion = player.DequeuePlayerSelection<ValueSelection>();
+            _isRedraw = valueSeletion != null ? valueSeletion.ValueAsBool() : false;
 
             GManager.instance.selectCardPanel.CloseSelectCardPanel();
 
@@ -525,10 +524,16 @@ public class TurnStateMachine : MonoBehaviourPunCallbacks
     }
 
     [PunRPC]
-    void SetRedraw(bool isRedraw)
+    void SetRedraw(int playerID, bool isRedraw)
     {
-        _isRedraw = isRedraw;
-        _endSelect = true;
+        Player selectionPlayer = GManager.instance.GetPlayerFromID(playerID);
+
+        if (selectionPlayer == null)
+        {
+            return;
+        }
+
+        selectionPlayer.QueuePlayerSelection(new ValueSelection(isRedraw));
     }
     #endregion
 
@@ -749,12 +754,12 @@ public class TurnStateMachine : MonoBehaviourPunCallbacks
 
                     if (ContinuousController.instance.autoHatch)
                     {
-                        OnClickHatchObject();
+                        SendShouldHatch(true);
                     }
 
                     else
                     {
-                        gameContext.TurnPlayer.SetUpHatchObject(OnClickHatchObject);
+                        gameContext.TurnPlayer.SetUpHatchObject(() => SendShouldHatch(true));
                     }
                 }
                 #endregion
@@ -769,7 +774,7 @@ public class TurnStateMachine : MonoBehaviourPunCallbacks
                     {
                         GManager.instance.hideCannotSelectObject.SetUpHideCannotSelectObject(new List<FieldPermanentCard>() { fieldPermanentCard }, false);
 
-                        fieldPermanentCard.AddClickTarget((fieldPermanentCard1) => OnClickHatchObject());
+                        fieldPermanentCard.AddClickTarget((fieldPermanentCard1) => SendShouldHatch(true));
                         fieldPermanentCard.Outline_Select.gameObject.SetActive(true);
                         fieldPermanentCard.SetOrangeOutline();
                     }
@@ -796,14 +801,16 @@ public class TurnStateMachine : MonoBehaviourPunCallbacks
                         doHatch = true;
                     }
 
-                    SetBreedingPhase(doHatch);
+                    SetBreedingPhase(gameContext.TurnPlayer.PlayerID, doHatch);
                 }
                 #endregion
             }
 
-            yield return new WaitWhile(() => !endSelect_BreedingPhase && gameContext.TurnPhase == GameContext.phase.Breeding);
+            yield return new WaitWhile(() => !gameContext.TurnPlayer.HasPlayerSelection() && gameContext.TurnPhase == GameContext.phase.Breeding);
+            ValueSelection breedSelection = gameContext.TurnPlayer.DequeuePlayerSelection<ValueSelection>();
+            doAction_BreedingPhase = breedSelection != null ? breedSelection.ValueAsBool() : false;
+
             GManager.instance.hideCannotSelectObject.Close();
-            endSelect_BreedingPhase = false;
             gameContext.TurnPlayer.OffHatchObject();
             OffFieldCardTarget(gameContext.TurnPlayer);
             IsSelecting = true;
@@ -850,19 +857,24 @@ public class TurnStateMachine : MonoBehaviourPunCallbacks
         }
     }
 
-    void OnClickHatchObject()
+    public void SendShouldHatch(bool shouldHatch)
     {
         gameContext.TurnPlayer.OffHatchObject();
-        photonView.RPC("SetBreedingPhase", RpcTarget.All, true);
+        photonView.RPC("SetBreedingPhase", RpcTarget.All, gameContext.TurnPlayer.PlayerID, shouldHatch);
     }
 
-    bool endSelect_BreedingPhase = false;
     bool doAction_BreedingPhase = false;
     [PunRPC]
-    public void SetBreedingPhase(bool doAction_BreedingPhase)
+    public void SetBreedingPhase(int playerID, bool doBreeding)
     {
-        this.doAction_BreedingPhase = doAction_BreedingPhase;
-        endSelect_BreedingPhase = true;
+        Player selectionPlayer = GManager.instance.GetPlayerFromID(playerID);
+
+        if (selectionPlayer == null)
+        {
+            return;
+        }
+
+        selectionPlayer.QueuePlayerSelection(new ValueSelection(doBreeding));
     }
     #endregion
 
@@ -3467,27 +3479,9 @@ public class TurnStateMachine : MonoBehaviourPunCallbacks
     #endregion
 
     #region Go to the next phase
-    [PunRPC]
-    public void NextPhase()
+    public void PassTurn()
     {
-        if (gameContext.TurnPhase != GameContext.phase.Main)
-        {
-            int CurrentPhaseID = (int)gameContext.TurnPhase;
-
-            int NextPhaseID = ++CurrentPhaseID;
-
-            int MaxPhaseCount = Enum.GetNames(typeof(GameContext.phase)).Length;
-
-            if (NextPhaseID >= MaxPhaseCount)
-            {
-                NextPhaseID = 0;
-            }
-
-            isSync = true;
-            gameContext.TurnPhase = (GameContext.phase)Enum.ToObject(typeof(GameContext.phase), NextPhaseID);
-        }
-
-        else
+        if (gameContext.TurnPhase == GameContext.phase.Main)
         {
             ResetUI();
             ContinuousController.instance.StartCoroutine(GManager.instance.autoProcessing.EndTurnProcess());