Redesigned handling of attack allowed check related to the complete attack.

Mage.Sets/src/mage/sets/bornofthegods/LoyalPegasus.java

@@ -53,7 +53,7 @@ public class LoyalPegasus extends CardImpl {
         // Flying
         this.addAbility(FlyingAbility.getInstance());
         // Loyal Pegasus can't attack or block alone.
-        this.addAbility(CantAttackAloneAbility.getInstance());
+        this.addAbility(new CantAttackAloneAbility());
         this.addAbility(CantBlockAloneAbility.getInstance());
     }
 

Mage.Sets/src/mage/sets/dragonsmaze/MasterOfCruelties.java

@@ -69,7 +69,7 @@ public class MasterOfCruelties extends CardImpl {
         // Deathtouch
         this.addAbility(DeathtouchAbility.getInstance());
         // Master of Cruelties can only attack alone.
-        this.addAbility(CanAttackOnlyAloneAbility.getInstance());
+        this.addAbility(new CanAttackOnlyAloneAbility());
 
         // Whenever Master of Cruelties attacks a player and isn't blocked, that player's life total becomes 1. Master of Cruelties assigns no combat damage this combat.
         this.addAbility(new MasterOfCrueltiesTriggeredAbility());

Mage.Sets/src/mage/sets/gatecrash/EmberBeast.java

@@ -28,12 +28,12 @@
 package mage.sets.gatecrash;
 
 import java.util.UUID;
-import mage.constants.CardType;
-import mage.constants.Rarity;
 import mage.MageInt;
 import mage.abilities.keyword.CantAttackAloneAbility;
 import mage.abilities.keyword.CantBlockAloneAbility;
 import mage.cards.CardImpl;
+import mage.constants.CardType;
+import mage.constants.Rarity;
 
 /**
  *
@@ -50,7 +50,7 @@ public class EmberBeast extends CardImpl {
         this.toughness = new MageInt(4);
 
         // Ember Beast can't attack or block alone.
-        this.addAbility(CantAttackAloneAbility.getInstance());
+        this.addAbility(new CantAttackAloneAbility());
         this.addAbility(CantBlockAloneAbility.getInstance());
     }
 

Mage.Sets/src/mage/sets/journeyintonyx/SightlessBrawler.java

@@ -32,12 +32,11 @@ import mage.MageInt;
 import mage.abilities.Ability;
 import mage.abilities.common.SimpleStaticAbility;
 import mage.abilities.effects.Effect;
+import mage.abilities.effects.common.combat.CanAttackOnlyAloneEffect;
 import mage.abilities.effects.common.continuous.BoostEnchantedEffect;
-import mage.abilities.effects.common.continuous.GainAbilityAttachedEffect;
 import mage.abilities.keyword.BestowAbility;
 import mage.abilities.keyword.CantAttackAloneAbility;
 import mage.cards.CardImpl;
-import mage.constants.AttachmentType;
 import mage.constants.CardType;
 import mage.constants.Duration;
 import mage.constants.Rarity;
@@ -61,12 +60,12 @@ public class SightlessBrawler extends CardImpl {
         // Bestow 4W (If you cast this card for its bestow cost, it's an Aura spell with enchant creature. It becomes a creature again if it's not attached to a creature.)
         this.addAbility(new BestowAbility(this, "{4}{W}"));
         // Sightless Brawler can't attack alone.
-        this.addAbility(CantAttackAloneAbility.getInstance());
+        this.addAbility(new CantAttackAloneAbility());
         // Enchanted creature gets +3/+2 and can't attack alone.
         Effect effect = new BoostEnchantedEffect(3, 2, Duration.WhileOnBattlefield);
         effect.setText("Enchanted creature gets +3/+2");
         Ability ability = new SimpleStaticAbility(Zone.BATTLEFIELD, effect);
-        effect = new GainAbilityAttachedEffect(CantAttackAloneAbility.getInstance(), AttachmentType.AURA, Duration.WhileOnBattlefield);
+        effect = new CanAttackOnlyAloneEffect();
         effect.setText("and can't attack alone");
         ability.addEffect(effect);
         this.addAbility(ability);

Mage.Sets/src/mage/sets/magic2010/JackalFamiliar.java

@@ -27,14 +27,13 @@
  */
 package mage.sets.magic2010;
 
-import mage.constants.CardType;
+import java.util.UUID;
-import mage.constants.Rarity;
 import mage.MageInt;
 import mage.abilities.keyword.CantAttackAloneAbility;
 import mage.abilities.keyword.CantBlockAloneAbility;
 import mage.cards.CardImpl;
-
+import mage.constants.CardType;
-import java.util.UUID;
+import mage.constants.Rarity;
 
 /**
  * @author magenoxx_at_gmail.com
@@ -50,7 +49,7 @@ public class JackalFamiliar extends CardImpl {
         this.toughness = new MageInt(2);
 
         // Jackal Familiar can't attack or block alone.
-        this.addAbility(CantAttackAloneAbility.getInstance());
+        this.addAbility(new CantAttackAloneAbility());
         this.addAbility(CantBlockAloneAbility.getInstance());
     }
 

Mage.Sets/src/mage/sets/magic2013/MoggFlunkies.java

@@ -27,14 +27,13 @@
  */
 package mage.sets.magic2013;
 
-import mage.constants.CardType;
+import java.util.UUID;
-import mage.constants.Rarity;
 import mage.MageInt;
 import mage.abilities.keyword.CantAttackAloneAbility;
 import mage.abilities.keyword.CantBlockAloneAbility;
 import mage.cards.CardImpl;
-
+import mage.constants.CardType;
-import java.util.UUID;
+import mage.constants.Rarity;
 
 /**
  * @author magenoxx_at_gmail.com
@@ -50,7 +49,7 @@ public class MoggFlunkies extends CardImpl {
         this.toughness = new MageInt(3);
 
         // Mogg Flunkies can't attack or block alone.
-        this.addAbility(CantAttackAloneAbility.getInstance());
+        this.addAbility(new CantAttackAloneAbility());
         this.addAbility(CantBlockAloneAbility.getInstance());
     }
 

Mage.Sets/src/mage/sets/magicorigins/BondedConstruct.java

@@ -48,7 +48,7 @@ public class BondedConstruct extends CardImpl {
         this.toughness = new MageInt(1);
 
         // Bonded Construct can't attack alone.
-        this.addAbility(CantAttackAloneAbility.getInstance());
+        this.addAbility(new CantAttackAloneAbility());
     }
 
     public BondedConstruct(final BondedConstruct card) {

Mage.Sets/src/mage/sets/masterseditionii/Errantry.java

@@ -32,12 +32,10 @@ import mage.abilities.Ability;
 import mage.abilities.common.SimpleStaticAbility;
 import mage.abilities.effects.Effect;
 import mage.abilities.effects.common.AttachEffect;
+import mage.abilities.effects.common.combat.CanAttackOnlyAloneEffect;
 import mage.abilities.effects.common.continuous.BoostEnchantedEffect;
-import mage.abilities.effects.common.continuous.GainAbilityAttachedEffect;
-import mage.abilities.keyword.CanAttackOnlyAloneAbility;
 import mage.abilities.keyword.EnchantAbility;
 import mage.cards.CardImpl;
-import mage.constants.AttachmentType;
 import mage.constants.CardType;
 import mage.constants.Duration;
 import mage.constants.Outcome;
@@ -49,7 +47,7 @@ import mage.target.common.TargetCreaturePermanent;
 /**
  *
  * @author LoneFox
-
+ *
  */
 public class Errantry extends CardImpl {
 
@@ -66,8 +64,8 @@ public class Errantry extends CardImpl {
         this.addAbility(ability);
         // Enchanted creature gets +3/+0 and can only attack alone.
         ability = new SimpleStaticAbility(Zone.BATTLEFIELD, new BoostEnchantedEffect(3, 0, Duration.WhileOnBattlefield));
-        Effect effect = new GainAbilityAttachedEffect(CanAttackOnlyAloneAbility.getInstance(), AttachmentType.AURA);
+        Effect effect = new CanAttackOnlyAloneEffect();
-        effect.setText("and can only attack alone.");
+        effect.setText("and can only attack alone");
         ability.addEffect(effect);
         this.addAbility(ability);
     }

Mage.Tests/src/test/java/org/mage/test/combat/CantAttackOrBlockAloneTest.java

@@ -48,6 +48,23 @@ public class CantAttackOrBlockAloneTest extends CardTestPlayerBase {
         assertLife(playerA, 15);
     }
 
+    /**
+     * Try to attack with two Flunkies
+     */
+    @Test
+    public void testCanAttackWithTwo() {
+        addCard(Zone.BATTLEFIELD, playerB, "Mogg Flunkies", 2); // 3/3
+
+        attack(2, playerB, "Mogg Flunkies");
+        attack(2, playerB, "Mogg Flunkies");
+
+        setStopAt(2, PhaseStep.END_TURN);
+        execute();
+
+        assertLife(playerA, 14);
+
+    }
+
     /**
      * Try to block alone
      */

Mage/src/main/java/mage/abilities/effects/RestrictionEffect.java

@@ -69,6 +69,10 @@ public abstract class RestrictionEffect extends ContinuousEffectImpl {
         return true;
     }
 
+    public boolean canAttackCheckAfter(int numberOfAttackers, Ability source, Game game) {
+        return true;
+    }
+
     public boolean canBlock(Permanent attacker, Permanent blocker, Ability source, Game game) {
         return true;
     }

Mage/src/main/java/mage/abilities/effects/common/combat/CanAttackOnlyAloneEffect.java

@@ -0,0 +1,43 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package mage.abilities.effects.common.combat;
+
+import mage.abilities.Ability;
+import mage.abilities.effects.RestrictionEffect;
+import mage.constants.Duration;
+import mage.game.Game;
+import mage.game.permanent.Permanent;
+
+/**
+ *
+ * @author LevelX2
+ */
+public class CanAttackOnlyAloneEffect extends RestrictionEffect {
+
+    public CanAttackOnlyAloneEffect() {
+        super(Duration.WhileOnBattlefield);
+        staticText = "{this} can only attack alone";
+    }
+
+    public CanAttackOnlyAloneEffect(final CanAttackOnlyAloneEffect effect) {
+        super(effect);
+    }
+
+    @Override
+    public CanAttackOnlyAloneEffect copy() {
+        return new CanAttackOnlyAloneEffect(this);
+    }
+
+    @Override
+    public boolean canAttackCheckAfter(int numberOfAttackers, Ability source, Game game) {
+        return numberOfAttackers == 1;
+    }
+
+    @Override
+    public boolean applies(Permanent permanent, Ability source, Game game) {
+        return source.getSourceId().equals(permanent.getId());
+    }
+}

Mage/src/main/java/mage/abilities/effects/common/combat/CantAttackAloneEffect.java

@@ -0,0 +1,43 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package mage.abilities.effects.common.combat;
+
+import mage.abilities.Ability;
+import mage.abilities.effects.RestrictionEffect;
+import mage.constants.Duration;
+import mage.game.Game;
+import mage.game.permanent.Permanent;
+
+/**
+ *
+ * @author LevelX2
+ */
+public class CantAttackAloneEffect extends RestrictionEffect {
+
+    public CantAttackAloneEffect() {
+        super(Duration.WhileOnBattlefield);
+        staticText = "{this} can't attack alone";
+    }
+
+    public CantAttackAloneEffect(final CantAttackAloneEffect effect) {
+        super(effect);
+    }
+
+    @Override
+    public CantAttackAloneEffect copy() {
+        return new CantAttackAloneEffect(this);
+    }
+
+    @Override
+    public boolean canAttackCheckAfter(int numberOfAttackers, Ability source, Game game) {
+        return numberOfAttackers > 1;
+    }
+
+    @Override
+    public boolean applies(Permanent permanent, Ability source, Game game) {
+        return source.getSourceId().equals(permanent.getId());
+    }
+}

Mage/src/main/java/mage/abilities/keyword/CanAttackOnlyAloneAbility.java

@@ -25,41 +25,28 @@
  * authors and should not be interpreted as representing official policies, either expressed
  * or implied, of BetaSteward_at_googlemail.com.
  */
-
 package mage.abilities.keyword;
 
-import java.io.ObjectStreamException;
+import mage.abilities.common.SimpleStaticAbility;
+import mage.abilities.effects.common.combat.CanAttackOnlyAloneEffect;
 import mage.constants.Zone;
-import mage.abilities.MageSingleton;
-import mage.abilities.StaticAbility;
 
 /**
  * @author LevelX2
  */
-public class CanAttackOnlyAloneAbility extends StaticAbility implements MageSingleton {
+public class CanAttackOnlyAloneAbility extends SimpleStaticAbility {
 
-    private static final CanAttackOnlyAloneAbility fINSTANCE = new CanAttackOnlyAloneAbility();
+    public CanAttackOnlyAloneAbility() {
-
+        super(Zone.BATTLEFIELD, new CanAttackOnlyAloneEffect());
-    private Object readResolve() throws ObjectStreamException {
-        return fINSTANCE;
     }
 
-    public static CanAttackOnlyAloneAbility getInstance() {
+    private CanAttackOnlyAloneAbility(CanAttackOnlyAloneAbility ability) {
-        return fINSTANCE;
+        super(ability);
-    }
-
-    private CanAttackOnlyAloneAbility() {
-        super(Zone.BATTLEFIELD, null);
-    }
-
-    @Override
-    public String getRule() {
-        return "{this} can only attack alone.";
     }
 
     @Override
     public CanAttackOnlyAloneAbility copy() {
-        return fINSTANCE;
+        return new CanAttackOnlyAloneAbility(this);
     }
 
 }

Mage/src/main/java/mage/abilities/keyword/CantAttackAloneAbility.java

@@ -25,42 +25,28 @@
  * authors and should not be interpreted as representing official policies, either expressed
  * or implied, of BetaSteward_at_googlemail.com.
  */
-
 package mage.abilities.keyword;
 
+import mage.abilities.common.SimpleStaticAbility;
+import mage.abilities.effects.common.combat.CantAttackAloneEffect;
 import mage.constants.Zone;
-import mage.abilities.MageSingleton;
-import mage.abilities.StaticAbility;
-
-import java.io.ObjectStreamException;
 
 /**
  * @author magenoxx_at_googlemail.com
  */
-public class CantAttackAloneAbility extends StaticAbility implements MageSingleton {
+public class CantAttackAloneAbility extends SimpleStaticAbility {
 
-    private static final CantAttackAloneAbility fINSTANCE = new CantAttackAloneAbility();
+    public CantAttackAloneAbility() {
-
+        super(Zone.BATTLEFIELD, new CantAttackAloneEffect());
-    private Object readResolve() throws ObjectStreamException {
-        return fINSTANCE;
     }
 
-    public static CantAttackAloneAbility getInstance() {
+    private CantAttackAloneAbility(CantAttackAloneAbility ability) {
-        return fINSTANCE;
+        super(ability);
-    }
-
-    private CantAttackAloneAbility() {
-        super(Zone.BATTLEFIELD, null);
-    }
-
-    @Override
-    public String getRule() {
-        return "{this} can't attack alone.";
     }
 
     @Override
     public CantAttackAloneAbility copy() {
-        return fINSTANCE;
+        return new CantAttackAloneAbility(this);
     }
 
 }

Mage/src/main/java/mage/game/combat/Combat.java

@@ -36,11 +36,10 @@ import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.UUID;
+import mage.MageObject;
 import mage.abilities.Ability;
 import mage.abilities.effects.RequirementEffect;
 import mage.abilities.effects.RestrictionEffect;
-import mage.abilities.keyword.CanAttackOnlyAloneAbility;
-import mage.abilities.keyword.CantAttackAloneAbility;
 import mage.abilities.keyword.VigilanceAbility;
 import mage.constants.CardType;
 import mage.constants.Outcome;
@@ -58,12 +57,15 @@ import mage.target.common.TargetDefender;
 import mage.util.CardUtil;
 import mage.util.Copyable;
 import mage.util.trace.TraceUtil;
+import org.apache.log4j.Logger;
 
 /**
  * @author BetaSteward_at_googlemail.com
  */
 public class Combat implements Serializable, Copyable<Combat> {
 
+    private static final Logger logger = Logger.getLogger(Combat.class);
+
     private static FilterPlaneswalkerPermanent filterPlaneswalker = new FilterPlaneswalkerPermanent();
     private static FilterCreatureForCombatBlock filterBlockers = new FilterCreatureForCombatBlock();
     // There are effects that let creatures assigns combat damage equal to its toughness rather than its power
@@ -252,14 +254,18 @@ public class Combat implements Serializable, Copyable<Combat> {
             Player player = game.getPlayer(attackerId);
             //20101001 - 508.1d
             game.getCombat().checkAttackRequirements(player, game);
-            if (!game.getPlayer(game.getActivePlayerId()).getAvailableAttackers(game).isEmpty()) {
+            boolean firstTime = true;
+            do {
+                if (!firstTime || !game.getPlayer(game.getActivePlayerId()).getAvailableAttackers(game).isEmpty()) {
                     player.selectAttackers(game, attackerId);
                 }
+                firstTime = false;
                 if (game.isPaused() || game.gameOver(null) || game.executingRollback()) {
                     return;
                 }
-            // because of possible undo during declare attackers it's neccassary to call here the methods with "game.getCombat()." to get the valid combat object!!!
+                // because of possible undo during declare attackers it's neccassary to call here the methods with "game.getCombat()." to get the current combat object!!!
-            game.getCombat().checkAttackRestrictions(player, game);
+                // I don't like it too - it has to be redesigned
+            } while (!game.getCombat().checkAttackRestrictions(player, game));
             game.getCombat().resumeSelectAttackers(game);
         }
     }
@@ -337,50 +343,60 @@ public class Combat implements Serializable, Copyable<Combat> {
         }
     }
 
-    protected void checkAttackRestrictions(Player player, Game game) {
+    /**
-        int count = 0;
+     *
+     * @param player
+     * @param game
+     * @return true if the attack with that set of creatures and attacked
+     * players/planeswalkers is possible
+     */
+    protected boolean checkAttackRestrictions(Player player, Game game) {
+        boolean check = true;
+        int numberOfChecks = 0;
+        UUID attackerToRemove = null;
+        Check:
+        while (check) {
+            check = false;
+            numberOfChecks++;
+            int numberAttackers = 0;
             for (CombatGroup group : groups) {
-            count += group.getAttackers().size();
+                numberAttackers += group.getAttackers().size();
             }
-
+            Player attackingPlayer = game.getPlayer(attackerId);
-        if (count > 1) {
+            if (attackerToRemove != null) {
-            List<UUID> tobeRemoved = new ArrayList<>();
+                removeAttacker(attackerToRemove, game);
-            for (CombatGroup group : groups) {
-                for (UUID attackingCreatureId : group.getAttackers()) {
-                    Permanent attacker = game.getPermanent(attackingCreatureId);
-                    if (count > 1 && attacker != null && attacker.getAbilities().containsKey(CanAttackOnlyAloneAbility.getInstance().getId())) {
-                        if (!game.isSimulation()) {
-                            game.informPlayers(attacker.getLogName() + " can only attack alone. Removing it from combat.");
             }
-                        tobeRemoved.add(attackingCreatureId);
+            for (UUID attackingCreatureId : this.getAttackers()) {
-                        count--;
+                Permanent attackingCreature = game.getPermanent(attackingCreatureId);
+                for (Map.Entry<RestrictionEffect, HashSet<Ability>> entry : game.getContinuousEffects().getApplicableRestrictionEffects(attackingCreature, game).entrySet()) {
+                    RestrictionEffect effect = entry.getKey();
+                    for (Ability ability : entry.getValue()) {
+                        if (!effect.canAttackCheckAfter(numberAttackers, ability, game)) {
+                            MageObject sourceObject = ability.getSourceObject(game);
+                            if (attackingPlayer.isHuman()) {
+                                game.informPlayer(attackingPlayer, attackingCreature.getIdName() + " can't attack this way (" + (sourceObject == null ? "null" : sourceObject.getIdName()) + ")");
+                                return false;
+                            } else {
+                                // remove attacking creatures for AI that are not allowed to attack
+                                // can create possible not allowed attack scenarios, but not sure how to solve this
+                                for (CombatGroup combatGroup : this.getGroups()) {
+                                    if (combatGroup.getAttackers().contains(attackingCreatureId)) {
+                                        attackerToRemove = attackingCreatureId;
+                                    }
+                                }
+                                check = true; // do the check again
+                                if (numberOfChecks > 50) {
+                                    logger.error("Seems to be an AI declare attacker lock (reached 50 check iterations) " + (sourceObject == null ? "null" : sourceObject.getIdName()));
+                                    return true; // break the check
+                                }
+                                continue Check;
                             }
                         }
                     }
-            for (UUID attackingCreatureId : tobeRemoved) {
-                this.removeAttacker(attackingCreatureId, game);
-            }
-        }
-
-        if (count == 1) {
-            List<UUID> tobeRemoved = new ArrayList<>();
-            for (CombatGroup group : groups) {
-                for (UUID attackingCreatureId : group.getAttackers()) {
-                    Permanent attacker = game.getPermanent(attackingCreatureId);
-                    if (attacker != null && attacker.getAbilities().containsKey(CantAttackAloneAbility.getInstance().getId())) {
-                        if (!game.isSimulation()) {
-                            game.informPlayers(attacker.getLogName() + " can't attack alone. Removing it from combat.");
-                        }
-                        tobeRemoved.add(attackingCreatureId);
                 }
             }
         }
-            for (UUID attackingCreatureId : tobeRemoved) {
+        return true;
-                this.removeAttacker(attackingCreatureId, game);
-            }
-
-        }
-
     }
 
     public void selectBlockers(Game game) {