예제 #1
0
  Cards ProteanHulkSearch(Game game, Ability source) {
    Cards cardsPicked = new CardsImpl(Zone.PICK);
    Player player = game.getPlayer(source.getControllerId());
    if (player != null) {
      GameEvent event =
          GameEvent.getEvent(
              GameEvent.EventType.SEARCH_LIBRARY,
              source.getControllerId(),
              source.getControllerId(),
              source.getControllerId(),
              Integer.MAX_VALUE);
      if (!game.replaceEvent(event)) {
        int manaCostLeftToFetch = 6;
        int librarySearchLimit = event.getAmount();

        FilterCard filter =
            new FilterCreatureCard(
                "number of creature cards with total converted mana cost 6 or less (6 CMC left)");
        filter.add(
            new ConvertedManaCostPredicate(ComparisonType.LessThan, manaCostLeftToFetch + 1));
        TargetCardInLibrary target = new TargetCardInLibrary(0, 1, filter);
        target.setCardLimit(librarySearchLimit);

        while (target.canChoose(source.getSourceId(), source.getControllerId(), game)) {
          target.choose(
              Outcome.PutCreatureInPlay, source.getControllerId(), source.getControllerId(), game);
          Card card = player.getLibrary().remove(target.getFirstTarget(), game);
          if (card == null) {
            break;
          }
          cardsPicked.add(card);
          game.setZone(card.getId(), Zone.PICK);
          game.getState().getLookedAt(source.getControllerId()).add("Protean Hulk", cardsPicked);

          librarySearchLimit--;
          if (librarySearchLimit == 0) {
            break;
          }
          manaCostLeftToFetch -= card.getManaCost().convertedManaCost();
          filter =
              new FilterCreatureCard(
                  "number of creature cards with total converted mana cost 6 or less ("
                      + manaCostLeftToFetch
                      + " CMC left)");
          filter.add(
              new ConvertedManaCostPredicate(ComparisonType.LessThan, manaCostLeftToFetch + 1));
          target = new TargetCardInLibrary(0, 1, filter);
          target.setCardLimit(librarySearchLimit);
        }
        game.fireEvent(
            GameEvent.getEvent(
                GameEvent.EventType.LIBRARY_SEARCHED,
                source.getControllerId(),
                source.getControllerId()));
      }
    }
    return cardsPicked;
  }
예제 #2
0
 @Override
 public boolean replaceEvent(GameEvent event, Ability source, Game game) {
   boolean retValue = false;
   GameEvent preventEvent =
       new GameEvent(
           GameEvent.EventType.PREVENT_DAMAGE,
           source.getFirstTarget(),
           source.getId(),
           source.getControllerId(),
           event.getAmount(),
           false);
   int damage = event.getAmount();
   if (!game.replaceEvent(preventEvent)) {
     event.setAmount(0);
     game.fireEvent(
         GameEvent.getEvent(
             GameEvent.EventType.PREVENTED_DAMAGE,
             source.getFirstTarget(),
             source.getId(),
             source.getControllerId(),
             damage));
     retValue = true;
   }
   Permanent permanent = game.getPermanent(source.getSourceId());
   if (permanent != null) {
     permanent.removeCounters(CounterType.P1P1.createInstance(damage), game);
   }
   return retValue;
 }
예제 #3
0
 @Override
 public boolean replaceEvent(GameEvent event, Ability source, Game game) {
   GameEvent preventEvent =
       new GameEvent(
           GameEvent.EventType.PREVENT_DAMAGE,
           source.getFirstTarget(),
           source.getId(),
           source.getControllerId(),
           event.getAmount(),
           false);
   if (!game.replaceEvent(preventEvent)) {
     int damage = event.getAmount();
     Permanent permanent = game.getPermanent(event.getSourceId());
     StringBuilder message = new StringBuilder();
     if (permanent != null) {
       message.append(" from ").append(permanent.getName());
     }
     message.insert(0, "Damage").append(" has been prevented: ").append(damage);
     event.setAmount(0);
     game.informPlayers(message.toString());
     game.fireEvent(
         GameEvent.getEvent(
             GameEvent.EventType.PREVENTED_DAMAGE,
             source.getFirstTarget(),
             source.getId(),
             source.getControllerId(),
             damage));
   }
   return false;
 }
예제 #4
0
 @Override
 public boolean replaceEvent(GameEvent event, Ability source, Game game) {
   GameEvent preventEvent =
       new GameEvent(
           GameEvent.EventType.PREVENT_DAMAGE,
           source.getControllerId(),
           source.getId(),
           source.getControllerId(),
           event.getAmount(),
           false);
   if (!game.replaceEvent(preventEvent)) {
     int damage = event.getAmount();
     if (damage > 0) {
       event.setAmount(damage - 1);
       this.used = true;
       game.fireEvent(
           GameEvent.getEvent(
               GameEvent.EventType.PREVENTED_DAMAGE,
               source.getControllerId(),
               source.getId(),
               source.getControllerId(),
               1));
     }
   }
   return false;
 }
예제 #5
0
 public void acceptBlockers(Game game) {
   if (attackers.isEmpty()) {
     return;
   }
   for (UUID blockerId : blockers) {
     for (UUID attackerId : attackers) {
       game.fireEvent(
           GameEvent.getEvent(
               GameEvent.EventType.BLOCKER_DECLARED,
               attackerId,
               blockerId,
               players.get(blockerId)));
     }
   }
   if (!blockers.isEmpty()) {
     for (UUID attackerId : attackers) {
       game.fireEvent(GameEvent.getEvent(GameEvent.EventType.CREATURE_BLOCKED, attackerId, null));
     }
   }
 }
예제 #6
0
 @Override
 public boolean pay(Ability ability, Game game, UUID sourceId, UUID controllerId, boolean noMana) {
   Permanent attachment = game.getPermanent(sourceId);
   Permanent permanent = game.getPermanent(attachment.getAttachedTo());
   if (permanent != null) {
     paid = permanent.removeAttachment(attachment.getId(), game);
     if (paid) {
       game.fireEvent(
           GameEvent.getEvent(GameEvent.EventType.UNATTACHED, sourceId, sourceId, controllerId));
     }
   }
   return paid;
 }
예제 #7
0
  public List<Combat> addBlockers(Game game) {
    Map<Integer, Combat> engagements = new HashMap<Integer, Combat>();
    int numGroups = game.getCombat().getGroups().size();
    if (numGroups == 0) return new ArrayList<Combat>();

    // add a node with no blockers
    Game sim = game.copy();
    engagements.put(sim.getCombat().getValue().hashCode(), sim.getCombat());
    sim.fireEvent(GameEvent.getEvent(GameEvent.EventType.DECLARED_BLOCKERS, playerId, playerId));

    List<Permanent> blockers = getAvailableBlockers(game);
    addBlocker(game, blockers, engagements);

    return new ArrayList<Combat>(engagements.values());
  }
예제 #8
0
 public void addBlocker(UUID blockerId, UUID playerId, Game game) {
   for (UUID attackerId : attackers) {
     if (game.replaceEvent(
         GameEvent.getEvent(
             GameEvent.EventType.DECLARE_BLOCKER, attackerId, blockerId, playerId))) {
       return;
     }
   }
   Permanent blocker = game.getPermanent(blockerId);
   if (blockerId != null && blocker != null) {
     blocker.setBlocking(blocker.getBlocking() + 1);
     blockers.add(blockerId);
     blockerOrder.add(blockerId);
     this.blocked = true;
     this.players.put(blockerId, playerId);
   }
 }
예제 #9
0
파일: Token.java 프로젝트: xdaft/mage
 public boolean putOntoBattlefield(int amount, Game game, UUID sourceId, UUID controllerId) {
   Card source = game.getCard(sourceId);
   String setCode = source != null ? source.getExpansionSetCode() : null;
   GameEvent event =
       GameEvent.getEvent(EventType.CREATE_TOKEN, null, sourceId, controllerId, amount);
   if (!game.replaceEvent(event)) {
     amount = event.getAmount();
     for (int i = 0; i < amount; i++) {
       PermanentToken permanent = new PermanentToken(this, controllerId, setCode, game);
       game.getState().addCard(permanent);
       game.addPermanent(permanent);
       this.lastAddedTokenId = permanent.getId();
       permanent.entersBattlefield(sourceId, game);
       game.applyEffects();
       game.fireEvent(
           new ZoneChangeEvent(permanent, controllerId, Zone.OUTSIDE, Zone.BATTLEFIELD));
     }
     return true;
   }
   return false;
 }
예제 #10
0
 protected int simulateBlockers(
     Game game,
     SimulationNode2 node,
     UUID defenderId,
     int depth,
     int alpha,
     int beta,
     boolean counter) {
   if (ALLOW_INTERRUPT && Thread.interrupted()) {
     Thread.currentThread().interrupt();
     logger.debug("interrupted");
     return GameStateEvaluator2.evaluate(playerId, game);
   }
   Integer val = null;
   SimulationNode2 bestNode = null;
   // check if defender is being attacked
   if (game.getCombat().isAttacked(defenderId, game)) {
     SimulatedPlayer2 defender = (SimulatedPlayer2) game.getPlayer(defenderId);
     if (logger.isDebugEnabled()) {
       logger.debug(
           defender.getName() + "'s possible blockers: " + defender.getAvailableBlockers(game));
     }
     List<Combat> combats = defender.addBlockers(game);
     for (Combat engagement : combats) {
       if (alpha >= beta) {
         logger.debug("Sim blockers -- pruning blockers");
         break;
       }
       Game sim = game.copy();
       for (CombatGroup group : engagement.getGroups()) {
         if (group.getAttackers().size() > 0) {
           UUID attackerId = group.getAttackers().get(0);
           for (UUID blockerId : group.getBlockers()) {
             sim.getPlayer(defenderId).declareBlocker(defenderId, blockerId, attackerId, sim);
           }
         }
       }
       sim.fireEvent(
           GameEvent.getEvent(GameEvent.EventType.DECLARED_BLOCKERS, defenderId, defenderId));
       SimulationNode2 newNode = new SimulationNode2(node, sim, depth, defenderId);
       if (logger.isDebugEnabled()) {
         logger.debug("Sim block for player:" + game.getPlayer(defenderId).getName());
       }
       sim.checkStateAndTriggered();
       while (!sim.getStack().isEmpty()) {
         sim.getStack().resolve(sim);
         logger.debug("Sim blockers: resolving triggered abilities");
         sim.applyEffects();
       }
       sim.fireEvent(
           GameEvent.getEvent(
               GameEvent.EventType.DECLARE_BLOCKERS_STEP_POST,
               sim.getActivePlayerId(),
               sim.getActivePlayerId()));
       Combat simCombat = sim.getCombat().copy();
       finishCombat(sim);
       if (sim.gameOver(null)) {
         val = GameStateEvaluator2.evaluate(playerId, sim);
       } else if (!counter) {
         val = simulatePostCombatMain(sim, newNode, depth - 1, alpha, beta);
       } else {
         val = GameStateEvaluator2.evaluate(playerId, sim);
       }
       if (!defenderId.equals(playerId)) {
         if (val < beta) {
           beta = val;
           bestNode = newNode;
           bestNode.setScore(val);
           bestNode.setCombat(simCombat);
         }
       } else {
         if (val > alpha) {
           alpha = val;
           bestNode = newNode;
           bestNode.setScore(val);
           bestNode.setCombat(simCombat);
         }
       }
     }
   }
   if (val == null) {
     val = GameStateEvaluator2.evaluate(playerId, game);
   }
   if (bestNode != null) {
     node.children.clear();
     node.children.add(bestNode);
     node.setScore(bestNode.getScore());
   }
   if (logger.isDebugEnabled()) {
     logger.debug(
         "Sim blockers: returning score: "
             + val
             + " depth:"
             + depth
             + " for player:"
             + game.getPlayer(node.getPlayerId()).getName());
   }
   return val;
 }
예제 #11
0
 protected int simulateAttackers(
     Game game,
     SimulationNode2 node,
     UUID attackerId,
     int depth,
     int alpha,
     int beta,
     boolean counter) {
   if (ALLOW_INTERRUPT && Thread.interrupted()) {
     Thread.currentThread().interrupt();
     logger.debug("interrupted");
     return GameStateEvaluator2.evaluate(playerId, game);
   }
   Integer val = null;
   SimulationNode2 bestNode = null;
   SimulatedPlayer2 attacker = (SimulatedPlayer2) game.getPlayer(attackerId);
   UUID defenderId = game.getOpponents(attackerId).iterator().next();
   if (logger.isDebugEnabled()) {
     logger.debug(
         attacker.getName()
             + "'s possible attackers: "
             + attacker.getAvailableAttackers(defenderId, game));
   }
   for (Combat engagement : attacker.addAttackers(game)) {
     if (logger.isDebugEnabled()) {
       logger.debug(
           "Sim Attackers: "
               + engagement.getAttackers()
               + ", blockers: "
               + engagement.getBlockers());
     }
     if (alpha >= beta) {
       logger.debug("Sim Attackers -- pruning attackers");
       break;
     }
     Game sim = game.copy();
     for (CombatGroup group : engagement.getGroups()) {
       for (UUID attackId : group.getAttackers()) {
         sim.getPlayer(attackerId).declareAttacker(attackId, defenderId, sim, false);
       }
     }
     sim.fireEvent(
         GameEvent.getEvent(GameEvent.EventType.DECLARED_ATTACKERS, attackerId, attackerId));
     SimulationNode2 newNode = new SimulationNode2(node, sim, depth, attackerId);
     if (logger.isDebugEnabled()) {
       logger.debug("Sim attack for player:" + game.getPlayer(attackerId).getName());
     }
     sim.checkStateAndTriggered();
     while (!sim.getStack().isEmpty()) {
       sim.getStack().resolve(sim);
       logger.debug("Sim attack: resolving triggered abilities");
       sim.applyEffects();
     }
     sim.fireEvent(
         GameEvent.getEvent(
             GameEvent.EventType.DECLARE_ATTACKERS_STEP_POST,
             sim.getActivePlayerId(),
             sim.getActivePlayerId()));
     Combat simCombat = sim.getCombat().copy();
     sim.getPhase().setStep(new DeclareBlockersStep());
     val = simulateCombat(sim, newNode, depth - 1, alpha, beta, counter);
     if (!attackerId.equals(playerId)) {
       if (val < beta) {
         beta = val;
         bestNode = newNode;
         bestNode.setScore(val);
         if (newNode.getChildren().size() > 0) {
           bestNode.setCombat(newNode.getChildren().get(0).getCombat());
         }
       }
     } else {
       if (val > alpha) {
         alpha = val;
         bestNode = newNode;
         bestNode.setScore(val);
         if (newNode.getChildren().size() > 0) {
           bestNode.setCombat(newNode.getChildren().get(0).getCombat());
         }
       }
     }
   }
   if (val == null) {
     val = GameStateEvaluator2.evaluate(playerId, game);
   }
   if (bestNode != null) {
     node.children.clear();
     node.children.add(bestNode);
     node.setScore(bestNode.getScore());
   }
   if (logger.isDebugEnabled()) {
     logger.debug(
         "Sim attackers: returning score: "
             + val
             + " depth:"
             + depth
             + " for player:"
             + game.getPlayer(node.getPlayerId()).getName());
   }
   return val;
 }
예제 #12
0
 protected int simulateCombat(
     Game game, SimulationNode2 node, int depth, int alpha, int beta, boolean counter) {
   Integer val = null;
   if (ALLOW_INTERRUPT && Thread.interrupted()) {
     Thread.currentThread().interrupt();
     logger.debug("interrupted");
     return GameStateEvaluator2.evaluate(playerId, game);
   }
   if (game.getTurn().getStepType() != PhaseStep.DECLARE_BLOCKERS) {
     game.getTurn().setPhase(new CombatPhase());
     if (game.getPhase().beginPhase(game, game.getActivePlayerId())) {
       simulateStep(game, new BeginCombatStep());
       game.getPhase().setStep(new DeclareAttackersStep());
       if (!game.getStep().skipStep(game, game.getActivePlayerId())) {
         game.fireEvent(
             new GameEvent(
                 GameEvent.EventType.DECLARE_ATTACKERS_STEP_PRE,
                 null,
                 null,
                 game.getActivePlayerId()));
         if (!game.replaceEvent(
             GameEvent.getEvent(
                 GameEvent.EventType.DECLARING_ATTACKERS,
                 game.getActivePlayerId(),
                 game.getActivePlayerId()))) {
           val =
               simulateAttackers(
                   game, node, game.getActivePlayerId(), depth, alpha, beta, counter);
         }
       } else if (!counter) {
         simulateToEnd(game);
         val = simulatePostCombatMain(game, node, depth, alpha, beta);
       }
     }
   } else {
     if (!game.getStep().skipStep(game, game.getActivePlayerId())) {
       game.fireEvent(
           new GameEvent(
               GameEvent.EventType.DECLARE_BLOCKERS_STEP_PRE,
               null,
               null,
               game.getActivePlayerId()));
       if (!game.replaceEvent(
           GameEvent.getEvent(
               GameEvent.EventType.DECLARING_BLOCKERS,
               game.getActivePlayerId(),
               game.getActivePlayerId()))) {
         // only suitable for two player games - only simulates blocks for 1st defender
         val =
             simulateBlockers(
                 game,
                 node,
                 game.getCombat().getDefenders().iterator().next(),
                 depth,
                 alpha,
                 beta,
                 counter);
       }
     } else if (!counter) {
       finishCombat(game);
       /// val = simulateCounterAttack(game, node, depth, alpha, beta);
     }
   }
   if (val == null) {
     val = GameStateEvaluator2.evaluate(playerId, game);
   }
   if (logger.isDebugEnabled()) {
     logger.debug(
         "returning -- combat score: "
             + val
             + " depth:"
             + depth
             + " for player:"
             + game.getPlayer(node.getPlayerId()).getName());
   }
   return val;
 }
예제 #13
0
  @Override
  public boolean activate(Game game, boolean noMana) {
    Player controller = game.getPlayer(this.getControllerId());
    if (controller == null) {
      return false;
    }
    game.applyEffects();

    /* 20130201 - 601.2b
     * If the spell is modal the player announces the mode choice (see rule 700.2).
     */
    if (!getModes().choose(game, this)) {
      return false;
    }
    if (controller.isTestMode()) {
      if (!controller.addTargets(this, game)) {
        return false;
      }
    }

    getSourceObject(game);

    /* 20130201 - 601.2b
     * If the player wishes to splice any cards onto the spell (see rule 702.45), he
     * or she reveals those cards in his or her hand.
     */
    if (this.abilityType.equals(AbilityType.SPELL)) {
      game.getContinuousEffects().applySpliceEffects(this, game);
    }

    // if ability can be cast for no mana, clear the mana costs now, because additional mana costs
    // must be paid.
    // For Flashback ability can be set X before, so the X costs have to be restored for the
    // flashbacked ability
    if (noMana) {
      if (this.getManaCostsToPay().getVariableCosts().size() > 0) {
        int xValue = this.getManaCostsToPay().getX();
        this.getManaCostsToPay().clear();
        VariableManaCost xCosts = new VariableManaCost();
        xCosts.setAmount(xValue);
        this.getManaCostsToPay().add(xCosts);
      } else {
        this.getManaCostsToPay().clear();
      }
    }
    // 20130201 - 601.2b
    // If the spell has alternative or additional costs that will be paid as it's being cast such
    // as buyback, kicker, or convoke costs (see rules 117.8 and 117.9), the player announces his
    // or her intentions to pay any or all of those costs (see rule 601.2e).
    // A player can't apply two alternative methods of casting or two alternative costs to a single
    // spell.
    if (!activateAlternateOrAdditionalCosts(sourceObject, noMana, controller, game)) {
      if (getAbilityType().equals(AbilityType.SPELL)
          && ((SpellAbility) this)
              .getSpellAbilityType()
              .equals(SpellAbilityType.FACE_DOWN_CREATURE)) {
        return false;
      }
    }

    // 20121001 - 601.2b
    // If the spell has a variable cost that will be paid as it's being cast (such as an {X} in
    // its mana cost; see rule 107.3), the player announces the value of that variable.
    VariableManaCost variableManaCost = handleManaXCosts(game, noMana, controller);
    String announceString = handleOtherXCosts(game, controller);
    // For effects from cards like Void Winnower x costs have to be set
    if (this.getAbilityType().equals(AbilityType.SPELL)
        && game.replaceEvent(
            GameEvent.getEvent(
                GameEvent.EventType.CAST_SPELL_LATE, getId(), getSourceId(), getControllerId()),
            this)) {
      return false;
    }
    for (Mode mode : this.getModes().getSelectedModes()) {
      this.getModes().setActiveMode(mode);
      // 20121001 - 601.2c
      // 601.2c The player announces his or her choice of an appropriate player, object, or zone for
      // each target the spell requires. A spell may require some targets only if an alternative or
      // additional cost (such as a buyback or kicker cost), or a particular mode, was chosen for
      // it;
      // otherwise, the spell is cast as though it did not require those targets. If the spell has a
      // variable number of targets, the player announces how many targets he or she will choose
      // before
      // he or she announces those targets. The same target can't be chosen multiple times for any
      // one
      // instance of the word "target" on the spell. However, if the spell uses the word "target" in
      // multiple places, the same object, player, or zone can be chosen once for each instance of
      // the
      // word "target" (as long as it fits the targeting criteria). If any effects say that an
      // object
      // or player must be chosen as a target, the player chooses targets so that he or she obeys
      // the
      // maximum possible number of such effects without violating any rules or effects that say
      // that
      // an object or player can't be chosen as a target. The chosen players, objects, and/or zones
      // each become a target of that spell. (Any abilities that trigger when those players,
      // objects,
      // and/or zones become the target of a spell trigger at this point; they'll wait to be put on
      // the stack until the spell has finished being cast.)

      if (sourceObject != null
          && !this.getAbilityType()
              .equals(AbilityType.TRIGGERED)) { // triggered abilities check this already in
        // playerImpl.triggerAbility
        sourceObject.adjustTargets(this, game);
      }
      if (mode.getTargets().size() > 0
          && mode.getTargets()
                  .chooseTargets(
                      getEffects().get(0).getOutcome(), this.controllerId, this, noMana, game)
              == false) {
        if ((variableManaCost != null || announceString != null) && !game.isSimulation()) {
          game.informPlayer(
              controller,
              (sourceObject != null ? sourceObject.getIdName() : "")
                  + ": no valid targets with this value of X");
        }
        return false; // when activation of ability is canceled during target selection
      }
    } // end modes

    // TODO: Handle optionalCosts at the same time as already OptionalAdditionalSourceCosts are
    // handled.
    for (Cost cost : optionalCosts) {
      if (cost instanceof ManaCost) {
        cost.clearPaid();
        if (controller.chooseUse(
            Outcome.Benefit, "Pay optional cost " + cost.getText() + "?", this, game)) {
          manaCostsToPay.add((ManaCost) cost);
        }
      }
    }
    // 20100716 - 601.2e
    if (sourceObject != null) {
      sourceObject.adjustCosts(this, game);
      if (sourceObject instanceof Card) {
        for (Ability ability : ((Card) sourceObject).getAbilities(game)) {
          if (ability instanceof AdjustingSourceCosts) {
            ((AdjustingSourceCosts) ability).adjustCosts(this, game);
          }
        }
      } else {
        for (Ability ability : sourceObject.getAbilities()) {
          if (ability instanceof AdjustingSourceCosts) {
            ((AdjustingSourceCosts) ability).adjustCosts(this, game);
          }
        }
      }
    }

    // this is a hack to prevent mana abilities with mana costs from causing endless loops - pay
    // other costs first
    if (this instanceof ManaAbility
        && !costs.pay(this, game, sourceId, controllerId, noMana, null)) {
      logger.debug("activate mana ability failed - non mana costs");
      return false;
    }

    // 20101001 - 601.2e
    if (costModificationActive) {
      game.getContinuousEffects().costModification(this, game);
    } else {
      costModificationActive = true;
    }

    UUID activatorId = controllerId;
    if ((this instanceof ActivatedAbilityImpl)
        && ((ActivatedAbilityImpl) this).getActivatorId() != null) {
      activatorId = ((ActivatedAbilityImpl) this).getActivatorId();
    }

    // 20100716 - 601.2f  (noMana is not used here, because mana costs were cleared for this ability
    // before adding additional costs and applying cost modification effects)
    if (!manaCostsToPay.pay(this, game, sourceId, activatorId, false, null)) {
      return false; // cancel during mana payment
    }

    // 20100716 - 601.2g
    if (!costs.pay(this, game, sourceId, activatorId, noMana, null)) {
      logger.debug("activate failed - non mana costs");
      return false;
    }
    if (!game.isSimulation()) {
      // inform about x costs now, so canceled announcements are not shown in the log
      if (announceString != null) {
        game.informPlayers(announceString);
      }
      if (variableManaCost != null) {
        int xValue = getManaCostsToPay().getX();
        game.informPlayers(
            controller.getLogName()
                + " announces a value of "
                + xValue
                + " for "
                + variableManaCost.getText());
      }
    }
    activated = true;
    // fire if tapped for mana (may only fire now because else costs of ability itself can be payed
    // with mana of abilities that trigger for that event
    if (this.getAbilityType().equals(AbilityType.MANA)) {
      for (Cost cost : costs) {
        if (cost instanceof TapSourceCost) {
          Mana mana = null;
          Effect effect = getEffects().get(0);
          if (effect instanceof DynamicManaEffect) {
            mana = ((DynamicManaEffect) effect).getMana(game, this);
          } else if (effect instanceof BasicManaEffect) {
            mana = ((BasicManaEffect) effect).getMana(game, this);
          }
          if (mana != null
              && mana.getAny()
                  == 0) { // if mana == null or Any > 0 the event has to be fired in the mana effect
            // to know which mana was produced
            ManaEvent event =
                new ManaEvent(
                    GameEvent.EventType.TAPPED_FOR_MANA, sourceId, sourceId, controllerId, mana);
            if (!game.replaceEvent(event)) {
              game.fireEvent(event);
            }
          }
          break;
        }
      }
    }
    return true;
  }