Refactor: Hidden keywords to StaticAbilityMode (Issue #3307)

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

@@ -20,6 +20,7 @@
 import forge.game.event.GameEventCardStatsChanged;
 import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
+import forge.game.staticability.StaticAbilityCantGainControl;
 import forge.game.trigger.TriggerType;
 import forge.game.zone.ZoneType;
 import forge.util.Localizer;
@@ -87,7 +88,13 @@ protected String getStackDescription(SpellAbility sa) {
     }
 
     private static void doLoseControl(final Card c, final Card host, final long tStamp) {
-        if (null == c || c.hasKeyword("Other players can't gain control of CARDNAME.")) {
+        if (null == c) {
+            return;
+        }
+
+        boolean cantGainControl = c.hasKeyword("Other players can't gain control of CARDNAME.") || StaticAbilityCantGainControl.cantGainControl(c);
+
+        if (cantGainControl) {
             return;
         }
         final Game game = host.getGame();

forge-game/src/main/java/forge/game/card/Card.java

@@ -6025,7 +6025,9 @@ public final int getTotalDamageDoneBy() {
 
     // this is the amount of damage a creature needs to receive before it dies
     public final int getLethal() {
-        if (hasKeyword("Lethal damage dealt to CARDNAME is determined by its power rather than its toughness.")) {
+        boolean lethalByPower = hasKeyword("Lethal damage dealt to CARDNAME is determined by its power rather than its toughness.") || StaticAbilityLethalDamageByPower.isLethalDamageByPower(this);
+
+        if (lethalByPower) {
             return getNetPower();
         }
         return getNetToughness();

forge-game/src/main/java/forge/game/combat/CombatUtil.java

@@ -32,6 +32,7 @@
 import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
 import forge.game.staticability.StaticAbility;
+import forge.game.staticability.StaticAbilityMode;
 import forge.game.staticability.StaticAbilityBlockRestrict;
 import forge.game.staticability.StaticAbilityCantAttackBlock;
 import forge.game.staticability.StaticAbilityMustBlock;
@@ -832,9 +833,28 @@ public static boolean mustBlockAnAttacker(final Card blocker, final Combat comba
     }
 
     private static boolean attackerLureSatisfied(final Card attacker, final Card blocker, final CardCollection blockers) {
-        if (attacker.hasStartOfKeyword("All creatures able to block CARDNAME do so.")
-                || (attacker.hasStartOfKeyword("CARDNAME must be blocked if able.")
-                        && blockers.isEmpty())
+        boolean lure = attacker.hasStartOfKeyword("All creatures able to block CARDNAME do so.");
+        if (!lure) {
+            for (StaticAbility sa : attacker.getStaticAbilities()) {
+                if (sa.checkConditions(StaticAbilityMode.MustBeBlockedByAll)) {
+                    lure = true;
+                    break;
+                }
+            }
+        }
+
+        boolean mustBeBlocked = attacker.hasStartOfKeyword("CARDNAME must be blocked if able.");
+        if (!mustBeBlocked) {
+            for (StaticAbility sa : attacker.getStaticAbilities()) {
+                if (sa.checkConditions(StaticAbilityMode.MustBeBlocked)) {
+                    mustBeBlocked = true;
+                    break;
+                }
+            }
+        }
+
+        if (lure
+                || (mustBeBlocked && blockers.isEmpty())
                 || (attacker.hasStartOfKeyword("CARDNAME must be blocked by exactly one creature if able.")
                         && blockers.size() != 1)
                 || (attacker.hasStartOfKeyword("CARDNAME must be blocked by two or more creatures if able.")
@@ -925,14 +945,15 @@ public static boolean canBlock(final Card attacker, final Card blocker, final Co
         }
 
         // TODO remove with HiddenKeyword or Static Ability
+        final java.util.List<Card> currentBlockers = combat != null ? combat.getBlockers(attacker) : java.util.Collections.emptyList();
         boolean mustBeBlockedBy = false;
         for (KeywordInterface inst : attacker.getKeywords()) {
             String keyword = inst.getOriginal();
             // MustBeBlockedBy <valid>
             if (keyword.startsWith("MustBeBlockedBy ")) {
                 final String valid = keyword.substring("MustBeBlockedBy ".length());
                 if (blocker.isValid(valid, null, null, null) &&
-                        CardLists.getValidCardCount(combat.getBlockers(attacker), valid, null, null, null) == 0) {
+                        CardLists.getValidCardCount(currentBlockers, valid, null, null, null) == 0) {
                     mustBeBlockedBy = true;
                     break;
                 }
@@ -949,10 +970,29 @@ public static boolean canBlock(final Card attacker, final Card blocker, final Co
 
         // if the attacker has no lure effect, but the blocker can block another
         // attacker with lure, the blocker can't block the former
-        if (!attacker.hasKeyword("All creatures able to block CARDNAME do so.")
-                && !(attacker.hasKeyword("CARDNAME must be blocked if able.") && combat.getBlockers(attacker).isEmpty())
-                && !(attacker.hasKeyword("CARDNAME must be blocked by exactly one creature if able.") && combat.getBlockers(attacker).size() != 1)
-                && !(attacker.hasKeyword("CARDNAME must be blocked by two or more creatures if able.") && combat.getBlockers(attacker).size() < 2)
+        boolean lure = attacker.hasKeyword("All creatures able to block CARDNAME do so.");
+        if (!lure) {
+            for (final StaticAbility sa : attacker.getStaticAbilities()) {
+                if (sa.checkConditions(StaticAbilityMode.MustBeBlockedByAll)) {
+                    lure = true;
+                    break;
+                }
+            }
+        }
+        boolean mustBeBlockedIfAble = attacker.hasKeyword("CARDNAME must be blocked if able.");
+        if (!mustBeBlockedIfAble) {
+             for (final StaticAbility sa : attacker.getStaticAbilities()) {
+                if (sa.checkConditions(StaticAbilityMode.MustBeBlocked)) {
+                    mustBeBlockedIfAble = true;
+                    break;
+                }
+            }
+        }
+
+        if (!lure
+                && !(mustBeBlockedIfAble && currentBlockers.isEmpty())
+                && !(attacker.hasKeyword("CARDNAME must be blocked by exactly one creature if able.") && currentBlockers.size() != 1)
+                && !(attacker.hasKeyword("CARDNAME must be blocked by two or more creatures if able.") && currentBlockers.size() < 2)
                 && !blocker.getMustBlockCards().contains(attacker)
                 && !mustBeBlockedBy
                 && mustBlockAnAttacker(blocker, combat, null)) {

forge-game/src/main/java/forge/game/phase/Untap.java

@@ -37,6 +37,7 @@
 import forge.game.player.Player;
 import forge.game.player.PlayerController.BinaryChoiceType;
 import forge.game.spellability.SpellAbility;
+import forge.game.staticability.StaticAbilityBounceAtUntap;
 import forge.game.staticability.StaticAbilityCantPhase;
 import forge.game.staticability.StaticAbilityUntapOtherPlayer;
 import forge.game.trigger.TriggerType;
@@ -91,6 +92,16 @@ private void doUntap() {
 
         CardZoneTable triggerList = new CardZoneTable(game.getLastStateBattlefield(), game.getLastStateGraveyard());
         CardCollection bounceList = CardLists.getKeyword(untapList, "During your next untap step, as you untap your permanents, return CARDNAME to its owner's hand.");
+
+        for (final Card c : untapList) {
+            if (bounceList.contains(c)) {
+                continue;
+            }
+            if (StaticAbilityBounceAtUntap.shouldBounceAtUntap(c)) {
+                bounceList.add(c);
+            }
+        }
+
         for (final Card c : bounceList) {
             Card moved = game.getAction().moveToHand(c, null);
             triggerList.put(ZoneType.Battlefield, moved.getZone().getZoneType(), moved);

forge-game/src/main/java/forge/game/spellability/AbilityActivated.java

@@ -24,6 +24,8 @@
 import forge.game.player.Player;
 import forge.game.player.PlayerController.FullControlFlag;
 import forge.game.staticability.StaticAbilityCantBeCast;
+import forge.game.staticability.StaticAbility;
+import forge.game.staticability.StaticAbilityMode;
 
 /**
  * <p>
@@ -87,8 +89,18 @@ public boolean canPlay() {
         }
 
         final Card c = this.getHostCard();
+
+        boolean cantBeActivated = c.hasKeyword("CARDNAME's activated abilities can't be activated.");
+        if (!cantBeActivated) {
+            for (final StaticAbility sa : c.getStaticAbilities()) {
+                if (sa.checkConditions(StaticAbilityMode.CantBeActivated)) {
+                    cantBeActivated = true;
+                    break;
+                }
+            }
+        }
 
-        if (c.hasKeyword("CARDNAME's activated abilities can't be activated.") || this.isSuppressed()) {
+        if (cantBeActivated || this.isSuppressed()) {
             return false;
         }
 

forge-game/src/main/java/forge/game/staticability/StaticAbilityBounceAtUntap.java

@@ -0,0 +1,28 @@
+package forge.game.staticability;
+
+import forge.game.card.Card;
+import forge.game.zone.ZoneType;
+
+public class StaticAbilityBounceAtUntap {
+
+    public static boolean shouldBounceAtUntap(Card card) {
+        for (final Card ca : card.getGame().getCardsIn(ZoneType.STATIC_ABILITIES_SOURCE_ZONES)) {
+            for (final StaticAbility stAb : ca.getStaticAbilities()) {
+                if (!stAb.checkConditions(StaticAbilityMode.BounceAtUntap)) {
+                    continue;
+                }
+                if (applyBounceAtUntapAbility(stAb, card)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    public static boolean applyBounceAtUntapAbility(StaticAbility stAb, Card card) {
+        if (!stAb.matchesValidParam("ValidCard", card)) {
+            return false;
+        }
+        return true;
+    }
+}

forge-game/src/main/java/forge/game/staticability/StaticAbilityCantGainControl.java

@@ -0,0 +1,28 @@
+package forge.game.staticability;
+
+import forge.game.card.Card;
+import forge.game.zone.ZoneType;
+
+public class StaticAbilityCantGainControl {
+
+    public static boolean cantGainControl(Card card) {
+        for (final Card ca : card.getGame().getCardsIn(ZoneType.STATIC_ABILITIES_SOURCE_ZONES)) {
+            for (final StaticAbility stAb : ca.getStaticAbilities()) {
+                if (!stAb.checkConditions(StaticAbilityMode.CantGainControl)) {
+                    continue;
+                }
+                if (applyCantGainControlAbility(stAb, card)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    public static boolean applyCantGainControlAbility(StaticAbility stAb, Card card) {
+        if (!stAb.matchesValidParam("ValidCard", card)) {
+            return false;
+        }
+        return true;
+    }
+}

forge-game/src/main/java/forge/game/staticability/StaticAbilityLethalDamageByPower.java

@@ -0,0 +1,28 @@
+package forge.game.staticability;
+
+import forge.game.card.Card;
+import forge.game.zone.ZoneType;
+
+public class StaticAbilityLethalDamageByPower {
+
+    public static boolean isLethalDamageByPower(Card card) {
+        for (final Card ca : card.getGame().getCardsIn(ZoneType.STATIC_ABILITIES_SOURCE_ZONES)) {
+            for (final StaticAbility stAb : ca.getStaticAbilities()) {
+                if (!stAb.checkConditions(StaticAbilityMode.LethalDamageByPower)) {
+                    continue;
+                }
+                if (applyLethalDamageByPowerAbility(stAb, card)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    public static boolean applyLethalDamageByPowerAbility(StaticAbility stAb, Card card) {
+        if (!stAb.matchesValidParam("ValidCard", card)) {
+            return false;
+        }
+        return true;
+    }
+}

forge-game/src/main/java/forge/game/staticability/StaticAbilityMode.java

@@ -46,6 +46,8 @@ public enum StaticAbilityMode {
     PlayerMustAttack,
     // StaticAbilityMustBlock
     MustBlock,
+    MustBeBlockedByAll,
+    MustBeBlocked,
 
     // StaticAbilityAssignCombatDamageAsUnblocked
     AssignCombatDamageAsUnblocked,
@@ -97,6 +99,11 @@ public enum StaticAbilityMode {
 
     // StaticAbilityCantBecomeMonarch
     CantBecomeMonarch,
+
+    // Hidden Keywords Refactoring (Issue #3307)
+    CantGainControl,
+    BounceAtUntap,
+    LethalDamageByPower,
 
     // StaticAbilityCantAttach
     CantAttach,