Damage: add Cause Param for damage deal, needed for Silhouette or Bronze Horse

forge-game/src/main/java/forge/game/GameEntity.java

@@ -24,6 +24,7 @@ import forge.game.card.CardDamageMap;
 import forge.game.card.CounterType;
 import forge.game.event.GameEventCardAttachment;
 import forge.game.event.GameEventCardAttachment.AttachMethod;
+import forge.game.spellability.SpellAbility;
 import forge.game.trigger.TriggerType;
 import forge.util.collect.FCollection;
 
@@ -58,22 +59,22 @@ public abstract class GameEntity extends GameObject implements IIdentifiable {
     }
 
     public final int addDamage(final int damage, final Card source, boolean isCombat, boolean noPrevention,
-            final CardDamageMap damageMap, final CardDamageMap preventMap) {
+            final CardDamageMap damageMap, final CardDamageMap preventMap, final SpellAbility cause) {
         if (noPrevention) {
-            return addDamageWithoutPrevention(damage, source, damageMap, preventMap);
+            return addDamageWithoutPrevention(damage, source, damageMap, preventMap, cause);
         } else if (isCombat) {
             return addCombatDamage(damage, source, damageMap, preventMap);
         } else {
-            return addDamage(damage, source, damageMap, preventMap);
+            return addDamage(damage, source, damageMap, preventMap, cause);
         }
     }
 
     public int addDamage(final int damage, final Card source, final CardDamageMap damageMap,
-            final CardDamageMap preventMap) {
+            final CardDamageMap preventMap, final SpellAbility cause) {
         int damageToDo = damage;
 
-        damageToDo = replaceDamage(damageToDo, source, false, true, damageMap, preventMap);
+        damageToDo = replaceDamage(damageToDo, source, false, true, damageMap, preventMap, cause);
-        damageToDo = preventDamage(damageToDo, source, false, preventMap);
+        damageToDo = preventDamage(damageToDo, source, false, preventMap, cause);
 
         return addDamageAfterPrevention(damageToDo, source, false, damageMap);
     }
@@ -82,8 +83,8 @@ public abstract class GameEntity extends GameObject implements IIdentifiable {
             final CardDamageMap preventMap) {
         int damageToDo = damage;
 
-        damageToDo = replaceDamage(damageToDo, source, true, true, damageMap, preventMap);
+        damageToDo = replaceDamage(damageToDo, source, true, true, damageMap, preventMap, null);
-        damageToDo = preventDamage(damageToDo, source, true, preventMap);
+        damageToDo = preventDamage(damageToDo, source, true, preventMap, null);
 
         if (damageToDo > 0) {
             source.getDamageHistory().registerCombatDamage(this);
@@ -97,13 +98,13 @@ public abstract class GameEntity extends GameObject implements IIdentifiable {
     }
 
     public int addDamageWithoutPrevention(final int damage, final Card source, final CardDamageMap damageMap,
-            final CardDamageMap preventMap) {
+            final CardDamageMap preventMap, final SpellAbility cause) {
-        int damageToDo = replaceDamage(damage, source, false, false, damageMap, preventMap);
+        int damageToDo = replaceDamage(damage, source, false, false, damageMap, preventMap, cause);
         return addDamageAfterPrevention(damageToDo, source, false, damageMap);
     }
 
     public int replaceDamage(final int damage, final Card source, final boolean isCombat, final boolean prevention,
-            final CardDamageMap damageMap, final CardDamageMap preventMap) {
+            final CardDamageMap damageMap, final CardDamageMap preventMap, final SpellAbility cause) {
         // Replacement effects
         final Map<String, Object> repParams = Maps.newHashMap();
         repParams.put("Event", "DamageDone");
@@ -114,6 +115,9 @@ public abstract class GameEntity extends GameObject implements IIdentifiable {
         repParams.put("NoPreventDamage", !prevention);
         repParams.put("DamageMap", damageMap);
         repParams.put("PreventMap", preventMap);
+        if (cause != null) {
+            repParams.put("Cause", cause);
+        }
 
         switch (getGame().getReplacementHandler().run(repParams)) {
         case NotReplaced:
@@ -126,7 +130,7 @@ public abstract class GameEntity extends GameObject implements IIdentifiable {
                 return newDamage;
             } else {
                 if (prevention) {
-                    newDamage = newTarget.preventDamage(newDamage, source, isCombat, preventMap);
+                    newDamage = newTarget.preventDamage(newDamage, source, isCombat, preventMap, cause);
                 }
                 newTarget.addDamageAfterPrevention(newDamage, source, isCombat, damageMap);
             }
@@ -146,7 +150,9 @@ public abstract class GameEntity extends GameObject implements IIdentifiable {
     // not change the game state)
     public abstract int staticReplaceDamage(final int damage, final Card source, final boolean isCombat);
 
-    public final int preventDamage(final int damage, final Card source, final boolean isCombat, CardDamageMap preventMap) {
+    public final int preventDamage(
+            final int damage, final Card source, final boolean isCombat, CardDamageMap preventMap,
+            final SpellAbility cause) {
         if (getGame().getStaticEffects().getGlobalRuleChange(GlobalRuleChange.noPrevention)
                 || source.hasKeyword("Damage that would be dealt by CARDNAME can't be prevented.")) {
             return damage;
@@ -163,6 +169,9 @@ public abstract class GameEntity extends GameObject implements IIdentifiable {
         repParams.put("IsCombat", isCombat);
         repParams.put("Prevention", true);
         repParams.put("PreventMap", preventMap);
+        if (cause != null) {
+            repParams.put("Cause", cause);
+        }
 
         switch (getGame().getReplacementHandler().run(repParams)) {
         case NotReplaced:

forge-game/src/main/java/forge/game/ability/effects/DamageAllEffect.java

@@ -97,13 +97,13 @@ public class DamageAllEffect extends DamageBaseEffect {
         }
 
         for (final Card c : list) {
-            c.addDamage(dmg, sourceLKI, damageMap, preventMap);
+            c.addDamage(dmg, sourceLKI, damageMap, preventMap, sa);
         }
 
         if (!players.equals("")) {
             final List<Player> playerList = AbilityUtils.getDefinedPlayers(card, players, sa);
             for (final Player p : playerList) {
-                p.addDamage(dmg, sourceLKI, damageMap, preventMap);
+                p.addDamage(dmg, sourceLKI, damageMap, preventMap, sa);
             }
         }
 

forge-game/src/main/java/forge/game/ability/effects/DamageDealEffect.java

@@ -156,7 +156,7 @@ public class DamageDealEffect extends DamageBaseEffect {
                 Player assigningPlayer = players.get(0);
                 Map<Card, Integer> map = assigningPlayer.getController().assignCombatDamage(sourceLKI, assigneeCards, dmg, null, true);
                 for (Entry<Card, Integer> dt : map.entrySet()) {
-                    dt.getKey().addDamage(dt.getValue(), sourceLKI, damageMap, preventMap);
+                    dt.getKey().addDamage(dt.getValue(), sourceLKI, damageMap, preventMap, sa);
                 }
 
                 if (!usedDamageMap) {
@@ -183,13 +183,13 @@ public class DamageDealEffect extends DamageBaseEffect {
                             c.clearAssignedDamage();
                         }
                         else {
-                            c.addDamage(dmg, sourceLKI, false, noPrevention, damageMap, preventMap);
+                            c.addDamage(dmg, sourceLKI, false, noPrevention, damageMap, preventMap, sa);
                         }
                     }
                 } else if (o instanceof Player) {
                     final Player p = (Player) o;
                     if (!targeted || p.canBeTargetedBy(sa)) {
-                        p.addDamage(dmg, sourceLKI, false, noPrevention, damageMap, preventMap);
+                        p.addDamage(dmg, sourceLKI, false, noPrevention, damageMap, preventMap, sa);
                     }
                 }
             }

forge-game/src/main/java/forge/game/ability/effects/DamageEachEffect.java

@@ -91,13 +91,13 @@ public class DamageEachEffect extends DamageBaseEffect {
                 if (o instanceof Card) {
                     final Card c = (Card) o;
                     if (c.isInPlay() && (!targeted || c.canBeTargetedBy(sa))) {
-                        c.addDamage(dmg, sourceLKI, damageMap, preventMap);
+                        c.addDamage(dmg, sourceLKI, damageMap, preventMap, sa);
                     }
 
                 } else if (o instanceof Player) {
                     final Player p = (Player) o;
                     if (!targeted || p.canBeTargetedBy(sa)) {
-                        p.addDamage(dmg, sourceLKI, damageMap, preventMap);
+                        p.addDamage(dmg, sourceLKI, damageMap, preventMap, sa);
                     }
                 }
             }
@@ -110,7 +110,7 @@ public class DamageEachEffect extends DamageBaseEffect {
 
                     final int dmg = CardFactoryUtil.xCount(source, card.getSVar("X"));
                     // System.out.println(source+" deals "+dmg+" damage to "+source);
-                    source.addDamage(dmg, sourceLKI, damageMap, preventMap);
+                    source.addDamage(dmg, sourceLKI, damageMap, preventMap, sa);
                 }
             }
             if (sa.getParam("DefinedCards").equals("Remembered")) {
@@ -122,7 +122,7 @@ public class DamageEachEffect extends DamageBaseEffect {
                         if (o instanceof Card) {
                             Card rememberedcard = (Card) o;
                             // System.out.println(source + " deals " + dmg + " damage to " + rememberedcard);
-                            rememberedcard.addDamage(dmg, sourceLKI, damageMap, preventMap);
+                            rememberedcard.addDamage(dmg, sourceLKI, damageMap, preventMap, sa);
                         }
                     }
                 }

forge-game/src/main/java/forge/game/ability/effects/FightEffect.java

@@ -63,8 +63,8 @@ public class FightEffect extends DamageBaseEffect {
         final int dmg1 = fightToughness ? fighters.get(0).getNetToughness() : fighters.get(0).getNetPower();
         final int dmg2 = fightToughness ? fighters.get(1).getNetToughness() : fighters.get(1).getNetPower();
 
-        dealDamage(fighters.get(0), fighters.get(1), dmg1, damageMap, preventMap);
+        dealDamage(fighters.get(0), fighters.get(1), dmg1, damageMap, preventMap, sa);
-        dealDamage(fighters.get(1), fighters.get(0), dmg2, damageMap, preventMap);
+        dealDamage(fighters.get(1), fighters.get(0), dmg2, damageMap, preventMap, sa);
 
         preventMap.triggerPreventDamage(false);
         damageMap.triggerDamageDoneOnce(false);
@@ -121,8 +121,8 @@ public class FightEffect extends DamageBaseEffect {
         return fighterList;
     }
     
-    private void dealDamage(Card source, Card target, int damage, CardDamageMap damageMap, CardDamageMap preventMap) {
+    private void dealDamage(Card source, Card target, int damage, CardDamageMap damageMap, CardDamageMap preventMap, final SpellAbility sa) {
-        target.addDamage(damage, source, damageMap, preventMap);
+        target.addDamage(damage, source, damageMap, preventMap, sa);
     }
 
 }

forge-game/src/main/java/forge/game/ability/effects/ReplaceSplitDamageEffect.java

@@ -57,13 +57,14 @@ public class ReplaceSplitDamageEffect extends SpellAbilityEffect {
 
             CardDamageMap damageMap = (CardDamageMap) originalParams.get("DamageMap");
             CardDamageMap preventMap = (CardDamageMap) originalParams.get("PreventMap");
+            SpellAbility cause = (SpellAbility) originalParams.get("Cause");
             
             boolean isCombat = (Boolean) originalParams.get("IsCombat");
             boolean noPrevention = (Boolean) originalParams.get("NoPreventDamage");
             
             GameEntity obj = (GameEntity) list.get(0);
 
-            obj.addDamage(n, sourceLKI, isCombat, noPrevention, damageMap, preventMap);
+            obj.addDamage(n, sourceLKI, isCombat, noPrevention, damageMap, preventMap, cause);
         }
 
         // no damage for original target anymore

forge-game/src/main/java/forge/game/cost/CostDamage.java

@@ -64,7 +64,7 @@ public class CostDamage extends CostPart {
         CardDamageMap damageMap = new CardDamageMap();
         CardDamageMap preventMap = new CardDamageMap();
 
-        payer.addDamage(decision.c, source, damageMap, preventMap);
+        payer.addDamage(decision.c, source, damageMap, preventMap, null);
 
         preventMap.triggerPreventDamage(false);
         damageMap.triggerDamageDoneOnce(false);

forge-game/src/main/java/forge/game/replacement/ReplaceDamage.java

@@ -67,6 +67,22 @@ public class ReplaceDamage extends ReplacementEffect {
                 return false;
             }
         }
+        if (hasParam("ValidCause")) {
+            if (!runParams.containsKey("Cause")) {
+                return false;
+            }
+            SpellAbility cause = (SpellAbility) runParams.get("Cause");
+            String validCause = getParam("ValidCause");
+            validCause = AbilityUtils.applyAbilityTextChangeEffects(validCause, this);
+            if (!matchesValid(cause, validCause.split(","), getHostCard())) {
+                return false;
+            }
+            if (hasParam("CauseIsSource")) {
+                if (!cause.getHostCard().equals(runParams.get("DamageSource"))) {
+                    return false;
+                }
+            }
+        }
         if (((Integer) runParams.get("DamageAmount")) == 0) {
             // If no actual damage is dealt, there is nothing to replace
             return false;

forge-gui/src/main/java/forge/player/HumanPlay.java

@@ -424,7 +424,7 @@ public class HumanPlay {
                 CardDamageMap damageMap = new CardDamageMap();
                 CardDamageMap preventMap = new CardDamageMap();
 
-                p.addDamage(amount, source, damageMap, preventMap);
+                p.addDamage(amount, source, damageMap, preventMap, null);
 
                 preventMap.triggerPreventDamage(false);
                 damageMap.triggerDamageDoneOnce(false);