forked from External/mage
356 lines
16 KiB
Java
356 lines
16 KiB
Java
package mage.abilities.mana;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.HashSet;
|
|
import java.util.List;
|
|
import java.util.Set;
|
|
import mage.Mana;
|
|
import mage.abilities.Ability;
|
|
import mage.abilities.costs.Cost;
|
|
import mage.abilities.costs.common.TapSourceCost;
|
|
import mage.game.Game;
|
|
import mage.game.events.GameEvent;
|
|
import mage.game.events.ManaEvent;
|
|
import org.apache.log4j.Logger;
|
|
|
|
/**
|
|
*
|
|
* @author BetaSteward_at_googlemail.com
|
|
*
|
|
* this class is used to build a list of all possible mana combinations it can
|
|
* be used to find all the ways to pay a mana cost or all the different mana
|
|
* combinations available to a player
|
|
*
|
|
*/
|
|
public class ManaOptions extends ArrayList<Mana> {
|
|
|
|
private static final Logger logger = Logger.getLogger(ManaOptions.class);
|
|
|
|
public ManaOptions() {
|
|
}
|
|
|
|
public ManaOptions(final ManaOptions options) {
|
|
for (Mana mana : options) {
|
|
this.add(mana.copy());
|
|
}
|
|
}
|
|
|
|
public void addMana(List<ActivatedManaAbilityImpl> abilities, Game game) {
|
|
if (isEmpty()) {
|
|
this.add(new Mana());
|
|
}
|
|
if (!abilities.isEmpty()) {
|
|
if (abilities.size() == 1) {
|
|
//if there is only one mana option available add it to all the existing options
|
|
List<Mana> netManas = abilities.get(0).getNetMana(game);
|
|
if (netManas.size() == 1) {
|
|
if (!hasTapCost(abilities.get(0)) || checkTappedForManaReplacement(abilities.get(0), game, netManas.get(0))) {
|
|
addMana(netManas.get(0));
|
|
}
|
|
} else {
|
|
List<Mana> copy = copy();
|
|
this.clear();
|
|
boolean hasTapCost = hasTapCost(abilities.get(0));
|
|
for (Mana netMana : netManas) {
|
|
for (Mana mana : copy) {
|
|
if (!hasTapCost || checkTappedForManaReplacement(abilities.get(0), game, netMana)) {
|
|
Mana newMana = new Mana();
|
|
newMana.add(mana);
|
|
newMana.add(netMana);
|
|
this.add(newMana);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
} else { // mana source has more than 1 ability
|
|
//perform a union of all existing options and the new options
|
|
List<Mana> copy = copy();
|
|
this.clear();
|
|
for (ActivatedManaAbilityImpl ability : abilities) {
|
|
boolean hasTapCost = hasTapCost(ability);
|
|
for (Mana netMana : ability.getNetMana(game)) {
|
|
if (!hasTapCost || checkTappedForManaReplacement(ability, game, netMana)) {
|
|
SkipAddMana:
|
|
for (Mana mana : copy) {
|
|
Mana newMana = new Mana();
|
|
newMana.add(mana);
|
|
newMana.add(netMana);
|
|
for (Mana existingMana : this) {
|
|
if (existingMana.equalManaValue(newMana)) {
|
|
continue SkipAddMana;
|
|
}
|
|
Mana moreValuable = Mana.getMoreValuableMana(newMana, existingMana);
|
|
if (moreValuable != null) {
|
|
// only keep the more valuable mana
|
|
existingMana.setToMana(moreValuable);
|
|
continue SkipAddMana;
|
|
}
|
|
}
|
|
this.add(newMana);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private boolean checkTappedForManaReplacement(Ability ability, Game game, Mana mana) {
|
|
ManaEvent event = new ManaEvent(GameEvent.EventType.TAPPED_FOR_MANA, ability.getSourceId(), ability.getSourceId(), ability.getControllerId(), mana);
|
|
if (!game.replaceEvent(event)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private boolean hasTapCost(Ability ability) {
|
|
for (Cost cost : ability.getCosts()) {
|
|
if (cost instanceof TapSourceCost) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public void addManaWithCost(List<ActivatedManaAbilityImpl> abilities, Game game) {
|
|
if (isEmpty()) {
|
|
this.add(new Mana());
|
|
}
|
|
if (!abilities.isEmpty()) {
|
|
if (abilities.size() == 1) {
|
|
//if there is only one mana option available add it to all the existing options
|
|
ActivatedManaAbilityImpl ability = abilities.get(0);
|
|
List<Mana> netManas = abilities.get(0).getNetMana(game);
|
|
// no mana costs
|
|
if (ability.getManaCosts().isEmpty()) {
|
|
if (netManas.size() == 1) {
|
|
addMana(netManas.get(0));
|
|
} else {
|
|
List<Mana> copy = copy();
|
|
this.clear();
|
|
for (Mana netMana : netManas) {
|
|
for (Mana mana : copy) {
|
|
Mana newMana = new Mana();
|
|
newMana.add(mana);
|
|
newMana.add(netMana);
|
|
this.add(newMana);
|
|
}
|
|
}
|
|
}
|
|
} else // the ability has mana costs
|
|
if (netManas.size() == 1) {
|
|
subtractCostAddMana(ability.getManaCosts().getMana(), netManas.get(0), ability.getCosts().isEmpty());
|
|
} else {
|
|
List<Mana> copy = copy();
|
|
this.clear();
|
|
for (Mana netMana : netManas) {
|
|
for (Mana mana : copy) {
|
|
Mana newMana = new Mana();
|
|
newMana.add(mana);
|
|
newMana.add(netMana);
|
|
subtractCostAddMana(ability.getManaCosts().getMana(), netMana, ability.getCosts().isEmpty());
|
|
}
|
|
}
|
|
}
|
|
} else if (abilities.size() > 1) {
|
|
//perform a union of all existing options and the new options
|
|
List<Mana> copy = copy();
|
|
this.clear();
|
|
for (ActivatedManaAbilityImpl ability : abilities) {
|
|
boolean hasTapCost = hasTapCost(ability);
|
|
List<Mana> netManas = ability.getNetMana(game);
|
|
|
|
if (ability.getManaCosts().isEmpty()) {
|
|
for (Mana netMana : netManas) {
|
|
if (!hasTapCost || checkTappedForManaReplacement(ability, game, netMana)) {
|
|
for (Mana mana : copy) {
|
|
Mana newMana = new Mana();
|
|
newMana.add(mana);
|
|
newMana.add(netMana);
|
|
this.add(newMana);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
for (Mana netMana : netManas) {
|
|
if (!hasTapCost || checkTappedForManaReplacement(ability, game, netMana)) {
|
|
for (Mana previousMana : copy) {
|
|
CombineWithExisting:
|
|
for (Mana manaOption : ability.getManaCosts().getManaOptions()) {
|
|
Mana newMana = new Mana(previousMana);
|
|
if (previousMana.includesMana(manaOption)) { // costs can be paid
|
|
newMana.subtractCost(manaOption);
|
|
newMana.add(netMana);
|
|
// if the new mana is in all colors more than another already existing than replace
|
|
for (Mana existingMana : this) {
|
|
Mana moreValuable = Mana.getMoreValuableMana(newMana, existingMana);
|
|
if (moreValuable != null) {
|
|
existingMana.setToMana(moreValuable);
|
|
logger.trace("mana replaced " + newMana.toString() + " <=> " + existingMana.toString() + " from " + ability.getRule());
|
|
continue CombineWithExisting;
|
|
}
|
|
}
|
|
// no existing Mana includes this new mana so add
|
|
this.add(newMana);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void addMana(Mana addMana) {
|
|
if (isEmpty()) {
|
|
this.add(new Mana());
|
|
}
|
|
for (Mana mana : this) {
|
|
mana.add(addMana);
|
|
}
|
|
}
|
|
|
|
public void addMana(ManaOptions options) {
|
|
if (isEmpty()) {
|
|
this.add(new Mana());
|
|
}
|
|
if (!options.isEmpty()) {
|
|
if (options.size() == 1) {
|
|
//if there is only one mana option available add it to all the existing options
|
|
addMana(options.get(0));
|
|
} else if (options.size() > 1) {
|
|
//perform a union of all existing options and the new options
|
|
List<Mana> copy = copy();
|
|
this.clear();
|
|
for (Mana addMana : options) {
|
|
for (Mana mana : copy) {
|
|
Mana newMana = new Mana();
|
|
newMana.add(mana);
|
|
newMana.add(addMana);
|
|
this.add(newMana);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public ManaOptions copy() {
|
|
return new ManaOptions(this);
|
|
}
|
|
|
|
public void subtractCostAddMana(Mana cost, Mana addMana, boolean onlyManaCosts) {
|
|
if (isEmpty()) {
|
|
this.add(new Mana());
|
|
}
|
|
boolean repeatable = false;
|
|
if (addMana.getAny() == 1 && addMana.count() == 1 && onlyManaCosts) {
|
|
// deactivated because it does cause loops TODO: Find reason
|
|
repeatable = true; // only replace to any with mana costs only will be repeated if able
|
|
}
|
|
List<Mana> copy = copy();
|
|
this.clear();
|
|
for (Mana mana : copy) {
|
|
Mana oldMan = mana.copy();
|
|
if (mana.includesMana(cost)) {
|
|
// colorless costs can be paid with different colored mana, can lead to different color combinations
|
|
if (cost.getGeneric() > 0 && cost.getGeneric() > (mana.getGeneric() + mana.getColorless())) {
|
|
Mana coloredCost = cost.copy();
|
|
coloredCost.setGeneric(0);
|
|
mana.subtract(coloredCost);
|
|
for (Mana payCombination : getPossiblePayCombinations(cost.getGeneric(), mana)) {
|
|
Mana newMana = mana.copy();
|
|
newMana.subtract(payCombination);
|
|
newMana.add(addMana);
|
|
if (oldMan.contains(newMana) && oldMan.count() > newMana.count()) {
|
|
newMana.setToMana(oldMan);
|
|
}
|
|
this.add(newMana);
|
|
}
|
|
} else {
|
|
while (mana.includesMana(cost)) {
|
|
mana.subtractCost(cost);
|
|
mana.add(addMana);
|
|
if (!repeatable) {
|
|
break;
|
|
}
|
|
}
|
|
// Don't use mana that only reduce the available mana
|
|
if (oldMan.contains(mana) && oldMan.count() > mana.count()) {
|
|
mana.setToMana(oldMan);
|
|
}
|
|
this.add(mana);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private List<Mana> getPossiblePayCombinations(int number, Mana manaAvailable) {
|
|
List<Mana> payCombinations = new ArrayList<>();
|
|
List<String> payCombinationsStrings = new ArrayList<>();
|
|
if (manaAvailable.countColored() > 0) {
|
|
|
|
for (int i = 0; i < number; i++) {
|
|
List<Mana> existingManas = new ArrayList<>();
|
|
if (i > 0) {
|
|
existingManas.addAll(payCombinations);
|
|
payCombinations.clear();
|
|
payCombinationsStrings.clear();
|
|
} else {
|
|
existingManas.add(new Mana());
|
|
}
|
|
for (Mana existingMana : existingManas) {
|
|
Mana manaToPay = manaAvailable.copy();
|
|
manaToPay.subtract(existingMana);
|
|
if (manaToPay.getBlack() > 0 && !payCombinationsStrings.contains(existingMana.toString() + Mana.BlackMana(1).toString())) {
|
|
manaToPay.subtract(Mana.BlackMana(1));
|
|
addManaCombination(Mana.BlackMana(1), existingMana, payCombinations, payCombinationsStrings);
|
|
}
|
|
if (manaToPay.getBlue() > 0 && !payCombinationsStrings.contains(existingMana.toString() + Mana.BlueMana(1).toString())) {
|
|
manaToPay.subtract(Mana.BlueMana(1));
|
|
addManaCombination(Mana.BlueMana(1), existingMana, payCombinations, payCombinationsStrings);
|
|
}
|
|
if (manaToPay.getGreen() > 0 && !payCombinationsStrings.contains(existingMana.toString() + Mana.GreenMana(1).toString())) {
|
|
manaToPay.subtract(Mana.GreenMana(1));
|
|
addManaCombination(Mana.GreenMana(1), existingMana, payCombinations, payCombinationsStrings);
|
|
}
|
|
if (manaToPay.getRed() > 0 && !payCombinationsStrings.contains(existingMana.toString() + Mana.RedMana(1).toString())) {
|
|
manaToPay.subtract(Mana.RedMana(1));
|
|
addManaCombination(Mana.RedMana(1), existingMana, payCombinations, payCombinationsStrings);
|
|
}
|
|
if (manaToPay.getWhite() > 0 && !payCombinationsStrings.contains(existingMana.toString() + Mana.WhiteMana(1).toString())) {
|
|
manaToPay.subtract(Mana.WhiteMana(1));
|
|
addManaCombination(Mana.WhiteMana(1), existingMana, payCombinations, payCombinationsStrings);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
payCombinations.add(Mana.ColorlessMana(number));
|
|
}
|
|
return payCombinations;
|
|
}
|
|
|
|
private void addManaCombination(Mana mana, Mana existingMana, List<Mana> payCombinations, List<String> payCombinationsStrings) {
|
|
Mana newMana = existingMana.copy();
|
|
newMana.add(mana);
|
|
payCombinations.add(newMana);
|
|
payCombinationsStrings.add(newMana.toString());
|
|
}
|
|
|
|
public void removeDuplicated() {
|
|
Set<String> list = new HashSet<>();
|
|
|
|
for (int i = this.size() - 1; i >= 0; i--) {
|
|
String s = this.get(i).toString();
|
|
if (list.contains(s)) {
|
|
// remove duplicated
|
|
this.remove(i);
|
|
} else {
|
|
list.add(s);
|
|
}
|
|
}
|
|
}
|
|
}
|