forked from External/mage
implement [FIN] Sorceress's Schemes (#13694) ; small refactor of TargerCard
This commit is contained in:
Susucre
parent
03d8f1bd94
commit
dcf785ed12
5 changed files with 481 additions and 116 deletions
|
|
@ -56,6 +56,18 @@ public class TargetCard extends TargetObject {
|
|||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if there are enough {@link Card} that can be selected.
|
||||
*
|
||||
* @param sourceControllerId - controller of the select event
|
||||
* @param game
|
||||
* @return - true if enough valid {@link Card} exist
|
||||
*/
|
||||
@Override
|
||||
public boolean canChoose(UUID sourceControllerId, Game game) {
|
||||
return canChoose(sourceControllerId, null, game);
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if there are enough {@link Card cards} in the appropriate zone that the player can choose from among them
|
||||
* or if they are autochosen since there are fewer than the minimum number.
|
||||
|
|
@ -67,7 +79,6 @@ public class TargetCard extends TargetObject {
|
|||
*/
|
||||
@Override
|
||||
public boolean canChoose(UUID sourceControllerId, Ability source, Game game) {
|
||||
UUID sourceId = source != null ? source.getSourceId() : null;
|
||||
int possibleTargets = 0;
|
||||
if (getMinNumberOfTargets() == 0) { // if 0 target is valid, the canChoose is always true
|
||||
return true;
|
||||
|
|
@ -80,150 +91,245 @@ public class TargetCard extends TargetObject {
|
|||
}
|
||||
switch (zone) {
|
||||
case HAND:
|
||||
for (Card card : player.getHand().getCards(filter, sourceControllerId, source, game)) {
|
||||
if (sourceId == null || isNotTarget() || !game.replaceEvent(new TargetEvent(card, sourceId, sourceControllerId))) {
|
||||
possibleTargets++;
|
||||
if (possibleTargets >= this.minNumberOfTargets) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
possibleTargets += countPossibleTargetInHand(game, player, sourceControllerId, source,
|
||||
filter, isNotTarget(), this.minNumberOfTargets - possibleTargets);
|
||||
break;
|
||||
case GRAVEYARD:
|
||||
for (Card card : player.getGraveyard().getCards(filter, sourceControllerId, source, game)) {
|
||||
if (sourceId == null || isNotTarget() || !game.replaceEvent(new TargetEvent(card, sourceId, sourceControllerId))) {
|
||||
possibleTargets++;
|
||||
if (possibleTargets >= this.minNumberOfTargets) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
possibleTargets += countPossibleTargetInGraveyard(game, player, sourceControllerId, source,
|
||||
filter, isNotTarget(), this.minNumberOfTargets - possibleTargets);
|
||||
break;
|
||||
case LIBRARY:
|
||||
for (Card card : player.getLibrary().getUniqueCards(game)) {
|
||||
if (sourceId == null || isNotTarget() || !game.replaceEvent(new TargetEvent(card, sourceId, sourceControllerId))) {
|
||||
if (filter.match(card, game)) {
|
||||
possibleTargets++;
|
||||
if (possibleTargets >= this.minNumberOfTargets) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
possibleTargets += countPossibleTargetInLibrary(game, player, sourceControllerId, source,
|
||||
filter, isNotTarget(), this.minNumberOfTargets - possibleTargets);
|
||||
break;
|
||||
case EXILED:
|
||||
for (Card card : game.getExile().getPermanentExile().getCards(game)) {
|
||||
if (sourceId == null || isNotTarget() || !game.replaceEvent(new TargetEvent(card, sourceId, sourceControllerId))) {
|
||||
if (filter.match(card, player.getId(), game)) {
|
||||
possibleTargets++;
|
||||
if (possibleTargets >= this.minNumberOfTargets) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
possibleTargets += countPossibleTargetInExile(game, player, sourceControllerId, source,
|
||||
filter, isNotTarget(), this.minNumberOfTargets - possibleTargets);
|
||||
break;
|
||||
case COMMAND:
|
||||
List<Card> possibleCards = game.getCommandersIds(player, CommanderCardType.ANY, false).stream()
|
||||
.map(game::getCard)
|
||||
.filter(Objects::nonNull)
|
||||
.filter(card -> game.getState().getZone(card.getId()).equals(Zone.COMMAND))
|
||||
.filter(card -> filter.match(card, sourceControllerId, source, game))
|
||||
.collect(Collectors.toList());
|
||||
for (Card card : possibleCards) {
|
||||
if (sourceId == null || isNotTarget() || !game.replaceEvent(new TargetEvent(card, sourceId, sourceControllerId))) {
|
||||
possibleTargets++;
|
||||
if (possibleTargets >= this.minNumberOfTargets) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
possibleTargets += countPossibleTargetInCommandZone(game, player, sourceControllerId, source,
|
||||
filter, isNotTarget(), this.minNumberOfTargets - possibleTargets);
|
||||
break;
|
||||
}
|
||||
if (possibleTargets >= this.minNumberOfTargets) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if there are enough {@link Card} that can be selected.
|
||||
*
|
||||
* @param sourceControllerId - controller of the select event
|
||||
* @param game
|
||||
* @return - true if enough valid {@link Card} exist
|
||||
* count up to N possible target cards in a player's hand matching the filter
|
||||
*/
|
||||
@Override
|
||||
public boolean canChoose(UUID sourceControllerId, Game game) {
|
||||
return canChoose(sourceControllerId, null, game);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Set<UUID> possibleTargets(UUID sourceControllerId, Ability source, Game game) {
|
||||
Set<UUID> possibleTargets = new HashSet<>();
|
||||
protected static int countPossibleTargetInHand(Game game, Player player, UUID sourceControllerId, Ability source, FilterCard filter, boolean isNotTarget, int countUpTo) {
|
||||
UUID sourceId = source != null ? source.getSourceId() : null;
|
||||
for (UUID playerId : game.getState().getPlayersInRange(sourceControllerId, game)) {
|
||||
Player player = game.getPlayer(playerId);
|
||||
if (player != null) {
|
||||
switch (zone) {
|
||||
case HAND:
|
||||
for (Card card : player.getHand().getCards(filter, sourceControllerId, source, game)) {
|
||||
// TODO: Why for sourceId == null?
|
||||
if (sourceId == null || isNotTarget() || !game.replaceEvent(new TargetEvent(card, sourceId, sourceControllerId))) {
|
||||
possibleTargets.add(card.getId());
|
||||
}
|
||||
}
|
||||
break;
|
||||
case GRAVEYARD:
|
||||
for (Card card : player.getGraveyard().getCards(filter, sourceControllerId, source, game)) {
|
||||
if (sourceId == null || isNotTarget() || !game.replaceEvent(new TargetEvent(card, sourceId, sourceControllerId))) {
|
||||
possibleTargets.add(card.getId());
|
||||
}
|
||||
}
|
||||
break;
|
||||
case LIBRARY:
|
||||
for (Card card : player.getLibrary().getUniqueCards(game)) {
|
||||
if (sourceId == null || isNotTarget() || !game.replaceEvent(new TargetEvent(card, sourceId, sourceControllerId))) {
|
||||
if (filter.match(card, sourceControllerId, source, game)) {
|
||||
possibleTargets.add(card.getId());
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
case EXILED:
|
||||
for (Card card : game.getExile().getPermanentExile().getCards(game)) {
|
||||
if (sourceId == null || isNotTarget() || !game.replaceEvent(new TargetEvent(card, sourceId, sourceControllerId))) {
|
||||
if (filter.match(card, sourceControllerId, source, game)) {
|
||||
possibleTargets.add(card.getId());
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
case COMMAND:
|
||||
List<Card> possibleCards = game.getCommandersIds(player, CommanderCardType.ANY, false).stream()
|
||||
.map(game::getCard)
|
||||
.filter(Objects::nonNull)
|
||||
.filter(card -> game.getState().getZone(card.getId()).equals(Zone.COMMAND))
|
||||
.filter(card -> filter.match(card, sourceControllerId, source, game))
|
||||
.collect(Collectors.toList());
|
||||
for (Card card : possibleCards) {
|
||||
if (sourceId == null || isNotTarget() || !game.replaceEvent(new TargetEvent(card, sourceId, sourceControllerId))) {
|
||||
possibleTargets.add(card.getId());
|
||||
}
|
||||
}
|
||||
break;
|
||||
int possibleTargets = 0;
|
||||
for (Card card : player.getHand().getCards(filter, sourceControllerId, source, game)) {
|
||||
if (sourceId == null || isNotTarget || !game.replaceEvent(new TargetEvent(card, sourceId, sourceControllerId))) {
|
||||
possibleTargets++;
|
||||
if (possibleTargets >= countUpTo) {
|
||||
return possibleTargets; // early return for faster computation.
|
||||
}
|
||||
}
|
||||
}
|
||||
return possibleTargets;
|
||||
}
|
||||
|
||||
/**
|
||||
* count up to N possible target cards in a player's graveyard matching the filter
|
||||
*/
|
||||
protected static int countPossibleTargetInGraveyard(Game game, Player player, UUID sourceControllerId, Ability source, FilterCard filter, boolean isNotTarget, int countUpTo) {
|
||||
UUID sourceId = source != null ? source.getSourceId() : null;
|
||||
int possibleTargets = 0;
|
||||
for (Card card : player.getGraveyard().getCards(filter, sourceControllerId, source, game)) {
|
||||
if (sourceId == null || isNotTarget || !game.replaceEvent(new TargetEvent(card, sourceId, sourceControllerId))) {
|
||||
possibleTargets++;
|
||||
if (possibleTargets >= countUpTo) {
|
||||
return possibleTargets; // early return for faster computation.
|
||||
}
|
||||
}
|
||||
}
|
||||
return possibleTargets;
|
||||
}
|
||||
|
||||
/**
|
||||
* count up to N possible target cards in a player's library matching the filter
|
||||
*/
|
||||
protected static int countPossibleTargetInLibrary(Game game, Player player, UUID sourceControllerId, Ability source, FilterCard filter, boolean isNotTarget, int countUpTo) {
|
||||
UUID sourceId = source != null ? source.getSourceId() : null;
|
||||
int possibleTargets = 0;
|
||||
for (Card card : player.getLibrary().getUniqueCards(game)) {
|
||||
if (sourceId == null || isNotTarget || !game.replaceEvent(new TargetEvent(card, sourceId, sourceControllerId))) {
|
||||
if (filter.match(card, game)) {
|
||||
possibleTargets++;
|
||||
if (possibleTargets >= countUpTo) {
|
||||
return possibleTargets; // early return for faster computation.
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return possibleTargets;
|
||||
}
|
||||
|
||||
/**
|
||||
* count up to N possible target cards in a player's exile matching the filter
|
||||
*/
|
||||
protected static int countPossibleTargetInExile(Game game, Player player, UUID sourceControllerId, Ability source, FilterCard filter, boolean isNotTarget, int countUpTo) {
|
||||
UUID sourceId = source != null ? source.getSourceId() : null;
|
||||
int possibleTargets = 0;
|
||||
for (Card card : game.getExile().getPermanentExile().getCards(game)) {
|
||||
if (sourceId == null || isNotTarget || !game.replaceEvent(new TargetEvent(card, sourceId, sourceControllerId))) {
|
||||
if (filter.match(card, player.getId(), game)) {
|
||||
possibleTargets++;
|
||||
if (possibleTargets >= countUpTo) {
|
||||
return possibleTargets; // early return for faster computation.
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return possibleTargets;
|
||||
}
|
||||
|
||||
/**
|
||||
* count up to N possible target cards in a player's command zone matching the filter
|
||||
*/
|
||||
protected static int countPossibleTargetInCommandZone(Game game, Player player, UUID sourceControllerId, Ability source, FilterCard filter, boolean isNotTarget, int countUpTo) {
|
||||
UUID sourceId = source != null ? source.getSourceId() : null;
|
||||
int possibleTargets = 0;
|
||||
List<Card> possibleCards = game.getCommandersIds(player, CommanderCardType.ANY, false).stream()
|
||||
.map(game::getCard)
|
||||
.filter(Objects::nonNull)
|
||||
.filter(card -> game.getState().getZone(card.getId()).equals(Zone.COMMAND))
|
||||
.filter(card -> filter.match(card, sourceControllerId, source, game))
|
||||
.collect(Collectors.toList());
|
||||
for (Card card : possibleCards) {
|
||||
if (sourceId == null || isNotTarget || !game.replaceEvent(new TargetEvent(card, sourceId, sourceControllerId))) {
|
||||
possibleTargets++;
|
||||
if (possibleTargets >= countUpTo) {
|
||||
return possibleTargets; // early return for faster computation.
|
||||
}
|
||||
}
|
||||
}
|
||||
return possibleTargets;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Set<UUID> possibleTargets(UUID sourceControllerId, Game game) {
|
||||
return possibleTargets(sourceControllerId, (Ability) null, game);
|
||||
}
|
||||
|
||||
public Set<UUID> possibleTargets(UUID sourceControllerId, Cards cards, Ability source, Game game) {
|
||||
return cards.getCards(filter, sourceControllerId, source, game).stream().map(MageItem::getId).collect(Collectors.toSet());
|
||||
}
|
||||
|
||||
@Override
|
||||
public Set<UUID> possibleTargets(UUID sourceControllerId, Game game) {
|
||||
return possibleTargets(sourceControllerId, (Ability) null, game);
|
||||
public Set<UUID> possibleTargets(UUID sourceControllerId, Ability source, Game game) {
|
||||
Set<UUID> possibleTargets = new HashSet<>();
|
||||
for (UUID playerId : game.getState().getPlayersInRange(sourceControllerId, game)) {
|
||||
Player player = game.getPlayer(playerId);
|
||||
if (player != null) {
|
||||
switch (zone) {
|
||||
case HAND:
|
||||
possibleTargets.addAll(getAllPossibleTargetInHand(game, player, sourceControllerId, source, filter, isNotTarget()));
|
||||
break;
|
||||
case GRAVEYARD:
|
||||
possibleTargets.addAll(getAllPossibleTargetInGraveyard(game, player, sourceControllerId, source, filter, isNotTarget()));
|
||||
break;
|
||||
case LIBRARY:
|
||||
possibleTargets.addAll(getAllPossibleTargetInLibrary(game, player, sourceControllerId, source, filter, isNotTarget()));
|
||||
break;
|
||||
case EXILED:
|
||||
possibleTargets.addAll(getAllPossibleTargetInExile(game, player, sourceControllerId, source, filter, isNotTarget()));
|
||||
break;
|
||||
case COMMAND:
|
||||
possibleTargets.addAll(getAllPossibleTargetInCommandZone(game, player, sourceControllerId, source, filter, isNotTarget()));
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return possibleTargets;
|
||||
}
|
||||
|
||||
/**
|
||||
* set of all matching target in a player's hand
|
||||
*/
|
||||
protected static Set<UUID> getAllPossibleTargetInHand(Game game, Player player, UUID sourceControllerId, Ability source, FilterCard filter, boolean isNotTarget) {
|
||||
Set<UUID> possibleTargets = new HashSet<>();
|
||||
UUID sourceId = source != null ? source.getSourceId() : null;
|
||||
for (Card card : player.getHand().getCards(filter, sourceControllerId, source, game)) {
|
||||
// TODO: Why for sourceId == null?
|
||||
if (sourceId == null || isNotTarget || !game.replaceEvent(new TargetEvent(card, sourceId, sourceControllerId))) {
|
||||
possibleTargets.add(card.getId());
|
||||
}
|
||||
}
|
||||
return possibleTargets;
|
||||
}
|
||||
|
||||
/**
|
||||
* set of all matching target in a player's hand
|
||||
*/
|
||||
protected static Set<UUID> getAllPossibleTargetInGraveyard(Game game, Player player, UUID sourceControllerId, Ability source, FilterCard filter, boolean isNotTarget) {
|
||||
Set<UUID> possibleTargets = new HashSet<>();
|
||||
UUID sourceId = source != null ? source.getSourceId() : null;
|
||||
for (Card card : player.getGraveyard().getCards(filter, sourceControllerId, source, game)) {
|
||||
if (sourceId == null || isNotTarget || !game.replaceEvent(new TargetEvent(card, sourceId, sourceControllerId))) {
|
||||
possibleTargets.add(card.getId());
|
||||
}
|
||||
}
|
||||
return possibleTargets;
|
||||
}
|
||||
|
||||
/**
|
||||
* set of all matching target in a player's hand
|
||||
*/
|
||||
protected static Set<UUID> getAllPossibleTargetInLibrary(Game game, Player player, UUID sourceControllerId, Ability source, FilterCard filter, boolean isNotTarget) {
|
||||
Set<UUID> possibleTargets = new HashSet<>();
|
||||
UUID sourceId = source != null ? source.getSourceId() : null;
|
||||
for (Card card : player.getLibrary().getUniqueCards(game)) {
|
||||
if (sourceId == null || isNotTarget || !game.replaceEvent(new TargetEvent(card, sourceId, sourceControllerId))) {
|
||||
if (filter.match(card, sourceControllerId, source, game)) {
|
||||
possibleTargets.add(card.getId());
|
||||
}
|
||||
}
|
||||
}
|
||||
return possibleTargets;
|
||||
}
|
||||
|
||||
/**
|
||||
* set of all matching target for a player in exile
|
||||
*/
|
||||
protected static Set<UUID> getAllPossibleTargetInExile(Game game, Player player, UUID sourceControllerId, Ability source, FilterCard filter, boolean isNotTarget) {
|
||||
Set<UUID> possibleTargets = new HashSet<>();
|
||||
UUID sourceId = source != null ? source.getSourceId() : null;
|
||||
for (Card card : game.getExile().getPermanentExile().getCards(game)) {
|
||||
if (sourceId == null || isNotTarget || !game.replaceEvent(new TargetEvent(card, sourceId, sourceControllerId))) {
|
||||
if (filter.match(card, sourceControllerId, source, game)) {
|
||||
possibleTargets.add(card.getId());
|
||||
}
|
||||
}
|
||||
}
|
||||
return possibleTargets;
|
||||
}
|
||||
|
||||
/**
|
||||
* set of all matching target in a player's command zone
|
||||
*/
|
||||
protected static Set<UUID> getAllPossibleTargetInCommandZone(Game game, Player player, UUID sourceControllerId, Ability source, FilterCard filter, boolean isNotTarget) {
|
||||
Set<UUID> possibleTargets = new HashSet<>();
|
||||
UUID sourceId = source != null ? source.getSourceId() : null;
|
||||
List<Card> possibleCards = game.getCommandersIds(player, CommanderCardType.ANY, false).stream()
|
||||
.map(game::getCard)
|
||||
.filter(Objects::nonNull)
|
||||
.filter(card -> game.getState().getZone(card.getId()).equals(Zone.COMMAND))
|
||||
.filter(card -> filter.match(card, sourceControllerId, source, game))
|
||||
.collect(Collectors.toList());
|
||||
for (Card card : possibleCards) {
|
||||
if (sourceId == null || isNotTarget || !game.replaceEvent(new TargetEvent(card, sourceId, sourceControllerId))) {
|
||||
possibleTargets.add(card.getId());
|
||||
}
|
||||
}
|
||||
return possibleTargets;
|
||||
}
|
||||
|
||||
// TODO: check all class targets, if it override canTarget then make sure it override ALL 3 METHODS with canTarget and possibleTargets (method with cards doesn't need)
|
||||
|
|
|
|||
|
|
@ -0,0 +1,104 @@
|
|||
package mage.target.common;
|
||||
|
||||
import mage.abilities.Ability;
|
||||
import mage.cards.Card;
|
||||
import mage.constants.Zone;
|
||||
import mage.filter.FilterCard;
|
||||
import mage.game.Game;
|
||||
import mage.players.Player;
|
||||
import mage.target.TargetCard;
|
||||
|
||||
import java.util.HashSet;
|
||||
import java.util.Set;
|
||||
import java.util.UUID;
|
||||
|
||||
/**
|
||||
* @author Susucr
|
||||
*/
|
||||
public class TargetCardInYourGraveyardOrExile extends TargetCard {
|
||||
|
||||
private final FilterCard filterGraveyard;
|
||||
private final FilterCard filterExile;
|
||||
|
||||
public TargetCardInYourGraveyardOrExile(FilterCard filterGraveyard, FilterCard filterExile) {
|
||||
super(1, 1, Zone.GRAVEYARD, filterGraveyard); // we do not actually use those, as all is overwritten
|
||||
this.filterGraveyard = filterGraveyard;
|
||||
this.filterExile = filterExile;
|
||||
this.targetName = filterGraveyard.getMessage() + " or " + filterExile.getMessage();
|
||||
}
|
||||
|
||||
protected TargetCardInYourGraveyardOrExile(final TargetCardInYourGraveyardOrExile target) {
|
||||
super(target);
|
||||
this.filterGraveyard = target.filterGraveyard;
|
||||
this.filterExile = target.filterExile;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean canChoose(UUID sourceControllerId, Ability source, Game game) {
|
||||
Player player = game.getPlayer(sourceControllerId);
|
||||
if (player == null) {
|
||||
return false;
|
||||
}
|
||||
int possibleTargets = 0;
|
||||
// in your graveyard:
|
||||
possibleTargets += countPossibleTargetInGraveyard(game, player, sourceControllerId, source,
|
||||
filterGraveyard, isNotTarget(), this.minNumberOfTargets - possibleTargets);
|
||||
if (possibleTargets >= this.minNumberOfTargets) {
|
||||
return true;
|
||||
}
|
||||
// in exile:
|
||||
possibleTargets += countPossibleTargetInExile(game, player, sourceControllerId, source,
|
||||
filterExile, isNotTarget(), this.minNumberOfTargets - possibleTargets);
|
||||
return possibleTargets >= this.minNumberOfTargets;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Set<UUID> possibleTargets(UUID sourceControllerId, Game game) {
|
||||
return this.possibleTargets(sourceControllerId, (Ability) null, game);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Set<UUID> possibleTargets(UUID sourceControllerId, Ability source, Game game) {
|
||||
Set<UUID> possibleTargets = new HashSet<>();
|
||||
Player player = game.getPlayer(sourceControllerId);
|
||||
if (player == null) {
|
||||
return possibleTargets;
|
||||
}
|
||||
// in your graveyard:
|
||||
possibleTargets.addAll(getAllPossibleTargetInGraveyard(game, player, sourceControllerId, source, filterGraveyard, isNotTarget()));
|
||||
// in exile:
|
||||
possibleTargets.addAll(getAllPossibleTargetInExile(game, player, sourceControllerId, source, filterExile, isNotTarget()));
|
||||
return possibleTargets;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean canTarget(UUID id, Ability source, Game game) {
|
||||
return this.canTarget(source.getControllerId(), id, source, game);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean canTarget(UUID playerId, UUID id, Ability source, Game game) {
|
||||
Card card = game.getCard(id);
|
||||
if (card == null) {
|
||||
return false;
|
||||
}
|
||||
switch (game.getState().getZone(id)) {
|
||||
case GRAVEYARD:
|
||||
return filterGraveyard.match(card, playerId, source, game);
|
||||
case EXILED:
|
||||
return filterExile.match(card, playerId, source, game);
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean canTarget(UUID id, Game game) {
|
||||
return this.canTarget(null, id, null, game);
|
||||
}
|
||||
|
||||
@Override
|
||||
public TargetCardInYourGraveyardOrExile copy() {
|
||||
return new TargetCardInYourGraveyardOrExile(this);
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue