external-repos/forge
1
0
Fork 0
mirror of https://github.com/Card-Forge/forge.git synced 2025-11-19 12:18:00 +00:00
Code Issues Packages Projects Releases Wiki Activity

Support storing commander and commander damage in player view

Browse Source
This commit is contained in:
drdev
2014-10-09 00:33:38 +00:00
parent 5563d8b1c6
commit 6c95af229a
9 changed files with 116 additions and 93 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
forge-ai/src/main/java/forge/ai/ComputerUtilCombat.java
View File

@@ -289,15 +289,14 @@ public class ComputerUtilCombat {
public static List<Card> getLifeThreateningCommanders(final Player ai, final Combat combat) { public static List<Card> getLifeThreateningCommanders(final Player ai, final Combat combat) {
List<Card> res = new ArrayList<Card>(); List<Card> res = new ArrayList<Card>();
for (Card c : combat.getAttackers()) {
for(Card c : combat.getAttackers()) { if (c.isCommander()) {
if(c.isCommander()) { int currentCommanderDamage = ai.getCommanderDamage(c);
int currentCommanderDamage = ai.getCommanderDamage().containsKey(c) ? ai.getCommanderDamage().get(c) : 0; if (damageIfUnblocked(c, ai, combat, false) + currentCommanderDamage >= 21) {
if (damageIfUnblocked(c, ai, combat, false) + currentCommanderDamage >= 21)
res.add(c); res.add(c);
}
} }
} }
return res; return res;
} }

9
forge-game/src/main/java/forge/game/card/CardFactoryUtil.java
View File

@@ -2114,13 +2114,12 @@ public class CardFactoryUtil {
else { else {
text = "Commander Damage to " + p.getName() + ": "; text = "Commander Damage to " + p.getName() + ": ";
} }
final Map<Card,Integer> map = p.getCommanderDamage(); int damage = p.getCommanderDamage(originPlayer.getCommander());
if (map.containsKey(originPlayer.getCommander())) { if (damage > 0) {
sb.append(text + map.get(originPlayer.getCommander()) + "\r\n"); sb.append(text + damage + "\r\n");
} }
} }
return sb.toString(); return sb.toString();
} }

25
forge-game/src/main/java/forge/game/player/Player.java
View File

@@ -78,7 +78,7 @@ public class Player extends GameEntity implements Comparable<Player> {
ZoneType.Library, ZoneType.Graveyard, ZoneType.Hand, ZoneType.Exile, ZoneType.Command, ZoneType.Ante, ZoneType.Library, ZoneType.Graveyard, ZoneType.Hand, ZoneType.Exile, ZoneType.Command, ZoneType.Ante,
ZoneType.Sideboard, ZoneType.PlanarDeck, ZoneType.SchemeDeck)); ZoneType.Sideboard, ZoneType.PlanarDeck, ZoneType.SchemeDeck));
private final Map<Card,Integer> commanderDamage = new HashMap<Card,Integer>(); private final Map<Card, Integer> commanderDamage = new HashMap<Card, Integer>();
private int poisonCounters = 0; private int poisonCounters = 0;
private int life = 20; private int life = 20;
@@ -496,12 +496,8 @@ public class Player extends GameEntity implements Comparable<Player> {
} }
if (source.isCommander() && isCombat) { if (source.isCommander() && isCombat) {
if (!commanderDamage.containsKey(source)) { commanderDamage.put(source, getCommanderDamage(source) + amount);
commanderDamage.put(source, amount); view.updateCommanderDamage(this);
}
else {
commanderDamage.put(source,commanderDamage.get(source) + amount);
}
} }
assignedDamage.put(source, amount); assignedDamage.put(source, amount);
@@ -1795,9 +1791,8 @@ public class Player extends GameEntity implements Comparable<Player> {
} }
if (game.getRules().hasAppliedVariant(GameType.Commander)) { if (game.getRules().hasAppliedVariant(GameType.Commander)) {
Map<Card,Integer> cmdDmg = getCommanderDamage(); for (Entry<Card, Integer> entry : getCommanderDamage()) {
for (Card c : cmdDmg.keySet()) { if (entry.getValue() >= 21) {
if (cmdDmg.get(c) >= 21) {
return loseConditionMet(GameLossReason.CommanderDamage, null); return loseConditionMet(GameLossReason.CommanderDamage, null);
} }
} }
@@ -2709,11 +2704,17 @@ public class Player extends GameEntity implements Comparable<Player> {
return commander; return commander;
} }
public void setCommander(Card commander0) { public void setCommander(Card commander0) {
if (commander == commander0) { return; }
commander = commander0; commander = commander0;
view.updateCommander(this);
} }
public Map<Card,Integer> getCommanderDamage() { public Iterable<Entry<Card, Integer>> getCommanderDamage() {
return commanderDamage; return commanderDamage.entrySet();
}
public int getCommanderDamage(Card commander) {
Integer damage = commanderDamage.get(commander);
return damage == null ? 0 : damage.intValue();
} }
public boolean isPlayingExtraTurn() { public boolean isPlayingExtraTurn() {

23
forge-game/src/main/java/forge/game/player/PlayerView.java
View File

@@ -1,13 +1,15 @@
package forge.game.player; package forge.game.player;
import java.util.HashMap;
import java.util.Map; import java.util.Map;
import java.util.Map.Entry;
import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableList;
import com.google.common.collect.Maps; import com.google.common.collect.Maps;
import forge.card.MagicColor; import forge.card.MagicColor;
import forge.game.GameEntityView; import forge.game.GameEntityView;
import forge.game.card.CardFactoryUtil; import forge.game.card.Card;
import forge.game.card.CardView; import forge.game.card.CardView;
import forge.game.zone.PlayerZone; import forge.game.zone.PlayerZone;
import forge.game.zone.ZoneType; import forge.game.zone.ZoneType;
@@ -102,11 +104,22 @@ public class PlayerView extends GameEntityView {
set(TrackableProperty.Keywords, ImmutableList.of(p.getKeywords())); set(TrackableProperty.Keywords, ImmutableList.of(p.getKeywords()));
} }
public String getCommanderInfo() { public CardView getCommander() {
return get(TrackableProperty.CommanderInfo); return get(TrackableProperty.Commander);
} }
void updateCommanderInfo(Player p) { void updateCommander(Player p) {
set(TrackableProperty.CommanderInfo, CardFactoryUtil.getCommanderInfo(p).trim().replace("\r\n", "; ")); set(TrackableProperty.Commander, PlayerView.get(p.getCommander()));
}
public Map<Integer, Integer> getCommanderDamage() {
return get(TrackableProperty.CommanderDamage);
}
void updateCommanderDamage(Player p) {
Map<Integer, Integer> map = new HashMap<Integer, Integer>();
for (Entry<Card, Integer> entry : p.getCommanderDamage()) {
map.put(entry.getKey().getId(), entry.getValue());
}
set(TrackableProperty.CommanderDamage, map);
} }
public Iterable<CardView> getAnte() { public Iterable<CardView> getAnte() {

3
forge-game/src/main/java/forge/trackable/TrackableDeserializer.java
View File

@@ -19,6 +19,9 @@ public class TrackableDeserializer {
public int readInt() { public int readInt() {
return Integer.parseInt(readString()); return Integer.parseInt(readString());
} }
public byte readByte() {
return Byte.parseByte(readString());
}
public long readLong() { public long readLong() {
return Long.parseLong(readString()); return Long.parseLong(readString());
} }

3
forge-game/src/main/java/forge/trackable/TrackableProperty.java
View File

@@ -79,7 +79,8 @@ public enum TrackableProperty {
HasUnlimitedHandSize(TrackableTypes.BooleanType), HasUnlimitedHandSize(TrackableTypes.BooleanType),
NumDrawnThisTurn(TrackableTypes.IntegerType), NumDrawnThisTurn(TrackableTypes.IntegerType),
Keywords(TrackableTypes.BooleanType), Keywords(TrackableTypes.BooleanType),
CommanderInfo(TrackableTypes.StringType), Commander(TrackableTypes.CardViewType),
CommanderDamage(TrackableTypes.IntegerMapType),
Ante(TrackableTypes.CardViewCollectionType), Ante(TrackableTypes.CardViewCollectionType),
Battlefield(TrackableTypes.CardViewCollectionType), Battlefield(TrackableTypes.CardViewCollectionType),
Command(TrackableTypes.CardViewCollectionType), Command(TrackableTypes.CardViewCollectionType),

11
forge-game/src/main/java/forge/trackable/TrackableSerializer.java
View File

@@ -23,16 +23,19 @@ public class TrackableSerializer {
write(value ? "1" : "0"); write(value ? "1" : "0");
} }
public void write(int value) { public void write(int value) {
write(String.valueOf(value)); write(Integer.toString(value));
}
public void write(byte value) {
write(Byte.toString(value));
} }
public void write(long value) { public void write(long value) {
write(String.valueOf(value)); write(Long.toString(value));
} }
public void write(float value) { public void write(float value) {
write(String.valueOf(value)); write(Float.toString(value));
} }
public void write(double value) { public void write(double value) {
write(String.valueOf(value)); write(Double.toString(value));
} }
public void write(TrackableIndex<? extends TrackableObject> index) { public void write(TrackableIndex<? extends TrackableObject> index) {
write(index.size()); write(index.size());

122
forge-game/src/main/java/forge/trackable/TrackableTypes.java
View File

@@ -1,18 +1,13 @@
package forge.trackable; package forge.trackable;
import java.util.HashMap; import java.util.HashMap;
import java.util.HashSet;
import java.util.Map; import java.util.Map;
import java.util.Map.Entry; import java.util.Map.Entry;
import java.util.Set; import java.util.Set;
import java.util.TreeMap; import java.util.TreeMap;
import org.apache.commons.lang3.StringUtils;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import forge.card.ColorSet; import forge.card.ColorSet;
import forge.card.MagicColor;
import forge.card.mana.ManaCost; import forge.card.mana.ManaCost;
import forge.game.GameEntityView; import forge.game.GameEntityView;
import forge.game.card.CardView; import forge.game.card.CardView;
@@ -301,8 +296,6 @@ public class TrackableTypes {
} }
}; };
public static final TrackableType<Set<String>> StringSetType = new TrackableType<Set<String>>() { public static final TrackableType<Set<String>> StringSetType = new TrackableType<Set<String>>() {
private static final char DELIM = (char)6;
@Override @Override
public Set<String> getDefaultValue() { public Set<String> getDefaultValue() {
return null; return null;
@@ -310,22 +303,26 @@ public class TrackableTypes {
@Override @Override
public Set<String> deserialize(TrackableDeserializer td, Set<String> oldValue) { public Set<String> deserialize(TrackableDeserializer td, Set<String> oldValue) {
String value = td.readString(); int size = td.readInt();
if (value.length() > 0) { if (size > 0) {
return Sets.newHashSet(StringUtils.split(value, DELIM)); Set<String> set = new HashSet<String>();
for (int i = 0; i < size; i++) {
set.add(td.readString());
}
return set;
} }
return null; return null;
} }
@Override @Override
public void serialize(TrackableSerializer ts, Set<String> value) { public void serialize(TrackableSerializer ts, Set<String> value) {
ts.write(StringUtils.join(value, DELIM)); ts.write(value.size());
for (String s : value) {
ts.write(s);
}
} }
}; };
public static final TrackableType<Map<String, String>> StringMapType = new TrackableType<Map<String, String>>() { public static final TrackableType<Map<String, String>> StringMapType = new TrackableType<Map<String, String>>() {
private static final char DELIM_1 = (char)6;
private static final char DELIM_2 = (char)7;
@Override @Override
public Map<String, String> getDefaultValue() { public Map<String, String> getDefaultValue() {
return null; return null;
@@ -333,13 +330,11 @@ public class TrackableTypes {
@Override @Override
public Map<String, String> deserialize(TrackableDeserializer td, Map<String, String> oldValue) { public Map<String, String> deserialize(TrackableDeserializer td, Map<String, String> oldValue) {
String value = td.readString(); int size = td.readInt();
if (value.length() > 0) { if (size > 0) {
Map<String, String> map = ImmutableMap.of(); Map<String, String> map = new HashMap<String, String>();
String[] entries = StringUtils.split(value, DELIM_1); for (int i = 0; i < size; i++) {
for (String entry : entries) { map.put(td.readString(), td.readString());
int idx = entry.indexOf(DELIM_2);
map.put(entry.substring(0, idx), entry.substring(idx + 1));
} }
return map; return map;
} }
@@ -348,20 +343,42 @@ public class TrackableTypes {
@Override @Override
public void serialize(TrackableSerializer ts, Map<String, String> value) { public void serialize(TrackableSerializer ts, Map<String, String> value) {
StringBuilder builder = new StringBuilder(); ts.write(value.size());
for (Entry<String, String> entry : value.entrySet()) { for (Entry<String, String> entry : value.entrySet()) {
if (builder.length() > 0) { ts.write(entry.getKey());
builder.append(DELIM_1); ts.write(entry.getValue());
} }
builder.append(entry.getKey() + DELIM_2 + entry.getValue()); }
};
public static final TrackableType<Map<Integer, Integer>> IntegerMapType = new TrackableType<Map<Integer, Integer>>() {
@Override
public Map<Integer, Integer> getDefaultValue() {
return null;
}
@Override
public Map<Integer, Integer> deserialize(TrackableDeserializer td, Map<Integer, Integer> oldValue) {
int size = td.readInt();
if (size > 0) {
Map<Integer, Integer> map = new HashMap<Integer, Integer>();
for (int i = 0; i < size; i++) {
map.put(td.readInt(), td.readInt());
}
return map;
}
return null;
}
@Override
public void serialize(TrackableSerializer ts, Map<Integer, Integer> value) {
ts.write(value.size());
for (Entry<Integer, Integer> entry : value.entrySet()) {
ts.write(entry.getKey());
ts.write(entry.getValue());
} }
ts.write(builder.toString());
} }
}; };
public static final TrackableType<Map<Byte, Integer>> ManaMapType = new TrackableType<Map<Byte, Integer>>() { public static final TrackableType<Map<Byte, Integer>> ManaMapType = new TrackableType<Map<Byte, Integer>>() {
private static final char DELIM_1 = (char)6;
private static final char DELIM_2 = (char)7;
@Override @Override
public Map<Byte, Integer> getDefaultValue() { public Map<Byte, Integer> getDefaultValue() {
return null; return null;
@@ -369,13 +386,11 @@ public class TrackableTypes {
@Override @Override
public Map<Byte, Integer> deserialize(TrackableDeserializer td, Map<Byte, Integer> oldValue) { public Map<Byte, Integer> deserialize(TrackableDeserializer td, Map<Byte, Integer> oldValue) {
String value = td.readString(); int size = td.readInt();
if (value.length() > 0) { if (size > 0) {
Map<Byte, Integer> map = Maps.newHashMapWithExpectedSize(MagicColor.NUMBER_OR_COLORS + 1); Map<Byte, Integer> map = new HashMap<Byte, Integer>();
String[] entries = StringUtils.split(value, DELIM_1); for (int i = 0; i < size; i++) {
for (String entry : entries) { map.put(td.readByte(), td.readInt());
int idx = entry.indexOf(DELIM_2);
map.put(Byte.valueOf(entry.substring(0, idx)), Integer.valueOf(entry.substring(idx + 1)));
} }
return map; return map;
} }
@@ -384,20 +399,14 @@ public class TrackableTypes {
@Override @Override
public void serialize(TrackableSerializer ts, Map<Byte, Integer> value) { public void serialize(TrackableSerializer ts, Map<Byte, Integer> value) {
StringBuilder builder = new StringBuilder(); ts.write(value.size());
for (Entry<Byte, Integer> entry : value.entrySet()) { for (Entry<Byte, Integer> entry : value.entrySet()) {
if (builder.length() > 0) { ts.write(entry.getKey());
builder.append(DELIM_1); ts.write(entry.getValue());
}
builder.append(Byte.toString(entry.getKey()) + DELIM_2 + Integer.toString(entry.getValue()));
} }
ts.write(builder.toString());
} }
}; };
public static final TrackableType<Map<CounterType, Integer>> CounterMapType = new TrackableType<Map<CounterType, Integer>>() { public static final TrackableType<Map<CounterType, Integer>> CounterMapType = new TrackableType<Map<CounterType, Integer>>() {
private static final char DELIM_1 = (char)6;
private static final char DELIM_2 = (char)7;
@Override @Override
public Map<CounterType, Integer> getDefaultValue() { public Map<CounterType, Integer> getDefaultValue() {
return null; return null;
@@ -405,13 +414,11 @@ public class TrackableTypes {
@Override @Override
public Map<CounterType, Integer> deserialize(TrackableDeserializer td, Map<CounterType, Integer> oldValue) { public Map<CounterType, Integer> deserialize(TrackableDeserializer td, Map<CounterType, Integer> oldValue) {
String value = td.readString(); int size = td.readInt();
if (value.length() > 0) { if (size > 0) {
Map<CounterType, Integer> map = new TreeMap<CounterType, Integer>(); Map<CounterType, Integer> map = new TreeMap<CounterType, Integer>();
String[] entries = StringUtils.split(value, DELIM_1); for (int i = 0; i < size; i++) {
for (String entry : entries) { map.put(CounterType.valueOf(td.readString()), td.readInt());
int idx = entry.indexOf(DELIM_2);
map.put(CounterType.valueOf(entry.substring(0, idx)), Integer.valueOf(entry.substring(idx + 1)));
} }
return map; return map;
} }
@@ -420,14 +427,11 @@ public class TrackableTypes {
@Override @Override
public void serialize(TrackableSerializer ts, Map<CounterType, Integer> value) { public void serialize(TrackableSerializer ts, Map<CounterType, Integer> value) {
StringBuilder builder = new StringBuilder(); ts.write(value.size());
for (Entry<CounterType, Integer> entry : value.entrySet()) { for (Entry<CounterType, Integer> entry : value.entrySet()) {
if (builder.length() > 0) { ts.write(entry.getKey().name());
builder.append(DELIM_1); ts.write(entry.getValue());
}
builder.append(entry.getKey().name() + DELIM_2 + Integer.toString(entry.getValue()));
} }
ts.write(builder.toString());
} }
}; };
} }

2
forge-gui/src/main/java/forge/achievement/Blackjack.java
View File

@@ -20,7 +20,7 @@ public class Blackjack extends Achievement {
if (player.getOutcome().hasWon()) { if (player.getOutcome().hasWon()) {
for (Player p : game.getRegisteredPlayers()) { for (Player p : game.getRegisteredPlayers()) {
if (p.isOpponentOf(player) && p.getOutcome().lossState == GameLossReason.CommanderDamage) { if (p.isOpponentOf(player) && p.getOutcome().lossState == GameLossReason.CommanderDamage) {
Integer damage = p.getCommanderDamage().get(player.getCommander()); Integer damage = p.getCommanderDamage(player.getCommander());
if (damage != null && damage >= THRESHOLD) { if (damage != null && damage >= THRESHOLD) {
return damage; return damage;
} }