Пример #1
0
  @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);
    }
  }
Пример #2
0
  @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;
  }
Пример #3
0
  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."));
  }
Пример #4
0
  @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;
  }
Пример #5
0
    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);
    }
Пример #6
0
  @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;
  }
Пример #7
0
  @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;
  }