forked from External/mage
338 lines
12 KiB
Java
338 lines
12 KiB
Java
package mage.game.permanent;
|
|
|
|
import mage.abilities.Ability;
|
|
import mage.abilities.keyword.PhasingAbility;
|
|
import mage.constants.CardType;
|
|
import mage.constants.RangeOfInfluence;
|
|
import mage.filter.FilterPermanent;
|
|
import mage.game.Game;
|
|
|
|
import java.io.Serializable;
|
|
import java.util.*;
|
|
import java.util.Map.Entry;
|
|
import java.util.stream.Collectors;
|
|
|
|
/**
|
|
* @author BetaSteward_at_googlemail.com
|
|
*/
|
|
public class Battlefield implements Serializable {
|
|
|
|
private final Map<UUID, Permanent> field = new LinkedHashMap<>();
|
|
|
|
public Battlefield() {
|
|
}
|
|
|
|
protected Battlefield(final Battlefield battlefield) {
|
|
for (Entry<UUID, Permanent> entry : battlefield.field.entrySet()) {
|
|
field.put(entry.getKey(), entry.getValue().copy());
|
|
}
|
|
}
|
|
|
|
public Battlefield copy() {
|
|
return new Battlefield(this);
|
|
}
|
|
|
|
public void reset(Game game) {
|
|
for (Permanent perm : field.values()) {
|
|
perm.reset(game);
|
|
}
|
|
}
|
|
|
|
public void clear() {
|
|
field.clear();
|
|
}
|
|
|
|
/**
|
|
* Returns a count of all {@link Permanent} that match the filter and are
|
|
* controlled by controllerId.
|
|
* <p>
|
|
* Some filter predicates do not work here (e.g. AnotherPredicate() because
|
|
* filter.match() is called without controllerId. To use this predicates you
|
|
* can use count() instead of countAll()
|
|
*/
|
|
public int countAll(FilterPermanent filter, UUID controllerId, Game game) {
|
|
return (int) field.values()
|
|
.stream()
|
|
.filter(permanent -> permanent.isControlledBy(controllerId)
|
|
&& filter.match(permanent, game)
|
|
&& permanent.isPhasedIn())
|
|
.count();
|
|
|
|
}
|
|
|
|
/**
|
|
* Returns a count of all {@link Permanent} that are within the range of
|
|
* influence of the specified player id and that match the supplied filter.
|
|
*/
|
|
public int count(FilterPermanent filter, UUID sourcePlayerId, Ability source, Game game) {
|
|
if (game.getRangeOfInfluence() == RangeOfInfluence.ALL) {
|
|
return (int) field.values()
|
|
.stream()
|
|
.filter(permanent -> filter.match(permanent, sourcePlayerId, source, game)
|
|
&& permanent.isPhasedIn())
|
|
.count();
|
|
} else {
|
|
List<UUID> range = game.getState().getPlayersInRange(sourcePlayerId, game);
|
|
return (int) field.values()
|
|
.stream()
|
|
.filter(permanent -> range.contains(permanent.getControllerId())
|
|
&& filter.match(permanent, sourcePlayerId, source, game)
|
|
&& permanent.isPhasedIn()).count();
|
|
}
|
|
}
|
|
|
|
public boolean containsControlled(FilterPermanent filter, Ability source, Game game, int num) {
|
|
return containsControlled(filter, source.getControllerId(), source, game, num);
|
|
}
|
|
|
|
/**
|
|
* Returns true if the battlefield contains num or more {@link Permanent}
|
|
* that matches the filter and is controlled by controllerId. This method
|
|
* ignores the range of influence.
|
|
*
|
|
* @param controllerId controller and source can be different (from different players)
|
|
*/
|
|
public boolean containsControlled(FilterPermanent filter, UUID controllerId, Ability source, Game game, int num) {
|
|
return field.values()
|
|
.stream()
|
|
.filter(permanent -> permanent.isControlledBy(controllerId)
|
|
&& filter.match(permanent, controllerId, source, game)
|
|
&& permanent.isPhasedIn())
|
|
.count() >= num;
|
|
}
|
|
|
|
public boolean contains(FilterPermanent filter, Ability source, Game game, int num) {
|
|
return contains(filter, source.getControllerId(), source, game, num);
|
|
}
|
|
|
|
/**
|
|
* Returns true if the battlefield contains num or more {@link Permanent}
|
|
* that is within the range of influence of the specified player id and that
|
|
* matches the supplied filter.
|
|
*/
|
|
public boolean contains(FilterPermanent filter, UUID sourcePlayerId, Ability source, Game game, int num) {
|
|
if (game.getRangeOfInfluence() == RangeOfInfluence.ALL) {
|
|
return field.values().stream()
|
|
.filter(permanent -> filter.match(permanent, sourcePlayerId, source, game)
|
|
&& permanent.isPhasedIn()).count() >= num;
|
|
|
|
} else {
|
|
List<UUID> range = game.getState().getPlayersInRange(sourcePlayerId, game);
|
|
return field.values().stream()
|
|
.filter(permanent -> range.contains(permanent.getControllerId())
|
|
&& filter.match(permanent, sourcePlayerId, source, game)
|
|
&& permanent.isPhasedIn())
|
|
.count() >= num;
|
|
}
|
|
}
|
|
|
|
public void addPermanent(Permanent permanent) {
|
|
field.put(permanent.getId(), permanent);
|
|
}
|
|
|
|
/**
|
|
* Find a permanent on the battlefield by its ID.
|
|
* If you are working with cards and want to know if it is on the battlefield then use game.getState().getZone() instead.
|
|
* Note that the card ID and permanant ID may be different (e.g. MDFC puts a half card on the battlefield, not the main card).
|
|
*
|
|
* @param key the UUID of a permanent to be retrieved
|
|
* @return the permanent matching the passed in UUID
|
|
*/
|
|
public Permanent getPermanent(UUID key) {
|
|
return field.get(key);
|
|
}
|
|
|
|
public void removePermanent(UUID key) {
|
|
field.remove(key);
|
|
}
|
|
|
|
/**
|
|
* Check whether the battlefield contains a permanent with the passed in UUID.
|
|
*
|
|
* @param key the UUID whose existence we're checking for among permanents on the battlefield
|
|
* @return whether the passed in UUID matches a permanent on the battlefield
|
|
*/
|
|
public boolean containsPermanent(UUID key) {
|
|
return field.containsKey(key);
|
|
}
|
|
|
|
public void beginningOfTurn(Game game) {
|
|
for (Permanent perm : field.values()) {
|
|
perm.beginningOfTurn(game);
|
|
}
|
|
}
|
|
|
|
public void endOfTurn(Game game) {
|
|
for (Permanent perm : field.values()) {
|
|
perm.endOfTurn(game);
|
|
}
|
|
}
|
|
|
|
public Collection<Permanent> getAllPermanents() {
|
|
return field.values();
|
|
}
|
|
|
|
public List<Permanent> getAllActivePermanents() {
|
|
return field.values()
|
|
.stream()
|
|
.filter(Permanent::isPhasedIn)
|
|
.collect(Collectors.toList());
|
|
}
|
|
|
|
/**
|
|
* Returns all {@link Permanent} on the battlefield that are controlled by
|
|
* the specified player id. The method ignores the range of influence.
|
|
*/
|
|
public List<Permanent> getAllActivePermanents(UUID controllerId) {
|
|
return field.values()
|
|
.stream()
|
|
.filter(perm -> perm.isPhasedIn()
|
|
&& perm.isControlledBy(controllerId))
|
|
.collect(Collectors.toList());
|
|
}
|
|
|
|
/**
|
|
* Returns all {@link Permanent} on the battlefield that match the specified
|
|
* {@link CardType}. This method ignores the range of influence.
|
|
* @deprecated
|
|
*/
|
|
@Deprecated
|
|
public List<Permanent> getAllActivePermanents(CardType type, Game game) {
|
|
return field.values()
|
|
.stream()
|
|
.filter(perm -> perm.isPhasedIn() && perm.getCardType(game).contains(type))
|
|
.collect(Collectors.toList());
|
|
}
|
|
|
|
/**
|
|
* Returns all {@link Permanent} on the battlefield that match the supplied
|
|
* filter. This method ignores the range of influence and ignores
|
|
* ObjectSourcePlayer predicates in the filter (e.g. controller predicates)
|
|
* @deprecated
|
|
*/
|
|
@Deprecated
|
|
public List<Permanent> getAllActivePermanents(FilterPermanent filter, Game game) {
|
|
return field.values()
|
|
.stream()
|
|
.filter(perm -> perm.isPhasedIn() && filter.match(perm, game))
|
|
.collect(Collectors.toList());
|
|
}
|
|
|
|
/**
|
|
* Returns all {@link Permanent} that match the filter and are controlled by
|
|
* controllerId. This method ignores the range of influence and ignores
|
|
* ObjectSourcePlayer predicates in the filter
|
|
*/
|
|
public List<Permanent> getAllActivePermanents(FilterPermanent filter, UUID controllerId, Game game) {
|
|
return field.values()
|
|
.stream()
|
|
.filter(perm -> perm.isPhasedIn() && perm.isControlledBy(controllerId) && filter.match(perm, game))
|
|
.collect(Collectors.toList());
|
|
}
|
|
|
|
/**
|
|
* Returns all {@link Permanent} that are within the range of influence of
|
|
* the specified player id and that match the supplied filter.
|
|
*/
|
|
public List<Permanent> getActivePermanents(FilterPermanent filter, UUID sourcePlayerId, Game game) {
|
|
return getActivePermanents(filter, sourcePlayerId, null, game);
|
|
}
|
|
|
|
/**
|
|
* Returns all {@link Permanent} that are within the range of influence of
|
|
* the specified player id and that match the supplied filter.
|
|
*/
|
|
public List<Permanent> getActivePermanents(FilterPermanent filter, UUID sourcePlayerId, Ability source, Game game) {
|
|
if (game.getRangeOfInfluence() == RangeOfInfluence.ALL) {
|
|
return field.values()
|
|
.stream()
|
|
.filter(perm -> perm.isPhasedIn() && filter.match(perm, sourcePlayerId, source, game))
|
|
.collect(Collectors.toList());
|
|
} else {
|
|
List<UUID> range = game.getState().getPlayersInRange(sourcePlayerId, game);
|
|
return field.values()
|
|
.stream()
|
|
.filter(perm -> perm.isPhasedIn() && range.contains(perm.getControllerId())
|
|
&& filter.match(perm, sourcePlayerId, source, game)).collect(Collectors.toList());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns all {@link Permanent} that are within the range of influence of
|
|
* the specified player id.
|
|
*/
|
|
public List<Permanent> getActivePermanents(UUID sourcePlayerId, Game game) {
|
|
if (game.getRangeOfInfluence() == RangeOfInfluence.ALL) {
|
|
return getAllActivePermanents();
|
|
} else {
|
|
List<UUID> range = game.getState().getPlayersInRange(sourcePlayerId, game);
|
|
return field.values()
|
|
.stream()
|
|
.filter(perm -> perm.isPhasedIn()
|
|
&& range.contains(perm.getControllerId()))
|
|
.collect(Collectors.toList());
|
|
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns controlled permanents with phasing ability that are phased in, so that they can be phased out
|
|
*/
|
|
public List<Permanent> getPhasingOut(Game game, UUID controllerId) {
|
|
return field.values()
|
|
.stream()
|
|
.filter(perm -> perm.hasAbility(PhasingAbility.getInstance(), game)
|
|
&& perm.isPhasedIn()
|
|
&& perm.isControlledBy(controllerId))
|
|
.collect(Collectors.toList());
|
|
}
|
|
|
|
/**
|
|
* Returns controlled permanents that are phased out, so that they can be phased in
|
|
*/
|
|
public List<Permanent> getPhasedOut(UUID controllerId) {
|
|
return field.values()
|
|
.stream()
|
|
.filter(perm -> !perm.isPhasedIn() && perm.isControlledBy(controllerId))
|
|
.collect(Collectors.toList());
|
|
}
|
|
|
|
public void resetPermanentsControl() {
|
|
for (Permanent perm : field.values()) {
|
|
if (perm.isPhasedIn()) {
|
|
perm.resetControl();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* since control could change several times during applyEvents we only want
|
|
* to fire control changed events after all control change effects have been
|
|
* applied
|
|
*/
|
|
public boolean fireControlChangeEvents(Game game) {
|
|
boolean controlChanged = false;
|
|
for (Permanent perm : field.values()) {
|
|
if (perm.isPhasedIn()) {
|
|
controlChanged |= perm.checkControlChanged(game);
|
|
}
|
|
}
|
|
return controlChanged;
|
|
}
|
|
|
|
public int countTokens(UUID controllerId) {
|
|
return field
|
|
.values()
|
|
.stream()
|
|
.filter(Objects::nonNull)
|
|
.filter(PermanentToken.class::isInstance)
|
|
.map(permanent -> permanent.isControlledBy(controllerId))
|
|
.mapToInt(x -> x ? 1 : 0)
|
|
.sum();
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return "Permanents: " + field.size();
|
|
}
|
|
}
|