Exemple #1
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;
  }
  @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;
  }