[GNT] implemented Militant Angel

Mage/src/main/java/mage/abilities/dynamicvalue/common/AttackedThisTurnOpponentsCount.java

@@ -0,0 +1,44 @@
+
+package mage.abilities.dynamicvalue.common;
+
+import mage.abilities.Ability;
+import mage.abilities.dynamicvalue.DynamicValue;
+import mage.abilities.effects.Effect;
+import mage.game.Game;
+import mage.watchers.common.PlayersAttackedThisTurnWatcher;
+
+import java.util.UUID;
+
+/**
+ * @author JayDi85
+ */
+public class AttackedThisTurnOpponentsCount implements DynamicValue {
+
+    @Override
+    public int calculate(Game game, Ability sourceAbility, Effect effect) {
+        return this.calculate(game, sourceAbility.getControllerId());
+    }
+
+    public int calculate(Game game, UUID controllerId) {
+        PlayersAttackedThisTurnWatcher watcher = (PlayersAttackedThisTurnWatcher) game.getState().getWatchers().get(PlayersAttackedThisTurnWatcher.class.getSimpleName());
+        if (watcher != null) {
+            return watcher.getAttackedOpponentsCount(controllerId);
+        }
+        return 0;
+    }
+
+    @Override
+    public AttackedThisTurnOpponentsCount copy() {
+        return new AttackedThisTurnOpponentsCount();
+    }
+
+    @Override
+    public String toString() {
+        return "1";
+    }
+
+    @Override
+    public String getMessage() {
+        return "the number of opponents you attacked this turn";
+    }
+}

Mage/src/main/java/mage/game/GameImpl.java

@@ -1026,6 +1026,7 @@ public abstract class GameImpl implements Game, Serializable {
         watchers.add(new BlockedAttackerWatcher());
         watchers.add(new DamageDoneWatcher());
         watchers.add(new PlanarRollWatcher());
+        watchers.add(new PlayersAttackedThisTurnWatcher());
 
         //20100716 - 103.5
         for (UUID playerId : state.getPlayerList(startingPlayerId)) {

Mage/src/main/java/mage/watchers/common/PlayersAttackedThisTurnWatcher.java

@@ -0,0 +1,91 @@
+package mage.watchers.common;
+
+import mage.constants.WatcherScope;
+import mage.game.Game;
+import mage.game.events.GameEvent;
+import mage.players.PlayerList;
+import mage.watchers.Watcher;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+/**
+ * @author JayDi85
+ */
+public class PlayersAttackedThisTurnWatcher extends Watcher {
+
+    // how many players or opponents each player attacked this turn
+    private final Map<UUID, PlayerList> playersAttackedThisTurn = new HashMap<>();
+    private final Map<UUID, PlayerList> opponentsAttackedThisTurn = new HashMap<>();
+
+    public PlayersAttackedThisTurnWatcher() {
+        super(PlayersAttackedThisTurnWatcher.class.getSimpleName(), WatcherScope.GAME);
+    }
+
+    public PlayersAttackedThisTurnWatcher(final PlayersAttackedThisTurnWatcher watcher) {
+        super(watcher);
+
+        for (Map.Entry<UUID, PlayerList> entry : watcher.playersAttackedThisTurn.entrySet()) {
+            this.playersAttackedThisTurn.put(entry.getKey(), entry.getValue());
+        }
+
+        for (Map.Entry<UUID, PlayerList> entry : watcher.opponentsAttackedThisTurn.entrySet()) {
+            this.opponentsAttackedThisTurn.put(entry.getKey(), entry.getValue());
+        }
+    }
+
+    @Override
+    public PlayersAttackedThisTurnWatcher copy() {
+        return new PlayersAttackedThisTurnWatcher(this);
+    }
+
+    @Override
+    public void watch(GameEvent event, Game game) {
+        if (event.getType() == GameEvent.EventType.BEGINNING_PHASE_PRE) {
+            playersAttackedThisTurn.clear();
+            opponentsAttackedThisTurn.clear();
+        }
+
+        if (event.getType() == GameEvent.EventType.ATTACKER_DECLARED) {
+
+            // players
+            PlayerList playersAttacked = playersAttackedThisTurn.get(event.getPlayerId());
+            if (playersAttacked == null) {
+                playersAttacked = new PlayerList();
+            }
+            UUID playerDefender = game.getCombat().getDefendingPlayerId(event.getSourceId(), game);
+            if (playerDefender != null) {
+                playersAttacked.add(playerDefender);
+            }
+            playersAttackedThisTurn.put(event.getPlayerId(), playersAttacked);
+
+            // opponents
+            PlayerList opponentsAttacked = opponentsAttackedThisTurn.get(event.getPlayerId());
+            if (opponentsAttacked == null) {
+                opponentsAttacked = new PlayerList();
+            }
+            UUID opponentDefender = game.getCombat().getDefendingPlayerId(event.getSourceId(), game);
+            if (opponentDefender != null && game.getOpponents(event.getPlayerId()).contains(opponentDefender)) {
+                opponentsAttacked.add(opponentDefender);
+            }
+            opponentsAttackedThisTurn.put(event.getPlayerId(), opponentsAttacked);
+        }
+    }
+
+    public int getAttackedPlayersCount(UUID playerID) {
+        PlayerList defendersList = playersAttackedThisTurn.getOrDefault(playerID, null);
+        if (defendersList != null) {
+            return defendersList.size();
+        }
+        return 0;
+    }
+
+    public int getAttackedOpponentsCount(UUID playerID) {
+        PlayerList defendersList = opponentsAttackedThisTurn.getOrDefault(playerID, null);
+        if (defendersList != null) {
+            return defendersList.size();
+        }
+        return 0;
+    }
+}