Sanguosha.UI.Controls.PlayerViewModel.AskForCardUsage C# (CSharp) Method

        public void AskForCardUsage(Prompt prompt, ICardUsageVerifier verifier, int timeOutSeconds)
        {
            if (ViewModelBase.IsDetached) return;
            Trace.Assert(!Player.IsDead);
            Application.Current.Dispatcher.Invoke((ThreadStart)delegate()
            {
                GameModel.CurrentActivePlayer = this;
                TimeOutSeconds = timeOutSeconds;
                currentUsageVerifier = verifier;
                Trace.Assert(currentUsageVerifier != null);
                CurrentPrompt = prompt;
                CurrentPromptString = LogFormatter.Translate(prompt);

                if (prompt.Values.Count != 0 && prompt.Values[0] is TriggerSkill)
                {
                    var triggerSkill = (prompt.Values[0] as TriggerSkill);
                    foreach (var skill in SkillCommands)
                    {
                        if (skill.Skill is CardTransformSkill && (skill.Skill as CardTransformSkill).LinkedPassiveSkill != triggerSkill) continue;
                        if (skill.Skill is ActiveSkill && (skill.Skill as ActiveSkill).LinkedPassiveSkill != triggerSkill) continue;
                        if (skill.Skill is TriggerSkill && skill.Skill != triggerSkill) continue;
                        skill.IsHighlighted = true;
                        break;
                    }
                }

                if (verifier != null)
                {
                    foreach (var skillCommand in ActiveSkillCommands)
                    {
                        skillCommand.IsEnabled = (currentUsageVerifier.Verify(HostPlayer, skillCommand.Skill, new List<Card>(), new List<Player>()) != VerifierResult.Fail);
                    }

                    if (verifier.Helper != null &&
                    verifier.Helper.OtherDecksUsed != null && verifier.Helper.OtherDecksUsed.Count != 0)
                    {
                        var helper = verifier.Helper;
                        if (helper.OtherDecksUsed.Count > 0)
                        {
                            if (helper.OtherDecksUsed.Count != 1)
                            {
                                throw new NotImplementedException("Currently using more than one private decks is not supported");
                            }
                            var deck = helper.OtherDecksUsed[0];
                            var deckModel = PrivateDecks.FirstOrDefault(d => d.Name == deck.Name);
                            Trace.Assert(deckModel != null);
                            if (deckModel != CurrentSpecialDeck)
                            {
                                if (CurrentSpecialDeck != null)
                                {
                                    foreach (var card in CurrentSpecialDeck.Cards)
                                    {
                                        card.IsSelectionMode = false;
                                        card.OnSelectedChanged -= _OnCardSelected;
                                    }
                                }
                                foreach (var card in deckModel.Cards)
                                {
                                    card.IsSelectionMode = IsPlayable;
                                    card.OnSelectedChanged += _OnCardSelected;
                                }
                                CurrentSpecialDeck = deckModel;
                            }
                        }
                    }
                }

                if (!IsPlayable)
                {
                    TimeOutSeconds = timeOutSeconds;
                    CardUsageAnsweredEvent(null, null, null);
                    return;
                }

                foreach (var equipCommand in EquipCommands)
                {
                    equipCommand.OnSelectedChanged += _OnCardUsageSelectionChanged;
                    equipCommand.IsSelectionMode = true;
                }

                foreach (var card in HandCards)
                {
                    card.IsSelectionMode = true;
                    card.OnSelectedChanged += _OnCardSelected;
                }

                foreach (var playerModel in _game.PlayerModels)
                {
                    playerModel.IsSelectionMode = true;
                    playerModel.IsSelectionRepeatable = verifier.Helper.IsPlayerRepeatable;
                    playerModel.OnSelectedChanged += _OnCardUsageSelectionChanged;
                }

                foreach (var skillCommand in ActiveSkillCommands)
                {
                    if (skillCommand is GuHuoSkillCommand)
                    {
                        (skillCommand as GuHuoSkillCommand).GuHuoChoice = null;
                    }
                    skillCommand.OnSelectedChanged += _OnSkillCommandSelected;
                }

                if (verifier.AcceptableCardTypes != null)
                {
                    var defaultCard = HandCards.FirstOrDefault(c =>
                        verifier.Verify(HostPlayer, null, new List<Card>() { c.Card }, new List<Player>()) == VerifierResult.Success);
                    if (defaultCard != null)
                    {
                        defaultCard.IsSelected = true;
                    }
                }

                // @todo: update this.
                SubmitAnswerCommand = submitCardUsageCommand;
                CancelAnswerCommand = cancelCardUsageCommand;
                AbortAnswerCommand = abortCardUsageCommand;
                abortCardUsageCommand.CanExecuteStatus = currentUsageVerifier.Helper.IsActionStage;
                cancelCardUsageCommand.CanExecuteStatus = !currentUsageVerifier.Helper.IsActionStage;

                _UpdateCardUsageStatus();
            });
        }