Merge pull request #622 from BennAbbot/removed-rpc-from-old-selection-effects

Removed RPCs from Select Command Effects

Assets/Scripts/CardEffect/BT10/Green/BT10_090.cs

@@ -84,46 +84,29 @@ namespace DCGO.CardEffects.BT10
                     {
                         if (card.Owner.GetBattleAreaPermanents().Count(CanSelectPermanentCondition) >= 1 && card.Owner.HandCards.Count(CanSelectCardCondition) >= 1)
                         {
-                            if (card.Owner.isYou)
-                            {
-                                GManager.instance.commandText.OpenCommandText("From which area do you play a card?");
-
-                                List<Command_SelectCommand> command_SelectCommands = new List<Command_SelectCommand>()
-                                {
-                                    new Command_SelectCommand($"Under Tamer", () => photonView.RPC("SetFromHand", RpcTarget.All, false), 0),
-                                    new Command_SelectCommand($"From hand", () => photonView.RPC("SetFromHand", RpcTarget.All, true), 1),
-                                };
+                            string selectPlayerMessage = "From which area do you play a card?";
+                            string notSelectPlayerMessage = "The opponent is choosing from which area to play a card.";
 
-                                GManager.instance.selectCommandPanel.SetUpCommandButton(command_SelectCommands);
-                            }
-                            else
+                            List<SelectionElement<bool>> command_SelectCommands = new List<SelectionElement<bool>>()
                             {
-                                GManager.instance.commandText.OpenCommandText("The opponent is choosing from which area to play a card.");
+                                new SelectionElement<bool>(message: $"Under Tamer", value: false, spriteIndex: 0),
+                                new SelectionElement<bool>(message: $"From hand", value: false, spriteIndex: 1),
+                            };
 
-                                #region AIƒ‚�[ƒh
-
-                                if (GManager.instance.IsAI)
-                                {
-                                    SetFromHand(RandomUtility.IsSucceedProbability(0.5f));
-                                }
-
-                                #endregion
-                            }
+                            GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: command_SelectCommands, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
                         }
                         else if (card.Owner.GetBattleAreaPermanents().Count(CanSelectPermanentCondition) == 0 && card.Owner.HandCards.Count(CanSelectCardCondition) >= 1)
                         {
-                            SetFromHand(true);
+                            GManager.instance.userSelectionManager.SetBool(true);
                         }
                         else if (card.Owner.GetBattleAreaPermanents().Count(CanSelectPermanentCondition) >= 1 && card.Owner.HandCards.Count(CanSelectCardCondition) == 0)
                         {
-                            SetFromHand(false);
+                            GManager.instance.userSelectionManager.SetBool(false);
                         }
 
-                        yield return new WaitWhile(() => !endSelect);
-                        endSelect = false;
+                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
 
-                        GManager.instance.commandText.CloseCommandText();
-                        yield return new WaitWhile(() => GManager.instance.commandText.gameObject.activeSelf);
+                        bool fromHand = GManager.instance.userSelectionManager.SelectedBoolValue;
 
                         if (fromHand)
                         {
@@ -328,15 +311,5 @@ namespace DCGO.CardEffects.BT10
 
             return cardEffects;
         }
-
-        bool endSelect = false;
-        bool fromHand = false;
-
-        [PunRPC]
-        public void SetFromHand(bool fromHand)
-        {
-            this.fromHand = fromHand;
-            endSelect = true;
-        }
     }
 }

Assets/Scripts/CardEffect/BT10/Red/BT10_095.cs

@@ -106,87 +106,34 @@ namespace DCGO.CardEffects.BT10
                         {
                             yield return GManager.instance.photonWaitController.StartWait("FlyingHero_selectFirst");
 
-                            if (card.Owner.isYou)
+                            if (canSelectEffects.Count((effect) => !activatedEffects.Contains(effect)) >= 2)
                             {
-                                if (canSelectEffects.Count((effect) => !activatedEffects.Contains(effect)) >= 2)
+                                List<SelectionElement<int>> selectionElements = new List<SelectionElement<int>>()
                                 {
-                                    if (canSelectEffects.Count((effect) => !activatedEffects.Contains(effect)) == 2)
-                                    {
-                                        GManager.instance.commandText.OpenCommandText("Which effect will you activate the first?");
-                                    }
-
-                                    List<Command_SelectCommand> command_SelectCommands = new List<Command_SelectCommand>();
-
-                                    for (int i = 0; i < canSelectEffects.Count; i++)
-                                    {
-                                        if (!activatedEffects.Contains(canSelectEffects[i]))
-                                        {
-                                            int k = i;
-
-                                            string message = "";
-
-                                            switch (k)
-                                            {
-                                                case 0:
-                                                    message = "S Attack +1";
-                                                    break;
-
-                                                case 1:
-                                                    message = "Draw 2";
-                                                    break;
-                                            }
+                                    new SelectionElement<int>(message: $"S Attack +1", value : 0, spriteIndex: 0),
+                                    new SelectionElement<int>(message: $"Draw 2", value : 1, spriteIndex: 0),
+                                };
 
-                                            command_SelectCommands.Add(new Command_SelectCommand(message, () => photonView.RPC("SetEffectIndex", RpcTarget.All, k), 0));
-                                        }
-                                    }
+                                string selectPlayerMessage = "Which effect will you activate the first?";
+                                string notSelectPlayerMessage = "The opponent is choosing which effect activates.";
 
-                                    GManager.instance.selectCommandPanel.SetUpCommandButton(command_SelectCommands);
-                                }
-                                else
-                                {
-                                    for (int i = 0; i < canSelectEffects.Count; i++)
-                                    {
-                                        if (!activatedEffects.Contains(canSelectEffects[i]))
-                                        {
-                                            photonView.RPC("SetEffectIndex", RpcTarget.All, i);
-                                            break;
-                                        }
-                                    }
-                                }
+                                GManager.instance.userSelectionManager.SetIntSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
                             }
                             else
                             {
-                                GManager.instance.commandText.OpenCommandText("The opponent is choosing which effect activates.");
-
-                                #region AIƒ‚�[ƒh
-
-                                if (GManager.instance.IsAI)
+                                for (int i = 0; i < canSelectEffects.Count; i++)
                                 {
-                                    List<int> indexes = new List<int>();
-
-                                    for (int i = 0; i < canSelectEffects.Count; i++)
+                                    if (!activatedEffects.Contains(canSelectEffects[i]))
                                     {
-                                        if (!activatedEffects.Contains(canSelectEffects[i]))
-                                        {
-                                            int k = i;
-                                            indexes.Add(k);
-                                        }
-                                    }
-
-                                    if (indexes.Count >= 1)
-                                    {
-                                        SetEffectIndex(UnityEngine.Random.Range(0, indexes.Count));
+                                        GManager.instance.userSelectionManager.SetInt(i);
+                                        break;
                                     }
                                 }
-
-                                #endregion
                             }
 
-                            yield return new WaitWhile(() => !endSelect);
-                            endSelect = false;
+                            yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
 
-                            GManager.instance.commandText.CloseCommandText();
-                            yield return new WaitWhile(() => GManager.instance.commandText.gameObject.activeSelf);
+                            int effectIndex = GManager.instance.userSelectionManager.SelectedIntValue;
 
                             if (0 <= effectIndex && effectIndex <= canSelectEffects.Count - 1)
                             {
@@ -208,34 +155,20 @@ namespace DCGO.CardEffects.BT10
 
                     else
                     {
-                        if (card.Owner.isYou)
-                        {
-                            GManager.instance.commandText.OpenCommandText("Which effect will you activate?");
-
-                            List<Command_SelectCommand> command_SelectCommands = new List<Command_SelectCommand>()
-                                {
-                                    new Command_SelectCommand("S Attack +1", () => photonView.RPC("SetEffectIndex", RpcTarget.All, 0), 0),
-                                    new Command_SelectCommand("Draw 2", () => photonView.RPC("SetEffectIndex", RpcTarget.All, 1), 0),
-                                };
-
-                            GManager.instance.selectCommandPanel.SetUpCommandButton(command_SelectCommands);
-                        }
-                        else
-                        {
-                            GManager.instance.commandText.OpenCommandText("The opponent is choosing which effect activates.");
+                        List<SelectionElement<int>> selectionElements = new List<SelectionElement<int>>()
+                            {
+                                new SelectionElement<int>(message: $"S Attack +1", value : 0, spriteIndex: 0),
+                                new SelectionElement<int>(message: $"Draw 2", value : 1, spriteIndex: 0),
+                            };
 
-                            #region AIƒ‚�[ƒh
+                        string selectPlayerMessage = "Which effect will you activate?";
+                        string notSelectPlayerMessage = "The opponent is choosing which effect activates.";
 
-                            if (GManager.instance.IsAI)
-                            {
-                                SetEffectIndex(UnityEngine.Random.Range(0, canSelectEffects.Count));
-                            }
+                        GManager.instance.userSelectionManager.SetIntSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
 
-                            #endregion
-                        }
+                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
 
-                        yield return new WaitWhile(() => !endSelect);
-                        endSelect = false;
+                        int effectIndex = GManager.instance.userSelectionManager.SelectedIntValue;
 
                         GManager.instance.commandText.CloseCommandText();
                         yield return new WaitWhile(() => GManager.instance.commandText.gameObject.activeSelf);
@@ -278,15 +211,5 @@ namespace DCGO.CardEffects.BT10
 
             return cardEffects;
         }
-
-        int effectIndex = 0;
-        bool endSelect = false;
-
-        [PunRPC]
-        public void SetEffectIndex(int effectIndex)
-        {
-            this.effectIndex = effectIndex;
-            endSelect = true;
-        }
     }
 }

Assets/Scripts/CardEffect/BT10/Yellow/BT10_089.cs

@@ -84,46 +84,29 @@ namespace DCGO.CardEffects.BT10
                     {
                         if (card.Owner.GetBattleAreaPermanents().Count(CanSelectPermanentCondition) >= 1 && card.Owner.HandCards.Count(CanSelectCardCondition) >= 1)
                         {
-                            if (card.Owner.isYou)
+                            List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
                             {
-                                GManager.instance.commandText.OpenCommandText("From which area do you play a card?");
+                                new SelectionElement<bool>(message: $"Under Tamer", value : false, spriteIndex: 0),
+                                new SelectionElement<bool>(message: $"From hand", value : true, spriteIndex: 1),
+                            };
 
-                                List<Command_SelectCommand> command_SelectCommands = new List<Command_SelectCommand>()
-                                {
-                                    new Command_SelectCommand($"Under Tamer", () => photonView.RPC("SetFromHand", RpcTarget.All, false), 0),
-                                    new Command_SelectCommand($"From hand", () => photonView.RPC("SetFromHand", RpcTarget.All, true), 1),
-                                };
-
-                                GManager.instance.selectCommandPanel.SetUpCommandButton(command_SelectCommands);
-                            }
-                            else
-                            {
-                                GManager.instance.commandText.OpenCommandText("The opponent is choosing from which area to play a card.");
+                            string selectPlayerMessage = "From which area do you play a card?";
+                            string notSelectPlayerMessage = "The opponent is choosing from which area to play a card.";
 
-                                #region AIƒ‚�[ƒh
-
-                                if (GManager.instance.IsAI)
-                                {
-                                    SetFromHand(RandomUtility.IsSucceedProbability(0.5f));
-                                }
-
-                                #endregion
-                            }
+                            GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
                         }
                         else if (card.Owner.GetBattleAreaPermanents().Count(CanSelectPermanentCondition) == 0 && card.Owner.HandCards.Count(CanSelectCardCondition) >= 1)
                         {
-                            SetFromHand(true);
+                            GManager.instance.userSelectionManager.SetBool(true);
                         }
                         else if (card.Owner.GetBattleAreaPermanents().Count(CanSelectPermanentCondition) >= 1 && card.Owner.HandCards.Count(CanSelectCardCondition) == 0)
                         {
-                            SetFromHand(false);
+                            GManager.instance.userSelectionManager.SetBool(false);
                         }
 
-                        yield return new WaitWhile(() => !endSelect);
-                        endSelect = false;
+                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
 
-                        GManager.instance.commandText.CloseCommandText();
-                        yield return new WaitWhile(() => GManager.instance.commandText.gameObject.activeSelf);
+                        bool fromHand = GManager.instance.userSelectionManager.SelectedBoolValue;
 
                         if (fromHand)
                         {
@@ -328,15 +311,5 @@ namespace DCGO.CardEffects.BT10
 
             return cardEffects;
         }
-
-        bool endSelect = false;
-        bool fromHand = false;
-
-        [PunRPC]
-        public void SetFromHand(bool fromHand)
-        {
-            this.fromHand = fromHand;
-            endSelect = true;
-        }
     }
 }

Assets/Scripts/CardEffect/BT11/Black/BT11_071.cs

@@ -630,15 +630,5 @@ namespace DCGO.CardEffects.BT11
 
             return cardEffects;
         }
-
-        bool endSelect = false;
-        bool fromHand = false;
-
-        [PunRPC]
-        public void SetFromHand(bool fromHand)
-        {
-            this.fromHand = fromHand;
-            endSelect = true;
-        }
     }
 }

Assets/Scripts/CardEffect/BT18/Yellow/BT18_034.cs

@@ -109,41 +109,25 @@ namespace DCGO.CardEffects.BT18
                         {
                             if (card.Owner.Enemy.SecurityCards.Count == 0)
                             {
-                                SetDoDiscard(false);
+                                GManager.instance.userSelectionManager.SetBool(false);
                             }
                             else
                             {
-                                if (!card.Owner.isYou)
+                                List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
                                 {
-                                    GManager.instance.commandText.OpenCommandText("Will you discard the top card of your security?");
-
-                                    List<Command_SelectCommand> command_SelectCommands = new List<Command_SelectCommand>()
-                                {
-                                    new Command_SelectCommand($"Discard", () => photonView.RPC("SetDoDiscard", RpcTarget.All, true), 0),
-                                    new Command_SelectCommand($"Not Discard", () => photonView.RPC("SetDoDiscard", RpcTarget.All, false), 1),
+                                    new SelectionElement<bool>(message: $"Discard", value : true, spriteIndex: 0),
+                                    new SelectionElement<bool>(message: $"Not Discard", value : false, spriteIndex: 1),
                                 };
 
-                                    GManager.instance.selectCommandPanel.SetUpCommandButton(command_SelectCommands);
-                                }
-
-                                else
-                                {
-                                    GManager.instance.commandText.OpenCommandText("The opponent is choosing whether to discard security.");
+                                string selectPlayerMessage = "Will you discard the top card of your security?";
+                                string notSelectPlayerMessage = "The opponent is choosing whether to discard security.";
 
-                                    #region AI
-                                    if (GManager.instance.IsAI)
-                                    {
-                                        SetDoDiscard(RandomUtility.IsSucceedProbability(0.5f));
-                                    }
-                                    #endregion
-                                }
+                                GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner.Enemy, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
                             }
 
-                            yield return new WaitWhile(() => !endSelect);
-                            endSelect = false;
+                            yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
 
-                            GManager.instance.commandText.CloseCommandText();
-                            yield return new WaitWhile(() => GManager.instance.commandText.gameObject.activeSelf);
+                            bool doDiscard = GManager.instance.userSelectionManager.SelectedBoolValue;
 
                             if (!doDiscard)
                             {
@@ -235,41 +219,25 @@ namespace DCGO.CardEffects.BT18
                         {
                             if (card.Owner.Enemy.SecurityCards.Count == 0)
                             {
-                                SetDoDiscard(false);
+                                GManager.instance.userSelectionManager.SetBool(false);
                             }
                             else
                             {
-                                if (!card.Owner.isYou)
-                                {
-                                    GManager.instance.commandText.OpenCommandText("Will you discard the top card of your security?");
-
-                                    List<Command_SelectCommand> command_SelectCommands = new List<Command_SelectCommand>()
+                                List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
                                 {
-                                    new Command_SelectCommand($"Discard", () => photonView.RPC("SetDoDiscard", RpcTarget.All, true), 0),
-                                    new Command_SelectCommand($"Not Discard", () => photonView.RPC("SetDoDiscard", RpcTarget.All, false), 1),
+                                    new SelectionElement<bool>(message: $"Discard", value : true, spriteIndex: 0),
+                                    new SelectionElement<bool>(message: $"Not Discard", value : false, spriteIndex: 1),
                                 };
 
-                                    GManager.instance.selectCommandPanel.SetUpCommandButton(command_SelectCommands);
-                                }
-
-                                else
-                                {
-                                    GManager.instance.commandText.OpenCommandText("The opponent is choosing whether to discard security.");
+                                string selectPlayerMessage = "Will you discard the top card of your security?";
+                                string notSelectPlayerMessage = "The opponent is choosing whether to discard security.";
 
-                                    #region AI
-                                    if (GManager.instance.IsAI)
-                                    {
-                                        SetDoDiscard(RandomUtility.IsSucceedProbability(0.5f));
-                                    }
-                                    #endregion
-                                }
+                                GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner.Enemy, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
                             }
 
-                            yield return new WaitWhile(() => !endSelect);
-                            endSelect = false;
+                            yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
 
-                            GManager.instance.commandText.CloseCommandText();
-                            yield return new WaitWhile(() => GManager.instance.commandText.gameObject.activeSelf);
+                            bool doDiscard = GManager.instance.userSelectionManager.SelectedBoolValue;
 
                             if (!doDiscard)
                             {
@@ -439,17 +407,5 @@ namespace DCGO.CardEffects.BT18
 
             return cardEffects;
         }
-
-        #region Extras
-        bool endSelect = false;
-        bool doDiscard = false;
-
-        [PunRPC]
-        public void SetDoDiscard(bool doDiscard)
-        {
-            this.doDiscard = doDiscard;
-            endSelect = true;
-        }
-        #endregion 
     }
 }

Assets/Scripts/CardEffect/BT19/Purple/BT19_099.cs

@@ -278,49 +278,33 @@ namespace DCGO.CardEffects.BT19
                             {
                                 if (card.Owner.HandCards.Count(CanPlayWickedGodCondition) >= 1 && CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanPlayWickedGodCondition))
                                 {
-                                    if (card.Owner.isYou)
+                                    List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
                                     {
-                                        GManager.instance.commandText.OpenCommandText("From which area do you play a card?");
+                                        new SelectionElement<bool>(message: $"From hand", value : true, spriteIndex: 0),
+                                        new SelectionElement<bool>(message: $"From trash", value : false, spriteIndex: 1),
+                                    };
 
-                                        List<Command_SelectCommand> command_SelectCommands = new List<Command_SelectCommand>()
-                                {
-                                    new Command_SelectCommand($"From hand", () => photonView.RPC("SetFromHand", RpcTarget.All, true), 0),
-                                    new Command_SelectCommand($"From trash", () => photonView.RPC("SetFromHand", RpcTarget.All, false), 1),
-                                };
-
-                                        GManager.instance.selectCommandPanel.SetUpCommandButton(command_SelectCommands);
-                                    }
+                                    string selectPlayerMessage = "From which area do you play a card?";
+                                    string notSelectPlayerMessage = "The opponent is choosing from which area to play a card.";
 
-                                    else
-                                    {
-                                        GManager.instance.commandText.OpenCommandText("The opponent is choosing from which area to play a card.");
-
-                                        #region AIモード
-                                        if (GManager.instance.IsAI)
-                                        {
-                                            SetFromHand(RandomUtility.IsSucceedProbability(0.5f));
-                                        }
-                                        #endregion
-                                    }
+                                    GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
                                 }
 
                                 else if (card.Owner.HandCards.Count(CanPlayWickedGodCondition) == 0 && CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanPlayWickedGodCondition))
                                 {
-                                    SetFromHand(false);
+                                    GManager.instance.userSelectionManager.SetBool(false);
                                 }
 
                                 else if (card.Owner.HandCards.Count(CanPlayWickedGodCondition) >= 1 && card.Owner.TrashCards.Count(CanPlayWickedGodCondition) == 0)
                                 {
-                                    SetFromHand(true);
+                                    GManager.instance.userSelectionManager.SetBool(true);
                                 }
 
-                                yield return new WaitWhile(() => !endSelect);
-                                endSelect = false;
+                                yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
 
-                                GManager.instance.commandText.CloseCommandText();
-                                yield return new WaitWhile(() => GManager.instance.commandText.gameObject.activeSelf);
+                                bool fromHand = GManager.instance.userSelectionManager.SelectedBoolValue;
 
-                                List<CardSource> selectedCards = new List<CardSource>();
+                                List <CardSource> selectedCards = new List<CardSource>();
 
                                 IEnumerator SelectCardCoroutine(CardSource cardSource)
                                 {
@@ -416,15 +400,5 @@ namespace DCGO.CardEffects.BT19
 
             return cardEffects;
         }
-
-        bool endSelect = false;
-        bool fromHand = false;
-
-        [PunRPC]
-        public void SetFromHand(bool fromHand)
-        {
-            this.fromHand = fromHand;
-            endSelect = true;
-        }
     }
 }

Assets/Scripts/CardEffect/BT19/Yellow/BT19_043.cs

@@ -164,41 +164,25 @@ namespace DCGO.CardEffects.BT19
                 {   
                     if(card.Owner.Enemy.SecurityCards.Count > 0)
                     {
-                        if (!card.Owner.isYou)
+                        List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
                         {
-                            GManager.instance.commandText.OpenCommandText("Will you discard the top card of your security?");
+                            new SelectionElement<bool>(message: $"Discard", value : true, spriteIndex: 0),
+                            new SelectionElement<bool>(message: $"Not Discard", value : false, spriteIndex: 1),
+                        };
 
-                            List<Command_SelectCommand> command_SelectCommands = new List<Command_SelectCommand>()
-                    {
-                        new Command_SelectCommand($"Discard", () => photonView.RPC("SetDoDiscard", RpcTarget.All, true), 0),
-                        new Command_SelectCommand($"Not Discard", () => photonView.RPC("SetDoDiscard", RpcTarget.All, false), 1),
-                    };
-
-                            GManager.instance.selectCommandPanel.SetUpCommandButton(command_SelectCommands);
-                        }
-                        else
-                        {
-                            GManager.instance.commandText.OpenCommandText("The opponent is choosing whether to discard security.");
-
-                            #region AI
-                            if (GManager.instance.IsAI)
-                            {
-                                SetDoDiscard(RandomUtility.IsSucceedProbability(0.5f));
-                            }
-                            #endregion
-                        }
+                        string selectPlayerMessage = "Will you discard the top card of your security?";
+                        string notSelectPlayerMessage = "The opponent is choosing whether to discard security.";
 
-                        yield return new WaitWhile(() => !endSelect);
-                        endSelect = false;
-
-                        GManager.instance.commandText.CloseCommandText();
-                        yield return new WaitWhile(() => GManager.instance.commandText.gameObject.activeSelf);
+                        GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner.Enemy, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
                     }
                     else
                     {
-                        SetDoDiscard(false);
+                        GManager.instance.userSelectionManager.SetBool(false);
                     }
-                    
+
+                    yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
+
+                    bool doDiscard = GManager.instance.userSelectionManager.SelectedBoolValue;
 
                     if (!doDiscard)
                     {
@@ -240,17 +224,5 @@ namespace DCGO.CardEffects.BT19
 
             return cardEffects;
         }
-
-        #region Extras
-        bool endSelect = false;
-        bool doDiscard = false;
-
-        [PunRPC]
-        public void SetDoDiscard(bool doDiscard)
-        {
-            this.doDiscard = doDiscard;
-            endSelect = true;
-        }
-        #endregion 
     }
 }

Assets/Scripts/CardEffect/BT19/Yellow/BT19_094.cs

@@ -67,37 +67,25 @@ namespace DCGO.CardEffects.BT19
 
                         if (card.Owner.Enemy.SecurityCards.Count > 0)
                         {
-                            if (!card.Owner.isYou)
-                            {
-                                GManager.instance.commandText.OpenCommandText("Will you discard the top card of your security?");
+                            List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
+                        {
+                            new SelectionElement<bool>(message: $"Discard", value : true, spriteIndex: 0),
+                            new SelectionElement<bool>(message: $"Not Discard", value : false, spriteIndex: 1),
+                        };
 
-                                List<Command_SelectCommand> command_SelectCommands = new List<Command_SelectCommand>()
-                    {
-                        new Command_SelectCommand($"Discard", () => photonView.RPC("SetDoDiscard", RpcTarget.All, true), 0),
-                        new Command_SelectCommand($"Not Discard", () => photonView.RPC("SetDoDiscard", RpcTarget.All, false), 1),
-                    };
+                            string selectPlayerMessage = "Will you discard the top card of your security?";
+                            string notSelectPlayerMessage = "The opponent is choosing whether to discard security.";
 
-                                GManager.instance.selectCommandPanel.SetUpCommandButton(command_SelectCommands);
-                            }
-                            else
-                            {
-                                GManager.instance.commandText.OpenCommandText("The opponent is choosing whether to discard security.");
-
-                                #region AI
-                                if (GManager.instance.IsAI)
-                                {
-                                    SetDoDiscard(RandomUtility.IsSucceedProbability(0.5f));
-                                }
-                                #endregion
-                            }
+                            GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner.Enemy, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
+                        }
+                        else
+                        {
+                            GManager.instance.userSelectionManager.SetBool(false);
+                        }
 
-                            yield return new WaitWhile(() => !endSelect);
-                            endSelect = false;
+                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
 
-                            GManager.instance.commandText.CloseCommandText();
-                            yield return new WaitWhile(() => GManager.instance.commandText.gameObject.activeSelf);
-                        }
-                            
+                        bool doDiscard = GManager.instance.userSelectionManager.SelectedBoolValue;
 
                         if (!doDiscard)
                         {
@@ -264,18 +252,6 @@ namespace DCGO.CardEffects.BT19
             #endregion
 
             return cardEffects;
-        }
-
-        #region Extras
-        bool endSelect = false;
-        bool doDiscard = false;
-
-        [PunRPC]
-        public void SetDoDiscard(bool doDiscard)
-        {
-            this.doDiscard = doDiscard;
-            endSelect = true;
-        }
-        #endregion 
+        } 
     }
 }

Assets/Scripts/CardEffect/BT3/Yellow/BT3_102.cs

@@ -30,44 +30,27 @@ public class BT3_102 : CEntity_Effect
 
             IEnumerator ActivateCoroutine(Hashtable _hashtable)
             {
-                if (card.Owner.Enemy.SecurityCards.Count == 0)
+                if (card.Owner.Enemy.SecurityCards.Count > 0)
                 {
-                    SetDoDiscard(false);
-                }
+                    List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
+                        {
+                            new SelectionElement<bool>(message: $"Discard", value : true, spriteIndex: 0),
+                            new SelectionElement<bool>(message: $"Not Discard", value : false, spriteIndex: 1),
+                        };
 
+                    string selectPlayerMessage = "Will you discard the top card of your security?";
+                    string notSelectPlayerMessage = "The opponent is choosing whether to discard security.";
+
+                    GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner.Enemy, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
+                }
                 else
                 {
-                    if (!card.Owner.isYou)
-                    {
-                        GManager.instance.commandText.OpenCommandText("Will you discard the top card of your security?");
-
-                        List<Command_SelectCommand> command_SelectCommands = new List<Command_SelectCommand>()
-                                {
-                                    new Command_SelectCommand($"Discard", () => photonView.RPC("SetDoDiscard", RpcTarget.All, true), 0),
-                                    new Command_SelectCommand($"Not Discard", () => photonView.RPC("SetDoDiscard", RpcTarget.All, false), 1),
-                                };
-
-                        GManager.instance.selectCommandPanel.SetUpCommandButton(command_SelectCommands);
-                    }
-
-                    else
-                    {
-                        GManager.instance.commandText.OpenCommandText("The opponent is choosing whether to discard security.");
-
-                        #region AI
-                        if (GManager.instance.IsAI)
-                        {
-                            SetDoDiscard(RandomUtility.IsSucceedProbability(0.5f));
-                        }
-                        #endregion
-                    }
+                    GManager.instance.userSelectionManager.SetBool(false);
                 }
 
-                yield return new WaitWhile(() => !endSelect);
-                endSelect = false;
+                yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
 
-                GManager.instance.commandText.CloseCommandText();
-                yield return new WaitWhile(() => GManager.instance.commandText.gameObject.activeSelf);
+                bool doDiscard = GManager.instance.userSelectionManager.SelectedBoolValue;
 
                 if (!doDiscard)
                 {
@@ -87,14 +70,4 @@ public class BT3_102 : CEntity_Effect
 
         return cardEffects;
     }
-
-    bool endSelect = false;
-    bool doDiscard = false;
-
-    [PunRPC]
-    public void SetDoDiscard(bool doDiscard)
-    {
-        this.doDiscard = doDiscard;
-        endSelect = true;
-    }
 }

Assets/Scripts/CardEffect/BT5/Black/BT5_104.cs

@@ -70,36 +70,20 @@ public class BT5_104 : CEntity_Effect
                 {
                     if (card.Owner.fieldCardFrames.Count((frame) => frame.IsEmptyFrame()) >= 1)
                     {
-                        if (card.Owner.isYou)
+                        List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
                         {
-                            GManager.instance.commandText.OpenCommandText("Will you play a [Diaboromon] Token?");
+                            new SelectionElement<bool>(message: $"Play 1 Token", value : true, spriteIndex: 0),
+                            new SelectionElement<bool>(message: $"Not Play", value : false, spriteIndex: 1),
+                        };
 
-                            List<Command_SelectCommand> command_SelectCommands = new List<Command_SelectCommand>()
-                                {
-                                    new Command_SelectCommand($"Play 1 Token", () => photonView.RPC("SetPlayToken", RpcTarget.All, true), 0),
-                                    new Command_SelectCommand($"Not Play", () => photonView.RPC("SetPlayToken", RpcTarget.All, false), 1),
-                                };
+                        string selectPlayerMessage = "Will you play a [Diaboromon] Token?";
+                        string notSelectPlayerMessage = "The opponent is choosing whether to play a token.";
 
-                            GManager.instance.selectCommandPanel.SetUpCommandButton(command_SelectCommands);
-                        }
-
-                        else
-                        {
-                            GManager.instance.commandText.OpenCommandText("The opponent is choosing whether to play a token.");
-
-                            #region AIƒ‚�[ƒh
-                            if (GManager.instance.IsAI)
-                            {
-                                SetPlayToken(RandomUtility.IsSucceedProbability(0.5f));
-                            }
-                            #endregion
-                        }
+                        GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
 
-                        yield return new WaitWhile(() => !endSelect);
-                        endSelect = false;
+                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
 
-                        GManager.instance.commandText.CloseCommandText();
-                        yield return new WaitWhile(() => GManager.instance.commandText.gameObject.activeSelf);
+                        bool playToken = GManager.instance.userSelectionManager.SelectedBoolValue;
 
                         if (playToken)
                         {
@@ -117,14 +101,4 @@ public class BT5_104 : CEntity_Effect
 
         return cardEffects;
     }
-
-    bool endSelect = false;
-    bool playToken = false;
-
-    [PunRPC]
-    public void SetPlayToken(bool playToken)
-    {
-        this.playToken = playToken;
-        endSelect = true;
-    }
 }

Assets/Scripts/CardEffect/BT5/Purple/BT5_082.cs

@@ -128,96 +128,45 @@ public class BT5_082 : CEntity_Effect
                     {
                         yield return GManager.instance.photonWaitController.StartWait("Tactimon_selectFirst");
 
-                        if (card.Owner.isYou)
+                        if (canSelectEffects.Count((effect) => !activatedEffects.Contains(effect)) >= 2)
                         {
-                            if (canSelectEffects.Count((effect) => !activatedEffects.Contains(effect)) >= 2)
+                            List<SelectionElement<int>> selectionElements = new List<SelectionElement<int>>()
                             {
-                                if (canSelectEffects.Count((effect) => !activatedEffects.Contains(effect)) == 3)
-                                {
-                                    GManager.instance.commandText.OpenCommandText("Which effect will you activate the first?");
-                                }
-
-                                else if (canSelectEffects.Count((effect) => !activatedEffects.Contains(effect)) == 2)
-                                {
-                                    GManager.instance.commandText.OpenCommandText("Which effect will you activate the second?");
-                                }
-
-                                List<Command_SelectCommand> command_SelectCommands = new List<Command_SelectCommand>();
-
-                                for (int i = 0; i < canSelectEffects.Count; i++)
-                                {
-                                    if (!activatedEffects.Contains(canSelectEffects[i]))
-                                    {
-                                        int k = i;
-
-                                        string message = "";
+                                new SelectionElement<int>(message: $"Memory +1", value : 0, spriteIndex: 0),
+                                new SelectionElement<int>(message: $"DP +2000", value : 1, spriteIndex: 0),
+                                new SelectionElement<int>(message: $"Delete Digimons", value : 2, spriteIndex: 0),
+                            };
 
-                                        switch (k)
-                                        {
-                                            case 0:
-                                                message = "Memory +1";
-                                                break;
+                            string selectPlayerMessage = "Which effect will you activate?";
+                            string notSelectPlayerMessage = "The opponent is choosing which effect activates.";
 
-                                            case 1:
-                                                message = "DP +2000";
-                                                break;
-
-                                            case 2:
-                                                message = "Delete Digimon";
-                                                break;
-                                        }
-
-                                        command_SelectCommands.Add(new Command_SelectCommand(message, () => photonView.RPC("SetEffectIndex", RpcTarget.All, k), 0));
-                                    }
-                                }
-
-                                GManager.instance.selectCommandPanel.SetUpCommandButton(command_SelectCommands);
+                            if (canSelectEffects.Count((effect) => !activatedEffects.Contains(effect)) == 3)
+                            {
+                                selectPlayerMessage = "Which effect will you activate the first?";
                             }
 
-                            else
+                            else if (canSelectEffects.Count((effect) => !activatedEffects.Contains(effect)) == 2)
                             {
-                                for (int i = 0; i < canSelectEffects.Count; i++)
-                                {
-                                    if (!activatedEffects.Contains(canSelectEffects[i]))
-                                    {
-                                        photonView.RPC("SetEffectIndex", RpcTarget.All, i);
-                                        break;
-                                    }
-                                }
+                                selectPlayerMessage = "Which effect will you activate the second?";
                             }
-                        }
 
+                            GManager.instance.userSelectionManager.SetIntSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
+                        }
                         else
                         {
-                            GManager.instance.commandText.OpenCommandText("The opponent is choosing which effect activates.");
-
-                            #region AIモード
-                            if (GManager.instance.IsAI)
+                            for (int i = 0; i < canSelectEffects.Count; i++)
                             {
-                                List<int> indexes = new List<int>();
-
-                                for (int i = 0; i < canSelectEffects.Count; i++)
-                                {
-                                    if (!activatedEffects.Contains(canSelectEffects[i]))
-                                    {
-                                        int k = i;
-                                        indexes.Add(k);
-                                    }
-                                }
-
-                                if (indexes.Count >= 1)
+                                if (!activatedEffects.Contains(canSelectEffects[i]))
                                 {
-                                    SetEffectIndex(UnityEngine.Random.Range(0, indexes.Count));
+                                    GManager.instance.userSelectionManager.SetInt(i);
+                                    break;
                                 }
                             }
-                            #endregion
                         }
 
-                        yield return new WaitWhile(() => !endSelect);
-                        endSelect = false;
+                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
 
-                        GManager.instance.commandText.CloseCommandText();
-                        yield return new WaitWhile(() => GManager.instance.commandText.gameObject.activeSelf);
+                        int effectIndex = GManager.instance.userSelectionManager.SelectedIntValue;
 
                         if (0 <= effectIndex && effectIndex <= canSelectEffects.Count - 1)
                         {
@@ -237,37 +186,21 @@ public class BT5_082 : CEntity_Effect
                 #region 他のデジモンがいる場合(1つ選択)
                 else
                 {
-                    if (card.Owner.isYou)
+                    List<SelectionElement<int>> selectionElements = new List<SelectionElement<int>>()
                     {
-                        GManager.instance.commandText.OpenCommandText("Which effect will you activate?");
+                        new SelectionElement<int>(message: $"Memory +1", value : 0, spriteIndex: 0),
+                        new SelectionElement<int>(message: $"DP +2000", value : 1, spriteIndex: 0),
+                        new SelectionElement<int>(message: $"Delete Digimons", value : 2, spriteIndex: 0),
+                    };
 
-                        List<Command_SelectCommand> command_SelectCommands = new List<Command_SelectCommand>()
-                                {
-                                    new Command_SelectCommand("Memory +1", () => photonView.RPC("SetEffectIndex", RpcTarget.All, 0), 0),
-                                    new Command_SelectCommand("DP +2000", () => photonView.RPC("SetEffectIndex", RpcTarget.All, 1), 0),
-                                    new Command_SelectCommand("Delete Digimon", () => photonView.RPC("SetEffectIndex", RpcTarget.All, 2), 0),
-                                };
+                    string selectPlayerMessage = "Which effect will you activate?";
+                    string notSelectPlayerMessage = "The opponent is choosing which effect activates.";
 
-                        GManager.instance.selectCommandPanel.SetUpCommandButton(command_SelectCommands);
-                    }
+                    GManager.instance.userSelectionManager.SetIntSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
 
-                    else
-                    {
-                        GManager.instance.commandText.OpenCommandText("The opponent is choosing which effect activates.");
+                    yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
 
-                        #region AIモード
-                        if (GManager.instance.IsAI)
-                        {
-                            SetEffectIndex(UnityEngine.Random.Range(0, canSelectEffects.Count));
-                        }
-                        #endregion
-                    }
-
-                    yield return new WaitWhile(() => !endSelect);
-                    endSelect = false;
-
-                    GManager.instance.commandText.CloseCommandText();
-                    yield return new WaitWhile(() => GManager.instance.commandText.gameObject.activeSelf);
+                    int effectIndex = GManager.instance.userSelectionManager.SelectedIntValue;
 
                     if (0 <= effectIndex && effectIndex <= canSelectEffects.Count - 1)
                     {
@@ -282,14 +215,4 @@ public class BT5_082 : CEntity_Effect
 
         return cardEffects;
     }
-
-    int effectIndex = 0;
-    bool endSelect = false;
-
-    [PunRPC]
-    public void SetEffectIndex(int effectIndex)
-    {
-        this.effectIndex = effectIndex;
-        endSelect = true;
-    }
 }

Assets/Scripts/CardEffect/BT6/Black/BT6_111.cs

@@ -215,37 +215,20 @@ public class BT6_111 : CEntity_Effect
                         {
                             yield return GManager.instance.photonWaitController.StartWait("PayMemory_Alphamon");
 
-                            if (card.Owner.isYou)
+                            List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
                             {
-                                GManager.instance.commandText.OpenCommandText($"Will you pay 1 memory cost?(already paid cost:{count})");
+                                new SelectionElement<bool>(message: $"Pay Cost", value : true, spriteIndex: 0),
+                                new SelectionElement<bool>(message: $"Not Pay Cost", value : false, spriteIndex: 1),
+                            };
 
-                                List<Command_SelectCommand> command_SelectCommands = new List<Command_SelectCommand>()
-                                {
-                                    new Command_SelectCommand($"Pay Cost", () => photonView.RPC("SetPayCost", RpcTarget.All, true), 0),
-                                    new Command_SelectCommand($"Not Pay Cost", () => photonView.RPC("SetPayCost", RpcTarget.All, false), 1),
-                                };
+                            string selectPlayerMessage = $"Will you pay 1 memory cost?(already paid cost:{count})";
+                            string notSelectPlayerMessage = "The opponent is choosing whether to pay memory cost.";
 
-                                GManager.instance.selectCommandPanel.SetUpCommandButton(command_SelectCommands);
-                            }
-                            else
-                            {
-                                GManager.instance.commandText.OpenCommandText("The opponent is choosing whether to pay memory cost.");
+                            GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
 
-                                #region AIƒ‚�[ƒh
+                            yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
 
-                                if (GManager.instance.IsAI)
-                                {
-                                    SetPayCost(RandomUtility.IsSucceedProbability(0.5f));
-                                }
-
-                                #endregion
-                            }
-
-                            yield return new WaitWhile(() => !endSelect);
-                            endSelect = false;
-
-                            GManager.instance.commandText.CloseCommandText();
-                            yield return new WaitWhile(() => GManager.instance.commandText.gameObject.activeSelf);
+                            bool payCost = GManager.instance.userSelectionManager.SelectedBoolValue;
 
                             if (payCost)
                             {
@@ -313,15 +296,5 @@ public class BT6_111 : CEntity_Effect
         }
 
         return cardEffects;
-    }
-
-    bool endSelect = false;
-    bool payCost = false;
-
-    [PunRPC]
-    public void SetPayCost(bool payCost)
-    {
-        this.payCost = payCost;
-        endSelect = true;
-    }
+    } 
 }

Assets/Scripts/CardEffect/BT6/Red/BT6_016.cs

@@ -232,14 +232,4 @@ public class BT6_016 : CEntity_Effect
 
         return cardEffects;
     }
-
-    bool endSelect = false;
-    bool fromHand = false;
-
-    [PunRPC]
-    public void SetFromHand(bool fromHand)
-    {
-        this.fromHand = fromHand;
-        endSelect = true;
-    }
 }

Assets/Scripts/CardEffect/BT7/Red/BT7_017.cs

@@ -124,47 +124,31 @@ public class BT7_017 : CEntity_Effect
                     {
                         if (card.Owner.HandCards.Count(CanSelectCardCondition) >= 1 && CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition))
                         {
-                            if (card.Owner.isYou)
+                            List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
                             {
-                                GManager.instance.commandText.OpenCommandText("From which area do you place a card in digivolution cards?");
+                                new SelectionElement<bool>(message: $"From hand", value : true, spriteIndex: 0),
+                                new SelectionElement<bool>(message: $"From trash", value : false, spriteIndex: 1),
+                            };
 
-                                List<Command_SelectCommand> command_SelectCommands = new List<Command_SelectCommand>()
-                                {
-                                    new Command_SelectCommand($"From hand", () => photonView.RPC("SetFromHand", RpcTarget.All, true), 0),
-                                    new Command_SelectCommand($"From trash", () => photonView.RPC("SetFromHand", RpcTarget.All, false), 1),
-                                };
-
-                                GManager.instance.selectCommandPanel.SetUpCommandButton(command_SelectCommands);
-                            }
+                            string selectPlayerMessage = "From which area do you place a card in digivolution cards?";
+                            string notSelectPlayerMessage = "The opponent is choosing from which area to place a card in digivolution cards.";
 
-                            else
-                            {
-                                GManager.instance.commandText.OpenCommandText("The opponent is choosing from which area to place a card in digivolution cards.");
-
-                                #region AI���[�h
-                                if (GManager.instance.IsAI)
-                                {
-                                    SetFromHand(RandomUtility.IsSucceedProbability(0.5f));
-                                }
-                                #endregion
-                            }
+                            GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
                         }
 
                         else if (card.Owner.HandCards.Count(CanSelectCardCondition) == 0 && CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition))
                         {
-                            SetFromHand(false);
+                            GManager.instance.userSelectionManager.SetBool(false);
                         }
 
                         else if (card.Owner.HandCards.Count(CanSelectCardCondition) >= 1 && card.Owner.TrashCards.Count(CanSelectCardCondition) == 0)
                         {
-                            SetFromHand(true);
+                            GManager.instance.userSelectionManager.SetBool(true);
                         }
 
-                        yield return new WaitWhile(() => !endSelect);
-                        endSelect = false;
+                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
 
-                        GManager.instance.commandText.CloseCommandText();
-                        yield return new WaitWhile(() => GManager.instance.commandText.gameObject.activeSelf);
+                        bool fromHand = GManager.instance.userSelectionManager.SelectedBoolValue;
 
                         List<CardSource> selectedCards = new List<CardSource>();
 
@@ -277,14 +261,4 @@ public class BT7_017 : CEntity_Effect
 
         return cardEffects;
     }
-
-    bool endSelect = false;
-    bool fromHand = false;
-
-    [PunRPC]
-    public void SetFromHand(bool fromHand)
-    {
-        this.fromHand = fromHand;
-        endSelect = true;
-    }
 }

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

@@ -78,47 +78,31 @@ public class BT7_082 : CEntity_Effect
                     {
                         if (card.Owner.HandCards.Count(CanSelectCardCondition) >= 1 && CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition))
                         {
-                            if (card.Owner.isYou)
-                            {
-                                GManager.instance.commandText.OpenCommandText("From which area do you place a card in digivolution cards?");
-
-                                List<Command_SelectCommand> command_SelectCommands = new List<Command_SelectCommand>()
-                                {
-                                    new Command_SelectCommand($"From hand", () => photonView.RPC("SetFromHand", RpcTarget.All, true), 0),
-                                    new Command_SelectCommand($"From trash", () => photonView.RPC("SetFromHand", RpcTarget.All, false), 1),
-                                };
+                            List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
+                                    {
+                                        new SelectionElement<bool>(message: $"From hand", value : true, spriteIndex: 0),
+                                        new SelectionElement<bool>(message: $"From trash", value : false, spriteIndex: 1),
+                                    };
 
-                                GManager.instance.selectCommandPanel.SetUpCommandButton(command_SelectCommands);
-                            }
+                            string selectPlayerMessage = "From which area do you place a card in digivolution cards?";
+                            string notSelectPlayerMessage = "The opponent is choosing from which area to place a card in digivolution cards.";
 
-                            else
-                            {
-                                GManager.instance.commandText.OpenCommandText("The opponent is choosing from which area to place a card in digivolution cards.");
-
-                                #region AIƒ‚�[ƒh
-                                if (GManager.instance.IsAI)
-                                {
-                                    SetFromHand(RandomUtility.IsSucceedProbability(0.5f));
-                                }
-                                #endregion
-                            }
+                            GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
                         }
 
                         else if (card.Owner.HandCards.Count(CanSelectCardCondition) == 0 && CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition))
                         {
-                            SetFromHand(false);
+                            GManager.instance.userSelectionManager.SetBool(false);
                         }
 
                         else if (card.Owner.HandCards.Count(CanSelectCardCondition) >= 1 && card.Owner.TrashCards.Count(CanSelectCardCondition) == 0)
                         {
-                            SetFromHand(true);
+                            GManager.instance.userSelectionManager.SetBool(true);
                         }
 
-                        yield return new WaitWhile(() => !endSelect);
-                        endSelect = false;
+                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
 
-                        GManager.instance.commandText.CloseCommandText();
-                        yield return new WaitWhile(() => GManager.instance.commandText.gameObject.activeSelf);
+                        bool fromHand = GManager.instance.userSelectionManager.SelectedBoolValue;
 
                         List<CardSource> selectedCards = new List<CardSource>();
 
@@ -286,14 +270,4 @@ public class BT7_082 : CEntity_Effect
 
         return cardEffects;
     }
-
-    bool endSelect = false;
-    bool fromHand = false;
-
-    [PunRPC]
-    public void SetFromHand(bool fromHand)
-    {
-        this.fromHand = fromHand;
-        endSelect = true;
-    }
 }

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

@@ -84,47 +84,32 @@ public class BT7_083 : CEntity_Effect
                     {
                         if (card.Owner.HandCards.Count(CanSelectCardCondition) >= 1 && CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition))
                         {
-                            if (card.Owner.isYou)
+                            List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
                             {
-                                GManager.instance.commandText.OpenCommandText("From which area do you place a card in digivolution cards?");
+                                new SelectionElement<bool>(message: $"From hand", value : true, spriteIndex: 0),
+                                new SelectionElement<bool>(message: $"From trash", value : false, spriteIndex: 1),
+                            };
 
-                                List<Command_SelectCommand> command_SelectCommands = new List<Command_SelectCommand>()
-                                {
-                                    new Command_SelectCommand($"From hand", () => photonView.RPC("SetFromHand", RpcTarget.All, true), 0),
-                                    new Command_SelectCommand($"From trash", () => photonView.RPC("SetFromHand", RpcTarget.All, false), 1),
-                                };
+                            string selectPlayerMessage = "From which area do you place a card in digivolution cards?";
+                            string notSelectPlayerMessage = "The opponent is choosing from which area to place a card in digivolution cards.";
 
-                                GManager.instance.selectCommandPanel.SetUpCommandButton(command_SelectCommands);
-                            }
-
-                            else
-                            {
-                                GManager.instance.commandText.OpenCommandText("The opponent is choosing from which area to place a card in digivolution cards.");
-
-                                #region AI���[�h
-                                if (GManager.instance.IsAI)
-                                {
-                                    SetFromHand(RandomUtility.IsSucceedProbability(0.5f));
-                                }
-                                #endregion
-                            }
+                            GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
                         }
 
                         else if (card.Owner.HandCards.Count(CanSelectCardCondition) == 0 && CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition))
                         {
-                            SetFromHand(false);
+                            GManager.instance.userSelectionManager.SetBool(false);
                         }
 
                         else if (card.Owner.HandCards.Count(CanSelectCardCondition) >= 1 && card.Owner.TrashCards.Count(CanSelectCardCondition) == 0)
                         {
-                            SetFromHand(true);
+                            GManager.instance.userSelectionManager.SetBool(true);
                         }
 
-                        yield return new WaitWhile(() => !endSelect);
-                        endSelect = false;
+                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
+
+                        bool fromHand = GManager.instance.userSelectionManager.SelectedBoolValue;
 
-                        GManager.instance.commandText.CloseCommandText();
-                        yield return new WaitWhile(() => GManager.instance.commandText.gameObject.activeSelf);
 
                         List<CardSource> selectedCards = new List<CardSource>();
 
@@ -306,14 +291,4 @@ public class BT7_083 : CEntity_Effect
 
         return cardEffects;
     }
-
-    bool endSelect = false;
-    bool fromHand = false;
-
-    [PunRPC]
-    public void SetFromHand(bool fromHand)
-    {
-        this.fromHand = fromHand;
-        endSelect = true;
-    }
 }

Assets/Scripts/CardEffect/EX2/Purple/EX2_044.cs

@@ -166,36 +166,20 @@ namespace DCGO.CardEffects.EX2
                         {
                             if (card.Owner.LibraryCards.Count >= 1)
                             {
-                                if (card.Owner.isYou)
+                                List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
                                 {
-                                    GManager.instance.commandText.OpenCommandText("Will you trash the top cards of your deck?");
-
-                                    List<Command_SelectCommand> command_SelectCommands = new List<Command_SelectCommand>()
-                                {
-                                    new Command_SelectCommand($"Trash", () => photonView.RPC("SetDoTrash", RpcTarget.All, true), 0),
-                                    new Command_SelectCommand($"Not trash", () => photonView.RPC("SetDoTrash", RpcTarget.All, false), 1),
+                                    new SelectionElement<bool>(message: $"Trash", value : true, spriteIndex: 0),
+                                    new SelectionElement<bool>(message: $"Not trash", value : false, spriteIndex: 1),
                                 };
 
-                                    GManager.instance.selectCommandPanel.SetUpCommandButton(command_SelectCommands);
-                                }
-
-                                else
-                                {
-                                    GManager.instance.commandText.OpenCommandText("The opponent is choosing whether to trash the top cards of deck.");
+                                string selectPlayerMessage = "Will you trash the top cards of your deck?";
+                                string notSelectPlayerMessage = "The opponent is choosing whether to trash the top cards of deck.";
 
-                                    #region AIƒ‚�[ƒh
-                                    if (GManager.instance.IsAI)
-                                    {
-                                        SetDoTrash(RandomUtility.IsSucceedProbability(0.5f));
-                                    }
-                                    #endregion
-                                }
+                                GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
 
-                                yield return new WaitWhile(() => !endSelect);
-                                endSelect = false;
+                                yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
 
-                                GManager.instance.commandText.CloseCommandText();
-                                yield return new WaitWhile(() => GManager.instance.commandText.gameObject.activeSelf);
+                                bool doTrash = GManager.instance.userSelectionManager.SelectedBoolValue;
 
                                 if (doTrash)
                                 {
@@ -294,36 +278,20 @@ namespace DCGO.CardEffects.EX2
                         {
                             if (card.Owner.LibraryCards.Count >= 1)
                             {
-                                if (card.Owner.isYou)
-                                {
-                                    GManager.instance.commandText.OpenCommandText("Will you trash the top cards of your deck?");
-
-                                    List<Command_SelectCommand> command_SelectCommands = new List<Command_SelectCommand>()
+                                List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
                                 {
-                                    new Command_SelectCommand($"Trash", () => photonView.RPC("SetDoTrash", RpcTarget.All, true), 0),
-                                    new Command_SelectCommand($"Not trash", () => photonView.RPC("SetDoTrash", RpcTarget.All, false), 1),
+                                    new SelectionElement<bool>(message: $"Trash", value : true, spriteIndex: 0),
+                                    new SelectionElement<bool>(message: $"Not trash", value : false, spriteIndex: 1),
                                 };
 
-                                    GManager.instance.selectCommandPanel.SetUpCommandButton(command_SelectCommands);
-                                }
-
-                                else
-                                {
-                                    GManager.instance.commandText.OpenCommandText("The opponent is choosing whether to trash the top cards of deck.");
+                                string selectPlayerMessage = "Will you trash the top cards of your deck?";
+                                string notSelectPlayerMessage = "The opponent is choosing whether to trash the top cards of deck.";
 
-                                    #region AIƒ‚�[ƒh
-                                    if (GManager.instance.IsAI)
-                                    {
-                                        SetDoTrash(RandomUtility.IsSucceedProbability(0.5f));
-                                    }
-                                    #endregion
-                                }
+                                GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
 
-                                yield return new WaitWhile(() => !endSelect);
-                                endSelect = false;
+                                yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
 
-                                GManager.instance.commandText.CloseCommandText();
-                                yield return new WaitWhile(() => GManager.instance.commandText.gameObject.activeSelf);
+                                bool doTrash = GManager.instance.userSelectionManager.SelectedBoolValue;
 
                                 if (doTrash)
                                 {
@@ -359,15 +327,5 @@ namespace DCGO.CardEffects.EX2
 
             return cardEffects;
         }
-
-        bool endSelect = false;
-        bool doTrash = false;
-
-        [PunRPC]
-        public void SetDoTrash(bool doTrash)
-        {
-            this.doTrash = doTrash;
-            endSelect = true;
-        }
     }
 }

Assets/Scripts/CardEffect/EX2/White/EX2_007.cs

@@ -153,47 +153,31 @@ namespace DCGO.CardEffects.EX2
                             {
                                 if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition) && card.Owner.HandCards.Count(CanSelectCardCondition) >= 1)
                                 {
-                                    if (card.Owner.isYou)
+                                    List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
                                     {
-                                        GManager.instance.commandText.OpenCommandText("From which area do you select a card?");
+                                        new SelectionElement<bool>(message: $"From Field", value : false, spriteIndex: 0),
+                                        new SelectionElement<bool>(message: $"From hand", value : true, spriteIndex: 1),
+                                    };
 
-                                        List<Command_SelectCommand> command_SelectCommands = new List<Command_SelectCommand>()
-                                {
-                                    new Command_SelectCommand($"From Field", () => photonView.RPC("SetFromHand", RpcTarget.All, false), 0),
-                                    new Command_SelectCommand($"From hand", () => photonView.RPC("SetFromHand", RpcTarget.All, true), 1),
-                                };
-
-                                        GManager.instance.selectCommandPanel.SetUpCommandButton(command_SelectCommands);
-                                    }
+                                    string selectPlayerMessage = "From which area do you play a card?";
+                                    string notSelectPlayerMessage = "The opponent is choosing from which area to play a card.";
 
-                                    else
-                                    {
-                                        GManager.instance.commandText.OpenCommandText("The opponent is choosing from which area to select a card.");
-
-                                        #region AI
-                                        if (GManager.instance.IsAI)
-                                        {
-                                            SetFromHand(RandomUtility.IsSucceedProbability(0.5f));
-                                        }
-                                        #endregion
-                                    }
+                                    GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
                                 }
 
                                 else if (!CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition) && card.Owner.HandCards.Count(CanSelectCardCondition) >= 1)
                                 {
-                                    SetFromHand(true);
+                                    GManager.instance.userSelectionManager.SetBool(true);
                                 }
 
                                 else if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition) && card.Owner.HandCards.Count(CanSelectCardCondition) == 0)
                                 {
-                                    SetFromHand(false);
+                                    GManager.instance.userSelectionManager.SetBool(false);
                                 }
 
-                                yield return new WaitWhile(() => !endSelect);
-                                endSelect = false;
+                                yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
 
-                                GManager.instance.commandText.CloseCommandText();
-                                yield return new WaitWhile(() => GManager.instance.commandText.gameObject.activeSelf);
+                                bool fromHand = GManager.instance.userSelectionManager.SelectedBoolValue;
 
                                 if (fromHand)
                                 {
@@ -531,15 +515,5 @@ namespace DCGO.CardEffects.EX2
 
             return cardEffects;
         }
-
-        bool endSelect = false;
-        bool fromHand = false;
-
-        [PunRPC]
-        public void SetFromHand(bool fromHand)
-        {
-            this.fromHand = fromHand;
-            endSelect = true;
-        }
     }
 }

Assets/Scripts/CardEffect/EX2/White/EX2_048.cs

@@ -119,47 +119,31 @@ namespace DCGO.CardEffects.EX2
                         {
                             if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition) && card.Owner.HandCards.Count(CanSelectCardCondition) >= 1)
                             {
-                                if (card.Owner.isYou)
-                                {
-                                    GManager.instance.commandText.OpenCommandText("From which area do you select a card?");
-
-                                    List<Command_SelectCommand> command_SelectCommands = new List<Command_SelectCommand>()
-                                {
-                                    new Command_SelectCommand($"From Field", () => photonView.RPC("SetFromHand", RpcTarget.All, false), 0),
-                                    new Command_SelectCommand($"From hand", () => photonView.RPC("SetFromHand", RpcTarget.All, true), 1),
-                                };
-
-                                    GManager.instance.selectCommandPanel.SetUpCommandButton(command_SelectCommands);
-                                }
+                                List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
+                                    {
+                                        new SelectionElement<bool>(message: $"From Field", value : false, spriteIndex: 0),
+                                        new SelectionElement<bool>(message: $"From hand", value : true, spriteIndex: 1),
+                                    };
 
-                                else
-                                {
-                                    GManager.instance.commandText.OpenCommandText("The opponent is choosing from which area to select a card.");
+                                string selectPlayerMessage = "From which area do you play a card?";
+                                string notSelectPlayerMessage = "The opponent is choosing from which area to play a card.";
 
-                                    #region AIƒ‚�[ƒh
-                                    if (GManager.instance.IsAI)
-                                    {
-                                        SetFromHand(RandomUtility.IsSucceedProbability(0.5f));
-                                    }
-                                    #endregion
-                                }
+                                GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
                             }
 
                             else if (!CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition) && card.Owner.HandCards.Count(CanSelectCardCondition) >= 1)
                             {
-                                SetFromHand(true);
+                                GManager.instance.userSelectionManager.SetBool(true);
                             }
 
                             else if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition) && card.Owner.HandCards.Count(CanSelectCardCondition) == 0)
                             {
-                                SetFromHand(false);
+                                GManager.instance.userSelectionManager.SetBool(false);
                             }
 
-                            yield return new WaitWhile(() => !endSelect);
-                            endSelect = false;
+                            yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
 
-                            GManager.instance.commandText.CloseCommandText();
-                            yield return new WaitWhile(() => GManager.instance.commandText.gameObject.activeSelf);
+                            bool fromHand = GManager.instance.userSelectionManager.SelectedBoolValue;
 
                             List<CardSource> selectedCards = new List<CardSource>();
                             Permanent selectedPermanent = null;
@@ -433,47 +417,31 @@ namespace DCGO.CardEffects.EX2
                                 {
                                     if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition) && card.Owner.HandCards.Count(CanSelectCardCondition) >= 1)
                                     {
-                                        if (card.Owner.isYou)
-                                        {
-                                            GManager.instance.commandText.OpenCommandText("From which area do you select a card?");
-
-                                            List<Command_SelectCommand> command_SelectCommands = new List<Command_SelectCommand>()
-                                {
-                                    new Command_SelectCommand($"From Field", () => photonView.RPC("SetFromHand", RpcTarget.All, false), 0),
-                                    new Command_SelectCommand($"From hand", () => photonView.RPC("SetFromHand", RpcTarget.All, true), 1),
-                                };
-
-                                            GManager.instance.selectCommandPanel.SetUpCommandButton(command_SelectCommands);
-                                        }
+                                        List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
+                                    {
+                                        new SelectionElement<bool>(message: $"From Field", value : false, spriteIndex: 0),
+                                        new SelectionElement<bool>(message: $"From hand", value : true, spriteIndex: 1),
+                                    };
 
-                                        else
-                                        {
-                                            GManager.instance.commandText.OpenCommandText("The opponent is choosing from which area to select a card.");
+                                        string selectPlayerMessage = "From which area do you play a card?";
+                                        string notSelectPlayerMessage = "The opponent is choosing from which area to play a card.";
 
-                                            #region AIƒ‚�[ƒh
-                                            if (GManager.instance.IsAI)
-                                            {
-                                                SetFromHand(RandomUtility.IsSucceedProbability(0.5f));
-                                            }
-                                            #endregion
-                                        }
+                                        GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
                                     }
 
                                     else if (!CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition) && card.Owner.HandCards.Count(CanSelectCardCondition) >= 1)
                                     {
-                                        SetFromHand(true);
+                                        GManager.instance.userSelectionManager.SetBool(true);
                                     }
 
                                     else if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition) && card.Owner.HandCards.Count(CanSelectCardCondition) == 0)
                                     {
-                                        SetFromHand(false);
+                                        GManager.instance.userSelectionManager.SetBool(false);
                                     }
 
-                                    yield return new WaitWhile(() => !endSelect);
-                                    endSelect = false;
+                                    yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
 
-                                    GManager.instance.commandText.CloseCommandText();
-                                    yield return new WaitWhile(() => GManager.instance.commandText.gameObject.activeSelf);
+                                    bool fromHand = GManager.instance.userSelectionManager.SelectedBoolValue;
 
                                     List<CardSource> selectedCards = new List<CardSource>();
                                     Permanent selectedPermanent = null;
@@ -616,15 +584,5 @@ namespace DCGO.CardEffects.EX2
 
             return cardEffects;
         }
-
-        bool endSelect = false;
-        bool fromHand = false;
-
-        [PunRPC]
-        public void SetFromHand(bool fromHand)
-        {
-            this.fromHand = fromHand;
-            endSelect = true;
-        }
     }
 }

Assets/Scripts/CardEffect/EX3/Green/EX3_070.cs

@@ -144,87 +144,40 @@ namespace DCGO.CardEffects.EX3
                         {
                             yield return GManager.instance.photonWaitController.StartWait("AvalonsGate_selectFirst");
 
-                            if (card.Owner.isYou)
+                            if (canSelectEffects.Count((effect) => !activatedEffects.Contains(effect)) >= 2)
                             {
-                                if (canSelectEffects.Count((effect) => !activatedEffects.Contains(effect)) >= 2)
+                                List<SelectionElement<int>> selectionElements = new List<SelectionElement<int>>()
                                 {
-                                    if (canSelectEffects.Count((effect) => !activatedEffects.Contains(effect)) == 2)
-                                    {
-                                        GManager.instance.commandText.OpenCommandText("Which effect will you activate the first?");
-                                    }
-
-                                    List<Command_SelectCommand> command_SelectCommands = new List<Command_SelectCommand>();
-
-                                    for (int i = 0; i < canSelectEffects.Count; i++)
-                                    {
-                                        if (!activatedEffects.Contains(canSelectEffects[i]))
-                                        {
-                                            int k = i;
-
-                                            string message = "";
-
-                                            switch (k)
-                                            {
-                                                case 0:
-                                                    message = "Suspend & gain Pierce";
-                                                    break;
-
-                                                case 1:
-                                                    message = "Unsuspend";
-                                                    break;
-                                            }
-
-                                            command_SelectCommands.Add(new Command_SelectCommand(message, () => photonView.RPC("SetEffectIndex", RpcTarget.All, k), 0));
-                                        }
-                                    }
+                                    new SelectionElement<int>(message: $"Suspend & gain Pierce", value : 0, spriteIndex: 0),
+                                    new SelectionElement<int>(message: $"Unsuspend", value : 1, spriteIndex: 0),
+                                };
 
-                                    GManager.instance.selectCommandPanel.SetUpCommandButton(command_SelectCommands);
-                                }
+                                string selectPlayerMessage = "Which effect will you activate?";
+                                string notSelectPlayerMessage = "The opponent is choosing which effect activates.";
 
-                                else
+                                if (canSelectEffects.Count((effect) => !activatedEffects.Contains(effect)) == 2)
                                 {
-                                    for (int i = 0; i < canSelectEffects.Count; i++)
-                                    {
-                                        if (!activatedEffects.Contains(canSelectEffects[i]))
-                                        {
-                                            photonView.RPC("SetEffectIndex", RpcTarget.All, i);
-                                            break;
-                                        }
-                                    }
+                                    selectPlayerMessage = "Which effect will you activate the first?";
                                 }
+
+                                GManager.instance.userSelectionManager.SetIntSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
                             }
 
                             else
                             {
-                                GManager.instance.commandText.OpenCommandText("The opponent is choosing which effect activates.");
-
-                                #region AIモード
-                                if (GManager.instance.IsAI)
+                                for (int i = 0; i < canSelectEffects.Count; i++)
                                 {
-                                    List<int> indexes = new List<int>();
-
-                                    for (int i = 0; i < canSelectEffects.Count; i++)
+                                    if (!activatedEffects.Contains(canSelectEffects[i]))
                                     {
-                                        if (!activatedEffects.Contains(canSelectEffects[i]))
-                                        {
-                                            int k = i;
-                                            indexes.Add(k);
-                                        }
-                                    }
-
-                                    if (indexes.Count >= 1)
-                                    {
-                                        SetEffectIndex(UnityEngine.Random.Range(0, indexes.Count));
+                                        GManager.instance.userSelectionManager.SetInt(i);
+                                        break;
                                     }
                                 }
-                                #endregion
                             }
 
-                            yield return new WaitWhile(() => !endSelect);
-                            endSelect = false;
+                            yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
 
-                            GManager.instance.commandText.CloseCommandText();
-                            yield return new WaitWhile(() => GManager.instance.commandText.gameObject.activeSelf);
+                            int effectIndex = GManager.instance.userSelectionManager.SelectedIntValue;
 
                             if (0 <= effectIndex && effectIndex <= canSelectEffects.Count - 1)
                             {
@@ -244,36 +197,20 @@ namespace DCGO.CardEffects.EX3
                     #region 名称に「エグザモン」を含むデジモンがいない場合(1つ選択)
                     else
                     {
-                        if (card.Owner.isYou)
+                        List<SelectionElement<int>> selectionElements = new List<SelectionElement<int>>()
                         {
-                            GManager.instance.commandText.OpenCommandText("Which effect will you activate?");
-
-                            List<Command_SelectCommand> command_SelectCommands = new List<Command_SelectCommand>()
-                                {
-                                    new Command_SelectCommand("Suspend & gain Pierce", () => photonView.RPC("SetEffectIndex", RpcTarget.All, 0), 0),
-                                    new Command_SelectCommand("Unsuspend", () => photonView.RPC("SetEffectIndex", RpcTarget.All, 1), 0),
-                                };
-
-                            GManager.instance.selectCommandPanel.SetUpCommandButton(command_SelectCommands);
-                        }
+                            new SelectionElement<int>(message: $"Suspend & gain Pierce", value : 0, spriteIndex: 0),
+                            new SelectionElement<int>(message: $"Unsuspend", value : 1, spriteIndex: 0),
+                        };
 
-                        else
-                        {
-                            GManager.instance.commandText.OpenCommandText("The opponent is choosing which effect activates.");
+                        string selectPlayerMessage = "Which effect will you activate?";
+                        string notSelectPlayerMessage = "The opponent is choosing which effect activates.";
 
-                            #region AIモード
-                            if (GManager.instance.IsAI)
-                            {
-                                SetEffectIndex(UnityEngine.Random.Range(0, canSelectEffects.Count));
-                            }
-                            #endregion
-                        }
+                        GManager.instance.userSelectionManager.SetIntSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
 
-                        yield return new WaitWhile(() => !endSelect);
-                        endSelect = false;
+                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
 
-                        GManager.instance.commandText.CloseCommandText();
-                        yield return new WaitWhile(() => GManager.instance.commandText.gameObject.activeSelf);
+                        int effectIndex = GManager.instance.userSelectionManager.SelectedIntValue;
 
                         if (0 <= effectIndex && effectIndex <= canSelectEffects.Count - 1)
                         {
@@ -365,15 +302,5 @@ namespace DCGO.CardEffects.EX3
 
             return cardEffects;
         }
-
-        int effectIndex = 0;
-        bool endSelect = false;
-
-        [PunRPC]
-        public void SetEffectIndex(int effectIndex)
-        {
-            this.effectIndex = effectIndex;
-            endSelect = true;
-        }
     }
 }

Assets/Scripts/CardEffect/EX3/Red/EX3_066.cs

@@ -147,47 +147,32 @@ namespace DCGO.CardEffects.EX3
                         {
                             if (card.Owner.HandCards.Count(CanSelectCardCondition) >= 1 && CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition))
                             {
-                                if (card.Owner.isYou)
-                                {
-                                    GManager.instance.commandText.OpenCommandText("From which area do you select a card?");
-
-                                    List<Command_SelectCommand> command_SelectCommands = new List<Command_SelectCommand>()
-                                {
-                                    new Command_SelectCommand($"From hand", () => photonView.RPC("SetFromHand", RpcTarget.All, true), 0),
-                                    new Command_SelectCommand($"From trash", () => photonView.RPC("SetFromHand", RpcTarget.All, false), 1),
-                                };
 
-                                    GManager.instance.selectCommandPanel.SetUpCommandButton(command_SelectCommands);
-                                }
+                                List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
+                                    {
+                                        new SelectionElement<bool>(message: $"From hand", value : true, spriteIndex: 0),
+                                        new SelectionElement<bool>(message: $"From trash", value : false, spriteIndex: 1),
+                                    };
 
-                                else
-                                {
-                                    GManager.instance.commandText.OpenCommandText("The opponent is choosing from which area to select a card.");
+                                string selectPlayerMessage = "From which area do you select a card?";
+                                string notSelectPlayerMessage = "The opponent is choosing from which area to select a card.";
 
-                                    #region AIƒ‚�[ƒh
-                                    if (GManager.instance.IsAI)
-                                    {
-                                        SetFromHand(RandomUtility.IsSucceedProbability(0.5f));
-                                    }
-                                    #endregion
-                                }
+                                GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
                             }
 
                             else if (card.Owner.HandCards.Count(CanSelectCardCondition) == 0 && CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition))
                             {
-                                SetFromHand(false);
+                                GManager.instance.userSelectionManager.SetBool(false);
                             }
 
                             else if (card.Owner.HandCards.Count(CanSelectCardCondition) >= 1 && card.Owner.TrashCards.Count(CanSelectCardCondition) == 0)
                             {
-                                SetFromHand(true);
+                                GManager.instance.userSelectionManager.SetBool(true);
                             }
 
-                            yield return new WaitWhile(() => !endSelect);
-                            endSelect = false;
+                            yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
 
-                            GManager.instance.commandText.CloseCommandText();
-                            yield return new WaitWhile(() => GManager.instance.commandText.gameObject.activeSelf);
+                            bool fromHand = GManager.instance.userSelectionManager.SelectedBoolValue;
 
                             List<CardSource> selectedCards = new List<CardSource>();
 
@@ -329,15 +314,5 @@ namespace DCGO.CardEffects.EX3
 
             return cardEffects;
         }
-
-        bool endSelect = false;
-        bool fromHand = false;
-
-        [PunRPC]
-        public void SetFromHand(bool fromHand)
-        {
-            this.fromHand = fromHand;
-            endSelect = true;
-        }
     }
 }

Assets/Scripts/CardEffect/EX4/Black/EX4_049.cs

@@ -57,38 +57,21 @@ namespace DCGO.CardEffects.EX4
                         if (card.Owner.GetBattleAreaDigimons().Contains(card.PermanentOfThisCard()))
                         {
                             yield return GManager.instance.photonWaitController.StartWait("Kuresgarurumon_Select_ETB");
-
-                            if (card.Owner.isYou)
+                            List<SelectionElement<int>> selectionElements = new List<SelectionElement<int>>()
                             {
-                                GManager.instance.commandText.OpenCommandText("Which effect will you activate?");
-
-                                List<Command_SelectCommand> command_SelectCommands = new List<Command_SelectCommand>()
-                                {
-                                    new Command_SelectCommand($"Deck Bounce", () => photonView.RPC("SetActionID", RpcTarget.All, 0), 0),
-                                    new Command_SelectCommand($"Your other 1 Digimon digivolves", () => photonView.RPC("SetActionID", RpcTarget.All, 1), 0),
-                                    new Command_SelectCommand($"DNA Digivolution", () => photonView.RPC("SetActionID", RpcTarget.All, 2), 0),
-                                };
+                                new SelectionElement<int>(message: $"Deck Bounce", value : 0, spriteIndex: 0),
+                                new SelectionElement<int>(message: $"Your other 1 Digimon digivolves", value : 1, spriteIndex: 0),
+                                new SelectionElement<int>(message: $"DNA Digivolution", value : 2, spriteIndex: 0),
+                            };
 
-                                GManager.instance.selectCommandPanel.SetUpCommandButton(command_SelectCommands);
-                            }
+                            string selectPlayerMessage = "Which effect will you activate?";
+                            string notSelectPlayerMessage = "The opponent is choosing which effect to activate.";
 
-                            else
-                            {
-                                GManager.instance.commandText.OpenCommandText("The opponent is choosing which effect to activate.");
-
-                                #region AI
-                                if (GManager.instance.IsAI)
-                                {
-                                    SetActionID(UnityEngine.Random.Range(0, 3));
-                                }
-                                #endregion
-                            }
+                            GManager.instance.userSelectionManager.SetIntSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
 
-                            yield return new WaitWhile(() => !endSelect);
-                            endSelect = false;
+                            yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
 
-                            GManager.instance.commandText.CloseCommandText();
-                            yield return new WaitWhile(() => GManager.instance.commandText.gameObject.activeSelf);
+                            int actionID = GManager.instance.userSelectionManager.SelectedIntValue;
 
                             switch (actionID)
                             {
@@ -580,14 +563,6 @@ namespace DCGO.CardEffects.EX4
         }
 
         bool endSelect = false;
-        int actionID = -1;
-
-        [PunRPC]
-        public void SetActionID(int actionID)
-        {
-            this.actionID = actionID;
-            endSelect = true;
-        }
 
         int[] JogressEvoRootsFrameIDs = new int[0];
 

Assets/Scripts/CardEffect/EX4/Black/EX4_051.cs

@@ -57,38 +57,21 @@ namespace DCGO.CardEffects.EX4
                         if (card.Owner.GetBattleAreaDigimons().Contains(card.PermanentOfThisCard()))
                         {
                             yield return GManager.instance.photonWaitController.StartWait("Kuresgarurumon_Select_ETB");
-
-                            if (card.Owner.isYou)
+                            List<SelectionElement<int>> selectionElements = new List<SelectionElement<int>>()
                             {
-                                GManager.instance.commandText.OpenCommandText("Which effect will you activate?");
-
-                                List<Command_SelectCommand> command_SelectCommands = new List<Command_SelectCommand>()
-                                {
-                                    new Command_SelectCommand($"De-Digivolve", () => photonView.RPC("SetActionID", RpcTarget.All, 0), 0),
-                                    new Command_SelectCommand($"Your other 1 Digimon digivolves", () => photonView.RPC("SetActionID", RpcTarget.All, 1), 0),
-                                    new Command_SelectCommand($"DNA Digivolution", () => photonView.RPC("SetActionID", RpcTarget.All, 2), 0),
-                                };
+                                new SelectionElement<int>(message: $"De-Digivolve", value : 0, spriteIndex: 0),
+                                new SelectionElement<int>(message: $"Your other 1 Digimon digivolves", value : 1, spriteIndex: 0),
+                                new SelectionElement<int>(message: $"DNA Digivolution", value : 2, spriteIndex: 0),
+                            };
 
-                                GManager.instance.selectCommandPanel.SetUpCommandButton(command_SelectCommands);
-                            }
+                            string selectPlayerMessage = "Which effect will you activate?";
+                            string notSelectPlayerMessage = "The opponent is choosing which effect to activate.";
 
-                            else
-                            {
-                                GManager.instance.commandText.OpenCommandText("The opponent is choosing which effect to activate.");
-
-                                #region AI
-                                if (GManager.instance.IsAI)
-                                {
-                                    SetActionID(UnityEngine.Random.Range(0, 3));
-                                }
-                                #endregion
-                            }
+                            GManager.instance.userSelectionManager.SetIntSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
 
-                            yield return new WaitWhile(() => !endSelect);
-                            endSelect = false;
+                            yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
 
-                            GManager.instance.commandText.CloseCommandText();
-                            yield return new WaitWhile(() => GManager.instance.commandText.gameObject.activeSelf);
+                            int actionID = GManager.instance.userSelectionManager.SelectedIntValue;
 
                             switch (actionID)
                             {
@@ -430,14 +413,6 @@ namespace DCGO.CardEffects.EX4
         }
 
         bool endSelect = false;
-        int actionID = -1;
-
-        [PunRPC]
-        public void SetActionID(int actionID)
-        {
-            this.actionID = actionID;
-            endSelect = true;
-        }
 
         int[] JogressEvoRootsFrameIDs = new int[0];
 

Assets/Scripts/CardEffect/P/Blue/P_012.cs

@@ -53,37 +53,20 @@ public class P_012 : CEntity_Effect
                         yield return ContinuousController.instance.StartCoroutine(new SuspendPermanentsClass(new List<Permanent>() { card.PermanentOfThisCard() }, hashtable).Tap());
 
                         yield return GManager.instance.photonWaitController.StartWait("Taichi_Select");
-
-                        if (card.Owner.isYou)
+                        List<SelectionElement<int>> selectionElements = new List<SelectionElement<int>>()
                         {
-                            GManager.instance.commandText.OpenCommandText("Which effect will you activate?");
+                            new SelectionElement<int>(message: $"Draw 1", value : 0, spriteIndex: 0),
+                            new SelectionElement<int>(message: $"DP +1000", value : 1, spriteIndex: 0),
+                        };
 
-                            List<Command_SelectCommand> command_SelectCommands = new List<Command_SelectCommand>()
-                                {
-                                    new Command_SelectCommand($"Draw 1", () => photonView.RPC("SetActionID", RpcTarget.All, 0), 0),
-                                    new Command_SelectCommand($"DP +1000", () => photonView.RPC("SetActionID", RpcTarget.All, 1), 0),
-                                };
+                        string selectPlayerMessage = "Which effect will you activate?";
+                        string notSelectPlayerMessage = "The opponent is choosing which effect to activate.";
 
-                            GManager.instance.selectCommandPanel.SetUpCommandButton(command_SelectCommands);
-                        }
-
-                        else
-                        {
-                            GManager.instance.commandText.OpenCommandText("The opponent is choosing which effect to activate.");
-
-                            #region AIƒ‚�[ƒh
-                            if (GManager.instance.IsAI)
-                            {
-                                SetActionID(UnityEngine.Random.Range(0, 2));
-                            }
-                            #endregion
-                        }
+                        GManager.instance.userSelectionManager.SetIntSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
 
-                        yield return new WaitWhile(() => !endSelect);
-                        endSelect = false;
+                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
 
-                        GManager.instance.commandText.CloseCommandText();
-                        yield return new WaitWhile(() => GManager.instance.commandText.gameObject.activeSelf);
+                        int actionID = GManager.instance.userSelectionManager.SelectedIntValue;
 
                         switch (actionID)
                         {
@@ -139,14 +122,4 @@ public class P_012 : CEntity_Effect
 
         return cardEffects;
     }
-
-    bool endSelect = false;
-    int actionID = -1;
-
-    [PunRPC]
-    public void SetActionID(int actionID)
-    {
-        this.actionID = actionID;
-        endSelect = true;
-    }
 }

Assets/Scripts/CardEffect/P/Purple/P_115.cs

@@ -108,47 +108,31 @@ public class P_115 : CEntity_Effect
                 {
                     if (card.Owner.HandCards.Count(CanSelectCardCondition) >= 1 && CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition))
                     {
-                        if (card.Owner.isYou)
-                        {
-                            GManager.instance.commandText.OpenCommandText("From which area do you play a card?");
-
-                            List<Command_SelectCommand> command_SelectCommands = new List<Command_SelectCommand>()
-                                {
-                                    new Command_SelectCommand($"From hand", () => photonView.RPC("SetFromHand", RpcTarget.All, true), 0),
-                                    new Command_SelectCommand($"From trash", () => photonView.RPC("SetFromHand", RpcTarget.All, false), 1),
-                                };
-
-                            GManager.instance.selectCommandPanel.SetUpCommandButton(command_SelectCommands);
-                        }
+                        List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
+                                    {
+                                        new SelectionElement<bool>(message: $"From hand", value : true, spriteIndex: 0),
+                                        new SelectionElement<bool>(message: $"From trash", value : false, spriteIndex: 1),
+                                    };
 
-                        else
-                        {
-                            GManager.instance.commandText.OpenCommandText("The opponent is choosing from which area to play a card.");
+                        string selectPlayerMessage = "From which area do you play a card?";
+                        string notSelectPlayerMessage = "The opponent is choosing from which area to play a card.";
 
-                            #region AIモード
-                            if (GManager.instance.IsAI)
-                            {
-                                SetFromHand(RandomUtility.IsSucceedProbability(0.5f));
-                            }
-                            #endregion
-                        }
+                        GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
                     }
 
                     else if (card.Owner.HandCards.Count(CanSelectCardCondition) == 0 && CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition))
                     {
-                        SetFromHand(false);
+                        GManager.instance.userSelectionManager.SetBool(false);
                     }
 
                     else if (card.Owner.HandCards.Count(CanSelectCardCondition) >= 1 && card.Owner.TrashCards.Count(CanSelectCardCondition) == 0)
                     {
-                        SetFromHand(true);
+                        GManager.instance.userSelectionManager.SetBool(true);
                     }
 
-                    yield return new WaitWhile(() => !endSelect);
-                    endSelect = false;
+                    yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
 
-                    GManager.instance.commandText.CloseCommandText();
-                    yield return new WaitWhile(() => GManager.instance.commandText.gameObject.activeSelf);
+                    bool fromHand = GManager.instance.userSelectionManager.SelectedBoolValue;
 
                     List<CardSource> selectedCards = new List<CardSource>();
 
@@ -274,14 +258,4 @@ public class P_115 : CEntity_Effect
 
         return cardEffects;
     }
-
-    bool endSelect = false;
-    bool fromHand = false;
-
-    [PunRPC]
-    public void SetFromHand(bool fromHand)
-    {
-        this.fromHand = fromHand;
-        endSelect = true;
-    }
 }