forked from External/mage
289 lines
10 KiB
Java
289 lines
10 KiB
Java
/*
|
|
* 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.view;
|
|
|
|
import mage.MageObject;
|
|
import mage.abilities.costs.Cost;
|
|
import mage.cards.Card;
|
|
import mage.constants.PhaseStep;
|
|
import mage.constants.TurnPhase;
|
|
import mage.constants.Zone;
|
|
import mage.game.ExileZone;
|
|
import mage.game.Game;
|
|
import mage.game.GameState;
|
|
import mage.game.combat.CombatGroup;
|
|
import mage.game.command.Emblem;
|
|
import mage.game.permanent.Permanent;
|
|
import mage.game.permanent.PermanentToken;
|
|
import mage.game.stack.Spell;
|
|
import mage.game.stack.StackAbility;
|
|
import mage.game.stack.StackObject;
|
|
import mage.players.Player;
|
|
|
|
import java.io.Serializable;
|
|
import java.util.*;
|
|
|
|
|
|
/**
|
|
*
|
|
* @author BetaSteward_at_googlemail.com
|
|
*/
|
|
public class GameView implements Serializable {
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
private final int priorityTime;
|
|
private final List<PlayerView> players = new ArrayList<>();
|
|
private SimpleCardsView hand;
|
|
private Set<UUID> canPlayInHand;
|
|
private Map<String, SimpleCardsView> opponentHands;
|
|
private final CardsView stack = new CardsView();
|
|
private final List<ExileView> exiles = new ArrayList<>();
|
|
private final List<RevealedView> revealed = new ArrayList<>();
|
|
private List<LookedAtView> lookedAt = new ArrayList<>();
|
|
private final List<CombatGroupView> combat = new ArrayList<>();
|
|
private final TurnPhase phase;
|
|
private final PhaseStep step;
|
|
private final UUID activePlayerId;
|
|
private String activePlayerName = "";
|
|
private String priorityPlayerName = "";
|
|
private final int turn;
|
|
private boolean special = false;
|
|
private final boolean isPlayer;
|
|
|
|
|
|
public GameView(GameState state, Game game, UUID createdForPlayerId) {
|
|
this.isPlayer = createdForPlayerId != null;
|
|
this.priorityTime = game.getPriorityTime();
|
|
for (Player player: state.getPlayers().values()) {
|
|
players.add(new PlayerView(player, state, game, createdForPlayerId));
|
|
}
|
|
for (StackObject stackObject: state.getStack()) {
|
|
if (stackObject instanceof StackAbility) {
|
|
// Stack Ability
|
|
MageObject object = game.getObject(stackObject.getSourceId());
|
|
Card card = game.getCard(stackObject.getSourceId());
|
|
if (card != null) {
|
|
if (object != null) {
|
|
stack.put(stackObject.getId(), new StackAbilityView(game, (StackAbility)stackObject, card.getName(), new CardView(card)));
|
|
} else {
|
|
stack.put(stackObject.getId(), new StackAbilityView(game, (StackAbility)stackObject, "", new CardView(card)));
|
|
}
|
|
if (card.canTransform()) {
|
|
updateLatestCardView(game, card, stackObject.getId());
|
|
}
|
|
checkPaid(stackObject.getId(), (StackAbility)stackObject);
|
|
} else if (object != null) {
|
|
if (object instanceof PermanentToken) {
|
|
PermanentToken token = (PermanentToken)object;
|
|
stack.put(stackObject.getId(), new StackAbilityView(game, (StackAbility)stackObject, token.getName(), new CardView(token)));
|
|
checkPaid(stackObject.getId(), (StackAbility)stackObject);
|
|
} else if (object instanceof Emblem) {
|
|
Card sourceCard = game.getCard(((Emblem)object).getSourceId());
|
|
if (sourceCard != null) {
|
|
((StackAbility)stackObject).setName("Emblem " + sourceCard.getName());
|
|
((StackAbility)stackObject).setExpansionSetCode(sourceCard.getExpansionSetCode());
|
|
} else {
|
|
throw new IllegalArgumentException("Source card for emblem not found.");
|
|
}
|
|
stack.put(stackObject.getId(),
|
|
new StackAbilityView(game, (StackAbility)stackObject, object.getName(), new CardView(new EmblemView(((Emblem)object),sourceCard))));
|
|
checkPaid(stackObject.getId(), ((StackAbility)stackObject));
|
|
} else {
|
|
StackAbility stackAbility = ((StackAbility)object);
|
|
stackAbility.newId();
|
|
stack.put(stackObject.getId(), new CardView(((StackAbility)stackObject)));
|
|
checkPaid(stackObject.getId(), ((StackAbility)stackObject));
|
|
}
|
|
} else {
|
|
|
|
}
|
|
}
|
|
else {
|
|
// Spell
|
|
stack.put(stackObject.getId(), new CardView((Spell)stackObject, null, stackObject.getControllerId().equals(createdForPlayerId)));
|
|
checkPaid(stackObject.getId(), (Spell)stackObject);
|
|
}
|
|
//stackOrder.add(stackObject.getId());
|
|
}
|
|
//Collections.reverse(stackOrder);
|
|
for (ExileZone exileZone: state.getExile().getExileZones()) {
|
|
exiles.add(new ExileView(exileZone, game));
|
|
}
|
|
for (String name: state.getRevealed().keySet()) {
|
|
revealed.add(new RevealedView(name, state.getRevealed().get(name), game));
|
|
}
|
|
this.phase = state.getTurn().getPhaseType();
|
|
this.step = state.getTurn().getStepType();
|
|
this.turn = state.getTurnNum();
|
|
this.activePlayerId = state.getActivePlayerId();
|
|
if (state.getActivePlayerId() != null) {
|
|
this.activePlayerName = state.getPlayer(state.getActivePlayerId()).getName();
|
|
} else {
|
|
this.activePlayerName = "";
|
|
}
|
|
if (state.getPriorityPlayerId() != null) {
|
|
this.priorityPlayerName = state.getPlayer(state.getPriorityPlayerId()).getName();
|
|
} else {
|
|
this.priorityPlayerName = "";
|
|
}
|
|
for (CombatGroup combatGroup: state.getCombat().getGroups()) {
|
|
combat.add(new CombatGroupView(combatGroup, game));
|
|
}
|
|
this.special = state.getSpecialActions().getControlledBy(state.getPriorityPlayerId()).size() > 0;
|
|
}
|
|
|
|
private void checkPaid(UUID uuid, StackAbility stackAbility) {
|
|
for (Cost cost : stackAbility.getManaCostsToPay()) {
|
|
if (!cost.isPaid()) {
|
|
return;
|
|
}
|
|
}
|
|
CardView cardView = stack.get(uuid);
|
|
cardView.paid = true;
|
|
}
|
|
|
|
private void checkPaid(UUID uuid, Spell spell) {
|
|
for (Cost cost : spell.getSpellAbility().getManaCostsToPay()) {
|
|
if (!cost.isPaid()) {
|
|
return;
|
|
}
|
|
}
|
|
CardView cardView = stack.get(uuid);
|
|
cardView.paid = true;
|
|
}
|
|
|
|
private void setPaid(UUID uuid) {
|
|
CardView cardView = stack.get(uuid);
|
|
cardView.paid = true;
|
|
}
|
|
|
|
private void updateLatestCardView(Game game, Card card, UUID stackId) {
|
|
if (!card.canTransform()) {
|
|
return;
|
|
}
|
|
Permanent permanent = game.getPermanent(card.getId());
|
|
if (permanent == null) {
|
|
permanent = (Permanent)game.getLastKnownInformation(card.getId(), Zone.BATTLEFIELD);
|
|
}
|
|
if (permanent != null) {
|
|
if (permanent.isTransformed()) {
|
|
StackAbilityView stackAbilityView = (StackAbilityView) stack.get(stackId);
|
|
stackAbilityView.getSourceCard().setTransformed(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
public List<PlayerView> getPlayers() {
|
|
return players;
|
|
}
|
|
|
|
public SimpleCardsView getHand() {
|
|
return hand;
|
|
}
|
|
|
|
public void setHand(SimpleCardsView hand) {
|
|
this.hand = hand;
|
|
}
|
|
|
|
public Map<String, SimpleCardsView> getOpponentHands() {
|
|
return opponentHands;
|
|
}
|
|
|
|
public void setOpponentHands(Map<String, SimpleCardsView> opponentHands) {
|
|
this.opponentHands = opponentHands;
|
|
}
|
|
|
|
public TurnPhase getPhase() {
|
|
return phase;
|
|
}
|
|
|
|
public PhaseStep getStep() {
|
|
return step;
|
|
}
|
|
|
|
public CardsView getStack() {
|
|
return stack;
|
|
}
|
|
|
|
public List<ExileView> getExile() {
|
|
return exiles;
|
|
}
|
|
|
|
public List<RevealedView> getRevealed() {
|
|
return revealed;
|
|
}
|
|
|
|
public List<LookedAtView> getLookedAt() {
|
|
return lookedAt;
|
|
}
|
|
|
|
public void setLookedAt(List<LookedAtView> list) {
|
|
this.lookedAt = list;
|
|
}
|
|
|
|
public List<CombatGroupView> getCombat() {
|
|
return combat;
|
|
}
|
|
|
|
public int getTurn() {
|
|
return this.turn;
|
|
}
|
|
|
|
public String getActivePlayerName() {
|
|
return activePlayerName;
|
|
}
|
|
|
|
public String getPriorityPlayerName() {
|
|
return priorityPlayerName;
|
|
}
|
|
|
|
public boolean getSpecial() {
|
|
return special;
|
|
}
|
|
|
|
public int getPriorityTime() {
|
|
return priorityTime;
|
|
}
|
|
|
|
public UUID getActivePlayerId() {
|
|
return activePlayerId;
|
|
}
|
|
|
|
public boolean isPlayer() {
|
|
return isPlayer;
|
|
}
|
|
|
|
public Set<UUID> getCanPlayInHand() {
|
|
return canPlayInHand;
|
|
}
|
|
|
|
public void setCanPlayInHand(Set<UUID> canPlayInHand) {
|
|
this.canPlayInHand = canPlayInHand;
|
|
}
|
|
}
|