forked from External/mage
142 lines
5 KiB
Java
142 lines
5 KiB
Java
package mage.abilities.keyword;
|
|
|
|
import mage.abilities.Ability;
|
|
import mage.abilities.SpellAbility;
|
|
import mage.abilities.costs.Cost;
|
|
import mage.abilities.costs.common.DiscardTargetCost;
|
|
import mage.abilities.effects.ContinuousEffect;
|
|
import mage.abilities.effects.ReplacementEffectImpl;
|
|
import mage.cards.Card;
|
|
import mage.constants.Duration;
|
|
import mage.constants.Outcome;
|
|
import mage.constants.SpellAbilityType;
|
|
import mage.constants.Zone;
|
|
import mage.game.Game;
|
|
import mage.game.events.GameEvent;
|
|
import mage.game.events.ZoneChangeEvent;
|
|
import mage.players.Player;
|
|
import mage.target.common.TargetCardInHand;
|
|
import mage.target.targetpointer.FixedTarget;
|
|
|
|
/**
|
|
* Jump-start is found on instants and sorceries. You can cast a card with
|
|
* jump-start from your graveyard by paying all its regular costs and one
|
|
* additional cost: discarding a card from your hand. Casting a spell with
|
|
* jump-start follows all the normal timing rules, so sorceries with jump-start
|
|
* are still limited to your main phases. A spell with jump-start that was cast
|
|
* from your graveyard can still be countered, and if it has targets, it won't
|
|
* do anything if all its targets disappear or otherwise become illegal. After a
|
|
* spell with jump-start cast from your graveyard resolves, is countered, or
|
|
* leaves the stack in any way, it's exiled.
|
|
*
|
|
* @author TheElk801
|
|
*/
|
|
public class JumpStartAbility extends SpellAbility {
|
|
|
|
private boolean replacementEffectAdded = false;
|
|
|
|
public JumpStartAbility(Card card) {
|
|
super(card.getManaCost(), card.getName() + " with jump-start", Zone.GRAVEYARD, SpellAbilityType.BASE_ALTERNATE);
|
|
this.getCosts().addAll(card.getSpellAbility().getCosts().copy());
|
|
Cost cost = new DiscardTargetCost(new TargetCardInHand());
|
|
cost.setText("");
|
|
this.addCost(cost);
|
|
this.getEffects().addAll(card.getSpellAbility().getEffects().copy());
|
|
this.getTargets().addAll(card.getSpellAbility().getTargets().copy());
|
|
this.spellAbilityType = SpellAbilityType.BASE_ALTERNATE;
|
|
this.timing = card.getSpellAbility().getTiming();
|
|
|
|
}
|
|
|
|
public JumpStartAbility(final JumpStartAbility ability) {
|
|
super(ability);
|
|
this.replacementEffectAdded = ability.replacementEffectAdded;
|
|
}
|
|
|
|
@Override
|
|
public SpellAbility getSpellAbilityToResolve(Game game) {
|
|
Card card = game.getCard(getSourceId());
|
|
if (card != null) {
|
|
if (!replacementEffectAdded) {
|
|
replacementEffectAdded = true;
|
|
ContinuousEffect effect = new JumpStartReplacementEffect();
|
|
effect.setTargetPointer(new FixedTarget(getSourceId(), game.getState().getZoneChangeCounter(getSourceId())));
|
|
game.addEffect(effect, this);
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public JumpStartAbility copy() {
|
|
return new JumpStartAbility(this);
|
|
}
|
|
|
|
@Override
|
|
public String getRule(boolean all) {
|
|
return getRule();
|
|
}
|
|
|
|
@Override
|
|
public String getRule() {
|
|
return "Jump-start <i>(You may cast this card from your graveyard "
|
|
+ "by discarding a card in addition to paying its other costs. "
|
|
+ "Then exile this card.)</i>";
|
|
}
|
|
}
|
|
|
|
class JumpStartReplacementEffect extends ReplacementEffectImpl {
|
|
|
|
public JumpStartReplacementEffect() {
|
|
super(Duration.OneUse, Outcome.Exile);
|
|
staticText = "(If this spell was cast with jump-start, "
|
|
+ "exile it instead of putting it anywhere else "
|
|
+ "any time it would leave the stack)";
|
|
}
|
|
|
|
public JumpStartReplacementEffect(final JumpStartReplacementEffect effect) {
|
|
super(effect);
|
|
}
|
|
|
|
@Override
|
|
public JumpStartReplacementEffect copy() {
|
|
return new JumpStartReplacementEffect(this);
|
|
}
|
|
|
|
@Override
|
|
public boolean apply(Game game, Ability source) {
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public boolean replaceEvent(GameEvent event, Ability source, Game game) {
|
|
Player controller = game.getPlayer(source.getControllerId());
|
|
if (controller != null) {
|
|
Card card = game.getCard(event.getTargetId());
|
|
if (card != null) {
|
|
discard();
|
|
return controller.moveCards(
|
|
card, Zone.EXILED, source, game, false, false, false, event.getAppliedEffects());
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public boolean checksEventType(GameEvent event, Game game) {
|
|
return event.getType() == GameEvent.EventType.ZONE_CHANGE;
|
|
}
|
|
|
|
@Override
|
|
public boolean applies(GameEvent event, Ability source, Game game) {
|
|
if (event.getTargetId().equals(source.getSourceId())
|
|
&& ((ZoneChangeEvent) event).getFromZone() == Zone.STACK
|
|
&& ((ZoneChangeEvent) event).getToZone() != Zone.EXILED) {
|
|
if (game.getState().getZoneChangeCounter(source.getSourceId()) == source.getSourceObjectZoneChangeCounter() + 1) {
|
|
return true;
|
|
}
|
|
|
|
}
|
|
return false;
|
|
}
|
|
}
|