@Override
public boolean perform(Game game, Event event, java.util.Map<Parameter, Set> parameters) {
Set result = new Set();
Identified producer = parameters.get(Parameter.SOURCE).getOne(Identified.class);
java.util.Set<Color> colors = parameters.get(Parameter.MANA).getAll(Color.class);
java.util.Set<ManaSymbol.ManaType> types =
parameters.get(Parameter.MANA).getAll(ManaSymbol.ManaType.class);
ManaPool pool = new ManaPool();
ManaSymbol addition = new ManaSymbol("");
addition.colors.addAll(colors);
for (ManaSymbol.ManaType type : types) {
if (ManaSymbol.ManaType.COLORLESS == type) {
addition.colorless = 1;
addition.name += "1";
} else {
Color color = type.getColor();
addition.colors.add(color);
addition.name += color.getLetter();
}
}
if (!addition.isZero()) pool.add(addition);
pool.addAll(parameters.get(Parameter.MANA).getAll(ManaSymbol.class));
int multiply = 1;
if (parameters.containsKey(Parameter.MULTIPLY))
multiply = Sum.get(parameters.get(Parameter.MULTIPLY));
if (multiply != 1) {
ManaPool newPool = new ManaPool();
if (multiply > 1) {
newPool.addAll(pool);
for (ManaSymbol symbol : pool)
for (int i = 1; i < multiply; ++i) newPool.add(symbol.create());
}
pool = newPool;
}
int number = 1;
if (parameters.containsKey(Parameter.NUMBER))
number = Sum.get(parameters.get(Parameter.NUMBER));
boolean snow = false;
if (producer.isGameObject())
snow = ((GameObject) producer).getSuperTypes().contains(SuperType.SNOW);
for (Player actualPlayer : parameters.get(Parameter.PLAYER).getAll(Player.class)) {
Player physicalPlayer = actualPlayer.getPhysical();
java.util.Set<CostCollection> choices = pool.explode("Add");
// TODO : Ticket 430
ManaPool chosen = null;
if (choices.isEmpty()) // empty pool to start with
chosen = pool;
else if (choices.size() == 1) chosen = choices.iterator().next().manaCost;
else {
// if all of the choices are mana of a single color, present
// it as a color choice
boolean allSingleColorSymbols = true;
for (CostCollection choiceCollection : choices) {
ManaPool choice = choiceCollection.manaCost;
if (choice.converted() != 1) {
allSingleColorSymbols = false;
break;
}
ManaSymbol symbol = choice.first();
if (symbol.colorless != 0) {
allSingleColorSymbols = false;
break;
}
if (symbol.colors.size() != 1) {
allSingleColorSymbols = false;
break;
}
}
if (allSingleColorSymbols) {
java.util.Set<Color> colorChoices = java.util.EnumSet.noneOf(Color.class);
for (CostCollection choice : choices)
colorChoices.add(choice.manaCost.first().colors.iterator().next());
Color chosenColor = physicalPlayer.chooseColor(colorChoices, producer.ID);
ManaSymbol s = pool.first().create();
s.colors = java.util.EnumSet.of(chosenColor);
s.colorless = 0;
chosen = new ManaPool(java.util.Collections.singleton(s));
} else
chosen =
physicalPlayer
.sanitizeAndChoose(
game.actualState,
1,
choices,
PlayerInterface.ChoiceType.MANA_EXPLOSION,
PlayerInterface.ChooseReason.HYBRID_MANA)
.iterator()
.next()
.manaCost;
}
for (int i = 0; i < number; ++i) {
// Use the reference mana to create a new mana to
// add to the pool
for (ManaSymbol newMana : chosen) {
newMana = newMana.create();
newMana.sourceID = producer.ID;
newMana.isSnow = snow;
physicalPlayer.pool.add(newMana);
result.add(newMana);
if (game.currentAction != null) game.currentAction.manaProduced.add(newMana);
}
}
}
GameObject source = event.getSource();
if (source.isActivatedAbility())
((ActivatedAbility) source.getPhysical()).addedMana(result.getAll(ManaSymbol.class));
event.setResult(Identity.instance(result));
return true;
}
@Override
public boolean perform(Game game, Event event, java.util.Map<Parameter, Set> parameters) {
GameObject object = parameters.get(Parameter.OBJECT).getOne(GameObject.class);
Identified newTarget = parameters.get(Parameter.TARGET).getOne(Identified.class);
java.util.Set<Target> canBeChanged = new java.util.HashSet<Target>();
java.util.Map<Target, Boolean> wasLegal = new java.util.HashMap<Target, Boolean>();
java.util.Map<Target, java.util.List<Target>> allChosenTargets =
new java.util.HashMap<Target, java.util.List<Target>>();
for (java.util.Map<Target, java.util.List<Target>> chosenTargets : object.getChosenTargets())
allChosenTargets.putAll(chosenTargets);
// Introduce this scope because there are two variables named
// 'restricted'
{
java.util.Set<Integer> restricted = new java.util.HashSet<Integer>();
for (Mode checkMode : object.getSelectedModes()) {
for (Target checkBaseTarget : checkMode.targets) {
java.util.Set<Integer> thisBaseTarget = new java.util.HashSet<Integer>();
for (Target checkTarget : allChosenTargets.get(checkBaseTarget)) {
Set legalCheck = checkTarget.legalChoicesNow(game, object);
boolean legal =
!(restricted.contains(checkTarget.targetID)
|| !legalCheck.contains(game.actualState.get(checkTarget.targetID)));
wasLegal.put(checkTarget, legal);
if (checkTarget.restrictFromLaterTargets) restricted.add(checkTarget.targetID);
thisBaseTarget.add(checkTarget.targetID);
}
}
}
}
for (Mode mode : object.getSelectedModes()) {
for (Target baseTarget : mode.targets) {
for (Target target : allChosenTargets.get(baseTarget)) {
Set targets = target.legalChoicesNow(game, object);
if (targets.contains(newTarget)) {
// The target won't "change" if its already set to
// this target.
if (target.targetID == newTarget.ID) continue;
int oldValue = target.targetID;
target.targetID = newTarget.ID;
boolean illegal = false;
java.util.Set<Integer> restricted = new java.util.HashSet<Integer>();
legalityCheck:
for (Mode checkMode : object.getSelectedModes()) {
for (Target checkBaseTarget : checkMode.targets) {
java.util.Set<Integer> thisBaseTarget = new java.util.HashSet<Integer>();
for (Target checkTarget : allChosenTargets.get(checkBaseTarget)) {
Set legalCheck = checkTarget.legalChoicesNow(game, object);
boolean targetWasLegal = wasLegal.get(checkTarget);
if (targetWasLegal
&& (thisBaseTarget.contains(checkTarget.targetID)
|| restricted.contains(checkTarget.targetID)
|| !legalCheck.contains(game.actualState.get(checkTarget.targetID)))) {
illegal = true;
break legalityCheck;
}
if (checkTarget.restrictFromLaterTargets) restricted.add(checkTarget.targetID);
thisBaseTarget.add(checkTarget.targetID);
}
}
}
target.targetID = oldValue;
if (!illegal) {
canBeChanged.add(target);
}
}
}
}
}
Player player = parameters.get(Parameter.PLAYER).getOne(Player.class);
java.util.List<Target> choice =
player.sanitizeAndChoose(
game.actualState,
1,
canBeChanged,
PlayerInterface.ChoiceType.SINGLE_TARGET,
PlayerInterface.ChooseReason.TARGET);
if (!choice.isEmpty()) {
event.setResult(Identity.instance(object));
Target chosenTarget = choice.get(0);
chosenTarget.targetID = newTarget.ID;
// Also set the target on the physical object
java.util.Map<Target, java.util.List<Target>>[] chosenTargets = object.getChosenTargets();
setPhysicalTarget:
for (int sideNumber = 0; sideNumber < object.getChosenTargets().length; ++sideNumber)
for (java.util.Map.Entry<Target, java.util.List<Target>> entry :
chosenTargets[sideNumber].entrySet()) {
for (int targetNumber = 0; targetNumber < entry.getValue().size(); ++targetNumber) {
if (entry.getValue().get(targetNumber) == chosenTarget) {
GameObject physical = object.getPhysical();
physical
.getChosenTargets()[sideNumber]
.get(entry.getKey())
.get(targetNumber)
.targetID =
newTarget.ID;
break setPhysicalTarget;
}
}
}
} else {
event.setResult(Identity.instance());
}
return choice.size() == 1;
}
