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) {
List<Card> res = new ArrayList<Card>();
for(Card c : combat.getAttackers()) {
if(c.isCommander()) {
int currentCommanderDamage = ai.getCommanderDamage().containsKey(c) ? ai.getCommanderDamage().get(c) : 0;
if (damageIfUnblocked(c, ai, combat, false) + currentCommanderDamage >= 21)
for (Card c : combat.getAttackers()) {
if (c.isCommander()) {
int currentCommanderDamage = ai.getCommanderDamage(c);
if (damageIfUnblocked(c, ai, combat, false) + currentCommanderDamage >= 21) {
res.add(c);
}
}
}
return res;
}

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

@@ -2114,13 +2114,12 @@ public class CardFactoryUtil {
else {
text = "Commander Damage to " + p.getName() + ": ";
}
final Map<Card,Integer> map = p.getCommanderDamage();
if (map.containsKey(originPlayer.getCommander())) {
sb.append(text + map.get(originPlayer.getCommander()) + "\r\n");
int damage = p.getCommanderDamage(originPlayer.getCommander());
if (damage > 0) {
sb.append(text + damage + "\r\n");
}
}
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.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 life = 20;
@@ -496,12 +496,8 @@ public class Player extends GameEntity implements Comparable<Player> {
}
if (source.isCommander() && isCombat) {
if (!commanderDamage.containsKey(source)) {
commanderDamage.put(source, amount);
}
else {
commanderDamage.put(source,commanderDamage.get(source) + amount);
}
commanderDamage.put(source, getCommanderDamage(source) + amount);
view.updateCommanderDamage(this);
}
assignedDamage.put(source, amount);
@@ -1795,9 +1791,8 @@ public class Player extends GameEntity implements Comparable<Player> {
}
if (game.getRules().hasAppliedVariant(GameType.Commander)) {
Map<Card,Integer> cmdDmg = getCommanderDamage();
for (Card c : cmdDmg.keySet()) {
if (cmdDmg.get(c) >= 21) {
for (Entry<Card, Integer> entry : getCommanderDamage()) {
if (entry.getValue() >= 21) {
return loseConditionMet(GameLossReason.CommanderDamage, null);
}
}
@@ -2709,11 +2704,17 @@ public class Player extends GameEntity implements Comparable<Player> {
return commander;
}
public void setCommander(Card commander0) {
if (commander == commander0) { return; }
commander = commander0;
view.updateCommander(this);
}
public Map<Card,Integer> getCommanderDamage() {
return commanderDamage;
public Iterable<Entry<Card, Integer>> getCommanderDamage() {
return commanderDamage.entrySet();
}
public int getCommanderDamage(Card commander) {
Integer damage = commanderDamage.get(commander);
return damage == null ? 0 : damage.intValue();
}
public boolean isPlayingExtraTurn() {

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

@@ -1,13 +1,15 @@
package forge.game.player;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Maps;
import forge.card.MagicColor;
import forge.game.GameEntityView;
import forge.game.card.CardFactoryUtil;
import forge.game.card.Card;
import forge.game.card.CardView;
import forge.game.zone.PlayerZone;
import forge.game.zone.ZoneType;
@@ -102,11 +104,22 @@ public class PlayerView extends GameEntityView {
set(TrackableProperty.Keywords, ImmutableList.of(p.getKeywords()));
}
public String getCommanderInfo() {
return get(TrackableProperty.CommanderInfo);
public CardView getCommander() {
return get(TrackableProperty.Commander);
}
void updateCommanderInfo(Player p) {
set(TrackableProperty.CommanderInfo, CardFactoryUtil.getCommanderInfo(p).trim().replace("\r\n", "; "));
void updateCommander(Player p) {
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() {

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

@@ -19,6 +19,9 @@ public class TrackableDeserializer {
public int readInt() {
return Integer.parseInt(readString());
}
public byte readByte() {
return Byte.parseByte(readString());
}
public long readLong() {
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),
NumDrawnThisTurn(TrackableTypes.IntegerType),
Keywords(TrackableTypes.BooleanType),
CommanderInfo(TrackableTypes.StringType),
Commander(TrackableTypes.CardViewType),
CommanderDamage(TrackableTypes.IntegerMapType),
Ante(TrackableTypes.CardViewCollectionType),
Battlefield(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");
}
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) {
write(String.valueOf(value));
write(Long.toString(value));
}
public void write(float value) {
write(String.valueOf(value));
write(Float.toString(value));
}
public void write(double value) {
write(String.valueOf(value));
write(Double.toString(value));
}
public void write(TrackableIndex<? extends TrackableObject> index) {
write(index.size());

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

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