Exemplo n.º 1
0
 private void Start()
 {
     if (cardView.CanBePlayed(ownerPlayer))
     {
         cardView.SetHighlightingEnabled(true);
     }
     else
     {
         cardView.SetHighlightingEnabled(false);
     }
 }
    public void PlayCard(CardView card)
    {
        if (card.CanBePlayed(this))
        {
            gameUI.endTurnButton.SetEnabled(false);

            var gameConfig  = GameManager.Instance.config;
            var libraryCard = gameConfig.GetCard(card.card.cardId);
            var cardType    = gameConfig.cardTypes.Find(x => x.id == libraryCard.cardTypeId);
            if (cardType.name == "Creature")
            {
                var boardCreature = Instantiate(boardCreaturePrefab);

                var board = GameObject.Find("PlayerBoard");
                boardCreature.tag = "PlayerOwned";
                boardCreature.transform.parent   = board.transform;
                boardCreature.transform.position = new Vector2(1.9f * playerBoardCards.Count, 0);
                boardCreature.GetComponent <BoardCreature>().ownerPlayer = this;
                boardCreature.GetComponent <BoardCreature>().PopulateWithInfo(card.card);

                playerHandCards.Remove(card);
                RearrangeHand();
                playerBoardCards.Add(boardCreature.GetComponent <BoardCreature>());

                Destroy(card.gameObject);

                currentCreature = boardCreature.GetComponent <BoardCreature>();

                RearrangeBottomBoard(() =>
                {
                    var triggeredAbilities             = libraryCard.abilities.FindAll(x => x is TriggeredAbility);
                    TriggeredAbility targetableAbility = null;
                    foreach (var ability in triggeredAbilities)
                    {
                        var triggeredAbility = ability as TriggeredAbility;
                        var trigger          = triggeredAbility.trigger as OnCardEnteredZoneTrigger;
                        if (trigger != null && trigger.zoneId == boardZone.zoneId && triggeredAbility.target is IUserTarget)
                        {
                            targetableAbility = triggeredAbility;
                            break;
                        }
                    }

                    // Preemptively move the card so that the effect solver can properly check the availability of targets
                    // by also taking into account this card (that is trying to be played).
                    playerInfo.namedZones["Hand"].RemoveCard(card.card);
                    playerInfo.namedZones["Board"].AddCard(card.card);

                    if (targetableAbility != null && effectSolver.AreTargetsAvailable(targetableAbility.effect, card.card, targetableAbility.target))
                    {
                        var targetingArrow = Instantiate(spellTargetingArrowPrefab).GetComponent <SpellTargetingArrow>();
                        boardCreature.GetComponent <BoardCreature>().abilitiesTargetingArrow = targetingArrow;
                        targetingArrow.effectTarget      = targetableAbility.target;
                        targetingArrow.targetType        = targetableAbility.target.GetTarget();
                        targetingArrow.onTargetSelected += () =>
                        {
                            PlayCreatureCard(card.card, targetingArrow.targetInfo);
                            effectSolver.MoveCard(netId, card.card, "Hand", "Board", targetingArrow.targetInfo);
                            currentCreature = null;
                            gameUI.endTurnButton.SetEnabled(true);
                        };
                        targetingArrow.Begin(boardCreature.transform.localPosition);
                    }
                    else
                    {
                        PlayCreatureCard(card.card);
                        effectSolver.MoveCard(netId, card.card, "Hand", "Board");
                        currentCreature = null;
                        gameUI.endTurnButton.SetEnabled(true);
                    }
                    boardCreature.GetComponent <BoardCreature>().fightTargetingArrowPrefab = fightTargetingArrowPrefab;
                });
            }
            else if (cardType.name == "Spell")
            {
                var spellsPivot = GameObject.Find("PlayerSpellsPivot");
                var sequence    = DOTween.Sequence();
                sequence.Append(card.transform.DOMove(spellsPivot.transform.position, 0.5f));
                sequence.Insert(0, card.transform.DORotate(Vector3.zero, 0.2f));
                sequence.Play().OnComplete(() =>
                {
                    card.GetComponent <SortingGroup>().sortingLayerName = "BoardCards";
                    card.GetComponent <SortingGroup>().sortingOrder     = 1000;

                    var boardSpell = card.gameObject.AddComponent <BoardSpell>();

                    var triggeredAbilities             = libraryCard.abilities.FindAll(x => x is TriggeredAbility);
                    TriggeredAbility targetableAbility = null;
                    foreach (var ability in triggeredAbilities)
                    {
                        var triggeredAbility = ability as TriggeredAbility;
                        var trigger          = triggeredAbility.trigger as OnCardEnteredZoneTrigger;
                        if (trigger != null && trigger.zoneId == boardZone.zoneId && triggeredAbility.target is IUserTarget)
                        {
                            targetableAbility = triggeredAbility;
                            break;
                        }
                    }

                    currentSpellCard = card;

                    if (targetableAbility != null && effectSolver.AreTargetsAvailable(targetableAbility.effect, card.card, targetableAbility.target))
                    {
                        var targetingArrow               = Instantiate(spellTargetingArrowPrefab).GetComponent <SpellTargetingArrow>();
                        boardSpell.targetingArrow        = targetingArrow;
                        targetingArrow.effectTarget      = targetableAbility.target;
                        targetingArrow.targetType        = targetableAbility.target.GetTarget();
                        targetingArrow.onTargetSelected += () =>
                        {
                            PlaySpellCard(card.card, targetingArrow.targetInfo);
                            effectSolver.MoveCard(netId, card.card, "Hand", "Board", targetingArrow.targetInfo);
                            currentSpellCard = null;
                            gameUI.endTurnButton.SetEnabled(true);
                        };
                        targetingArrow.Begin(boardSpell.transform.localPosition);
                    }
                    else
                    {
                        PlaySpellCard(card.card);
                        effectSolver.MoveCard(netId, card.card, "Hand", "Board");
                        currentSpellCard = null;
                        gameUI.endTurnButton.SetEnabled(true);
                    }
                });
            }
        }
        else
        {
            card.GetComponent <HandCard>().ResetToInitialPosition();
        }
    }