made method in PlayerController to pay optional costs, like propaganda and some upkeeps.

src/main/java/forge/game/GameAction.java

@@ -58,7 +58,6 @@ import forge.card.trigger.Trigger;
 import forge.card.trigger.TriggerType;
 import forge.card.trigger.ZCTrigger;
 import forge.game.ai.ComputerUtil;
-import forge.game.ai.ComputerUtilCost;
 import forge.game.event.GameEventCardDestroyed;
 import forge.game.event.GameEventCardRegenerated;
 import forge.game.event.GameEventCardSacrificed;
@@ -528,16 +527,7 @@ public class GameAction {
         final Ability recoverAbility = new Ability(recoverable, ManaCost.ZERO) {
             @Override
             public void resolve() {
-                Player p = recoverable.getController();
+                boolean hasPaid = recoverable.getController().getController().payManaOptional(recoverable, cost);
-                boolean hasPaid = false;
-                if (p.isHuman()) {
-                    hasPaid = HumanPlay.payCostDuringAbilityResolve(p, recoverable, cost, null);
-                } else { // computer
-                    if (ComputerUtilCost.canPayCost(abRecover, p)) {
-                        ComputerUtil.playNoStack(p, abRecover, game);
-                        hasPaid = true;
-                    }
-                }
                 
                 if (hasPaid)
                     moveToHand(recoverable);

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

@@ -43,15 +43,11 @@ import forge.card.cardfactory.CardFactoryUtil;
 import forge.card.cost.Cost;
 import forge.card.mana.ManaCost;
 import forge.card.spellability.Ability;
-import forge.card.spellability.AbilityStatic;
 import forge.card.staticability.StaticAbility;
 import forge.card.trigger.TriggerType;
 import forge.game.Game;
 import forge.game.GlobalRuleChange;
-import forge.game.ai.ComputerUtil;
 import forge.game.ai.ComputerUtilCard;
-import forge.game.ai.ComputerUtilCost;
-import forge.game.player.HumanPlay;
 import forge.game.player.Player;
 import forge.game.zone.PlayerZone;
 import forge.game.zone.ZoneType;
@@ -997,23 +993,8 @@ public class CombatUtil {
             }
         }
         
-        boolean needsToPay = !attackCost.getTotalMana().isZero() || !attackCost.isOnlyManaCost(); // true if needless to pay
+        boolean isFree = attackCost.getTotalMana().isZero() && attackCost.isOnlyManaCost(); // true if needless to pay
-        boolean isPaid = !needsToPay;
+        return isFree || c.getController().getController().payManaOptional(c, attackCost);
-        if (needsToPay) {
-            
-            final Ability ability = new AbilityStatic(c, attackCost, null) { @Override public void resolve() {} };
-            ability.setActivatingPlayer(c.getController());
-
-            if (c.getController().isHuman()) {
-                isPaid = HumanPlay.payCostDuringAbilityResolve(c.getController(), c, attackCost, null);
-            } else { // computer
-                if (ComputerUtilCost.canPayCost(ability, c.getController())) {
-                    ComputerUtil.playNoStack(c.getController(), ability, game);
-                    isPaid = true;
-                }
-            }
-        }
-        return isPaid;
     }
 
     /**

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

@@ -27,14 +27,9 @@ import forge.Card;
 import forge.CardLists;
 import forge.card.cost.Cost;
 import forge.card.mana.ManaCost;
-import forge.card.spellability.Ability;
-import forge.card.spellability.AbilityStatic;
 import forge.card.staticability.StaticAbility;
 import forge.card.trigger.TriggerType;
 import forge.game.Game;
-import forge.game.ai.ComputerUtil;
-import forge.game.ai.ComputerUtilCost;
-import forge.game.player.HumanPlay;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 
@@ -177,17 +172,7 @@ public class PhaseUtil {
                 
                 boolean hasPaid = blockCost.getTotalMana().isZero() && blockCost.isOnlyManaCost(); // true if needless to pay
                 if (!hasPaid) { 
-                    final Ability ability = new AbilityStatic(blocker, blockCost, null) { @Override public void resolve() {} };
+                    hasPaid = blocker.getController().getController().payManaOptional(blocker, blockCost);
-                    ability.setActivatingPlayer(blocker.getController());
-
-                    if (blocker.getController().isHuman()) {
-                        hasPaid = HumanPlay.payCostDuringAbilityResolve(blocker.getController(), blocker, blockCost, null);
-                    } else { // computer
-                        if (ComputerUtilCost.canPayCost(ability, blocker.getController())) {
-                            ComputerUtil.playNoStack(blocker.getController(), ability, game);
-                            hasPaid = true;
-                        }
-                    }
                 }
 
                 if ( !hasPaid ) {

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

@@ -42,7 +42,6 @@ import forge.game.ai.ComputerUtil;
 import forge.game.ai.ComputerUtilCard;
 import forge.game.ai.ComputerUtilCombat;
 import forge.game.ai.ComputerUtilCost;
-import forge.game.player.HumanPlay;
 import forge.game.player.Player;
 import forge.game.player.PlayerActionConfirmMode;
 import forge.game.zone.PlayerZone;
@@ -175,17 +174,8 @@ public class Upkeep extends Phase {
                 final Ability sacAbility = new Ability(c, ManaCost.ZERO) {
                     @Override
                     public void resolve() {
-                        boolean hasPaid = false;
+                        Cost cost = new Cost(c.getEchoCost().trim(), true);
-                        Player controller = c.getController();
+                        boolean hasPaid = c.getController().getController().payManaOptional(c, cost);
-                        if (controller.isHuman()) {
-                            Cost cost = new Cost(c.getEchoCost().trim(), true);
-                            hasPaid = HumanPlay.payCostDuringAbilityResolve(controller, c, cost, null);
-                        } else { // computer
-                            if (ComputerUtilCost.canPayCost(blankAbility, controller)) {
-                                ComputerUtil.playNoStack(controller, blankAbility, game);
-                                hasPaid = true;
-                            }
-                        }
                         
                         if (!hasPaid)
                             game.getAction().sacrifice(c, null);;
@@ -279,17 +269,8 @@ public class Upkeep extends Phase {
                     final Ability upkeepAbility = new Ability(c, ManaCost.ZERO) {
                         @Override
                         public void resolve() {
-                            boolean isPaid = false;
+                            boolean isPaid = controller.getController().payManaOptional(c, upkeepCost);
-                            if (controller.isHuman()) {
+
-                                isPaid = HumanPlay.payCostDuringAbilityResolve(controller, c, upkeepCost, this);
-                                    
-                            } else { // computer
-                                if (ComputerUtilCost.shouldPayCost(controller, c, upkeepCost) && ComputerUtilCost.canPayCost(blankAbility, controller)) {
-                                    ComputerUtil.playNoStack(controller, blankAbility, game); // this makes AI pay
-                                    isPaid = true;
-                                }
-                            }
-                            
                             if(!isPaid)
                                 game.getAction().sacrifice(c, null);
                         }

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

@@ -9,6 +9,7 @@ import org.apache.commons.lang3.tuple.ImmutablePair;
 
 import forge.Card;
 import forge.GameEntity;
+import forge.card.cost.Cost;
 import forge.card.mana.Mana;
 import forge.card.replacement.ReplacementEffect;
 import forge.card.spellability.SpellAbility;
@@ -126,4 +127,5 @@ public abstract class PlayerController {
 
     public abstract void takePriority();
     public abstract List<Card> chooseCardsToDiscardToMaximumHandSize(int numDiscard);
+    public abstract boolean payManaOptional(Card card, Cost cost);
 }

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

@@ -14,8 +14,11 @@ import forge.Card;
 import forge.CardLists;
 import forge.CardPredicates;
 import forge.GameEntity;
+import forge.card.cost.Cost;
 import forge.card.mana.Mana;
 import forge.card.replacement.ReplacementEffect;
+import forge.card.spellability.Ability;
+import forge.card.spellability.AbilityStatic;
 import forge.card.spellability.Spell;
 import forge.card.spellability.SpellAbility;
 import forge.card.spellability.Target;
@@ -26,6 +29,7 @@ import forge.game.ai.AiController;
 import forge.game.ai.ComputerUtil;
 import forge.game.ai.ComputerUtilBlock;
 import forge.game.ai.ComputerUtilCombat;
+import forge.game.ai.ComputerUtilCost;
 import forge.game.zone.ZoneType;
 import forge.util.Aggregates;
 
@@ -298,4 +302,19 @@ public class PlayerControllerAi extends PlayerController {
     public List<Card> chooseCardsToRevealFromHand(int min, int max, List<Card> valid) {
         return max == 0 ? Lists.<Card>newArrayList() : valid.subList(0, max);
     }
+
+    /* (non-Javadoc)
+     * @see forge.game.player.PlayerController#payManaOptional(forge.Card, forge.card.cost.Cost)
+     */
+    @Override
+    public boolean payManaOptional(Card c, Cost cost) {
+        final Ability ability = new AbilityStatic(c, cost, null) { @Override public void resolve() {} };
+        ability.setActivatingPlayer(c.getController());
+
+        if (ComputerUtilCost.canPayCost(ability, c.getController())) {
+            ComputerUtil.playNoStack(c.getController(), ability, game);
+            return true;
+        }
+        return false;
+    }
 }

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

@@ -16,6 +16,7 @@ import com.google.common.collect.Lists;
 import forge.Card;
 import forge.GameEntity;
 import forge.Singletons;
+import forge.card.cost.Cost;
 import forge.card.mana.Mana;
 import forge.card.replacement.ReplacementEffect;
 import forge.card.spellability.SpellAbility;
@@ -534,4 +535,13 @@ public class PlayerControllerHuman extends PlayerController {
         Singletons.getControl().getInputQueue().setInputAndWait(inp);
         return inp.getSelected();
     }
+
+
+    /* (non-Javadoc)
+     * @see forge.game.player.PlayerController#payManaOptional(forge.Card, forge.card.cost.Cost)
+     */
+    @Override
+    public boolean payManaOptional(Card c, Cost attackCost) {
+        return HumanPlay.payCostDuringAbilityResolve(player, c, attackCost, null);
+    }
 }