Examples with ConditionalMana mage.ConditionalMana used on opensource projects

Example 11 with ConditionalMana

use of mage.ConditionalMana in project mage by magefree.

the class ManaPool method removeConditional.

private void removeConditional(ConditionalManaInfo manaInfo, Ability ability, Game game, Cost costToPay, Mana usedManaToPay) {
    for (ConditionalMana mana : getConditionalMana()) {
        if (mana.get(manaInfo.manaType) > 0 && mana.apply(ability, game, mana.getManaProducerId(), costToPay)) {
            mana.set(manaInfo.manaType, CardUtil.overflowDec(mana.get(manaInfo.manaType), 1));
            usedManaToPay.increase(manaInfo.manaType);
            GameEvent event = new ManaPaidEvent(ability, mana.getManaProducerId(), mana.getFlag(), mana.getManaProducerOriginalId(), manaInfo.sourceObject, manaInfo.manaType);
            game.fireEvent(event);
            break;
        }
    }
}

Example 12 with ConditionalMana

use of mage.ConditionalMana in project mage by magefree.

the class ManaPool method emptyPool.

public int emptyPool(Game game) {
    int total = 0;
    Iterator<ManaPoolItem> it = manaItems.iterator();
    while (it.hasNext()) {
        ManaPoolItem item = it.next();
        ConditionalMana conditionalItem = item.getConditionalMana();
        for (ManaType manaType : ManaType.values()) {
            if (doNotEmptyManaTypes.contains(manaType)) {
                continue;
            }
            if (item.get(manaType) > 0) {
                total += emptyItem(item, item, game, manaType);
            }
            if (conditionalItem != null && conditionalItem.get(manaType) > 0) {
                total += emptyItem(item, conditionalItem, game, manaType);
            }
        }
        if (item.count() == 0) {
            it.remove();
        }
    }
    return total;
}

Example 13 with ConditionalMana

use of mage.ConditionalMana in project mage by magefree.

the class ComputerPlayer method playManaHandling.

protected boolean playManaHandling(Ability ability, ManaCost unpaid, final Game game) {
    // log.info("paying for " + unpaid.getText());
    ApprovingObject approvingObject = game.getContinuousEffects().asThough(ability.getSourceId(), AsThoughEffectType.SPEND_OTHER_MANA, ability, ability.getControllerId(), game);
    ManaCost cost;
    List<MageObject> producers;
    if (unpaid instanceof ManaCosts) {
        ManaCosts<ManaCost> manaCosts = (ManaCosts<ManaCost>) unpaid;
        cost = manaCosts.get(manaCosts.size() - 1);
        producers = getSortedProducers((ManaCosts) unpaid, game);
    } else {
        cost = unpaid;
        producers = this.getAvailableManaProducers(game);
        producers.addAll(this.getAvailableManaProducersWithCost(game));
    }
    for (MageObject mageObject : producers) {
        // otherwise the computer may not be able to pay the cost for that source
        ManaAbility: for (ActivatedManaAbilityImpl manaAbility : getManaAbilitiesSortedByManaCount(mageObject, game)) {
            int colored = 0;
            for (Mana mana : manaAbility.getNetMana(game)) {
                if (!unpaid.getMana().includesMana(mana)) {
                    continue ManaAbility;
                }
                colored += mana.countColored();
            }
            if (colored > 1 && (cost instanceof ColoredManaCost)) {
                for (Mana netMana : manaAbility.getNetMana(game)) {
                    if (cost.testPay(netMana)) {
                        if (netMana instanceof ConditionalMana && !((ConditionalMana) netMana).apply(ability, game, getId(), cost)) {
                            continue;
                        }
                        if (approvingObject != null && !canUseAsThoughManaToPayManaCost(cost, ability, netMana, manaAbility, mageObject, game)) {
                            continue;
                        }
                        if (activateAbility(manaAbility, game)) {
                            return true;
                        }
                    }
                }
            }
        }
    }
    for (MageObject mageObject : producers) {
        // pay all colored costs first
        for (ActivatedManaAbilityImpl manaAbility : getManaAbilitiesSortedByManaCount(mageObject, game)) {
            if (cost instanceof ColoredManaCost) {
                for (Mana netMana : manaAbility.getNetMana(game)) {
                    if (cost.testPay(netMana) || approvingObject != null) {
                        if (netMana instanceof ConditionalMana && !((ConditionalMana) netMana).apply(ability, game, getId(), cost)) {
                            continue;
                        }
                        if (approvingObject != null && !canUseAsThoughManaToPayManaCost(cost, ability, netMana, manaAbility, mageObject, game)) {
                            continue;
                        }
                        if (activateAbility(manaAbility, game)) {
                            return true;
                        }
                    }
                }
            }
        }
        // pay snow covered mana
        for (ActivatedManaAbilityImpl manaAbility : getManaAbilitiesSortedByManaCount(mageObject, game)) {
            if (cost instanceof SnowManaCost) {
                for (Mana netMana : manaAbility.getNetMana(game)) {
                    if (cost.testPay(netMana) || approvingObject != null) {
                        if (netMana instanceof ConditionalMana && !((ConditionalMana) netMana).apply(ability, game, getId(), cost)) {
                            continue;
                        }
                        if (approvingObject != null && !canUseAsThoughManaToPayManaCost(cost, ability, netMana, manaAbility, mageObject, game)) {
                            continue;
                        }
                        if (activateAbility(manaAbility, game)) {
                            return true;
                        }
                    }
                }
            }
        }
        // then pay hybrid
        for (ActivatedManaAbilityImpl manaAbility : getManaAbilitiesSortedByManaCount(mageObject, game)) {
            if (cost instanceof HybridManaCost) {
                for (Mana netMana : manaAbility.getNetMana(game)) {
                    if (cost.testPay(netMana) || approvingObject != null) {
                        if (netMana instanceof ConditionalMana && !((ConditionalMana) netMana).apply(ability, game, getId(), cost)) {
                            continue;
                        }
                        if (approvingObject != null && !canUseAsThoughManaToPayManaCost(cost, ability, netMana, manaAbility, mageObject, game)) {
                            continue;
                        }
                        if (activateAbility(manaAbility, game)) {
                            return true;
                        }
                    }
                }
            }
        }
        // then pay mono hybrid
        for (ActivatedManaAbilityImpl manaAbility : getManaAbilitiesSortedByManaCount(mageObject, game)) {
            if (cost instanceof MonoHybridManaCost) {
                for (Mana netMana : manaAbility.getNetMana(game)) {
                    if (cost.testPay(netMana) || approvingObject != null) {
                        if (netMana instanceof ConditionalMana && !((ConditionalMana) netMana).apply(ability, game, getId(), cost)) {
                            continue;
                        }
                        if (approvingObject != null && !canUseAsThoughManaToPayManaCost(cost, ability, netMana, manaAbility, mageObject, game)) {
                            continue;
                        }
                        if (activateAbility(manaAbility, game)) {
                            return true;
                        }
                    }
                }
            }
        }
        // pay colorless
        for (ActivatedManaAbilityImpl manaAbility : getManaAbilitiesSortedByManaCount(mageObject, game)) {
            if (cost instanceof ColorlessManaCost) {
                for (Mana netMana : manaAbility.getNetMana(game)) {
                    if (cost.testPay(netMana) || approvingObject != null) {
                        if (netMana instanceof ConditionalMana && !((ConditionalMana) netMana).apply(ability, game, getId(), cost)) {
                            continue;
                        }
                        if (approvingObject != null && !canUseAsThoughManaToPayManaCost(cost, ability, netMana, manaAbility, mageObject, game)) {
                            continue;
                        }
                        if (activateAbility(manaAbility, game)) {
                            return true;
                        }
                    }
                }
            }
        }
        // finally pay generic
        for (ActivatedManaAbilityImpl manaAbility : getManaAbilitiesSortedByManaCount(mageObject, game)) {
            if (cost instanceof GenericManaCost) {
                for (Mana netMana : manaAbility.getNetMana(game)) {
                    if (cost.testPay(netMana) || approvingObject != null) {
                        if (netMana instanceof ConditionalMana && !((ConditionalMana) netMana).apply(ability, game, getId(), cost)) {
                            continue;
                        }
                        if (approvingObject != null && !canUseAsThoughManaToPayManaCost(cost, ability, netMana, manaAbility, mageObject, game)) {
                            continue;
                        }
                        if (activateAbility(manaAbility, game)) {
                            return true;
                        }
                    }
                }
            }
        }
    }
    // pay phyrexian life costs
    if (cost.isPhyrexian()) {
        return cost.pay(ability, game, ability, playerId, false, null) || approvingObject != null;
    }
    // pay special mana like convoke cost (tap for pay)
    // GUI: user see "special" button while pay spell's cost
    // TODO: AI can't prioritize special mana types to pay, e.g. it will use first available
    SpecialAction specialAction = game.getState().getSpecialActions().getControlledBy(this.getId(), true).values().stream().findFirst().orElse(null);
    ManaOptions specialMana = specialAction == null ? null : specialAction.getManaOptions(ability, game, unpaid);
    if (specialMana != null) {
        for (Mana netMana : specialMana) {
            if (cost.testPay(netMana) || approvingObject != null) {
                if (netMana instanceof ConditionalMana && !((ConditionalMana) netMana).apply(ability, game, getId(), cost)) {
                    continue;
                }
                specialAction.setUnpaidMana(unpaid);
                if (activateAbility(specialAction, game)) {
                    return true;
                }
                // only one time try to pay
                break;
            }
        }
    }
    return false;
}

Example 14 with ConditionalMana

use of mage.ConditionalMana in project mage by magefree.

the class ComputerPlayer method canUseAsThoughManaToPayManaCost.

boolean canUseAsThoughManaToPayManaCost(ManaCost checkCost, Ability abilityToPay, Mana manaOption, Ability manaAbility, MageObject manaProducer, Game game) {
    // asThoughMana can change producing mana type, so you must check it here
    // cause some effects adds additional checks in getAsThoughManaType (example: Draugr Necromancer with snow mana sources)
    // simulate real asThoughMana usage
    ManaPoolItem possiblePoolItem;
    if (manaOption instanceof ConditionalMana) {
        ConditionalMana conditionalNetMana = (ConditionalMana) manaOption;
        possiblePoolItem = new ManaPoolItem(conditionalNetMana, manaAbility.getSourceObject(game), conditionalNetMana.getManaProducerOriginalId() != null ? conditionalNetMana.getManaProducerOriginalId() : manaAbility.getOriginalId());
    } else {
        possiblePoolItem = new ManaPoolItem(manaOption.getRed(), manaOption.getGreen(), manaOption.getBlue(), manaOption.getWhite(), manaOption.getBlack(), manaOption.getGeneric() + manaOption.getColorless(), manaProducer, manaAbility.getOriginalId(), manaOption.getFlag());
    }
    // cost can contains multiple mana types, must check each type (is it possible to pay a cost)
    for (ManaType checkType : ManaUtil.getManaTypesInCost(checkCost)) {
        // affected asThoughMana effect must fit a checkType with pool mana
        ManaType possibleAsThoughPoolManaType = game.getContinuousEffects().asThoughMana(checkType, possiblePoolItem, abilityToPay.getSourceId(), abilityToPay, abilityToPay.getControllerId(), game);
        if (possibleAsThoughPoolManaType == null) {
            // no affected asThough effects
            continue;
        }
        boolean canPay;
        if (possibleAsThoughPoolManaType == ManaType.COLORLESS) {
            // colorless can be payed by any color from the pool
            canPay = possiblePoolItem.count() > 0;
        } else {
            // colored must be payed by specific color from the pool (AsThough already changed it to fit with mana pool)
            canPay = possiblePoolItem.get(possibleAsThoughPoolManaType) > 0;
        }
        if (canPay) {
            return true;
        }
    }
    return false;
}