- Added a new Trigger: CombatDamageDoneOnce.

- Added Pyrewild Shaman.

src/main/java/forge/Card.java

@@ -8268,6 +8268,7 @@ public class Card extends GameEntity implements Comparable<Card> {
     /**
      * Fetch GameState for this card from references to players who may own or control this card. 
      */
+    @Override
     public GameState getGame() {
         
         Player controller = getController();

src/main/java/forge/GameEntity.java

@@ -20,6 +20,7 @@ package forge;
 import java.util.ArrayList;
 
 import forge.card.spellability.SpellAbility;
+import forge.game.GameState;
 import forge.game.player.Player;
 import forge.util.MyObservable;
 
@@ -424,4 +425,8 @@ public abstract class GameEntity extends MyObservable {
     public String toString() {
         return this.name;
     }
+
+    public GameState getGame() {
+        return null;
+    }
 }

src/main/java/forge/card/trigger/TriggerCombatDamageDoneOnce.java

@@ -0,0 +1,98 @@
+/*
+ * Forge: Play Magic: the Gathering.
+ * Copyright (C) 2011  Forge Team
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package forge.card.trigger;
+
+import java.util.List;
+
+import forge.Card;
+import forge.GameEntity;
+import forge.card.spellability.SpellAbility;
+
+/**
+ * <p>
+ * Trigger_DamageDone class.
+ * </p>
+ * 
+ * @author Forge
+ * @version $Id: TriggerDamageDone.java 21390 2013-05-08 07:44:50Z Max mtg $
+ */
+public class TriggerCombatDamageDoneOnce extends Trigger {
+
+    /**
+     * <p>
+     * Constructor for TriggerCombatDamageDoneOnc.
+     * </p>
+     * 
+     * @param params
+     *            a {@link java.util.HashMap} object.
+     * @param host
+     *            a {@link forge.Card} object.
+     * @param intrinsic
+     *            the intrinsic
+     */
+    public TriggerCombatDamageDoneOnce(final java.util.Map<String, String> params, final Card host, final boolean intrinsic) {
+        super(params, host, intrinsic);
+    }
+
+    /** {@inheritDoc} */
+    @SuppressWarnings("unchecked")
+    @Override
+    public final boolean performTest(final java.util.Map<String, Object> runParams2) {
+        final List<Card> srcs = (List<Card>) runParams2.get("DamageSources");
+        final GameEntity tgt = (GameEntity) runParams2.get("DamageTarget");
+
+        if (this.mapParams.containsKey("ValidSource")) {
+            boolean valid = false;
+            for (Card c : srcs) {
+                if (c.isValid(this.mapParams.get("ValidSource").split(","), this.getHostCard().getController(),this.getHostCard())) {
+                    valid = true;
+                }
+            }
+            if (!valid) {
+                return false;
+            }
+        }
+
+        if (this.mapParams.containsKey("ValidTarget")) {
+            if (!matchesValid(tgt, this.mapParams.get("ValidTarget").split(","), this.getHostCard())) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public final Trigger getCopy() {
+        final Trigger copy = new TriggerCombatDamageDoneOnce(this.mapParams, this.getHostCard(), this.isIntrinsic());
+        if (this.getOverridingAbility() != null) {
+            copy.setOverridingAbility(this.getOverridingAbility());
+        }
+
+        copyFieldsTo(copy);
+        return copy;
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public final void setTriggeringObjects(final SpellAbility sa) {
+        sa.setTriggeringObject("Sources", this.getRunParams().get("DamageSources"));
+        sa.setTriggeringObject("Target", this.getRunParams().get("DamageTarget"));
+    }
+}

src/main/java/forge/card/trigger/TriggerType.java

@@ -30,6 +30,7 @@ public enum TriggerType {
     CounterRemoved(TriggerCounterRemoved.class),
     Evolved(TriggerEvolved.class),
     Unequip(TriggerUnequip.class),
+    CombatDamageDoneOnce(TriggerCombatDamageDoneOnce.class),
     DamageDone(TriggerDamageDone.class),
     Championed(TriggerChampioned.class),
     TurnFaceUp(TriggerTurnFaceUp.class),

src/main/java/forge/game/phase/Combat.java

@@ -685,13 +685,30 @@ public class Combat {
         // This function handles both Regular and First Strike combat assignment
 
         final HashMap<Card, Integer> defMap = this.getDefendingDamageMap();
+        final HashMap<GameEntity, List<Card>> wasDamaged = new HashMap<GameEntity, List<Card>>();
 
         for (final Entry<Card, Integer> entry : defMap.entrySet()) {
             GameEntity defender = getDefendingEntity(entry.getKey());
             if (defender instanceof Player) { // player
-                ((Player) defender).addCombatDamage(entry.getValue(), entry.getKey());
+                if (((Player) defender).addCombatDamage(entry.getValue(), entry.getKey())) {
+                    if (wasDamaged.containsKey(defender)) {
+                        wasDamaged.get(defender).add(entry.getKey());
+                    } else {
+                        List<Card> l = new ArrayList<Card>();
+                        l.add(entry.getKey());
+                        wasDamaged.put(defender, l);
+                    }
+                }
             } else if (defender instanceof Card) { // planeswalker
-                ((Card) defender).getController().addCombatDamage(entry.getValue(), entry.getKey());
+                if (((Card) defender).getController().addCombatDamage(entry.getValue(), entry.getKey())) {
+                    if (wasDamaged.containsKey(defender)) {
+                        wasDamaged.get(defender).add(entry.getKey());
+                    } else {
+                        List<Card> l = new ArrayList<Card>();
+                        l.add(entry.getKey());
+                        wasDamaged.put(defender, l);
+                    }
+                }
             }
         }
 
@@ -723,6 +740,14 @@ public class Combat {
             damageMap.clear();
             c.clearAssignedDamage();
         }
+        
+        // Run triggers
+        for (final GameEntity ge : wasDamaged.keySet()) {
+            final HashMap<String, Object> runParams = new HashMap<String, Object>();
+            runParams.put("DamageSources", wasDamaged.get(ge));
+            runParams.put("DamageTarget", ge);
+            ge.getGame().getTriggerHandler().runTrigger(TriggerType.CombatDamageDoneOnce, runParams, false);
+        }
 
         // This was deeper before, but that resulted in the stack entry acting
         // like before.

src/main/java/forge/game/player/Player.java

@@ -196,6 +196,7 @@ public abstract class Player extends GameEntity implements Comparable<Player> {
         this.setName(name);
     }
 
+    @Override
     public GameState getGame() { // I'll probably regret about this  
         return game;
     }
@@ -976,7 +977,7 @@ public abstract class Player extends GameEntity implements Comparable<Player> {
      * @param source
      *            a {@link forge.Card} object.
      */
-    public final void addCombatDamage(final int damage, final Card source) {
+    public final boolean addCombatDamage(final int damage, final Card source) {
 
         int damageToDo = damage;
 
@@ -990,7 +991,9 @@ public abstract class Player extends GameEntity implements Comparable<Player> {
 
         if (damageToDo > 0) {
             GameActionUtil.executeCombatDamageToPlayerEffects(this, source, damageToDo);
+            return true;
         }
+        return false;
     }
 
     // ////////////////////////