Пример #1
0
    public void AttackCard(Card attackingCard, Card attackedCard)
    {
        BattleRow attackedCardRow = attackedCard.currentRow;

        attackedCard.OnCardAttacked(attackingCard);
        attackingCard.OnCardAttack();

        if (attackedCard.ShouldBeDestroyed())
        {
            UnitAttackType attackingUnitAttackType = attackingCard.GetUnitInstance().GetUnit().unitAttackType;
            if (attackingUnitAttackType == UnitAttackType.Melee)
            {
                if (attackedCardRow.GetCardsFromCountryOtherThatArgument(attackingCard.Country).Count <= 0)
                {
                    MoveCardToRow(attackingCard, attackedCardRow.RowIndex);
                }
            }

            attackedCard.currentRow.RemoveCardFromRow(attackedCard);

            //Remove card from proper controller (AI or Player)
            if (attackedCard.Country.isPlayerCountry)
            {
                RemovePlayerCard(attackedCard);
            }
            else
            {
                BattleAI.instance.RemoveCard(attackedCard);
            }

            Destroy(attackedCard.gameObject);
        }
    }
Пример #2
0
    public bool MoveCardToOtherRow(Card card, int targetRowIndex)
    {
        if (HaveCardEnoughStaminaToMove(card, targetRowIndex) && battlefield.IsRoadToRowClear(card, targetRowIndex))
        {
            BattleRow targetRow = battlefield.MoveCardToRow(card, targetRowIndex);
            currentCardAction = new CardActionMove(card, card.gameObject, new Vector3(targetRow.transform.position.x, card.transform.position.y, targetRow.transform.position.z));
            return(true);
        }

        return(false);
    }
Пример #3
0
    void HighlightRowOnProperColor(int i, Card card, int maxMoveDistance, ref bool foundEnemyCard)
    {
        BattleRow targetRow = GetBattleRowByIndex(i);

        if (i != card.currentRow.RowIndex)
        {
            if (targetRow.GetCardsFromCountryOtherThatArgument(card.Country).Count > 0)
            {
                foundEnemyCard = true;
                rows[i].SetHighlightActive(true, BattleRow.HighlightType.Attack);
            }
            else if (!foundEnemyCard && Mathf.Abs(i - card.currentRow.RowIndex) <= maxMoveDistance)
            {
                rows[i].SetHighlightActive(true, BattleRow.HighlightType.Normal);
            }
        }
    }
Пример #4
0
    void GenerateBattlefield(int width)
    {
        InitRows();

        for (int i = 0; i < width; i++)
        {
            Vector3   targetPos = new Vector3((i * rowWidth) - (rowWidth * (width - 1)) / 2f, -0.9f, 0) + battlefieldCenter.position;
            BattleRow battleRow = Instantiate(rowPrefab, targetPos, Quaternion.Euler(0, 0, 0));
            battleRow.transform.localScale = new Vector3(rowWidth, 1, 17.5f);
            battleRow.transform.SetParent(transform);
            battleRow.Setup(i);

            battleRow.GetComponent <BoxCollider>().enabled = false;
            battleRow.GetComponent <BoxCollider>().enabled = true;

            rows[i] = battleRow;
        }
    }
Пример #5
0
    IEnumerator MakeTurnWait()
    {
        List <Card> cards = myCards.GetCards();

        for (int i = 0; i < cards.Count; i++)
        {
            Card      currCard = cards[i];
            BattleRow nextRow  = GetRowWithOffsetFromCard(currCard, 1);
            if (nextRow)
            {
                //Move(currCard);
                int maxRowsAvailableToMove = 0;
                for (int j = 0; j <= currCard.GetUnitInstance().currentStamina; j++)
                {
                    StartCoroutine(AttackIfCan(currCard));
                    yield return(new WaitUntil(() => attackFinished));

                    attackFinished = false;

                    if (nextRow)
                    {
                        if (nextRow.GetCardsFromCountryOtherThatArgument(currCard.Country).Count <= 0)
                        {
                            maxRowsAvailableToMove++;
                        }
                        else
                        {
                            break;
                        }
                    }

                    BattleRow destinationRow = GetRowWithOffsetFromCard(currCard, 1);
                    BattleController.instance.MoveCardToOtherRow(currCard, destinationRow.RowIndex);

                    yield return(new WaitUntil(() => BattleController.instance.IsCardActionFinished()));
                }
            }

            yield return(new WaitUntil(() => BattleController.instance.IsCardActionFinished()));
        }
    }
Пример #6
0
    IEnumerator AttackIfCan(Card controlledCard)
    {
        int       rowOffset = 1;
        BattleRow nextRow   = GetRowWithOffsetFromCard(controlledCard, rowOffset);

        while (nextRow && controlledCard.GetUnitInstance().currentStamina >= 1 && controlledCard.GetUnitInstance().GetUnit().attackRange >= rowOffset)
        {
            List <Card> cardsToAttack = nextRow.GetCardsFromCountryOtherThatArgument(controlledCard.Country);
            Card        cardToAttack  = null;
            if (cardsToAttack.Count > 0)
            {
                cardToAttack = cardsToAttack[0];
                BattleController.instance.AttackCard(controlledCard, cardToAttack);
                yield return(new WaitUntil(() => BattleController.instance.IsCardActionFinished()));
            }
            else
            {
                rowOffset++;
                nextRow = GetRowWithOffsetFromCard(controlledCard, rowOffset);
            }
        }

        attackFinished = true;
    }