Merge branch 'develop' into Warning-Removal-Experimental-and-Animations

Assets/Scripts/CardEffect/BT7/White/BT7_112.cs

@@ -62,7 +62,8 @@ public class BT7_112 : CEntity_Effect
 
             bool PermanentCondition(Permanent targetPermanent)
             {
-                return targetPermanent.IsTamer;
+                return CardEffectCommons.IsPermanentExistsOnOwnerBattleArea(targetPermanent, card)
+                    && (targetPermanent.IsDigimon || targetPermanent.IsTamer);//Latest ruling is can return cards even when digivolving over level 6
             }
 
             bool CanSelectCardCondition(CardSource cardSource)
@@ -102,6 +103,30 @@ public class BT7_112 : CEntity_Effect
 
             IEnumerator ActivateCoroutine(Hashtable _hashtable)
             {
+                List<Permanent> permanents = CardEffectCommons.GetPermanentsFromHashtable(_hashtable);
+                if (permanents != null)
+                {
+                    if (!permanents
+                        .Filter(permanent => permanent != null && permanent.TopCard != null)
+                        .Any(permanent => permanent.IsTamer))//If digivolution is not over a tamer, trashing is optional but allowed
+                    {
+                        string selectPlayerMessage = "Will you place 10 Tamer or Hybrid cards to bottom of deck?";
+                        string notSelectPlayerMessage = "The opponent is choosing if they will return cards to deck.";
+
+                        List<SelectionElement<bool>> command_SelectCommands = new List<SelectionElement<bool>>()
+                        {
+                            new SelectionElement<bool>(message: $"Yes", value: true, spriteIndex: 0),
+                            new SelectionElement<bool>(message: $"No", value: false, spriteIndex: 1),
+                        };
+
+                        GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: command_SelectCommands, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
+
+                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
+
+                        if (!GManager.instance.userSelectionManager.SelectedBoolValue)
+                            yield break;
+                    }
+                }
                 if (card.Owner.HandCards.Count(CanSelectCardCondition) + card.Owner.TrashCards.Count(CanSelectCardCondition) >= 10)
                 {
                     List<CardSource> libraryCards = new List<CardSource>();

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/SelectCardEffect.cs

@@ -573,7 +573,16 @@ public class SelectCardEffect : MonoBehaviourPunCallbacks
                         _slectedInexesInList.Add(selectedIndex);
                     }
 
-                    photonView.RPC("SetTargetCardAndIndicies", RpcTarget.All, _selectPlayer.PlayerID, targetCardIDs.ToArray(), _slectedInexesInList.ToArray());
+                    if (_isLocal)
+                    {
+                        SetTargetCardAndIndicies(_selectPlayer.PlayerID, targetCardIDs.ToArray(), _slectedInexesInList.ToArray());
+                    }
+                    else
+                    {
+                        photonView.RPC("SetTargetCardAndIndicies", RpcTarget.All, _selectPlayer.PlayerID, targetCardIDs.ToArray(), _slectedInexesInList.ToArray());
+                    }
+
+                   
                 }
             }
             else
@@ -639,7 +648,7 @@ public class SelectCardEffect : MonoBehaviourPunCallbacks
                             CardIDs.Add(cardSource.CardIndex);
                         }
 
-                        if (GManager.instance.IsAI)
+                        if (GManager.instance.IsAI || _isLocal)
                         {
                             SetTargetCardAndIndicies(_selectPlayer.PlayerID, CardIDs.ToArray(), null);
                         }

Assets/Scripts/Script/TurnStateMachine.cs

@@ -346,7 +346,6 @@ public class TurnStateMachine : MonoBehaviourPunCallbacks
     public bool DoneStartGame { get; set; } = false;
 
     bool _isRedraw = false;
-    bool _endSelect = false;
     IEnumerator StartGame()
     {
 #if UNITY_EDITOR
@@ -389,7 +388,6 @@ public class TurnStateMachine : MonoBehaviourPunCallbacks
         foreach (Player player in gameContext.Players_ForNonTurnPlayer)
         {
             _isRedraw = false;
-            _endSelect = false;
 
             yield return GManager.instance.photonWaitController.StartWait($"Mulligan");
 
@@ -402,7 +400,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
@@ -423,8 +421,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,
@@ -436,9 +434,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);
                     }
                 }
             }
@@ -455,13 +453,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();
 
@@ -529,10 +528,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
 
@@ -753,12 +758,12 @@ public class TurnStateMachine : MonoBehaviourPunCallbacks
 
                     if (ContinuousController.instance.autoHatch)
                     {
-                        OnClickHatchObject();
+                        SendShouldHatch(true);
                     }
 
                     else
                     {
-                        gameContext.TurnPlayer.SetUpHatchObject(OnClickHatchObject);
+                        gameContext.TurnPlayer.SetUpHatchObject(() => SendShouldHatch(true));
                     }
                 }
                 #endregion
@@ -773,7 +778,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();
                     }
@@ -800,14 +805,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;
@@ -854,19 +861,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
 
@@ -3470,27 +3482,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());

Assets/Scripts/Script/UserSelectionManager.cs

@@ -182,12 +182,12 @@ public class UserSelectionManager : MonoBehaviourPunCallbacks
 
                 if (canSelectValue.Count >= 1)
                 {
-                    SetBool(canSelectValue[UnityEngine.Random.Range(0, canSelectValue.Count)]);
+                    SetBool_RPC(selectPlayer.PlayerID, canSelectValue[UnityEngine.Random.Range(0, canSelectValue.Count)]);
                 }
 
                 else
                 {
-                    SetBool(false);
+                    SetBool_RPC(selectPlayer.PlayerID, false);
                 }
             }
             #endregion