From 316f823ebf87c60d48d8eac446de723157054b4e Mon Sep 17 00:00:00 2001 From: Evan Kranzler Date: Sun, 22 Sep 2019 20:54:29 -0400 Subject: [PATCH] cleaned up the TargetAmount classes in preparation for updating them --- .../target/common/TargetAnyTargetAmount.java | 169 +--------- .../TargetCreatureOrPlaneswalkerAmount.java | 318 ++++++++---------- .../common/TargetCreatureOrPlayerAmount.java | 169 +--------- .../common/TargetPermanentOrPlayerAmount.java | 190 +++++++++++ 4 files changed, 359 insertions(+), 487 deletions(-) create mode 100644 Mage/src/main/java/mage/target/common/TargetPermanentOrPlayerAmount.java diff --git a/Mage/src/main/java/mage/target/common/TargetAnyTargetAmount.java b/Mage/src/main/java/mage/target/common/TargetAnyTargetAmount.java index 37c8d4f8fb4..cb3fa0c8d49 100644 --- a/Mage/src/main/java/mage/target/common/TargetAnyTargetAmount.java +++ b/Mage/src/main/java/mage/target/common/TargetAnyTargetAmount.java @@ -1,28 +1,24 @@ package mage.target.common; -import java.util.HashSet; -import java.util.Set; -import java.util.UUID; -import mage.MageObject; -import mage.abilities.Ability; import mage.abilities.dynamicvalue.DynamicValue; import mage.abilities.dynamicvalue.common.StaticValue; +import mage.constants.CardType; import mage.constants.Zone; -import mage.filter.Filter; -import mage.filter.StaticFilters; import mage.filter.common.FilterCreaturePlayerOrPlaneswalker; -import mage.game.Game; -import mage.game.permanent.Permanent; -import mage.players.Player; -import mage.target.TargetAmount; +import mage.filter.common.FilterPermanentOrPlayer; +import mage.filter.predicate.mageobject.CardTypePredicate; /** - * * @author BetaSteward_at_googlemail.com */ -public class TargetAnyTargetAmount extends TargetAmount { +public class TargetAnyTargetAmount extends TargetPermanentOrPlayerAmount { - protected final FilterCreaturePlayerOrPlaneswalker filter; + private static final FilterPermanentOrPlayer defaultFilter + = new FilterCreaturePlayerOrPlaneswalker("targets"); + + static { + defaultFilter.getPermanentFilter().add(new CardTypePredicate(CardType.CREATURE)); + } public TargetAnyTargetAmount(int amount) { // 107.1c If a rule or ability instructs a player to choose “any number,” that player may choose @@ -36,158 +32,17 @@ public class TargetAnyTargetAmount extends TargetAmount { public TargetAnyTargetAmount(DynamicValue amount) { super(amount); this.zone = Zone.ALL; - this.filter = new FilterCreaturePlayerOrPlaneswalker("targets"); + this.filter = defaultFilter; this.targetName = filter.getMessage(); } - public TargetAnyTargetAmount(final TargetAnyTargetAmount target) { + private TargetAnyTargetAmount(final TargetAnyTargetAmount target) { super(target); this.filter = target.filter.copy(); } - @Override - public Filter getFilter() { - return this.filter; - } - - @Override - public boolean canTarget(UUID objectId, Game game) { - Permanent permanent = game.getPermanent(objectId); - if (permanent != null) { - return filter.match(permanent, game); - } - Player player = game.getPlayer(objectId); - return player != null && filter.match(player, game); - } - - @Override - public boolean canTarget(UUID objectId, Ability source, Game game) { - Permanent permanent = game.getPermanent(objectId); - Player player = game.getPlayer(objectId); - - if (source != null) { - MageObject targetSource = source.getSourceObject(game); - if (permanent != null) { - return permanent.canBeTargetedBy(targetSource, source.getControllerId(), game) && filter.match(permanent, source.getSourceId(), source.getControllerId(), game); - } - if (player != null) { - return player.canBeTargetedBy(targetSource, source.getControllerId(), game) && filter.match(player, game); - } - } - - if (permanent != null) { - return filter.match(permanent, game); - } - return player != null && filter.match(player, game); - } - - @Override - public boolean canTarget(UUID playerId, UUID objectId, Ability source, Game game) { - return canTarget(objectId, source, game); - } - - @Override - public boolean canChoose(UUID sourceId, UUID sourceControllerId, Game game) { - int count = 0; - MageObject targetSource = game.getObject(sourceId); - for (UUID playerId : game.getState().getPlayersInRange(sourceControllerId, game)) { - Player player = game.getPlayer(playerId); - if (player != null && player.canBeTargetedBy(targetSource, sourceControllerId, game) && filter.match(player, game)) { - count++; - if (count >= this.minNumberOfTargets) { - return true; - } - } - } - for (Permanent permanent : game.getBattlefield().getActivePermanents(StaticFilters.FILTER_PERMANENT, sourceControllerId, game)) { - if (permanent.canBeTargetedBy(targetSource, sourceControllerId, game) && filter.match(permanent, sourceId, sourceControllerId, game)) { - count++; - if (count >= this.minNumberOfTargets) { - return true; - } - } - } - return false; - } - - @Override - public boolean canChoose(UUID sourceControllerId, Game game) { - int count = 0; - for (UUID playerId : game.getState().getPlayersInRange(sourceControllerId, game)) { - Player player = game.getPlayer(playerId); - if (player != null && filter.match(player, game)) { - count++; - if (count >= this.minNumberOfTargets) { - return true; - } - } - } - for (Permanent permanent : game.getBattlefield().getActivePermanents(StaticFilters.FILTER_PERMANENT, sourceControllerId, game)) { - if (filter.match(permanent, null, sourceControllerId, game)) { - count++; - if (count >= this.minNumberOfTargets) { - return true; - } - } - } - return false; - } - - @Override - public Set possibleTargets(UUID sourceId, UUID sourceControllerId, Game game) { - Set possibleTargets = new HashSet<>(); - MageObject targetSource = game.getObject(sourceId); - for (UUID playerId : game.getState().getPlayersInRange(sourceControllerId, game)) { - Player player = game.getPlayer(playerId); - if (player != null && player.canBeTargetedBy(targetSource, sourceControllerId, game) && filter.match(player, game)) { - possibleTargets.add(playerId); - } - } - for (Permanent permanent : game.getBattlefield().getActivePermanents(StaticFilters.FILTER_PERMANENT, sourceControllerId, game)) { - if (permanent.canBeTargetedBy(targetSource, sourceControllerId, game) && filter.match(permanent, sourceId, sourceControllerId, game)) { - possibleTargets.add(permanent.getId()); - } - } - return possibleTargets; - } - - @Override - public Set possibleTargets(UUID sourceControllerId, Game game) { - Set possibleTargets = new HashSet<>(); - for (UUID playerId : game.getState().getPlayersInRange(sourceControllerId, game)) { - Player player = game.getPlayer(playerId); - if (player != null && filter.match(player, game)) { - possibleTargets.add(playerId); - } - } - for (Permanent permanent : game.getBattlefield().getActivePermanents(StaticFilters.FILTER_PERMANENT, sourceControllerId, game)) { - if (filter.match(permanent, null, sourceControllerId, game)) { - possibleTargets.add(permanent.getId()); - } - } - return possibleTargets; - } - - @Override - public String getTargetedName(Game game) { - StringBuilder sb = new StringBuilder(); - for (UUID targetId : getTargets()) { - Permanent permanent = game.getPermanent(targetId); - if (permanent != null) { - sb.append(permanent.getLogName()).append('(').append(getTargetAmount(targetId)).append(") "); - } else { - Player player = game.getPlayer(targetId); - if (player != null) { - sb.append(player.getLogName()).append('(').append(getTargetAmount(targetId)).append(") "); - } - } - } - return sb.toString(); - } - @Override public TargetAnyTargetAmount copy() { return new TargetAnyTargetAmount(this); } - } diff --git a/Mage/src/main/java/mage/target/common/TargetCreatureOrPlaneswalkerAmount.java b/Mage/src/main/java/mage/target/common/TargetCreatureOrPlaneswalkerAmount.java index b3737156954..d005822bc04 100644 --- a/Mage/src/main/java/mage/target/common/TargetCreatureOrPlaneswalkerAmount.java +++ b/Mage/src/main/java/mage/target/common/TargetCreatureOrPlaneswalkerAmount.java @@ -1,179 +1,151 @@ - /* - * Copyright 2010 BetaSteward_at_googlemail.com. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without modification, are - * permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright notice, this list of - * conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright notice, this list - * of conditions and the following disclaimer in the documentation and/or other materials - * provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY BetaSteward_at_googlemail.com ``AS IS'' AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND - * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BetaSteward_at_googlemail.com OR - * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON - * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING - * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF - * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - * The views and conclusions contained in the software and documentation are those of the - * authors and should not be interpreted as representing official policies, either expressed - * or implied, of BetaSteward_at_googlemail.com. - */ - package mage.target.common; +package mage.target.common; - import java.util.HashSet; - import java.util.Set; - import java.util.UUID; - import mage.constants.Zone; - import mage.MageObject; - import mage.abilities.Ability; - import mage.abilities.dynamicvalue.DynamicValue; - import mage.abilities.dynamicvalue.common.StaticValue; - import mage.filter.Filter; - import mage.filter.common.FilterCreatureOrPlaneswalkerPermanent; - import mage.game.Game; - import mage.game.permanent.Permanent; - import mage.target.TargetAmount; +import mage.MageObject; +import mage.abilities.Ability; +import mage.abilities.dynamicvalue.DynamicValue; +import mage.abilities.dynamicvalue.common.StaticValue; +import mage.constants.Zone; +import mage.filter.Filter; +import mage.filter.common.FilterCreatureOrPlaneswalkerPermanent; +import mage.game.Game; +import mage.game.permanent.Permanent; +import mage.target.TargetAmount; - /** - * - * @author BetaSteward_at_googlemail.com - */ - public class TargetCreatureOrPlaneswalkerAmount extends TargetAmount { +import java.util.Objects; +import java.util.Set; +import java.util.UUID; +import java.util.stream.Collectors; - protected final FilterCreatureOrPlaneswalkerPermanent filter; +/** + * @author BetaSteward_at_googlemail.com + */ +public class TargetCreatureOrPlaneswalkerAmount extends TargetAmount { - public TargetCreatureOrPlaneswalkerAmount(int amount) { - // 107.1c If a rule or ability instructs a player to choose “any number,” that player may choose - // any positive number or zero, unless something (such as damage or counters) is being divided - // or distributed among “any number” of players and/or objects. In that case, a nonzero number - // of players and/or objects must be chosen if possible. - this(amount, new FilterCreatureOrPlaneswalkerPermanent()); - } - - public TargetCreatureOrPlaneswalkerAmount(DynamicValue amount) { - this(amount, new FilterCreatureOrPlaneswalkerPermanent()); - } - - public TargetCreatureOrPlaneswalkerAmount(int amount, FilterCreatureOrPlaneswalkerPermanent filter) { - this(new StaticValue(amount), filter); - } - - public TargetCreatureOrPlaneswalkerAmount(DynamicValue amount, FilterCreatureOrPlaneswalkerPermanent filter) { - super(amount); - this.zone = Zone.ALL; - this.filter = filter; - this.targetName = filter.getMessage(); - } - - public TargetCreatureOrPlaneswalkerAmount(final TargetCreatureOrPlaneswalkerAmount target) { - super(target); - this.filter = target.filter.copy(); - } - - @Override - public Filter getFilter() { - return this.filter; - } - - @Override - public boolean canTarget(UUID objectId, Game game) { - Permanent permanent = game.getPermanent(objectId); - return permanent != null && filter.match(permanent, game); - } - - @Override - public boolean canTarget(UUID objectId, Ability source, Game game) { - Permanent permanent = game.getPermanent(objectId); - if (permanent != null) { - if (source != null) { - MageObject targetSource = source.getSourceObject(game); - return permanent.canBeTargetedBy(targetSource, source.getControllerId(), game) && filter.match(permanent, source.getSourceId(), source.getControllerId(), game); - } else { - return filter.match(permanent, game); - } - } - return false; - } - - @Override - public boolean canTarget(UUID playerId, UUID objectId, Ability source, Game game) { - return canTarget(objectId, source, game); - } - - @Override - public boolean canChoose(UUID sourceId, UUID sourceControllerId, Game game) { - int count = 0; - MageObject targetSource = game.getObject(sourceId); - for (Permanent permanent : game.getBattlefield().getActivePermanents(new FilterCreatureOrPlaneswalkerPermanent(), sourceControllerId, game)) { - if (permanent.canBeTargetedBy(targetSource, sourceControllerId, game) && filter.match(permanent, sourceId, sourceControllerId, game)) { - count++; - if (count >= this.minNumberOfTargets) { - return true; - } - } - } - return false; - } - - @Override - public boolean canChoose(UUID sourceControllerId, Game game) { - int count = 0; - for (Permanent permanent : game.getBattlefield().getActivePermanents(new FilterCreatureOrPlaneswalkerPermanent(), sourceControllerId, game)) { - if (filter.match(permanent, null, sourceControllerId, game)) { - count++; - if (count >= this.minNumberOfTargets) { - return true; - } - } - } - return false; - } - - @Override - public Set possibleTargets(UUID sourceId, UUID sourceControllerId, Game game) { - Set possibleTargets = new HashSet<>(); - MageObject targetSource = game.getObject(sourceId); - for (Permanent permanent : game.getBattlefield().getActivePermanents(new FilterCreatureOrPlaneswalkerPermanent(), sourceControllerId, game)) { - if (permanent.canBeTargetedBy(targetSource, sourceControllerId, game) && filter.match(permanent, sourceId, sourceControllerId, game)) { - possibleTargets.add(permanent.getId()); - } - } - return possibleTargets; - } - - @Override - public Set possibleTargets(UUID sourceControllerId, Game game) { - Set possibleTargets = new HashSet<>(); - for (Permanent permanent : game.getBattlefield().getActivePermanents(new FilterCreatureOrPlaneswalkerPermanent(), sourceControllerId, game)) { - if (filter.match(permanent, null, sourceControllerId, game)) { - possibleTargets.add(permanent.getId()); - } - } - return possibleTargets; - } - - @Override - public String getTargetedName(Game game) { - StringBuilder sb = new StringBuilder(); - for (UUID targetId : getTargets()) { - Permanent permanent = game.getPermanent(targetId); - if (permanent != null) { - sb.append(permanent.getLogName()).append('(').append(getTargetAmount(targetId)).append(") "); - } - } - return sb.toString(); - } - - @Override - public TargetCreatureOrPlaneswalkerAmount copy() { - return new TargetCreatureOrPlaneswalkerAmount(this); - } + protected final FilterCreatureOrPlaneswalkerPermanent filter; + private static final FilterCreatureOrPlaneswalkerPermanent defaultFilter + = new FilterCreatureOrPlaneswalkerPermanent(); + public TargetCreatureOrPlaneswalkerAmount(int amount) { + // 107.1c If a rule or ability instructs a player to choose “any number,” that player may choose + // any positive number or zero, unless something (such as damage or counters) is being divided + // or distributed among “any number” of players and/or objects. In that case, a nonzero number + // of players and/or objects must be chosen if possible. + this(amount, defaultFilter); } + + public TargetCreatureOrPlaneswalkerAmount(DynamicValue amount) { + this(amount, defaultFilter); + } + + public TargetCreatureOrPlaneswalkerAmount(int amount, FilterCreatureOrPlaneswalkerPermanent filter) { + this(new StaticValue(amount), filter); + } + + public TargetCreatureOrPlaneswalkerAmount(DynamicValue amount, FilterCreatureOrPlaneswalkerPermanent filter) { + super(amount); + this.zone = Zone.ALL; + this.filter = filter; + this.targetName = filter.getMessage(); + } + + private TargetCreatureOrPlaneswalkerAmount(final TargetCreatureOrPlaneswalkerAmount target) { + super(target); + this.filter = target.filter.copy(); + } + + @Override + public Filter getFilter() { + return this.filter; + } + + @Override + public boolean canTarget(UUID objectId, Game game) { + Permanent permanent = game.getPermanent(objectId); + return permanent != null && filter.match(permanent, game); + } + + @Override + public boolean canTarget(UUID objectId, Ability source, Game game) { + Permanent permanent = game.getPermanent(objectId); + if (permanent != null) { + if (source != null) { + MageObject targetSource = source.getSourceObject(game); + return permanent.canBeTargetedBy(targetSource, source.getControllerId(), game) + && filter.match(permanent, source.getSourceId(), source.getControllerId(), game); + } else { + return filter.match(permanent, game); + } + } + return false; + } + + @Override + public boolean canTarget(UUID playerId, UUID objectId, Ability source, Game game) { + return canTarget(objectId, source, game); + } + + @Override + public boolean canChoose(UUID sourceId, UUID sourceControllerId, Game game) { + int count = 0; + for (Permanent permanent : game.getBattlefield().getActivePermanents(filter, sourceControllerId, sourceId, game)) { + count++; + if (count >= this.minNumberOfTargets) { + return true; + } + } + return false; + } + + @Override + public boolean canChoose(UUID sourceControllerId, Game game) { + int count = 0; + for (Permanent permanent : game.getBattlefield().getActivePermanents(filter, sourceControllerId, game)) { + count++; + if (count >= this.minNumberOfTargets) { + return true; + } + } + return false; + } + + @Override + public Set possibleTargets(UUID sourceId, UUID sourceControllerId, Game game) { + MageObject targetSource = game.getObject(sourceId); + return game + .getBattlefield() + .getActivePermanents(filter, sourceId, sourceControllerId, game) + .stream() + .filter(Objects::nonNull) + .filter(permanent -> permanent.canBeTargetedBy(targetSource, sourceControllerId, game)) + .map(Permanent::getId) + .collect(Collectors.toSet()); + } + + @Override + public Set possibleTargets(UUID sourceControllerId, Game game) { + return game + .getBattlefield() + .getActivePermanents(filter, sourceControllerId, game) + .stream() + .map(Permanent::getId) + .collect(Collectors.toSet()); + } + + @Override + public String getTargetedName(Game game) { + StringBuilder sb = new StringBuilder(); + for (UUID targetId : getTargets()) { + Permanent permanent = game.getPermanent(targetId); + if (permanent != null) { + sb.append(permanent.getLogName()).append('(').append(getTargetAmount(targetId)).append(") "); + } + } + return sb.toString(); + } + + @Override + public TargetCreatureOrPlaneswalkerAmount copy() { + return new TargetCreatureOrPlaneswalkerAmount(this); + } + +} diff --git a/Mage/src/main/java/mage/target/common/TargetCreatureOrPlayerAmount.java b/Mage/src/main/java/mage/target/common/TargetCreatureOrPlayerAmount.java index 06e7ebba6e1..00fa98bf457 100644 --- a/Mage/src/main/java/mage/target/common/TargetCreatureOrPlayerAmount.java +++ b/Mage/src/main/java/mage/target/common/TargetCreatureOrPlayerAmount.java @@ -1,29 +1,23 @@ - package mage.target.common; -import java.util.HashSet; -import java.util.Set; -import java.util.UUID; -import mage.MageObject; -import mage.abilities.Ability; import mage.abilities.dynamicvalue.DynamicValue; import mage.abilities.dynamicvalue.common.StaticValue; +import mage.constants.CardType; import mage.constants.Zone; -import mage.filter.Filter; -import mage.filter.StaticFilters; -import mage.filter.common.FilterCreatureOrPlayer; -import mage.game.Game; -import mage.game.permanent.Permanent; -import mage.players.Player; -import mage.target.TargetAmount; +import mage.filter.common.FilterPermanentOrPlayer; +import mage.filter.predicate.mageobject.CardTypePredicate; /** - * * @author BetaSteward_at_googlemail.com */ -public class TargetCreatureOrPlayerAmount extends TargetAmount { +public class TargetCreatureOrPlayerAmount extends TargetPermanentOrPlayerAmount { - protected final FilterCreatureOrPlayer filter; + private static final FilterPermanentOrPlayer defaultFilter + = new FilterPermanentOrPlayer("creatures and/or players"); + + static { + defaultFilter.getPermanentFilter().add(new CardTypePredicate(CardType.CREATURE)); + } public TargetCreatureOrPlayerAmount(int amount) { // 107.1c If a rule or ability instructs a player to choose “any number,” that player may choose @@ -37,156 +31,17 @@ public class TargetCreatureOrPlayerAmount extends TargetAmount { public TargetCreatureOrPlayerAmount(DynamicValue amount) { super(amount); this.zone = Zone.ALL; - this.filter = new FilterCreatureOrPlayer("creatures and/or players"); + this.filter = defaultFilter; this.targetName = filter.getMessage(); } - public TargetCreatureOrPlayerAmount(final TargetCreatureOrPlayerAmount target) { + private TargetCreatureOrPlayerAmount(final TargetCreatureOrPlayerAmount target) { super(target); this.filter = target.filter.copy(); } - @Override - public Filter getFilter() { - return this.filter; - } - - @Override - public boolean canTarget(UUID objectId, Game game) { - Permanent permanent = game.getPermanent(objectId); - if (permanent != null) { - return filter.match(permanent, game); - } - Player player = game.getPlayer(objectId); - return player != null && filter.match(player, game); - } - - @Override - public boolean canTarget(UUID objectId, Ability source, Game game) { - Permanent permanent = game.getPermanent(objectId); - Player player = game.getPlayer(objectId); - - if (source != null) { - MageObject targetSource = source.getSourceObject(game); - if (permanent != null) { - return permanent.canBeTargetedBy(targetSource, source.getControllerId(), game) && filter.match(permanent, source.getSourceId(), source.getControllerId(), game); - } - if (player != null) { - return player.canBeTargetedBy(targetSource, source.getControllerId(), game) && filter.match(player, game); - } - } - - if (permanent != null) { - return filter.match(permanent, game); - } - return player != null && filter.match(player, game); - } - - @Override - public boolean canTarget(UUID playerId, UUID objectId, Ability source, Game game) { - return canTarget(objectId, source, game); - } - - @Override - public boolean canChoose(UUID sourceId, UUID sourceControllerId, Game game) { - int count = 0; - MageObject targetSource = game.getObject(sourceId); - for (UUID playerId : game.getState().getPlayersInRange(sourceControllerId, game)) { - Player player = game.getPlayer(playerId); - if (player != null && player.canBeTargetedBy(targetSource, sourceControllerId, game) && filter.match(player, game)) { - count++; - if (count >= this.minNumberOfTargets) { - return true; - } - } - } - for (Permanent permanent : game.getBattlefield().getActivePermanents(StaticFilters.FILTER_PERMANENT_CREATURE, sourceControllerId, game)) { - if (permanent.canBeTargetedBy(targetSource, sourceControllerId, game) && filter.match(permanent, sourceId, sourceControllerId, game)) { - count++; - if (count >= this.minNumberOfTargets) { - return true; - } - } - } - return false; - } - - @Override - public boolean canChoose(UUID sourceControllerId, Game game) { - int count = 0; - for (UUID playerId : game.getState().getPlayersInRange(sourceControllerId, game)) { - Player player = game.getPlayer(playerId); - if (player != null && filter.match(player, game)) { - count++; - if (count >= this.minNumberOfTargets) { - return true; - } - } - } - for (Permanent permanent : game.getBattlefield().getActivePermanents(StaticFilters.FILTER_PERMANENT_CREATURE, sourceControllerId, game)) { - if (filter.match(permanent, null, sourceControllerId, game)) { - count++; - if (count >= this.minNumberOfTargets) { - return true; - } - } - } - return false; - } - - @Override - public Set possibleTargets(UUID sourceId, UUID sourceControllerId, Game game) { - Set possibleTargets = new HashSet<>(); - MageObject targetSource = game.getObject(sourceId); - for (UUID playerId : game.getState().getPlayersInRange(sourceControllerId, game)) { - Player player = game.getPlayer(playerId); - if (player != null && player.canBeTargetedBy(targetSource, sourceControllerId, game) && filter.match(player, game)) { - possibleTargets.add(playerId); - } - } - for (Permanent permanent : game.getBattlefield().getActivePermanents(StaticFilters.FILTER_PERMANENT_CREATURE, sourceControllerId, game)) { - if (permanent.canBeTargetedBy(targetSource, sourceControllerId, game) && filter.match(permanent, sourceId, sourceControllerId, game)) { - possibleTargets.add(permanent.getId()); - } - } - return possibleTargets; - } - - @Override - public Set possibleTargets(UUID sourceControllerId, Game game) { - Set possibleTargets = new HashSet<>(); - for (UUID playerId : game.getState().getPlayersInRange(sourceControllerId, game)) { - Player player = game.getPlayer(playerId); - if (player != null && filter.match(player, game)) { - possibleTargets.add(playerId); - } - } - for (Permanent permanent : game.getBattlefield().getActivePermanents(StaticFilters.FILTER_PERMANENT_CREATURE, sourceControllerId, game)) { - if (filter.match(permanent, null, sourceControllerId, game)) { - possibleTargets.add(permanent.getId()); - } - } - return possibleTargets; - } - - @Override - public String getTargetedName(Game game) { - StringBuilder sb = new StringBuilder(); - for (UUID targetId : getTargets()) { - Permanent permanent = game.getPermanent(targetId); - if (permanent != null) { - sb.append(permanent.getLogName()).append('(').append(getTargetAmount(targetId)).append(") "); - } else { - Player player = game.getPlayer(targetId); - sb.append(player.getLogName()).append('(').append(getTargetAmount(targetId)).append(") "); - } - } - return sb.toString(); - } - @Override public TargetCreatureOrPlayerAmount copy() { return new TargetCreatureOrPlayerAmount(this); } - } diff --git a/Mage/src/main/java/mage/target/common/TargetPermanentOrPlayerAmount.java b/Mage/src/main/java/mage/target/common/TargetPermanentOrPlayerAmount.java new file mode 100644 index 00000000000..623233dd23d --- /dev/null +++ b/Mage/src/main/java/mage/target/common/TargetPermanentOrPlayerAmount.java @@ -0,0 +1,190 @@ +package mage.target.common; + +import mage.MageObject; +import mage.abilities.Ability; +import mage.abilities.dynamicvalue.DynamicValue; +import mage.filter.Filter; +import mage.filter.StaticFilters; +import mage.filter.common.FilterPermanentOrPlayer; +import mage.game.Game; +import mage.game.permanent.Permanent; +import mage.players.Player; +import mage.target.TargetAmount; + +import java.util.HashSet; +import java.util.Objects; +import java.util.Set; +import java.util.UUID; + +/** + * @author TheElk801 + */ +public abstract class TargetPermanentOrPlayerAmount extends TargetAmount { + + protected FilterPermanentOrPlayer filter; + + TargetPermanentOrPlayerAmount(DynamicValue amount) { + super(amount); + } + + TargetPermanentOrPlayerAmount(final TargetPermanentOrPlayerAmount target) { + super(target); + this.filter = target.filter.copy(); + } + + @Override + public Filter getFilter() { + return this.filter; + } + + @Override + public boolean canTarget(UUID objectId, Game game) { + Permanent permanent = game.getPermanent(objectId); + if (permanent != null) { + return filter.match(permanent, game); + } + Player player = game.getPlayer(objectId); + return player != null && filter.match(player, game); + } + + @Override + public boolean canTarget(UUID objectId, Ability source, Game game) { + Permanent permanent = game.getPermanent(objectId); + Player player = game.getPlayer(objectId); + + if (source != null) { + MageObject targetSource = source.getSourceObject(game); + if (permanent != null) { + return permanent.canBeTargetedBy(targetSource, source.getControllerId(), game) + && filter.match(permanent, source.getSourceId(), source.getControllerId(), game); + } + if (player != null) { + return player.canBeTargetedBy(targetSource, source.getControllerId(), game) + && filter.match(player, game); + } + } + + if (permanent != null) { + return filter.match(permanent, game); + } + return player != null && filter.match(player, game); + } + + @Override + public boolean canTarget(UUID playerId, UUID objectId, Ability source, Game game) { + return canTarget(objectId, source, game); + } + + @Override + public boolean canChoose(UUID sourceId, UUID sourceControllerId, Game game) { + int count = 0; + MageObject targetSource = game.getObject(sourceId); + for (UUID playerId : game.getState().getPlayersInRange(sourceControllerId, game)) { + Player player = game.getPlayer(playerId); + if (player == null + || !player.canBeTargetedBy(targetSource, sourceControllerId, game) + || !filter.match(player, game)) { + continue; + } + count++; + if (count >= this.minNumberOfTargets) { + return true; + } + } + for (Permanent permanent : game.getBattlefield().getActivePermanents(filter.getPermanentFilter(), sourceControllerId, game)) { + if (!permanent.canBeTargetedBy(targetSource, sourceControllerId, game)) { + continue; + } + count++; + if (count >= this.minNumberOfTargets) { + return true; + } + } + return false; + } + + @Override + public boolean canChoose(UUID sourceControllerId, Game game) { + int count = 0; + for (UUID playerId : game.getState().getPlayersInRange(sourceControllerId, game)) { + Player player = game.getPlayer(playerId); + if (player == null || !filter.match(player, game)) { + continue; + } + count++; + if (count >= this.minNumberOfTargets) { + return true; + } + } + for (Permanent permanent : game.getBattlefield().getActivePermanents(filter.getPermanentFilter(), sourceControllerId, game)) { + count++; + if (count >= this.minNumberOfTargets) { + return true; + } + } + return false; + } + + @Override + public Set possibleTargets(UUID sourceId, UUID sourceControllerId, Game game) { + Set possibleTargets = new HashSet<>(); + MageObject targetSource = game.getObject(sourceId); + + game.getState() + .getPlayersInRange(sourceControllerId, game) + .stream() + .map(game::getPlayer) + .filter(Objects::nonNull) + .filter(player -> player.canBeTargetedBy(targetSource, sourceControllerId, game) + && filter.match(player, game) + ) + .map(Player::getId) + .forEach(possibleTargets::add); + + game.getBattlefield() + .getActivePermanents(filter.getPermanentFilter(), sourceControllerId, game) + .stream() + .filter(Objects::nonNull) + .filter(permanent -> permanent.canBeTargetedBy(targetSource, sourceControllerId, game)) + .map(Permanent::getId) + .forEach(possibleTargets::add); + + return possibleTargets; + } + + @Override + public Set possibleTargets(UUID sourceControllerId, Game game) { + Set possibleTargets = new HashSet<>(); + game.getState() + .getPlayersInRange(sourceControllerId, game) + .stream() + .map(game::getPlayer) + .filter(Objects::nonNull) + .filter(player -> filter.match(player, game)) + .map(Player::getId) + .forEach(possibleTargets::add); + + game.getBattlefield() + .getActivePermanents(filter.getPermanentFilter(), sourceControllerId, game) + .stream() + .map(Permanent::getId) + .forEach(possibleTargets::add); + + return possibleTargets; + } + + @Override + public String getTargetedName(Game game) { + StringBuilder sb = new StringBuilder(); + for (UUID targetId : getTargets()) { + Permanent permanent = game.getPermanent(targetId); + if (permanent != null) { + sb.append(permanent.getLogName()).append('(').append(getTargetAmount(targetId)).append(") "); + } else { + Player player = game.getPlayer(targetId); + sb.append(player.getLogName()).append('(').append(getTargetAmount(targetId)).append(") "); + } + } + return sb.toString(); + } +}