@Override
public void makeChoices(Game game, Event event, java.util.Map<Parameter, Set> parameters) {
int numberOfCards = 1;
if (parameters.containsKey(Parameter.NUMBER))
numberOfCards = Sum.get(parameters.get(Parameter.NUMBER));
if (numberOfCards < 0) numberOfCards = 0;
java.util.Set<Card> cardsInHand = null;
boolean specificChoices = parameters.containsKey(Parameter.CHOICE);
if (specificChoices) cardsInHand = parameters.get(Parameter.CHOICE).getAll(Card.class);
for (Player player : parameters.get(Parameter.PLAYER).getAll(Player.class)) {
if (!specificChoices)
cardsInHand = new Set(player.getHand(game.actualState).objects).getAll(Card.class);
java.util.Collection<Card> choices =
player.sanitizeAndChoose(
game.actualState,
numberOfCards,
cardsInHand,
PlayerInterface.ChoiceType.OBJECTS,
PlayerInterface.ChooseReason.DISCARD);
if (choices.size() != numberOfCards) event.allChoicesMade = false;
event.putChoices(player, choices);
}
}
@Override
public boolean attempt(Game game, Event event, java.util.Map<Parameter, Set> parameters) {
int successes = 0;
Set cause = parameters.get(Parameter.CAUSE);
int required = 1;
if (parameters.containsKey(Parameter.NUMBER))
required = Sum.get(parameters.get(Parameter.NUMBER));
for (Player player : parameters.get(Parameter.PLAYER).getAll(Player.class)) {
java.util.Set<Card> cards = null;
if (parameters.containsKey(Parameter.CHOICE))
cards = parameters.get(Parameter.CHOICE).getAll(Card.class);
else cards = new Set(player.getHand(game.actualState).objects).getAll(Card.class);
successes = 0;
for (Card thisCard : cards) {
java.util.Map<Parameter, Set> newParameters = new java.util.HashMap<Parameter, Set>();
newParameters.put(Parameter.CAUSE, cause);
newParameters.put(Parameter.CARD, new Set(thisCard));
if (createEvent(
game,
thisCard.getOwner(game.actualState) + " discards " + thisCard + ".",
DISCARD_ONE_CARD,
newParameters)
.attempt(event)) successes++;
if (successes == required) break;
}
if (successes != required) return false;
}
return true;
}
public PredatorsRapport(GameState state) {
super(state);
// Choose target creature you control. You gain life equal to that
// creature's power plus its toughness.
SetGenerator target =
targetedBy(this.addTarget(CREATURES_YOU_CONTROL, "target creature you control"));
this.addEffect(
gainLife(
You.instance(),
Sum.instance(Union.instance(PowerOf.instance(target), ToughnessOf.instance(target))),
"Choose target creature you control. You gain life equal to that creature's power plus its toughness."));
}
@Override
public boolean attempt(Game game, Event event, Map<Parameter, MagicSet> parameters) {
int lifeGain = Sum.get(parameters.get(Parameter.NUMBER));
if (lifeGain <= 0) return true;
MagicSet players = parameters.get(Parameter.PLAYER);
for (Player player : players.getAll(Player.class)) {
HashMap<Parameter, MagicSet> newParameters = new HashMap<Parameter, MagicSet>(parameters);
newParameters.put(Parameter.PLAYER, new MagicSet(player));
Event gainLifeOnePlayer =
createEvent(
game, player + " loses " + lifeGain + " life", GAIN_LIFE_ONE_PLAYER, newParameters);
if (!gainLifeOnePlayer.attempt(event)) return false;
}
return true;
}
public EnsnaringBridgeAbility0(GameState state) {
super(
state,
"Creatures with power greater than the number of cards in your hand can't attack.");
SetGenerator numberOfCardsInYourHand =
Count.instance(InZone.instance(HandOf.instance(You.instance())));
SetGenerator hasPowerGreater =
HasPower.instance(
Between.instance(
Sum.instance(Union.instance(numberGenerator(1), numberOfCardsInYourHand)),
Empty.instance()));
SetGenerator restriction = Intersect.instance(Attacking.instance(), hasPowerGreater);
ContinuousEffect.Part part =
new ContinuousEffect.Part(ContinuousEffectType.ATTACKING_RESTRICTION);
part.parameters.put(
ContinuousEffectType.Parameter.RESTRICTION, Identity.instance(restriction));
this.addEffectPart(part);
}
@Override
public boolean perform(Game game, Event event, Map<Parameter, MagicSet> parameters) {
int lifeGain = Sum.get(parameters.get(Parameter.NUMBER));
if (lifeGain <= 0) {
event.setResult(Empty.set);
return true;
}
MagicSet result = new MagicSet();
MagicSet players = parameters.get(Parameter.PLAYER);
for (Player player : players.getAll(Player.class)) {
HashMap<Parameter, MagicSet> newParameters = new HashMap<Parameter, MagicSet>(parameters);
newParameters.put(Parameter.PLAYER, new MagicSet(player));
Event gain =
createEvent(
game, player + " gains " + lifeGain + " life", GAIN_LIFE_ONE_PLAYER, newParameters);
gain.perform(event, false);
result.addAll(gain.getResult());
}
event.setResult(result);
return true;
}
@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;
}