external-repos/forge
1
0
Fork 0
mirror of https://github.com/Card-Forge/forge.git synced 2025-11-17 19:28:01 +00:00
Code Issues Packages Projects Releases Wiki Activity

calls to AI-related methods require the player parameter to have AIPlayer type to enable calls to ai-specific methods (like acquiring aicontroller by aiplayer.getcontroller().getai() and performing something from it) without need to cast types)

Browse Source
This commit is contained in:
Maxmtg
2013-02-05 06:25:01 +00:00
parent 5c4931a520
commit fffdc4acc6
97 changed files with 321 additions and 274 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
src/main/java/forge/card/abilityfactory/CommonAbility.java
View File

@@ -12,6 +12,7 @@ import forge.card.cost.Cost;
import forge.card.spellability.AbilityActivated;
import forge.card.spellability.AbilityManaPart;
import forge.card.spellability.Target;
import forge.game.player.AIPlayer;
public class CommonAbility extends AbilityActivated {
private final SpellEffect effect;
@@ -63,11 +64,11 @@ public class CommonAbility extends AbilityActivated {
@Override
public boolean canPlayAI() {
return ai.canPlayAIWithSubs(getActivatingPlayer(), this);
return ai.canPlayAIWithSubs((AIPlayer)getActivatingPlayer(), this);
}
@Override
public boolean doTrigger(final boolean mandatory) {
return ai.doTriggerAI(this.getActivatingPlayer(), this, mandatory);
return ai.doTriggerAI((AIPlayer)this.getActivatingPlayer(), this, mandatory);
}
}

7
src/main/java/forge/card/abilityfactory/CommonDrawback.java
View File

@@ -28,6 +28,7 @@ import forge.card.cardfactory.CardFactoryUtil;
import forge.card.spellability.AbilityManaPart;
import forge.card.spellability.AbilitySub;
import forge.card.spellability.Target;
import forge.game.player.AIPlayer;
public class CommonDrawback extends AbilitySub {
private final SpellEffect effect;
@@ -64,7 +65,7 @@ public class CommonDrawback extends AbilitySub {
@Override
public boolean canPlayAI() {
return ai.canPlayAIWithSubs(getActivatingPlayer(), this);
return ai.canPlayAIWithSubs((AIPlayer)getActivatingPlayer(), this);
}
@Override
@@ -74,7 +75,7 @@ public class CommonDrawback extends AbilitySub {
@Override
public boolean chkAIDrawback() {
if (!ai.chkAIDrawback(this, getActivatingPlayer())) {
if (!ai.chkAIDrawback(this, (AIPlayer)getActivatingPlayer())) {
return false;
}
final AbilitySub subAb = getSubAbility();
@@ -86,7 +87,7 @@ public class CommonDrawback extends AbilitySub {
@Override
public boolean doTrigger(final boolean mandatory) {
return ai.doTriggerAI(getActivatingPlayer(), this, mandatory);
return ai.doTriggerAI((AIPlayer)getActivatingPlayer(), this, mandatory);
}
}

7
src/main/java/forge/card/abilityfactory/CommonSpell.java
View File

@@ -11,6 +11,7 @@ import forge.card.cost.Cost;
import forge.card.spellability.AbilityManaPart;
import forge.card.spellability.Spell;
import forge.card.spellability.Target;
import forge.game.player.AIPlayer;
public class CommonSpell extends Spell {
private static final long serialVersionUID = -6741797239508483250L;
@@ -44,7 +45,7 @@ public class CommonSpell extends Spell {
@Override
public boolean canPlayAI() {
return ai.canPlayAIWithSubs(getActivatingPlayer(), this) && super.canPlayAI();
return ai.canPlayAIWithSubs((AIPlayer) getActivatingPlayer(), this) && super.canPlayAI();
}
@Override
@@ -56,9 +57,9 @@ public class CommonSpell extends Spell {
public boolean canPlayFromEffectAI(final boolean mandatory, final boolean withOutManaCost) {
boolean chance = false;
if (withOutManaCost) {
chance = ai.doTriggerNoCostWithSubs(this.getActivatingPlayer(), this, mandatory);
chance = ai.doTriggerNoCostWithSubs((AIPlayer)this.getActivatingPlayer(), this, mandatory);
}
chance = ai.doTriggerAI(this.getActivatingPlayer(), this, mandatory);
chance = ai.doTriggerAI((AIPlayer)this.getActivatingPlayer(), this, mandatory);
return chance;
}
}

14
src/main/java/forge/card/abilityfactory/SpellAiLogic.java
View File

@@ -4,11 +4,11 @@ package forge.card.abilityfactory;
import forge.card.spellability.AbilitySub;
import forge.card.spellability.SpellAbility;
import forge.game.ai.ComputerUtilCost;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
public abstract class SpellAiLogic {
public final boolean canPlayAIWithSubs(final Player aiPlayer, final SpellAbility sa) {
public final boolean canPlayAIWithSubs(final AIPlayer aiPlayer, final SpellAbility sa) {
final AbilitySub subAb = sa.getSubAbility();
if (subAb != null && !subAb.chkAIDrawback()) {
return false;
@@ -16,9 +16,9 @@ public abstract class SpellAiLogic {
return canPlayAI(aiPlayer, sa);
}
protected abstract boolean canPlayAI(final Player aiPlayer, final SpellAbility sa);
protected abstract boolean canPlayAI(final AIPlayer aiPlayer, final SpellAbility sa);
public final boolean doTriggerAI(final Player aiPlayer, final SpellAbility sa, final boolean mandatory) {
public final boolean doTriggerAI(final AIPlayer aiPlayer, final SpellAbility sa, final boolean mandatory) {
if (!ComputerUtilCost.canPayCost(sa, aiPlayer) && !mandatory) {
return false;
}
@@ -26,7 +26,7 @@ public abstract class SpellAiLogic {
return doTriggerNoCostWithSubs(aiPlayer, sa, mandatory);
}
public final boolean doTriggerNoCostWithSubs(final Player aiPlayer, final SpellAbility sa, final boolean mandatory)
public final boolean doTriggerNoCostWithSubs(final AIPlayer aiPlayer, final SpellAbility sa, final boolean mandatory)
{
if (!doTriggerAINoCost(aiPlayer, sa, mandatory)) {
return false;
@@ -38,11 +38,11 @@ public abstract class SpellAiLogic {
return true;
}
protected boolean doTriggerAINoCost(final Player aiPlayer, final SpellAbility sa, final boolean mandatory) {
protected boolean doTriggerAINoCost(final AIPlayer aiPlayer, final SpellAbility sa, final boolean mandatory) {
return canPlayAI(aiPlayer, sa) || mandatory;
}
public boolean chkAIDrawback(final SpellAbility sa, final Player aiPlayer) {
public boolean chkAIDrawback(final SpellAbility sa, final AIPlayer aiPlayer) {
return true;
}
}

4
src/main/java/forge/card/abilityfactory/ai/AddPhaseAi.java
View File

@@ -2,7 +2,7 @@ package forge.card.abilityfactory.ai;
import forge.card.abilityfactory.SpellAiLogic;
import forge.card.spellability.SpellAbility;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
/**
* TODO: Write javadoc for this type.
@@ -11,7 +11,7 @@ import forge.game.player.Player;
public class AddPhaseAi extends SpellAiLogic {
@Override
protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
return false;
}

5
src/main/java/forge/card/abilityfactory/ai/AddTurnAi.java
View File

@@ -23,6 +23,7 @@ import forge.card.spellability.SpellAbility;
import forge.card.spellability.Target;
import forge.card.abilityfactory.AbilityFactory;
import forge.card.abilityfactory.SpellAiLogic;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
/**
@@ -37,7 +38,7 @@ public class AddTurnAi extends SpellAiLogic {
@Override
protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
final Player opp = ai.getWeakestOpponent();
final Target tgt = sa.getTarget();
@@ -75,7 +76,7 @@ public class AddTurnAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
return doTriggerAINoCost(aiPlayer, sa, false);
}

4
src/main/java/forge/card/abilityfactory/ai/AlwaysPlayAi.java
View File

@@ -3,14 +3,14 @@ package forge.card.abilityfactory.ai;
import forge.card.abilityfactory.SpellAiLogic;
import forge.card.spellability.SpellAbility;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
public class AlwaysPlayAi extends SpellAiLogic {
/* (non-Javadoc)
* @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
return true;
}
}

7
src/main/java/forge/card/abilityfactory/ai/AnimateAi.java
View File

@@ -12,6 +12,7 @@ import forge.card.abilityfactory.SpellAiLogic;
import forge.card.spellability.SpellAbility;
import forge.card.spellability.Target;
import forge.game.phase.PhaseType;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
import forge.game.zone.ZoneType;
@@ -30,7 +31,7 @@ public class AnimateAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
final Target tgt = sa.getTarget();
final Card source = sa.getSourceCard();
@@ -113,7 +114,7 @@ public class AnimateAi extends SpellAiLogic {
// end animateCanPlayAI()
@Override
public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
public boolean chkAIDrawback(SpellAbility sa, AIPlayer aiPlayer) {
if (sa.getTarget() != null) {
sa.getTarget().resetTargets();
if (!animateTgtAI(sa)) {
@@ -138,7 +139,7 @@ public class AnimateAi extends SpellAiLogic {
* @return a boolean.
*/
@Override
protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
if (sa.getTarget() != null && !animateTgtAI(sa) && !mandatory) {
return false;

6
src/main/java/forge/card/abilityfactory/ai/AnimateAllAi.java
View File

@@ -2,17 +2,17 @@ package forge.card.abilityfactory.ai;
import forge.card.abilityfactory.SpellAiLogic;
import forge.card.spellability.SpellAbility;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
public class AnimateAllAi extends SpellAiLogic {
@Override
protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
return false;
} // end animateAllCanPlayAI()
@Override
protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
return false;
}

5
src/main/java/forge/card/abilityfactory/ai/AttachAi.java
View File

@@ -28,6 +28,7 @@ import forge.game.ai.ComputerUtilMana;
import forge.game.phase.CombatUtil;
import forge.game.phase.PhaseHandler;
import forge.game.phase.PhaseType;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
import forge.game.zone.ZoneType;
import forge.util.MyRandom;
@@ -38,7 +39,7 @@ public class AttachAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
final Random r = MyRandom.getRandom();
final Cost abCost = sa.getPayCosts();
final Card source = sa.getSourceCard();
@@ -580,7 +581,7 @@ public class AttachAi extends SpellAiLogic {
* @return true, if successful
*/
@Override
protected boolean doTriggerAINoCost(final Player ai, final SpellAbility sa, final boolean mandatory) {
protected boolean doTriggerAINoCost(final AIPlayer ai, final SpellAbility sa, final boolean mandatory) {
final Card card = sa.getSourceCard();
// Check if there are any valid targets
ArrayList<Object> targets = new ArrayList<Object>();

4
src/main/java/forge/card/abilityfactory/ai/BondAi.java
View File

@@ -19,7 +19,7 @@ package forge.card.abilityfactory.ai;
import forge.card.spellability.SpellAbility;
import forge.card.abilityfactory.SpellAiLogic;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
/**
* <p>
@@ -42,7 +42,7 @@ public final class BondAi extends SpellAiLogic {
* @return a boolean.
*/
@Override
protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
return true;
} // end bondCanPlayAI()
}

6
src/main/java/forge/card/abilityfactory/ai/CanPlayAsDrawbackAi.java
View File

@@ -3,7 +3,7 @@ package forge.card.abilityfactory.ai;
import forge.card.abilityfactory.SpellAiLogic;
import forge.card.spellability.SpellAbility;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
public class CanPlayAsDrawbackAi extends SpellAiLogic {
@@ -11,7 +11,7 @@ public class CanPlayAsDrawbackAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
return false;
}
@@ -29,7 +29,7 @@ public class CanPlayAsDrawbackAi extends SpellAiLogic {
* @return a boolean.
*/
@Override
protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
return false;
}

6
src/main/java/forge/card/abilityfactory/ai/CannotPlayAi.java
View File

@@ -3,14 +3,14 @@ package forge.card.abilityfactory.ai;
import forge.card.abilityfactory.SpellAiLogic;
import forge.card.spellability.SpellAbility;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
public class CannotPlayAi extends SpellAiLogic {
/* (non-Javadoc)
* @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
return false;
}
@@ -18,7 +18,7 @@ public class CannotPlayAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#chkAIDrawback(java.util.Map, forge.card.spellability.SpellAbility, forge.game.player.Player)
*/
@Override
public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
public boolean chkAIDrawback(SpellAbility sa, AIPlayer aiPlayer) {
return canPlayAI(aiPlayer, sa);
}
}

7
src/main/java/forge/card/abilityfactory/ai/ChangeZoneAi.java
View File

@@ -37,6 +37,7 @@ import forge.game.ai.ComputerUtilCost;
import forge.game.ai.ComputerUtilMana;
import forge.game.phase.Combat;
import forge.game.phase.PhaseType;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
import forge.game.zone.ZoneType;
import forge.gui.GuiChoose;
@@ -56,7 +57,7 @@ public class ChangeZoneAi extends SpellAiLogic {
* @return a boolean.
*/
@Override
protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
String origin = "";
if (sa.hasParam("Origin")) {
origin = sa.getParam("Origin");
@@ -89,7 +90,7 @@ public class ChangeZoneAi extends SpellAiLogic {
* @return a boolean.
*/
@Override
public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
public boolean chkAIDrawback(SpellAbility sa, AIPlayer aiPlayer) {
String origin = "";
if (sa.hasParam("Origin")) {
origin = sa.getParam("Origin");
@@ -120,7 +121,7 @@ public class ChangeZoneAi extends SpellAiLogic {
* @return a boolean.
*/
@Override
protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
String origin = "";
if (sa.hasParam("Origin")) {
origin = sa.getParam("Origin");

7
src/main/java/forge/card/abilityfactory/ai/ChangeZoneAllAi.java
View File

@@ -14,6 +14,7 @@ import forge.card.spellability.SpellAbility;
import forge.card.spellability.Target;
import forge.game.ai.ComputerUtilCost;
import forge.game.phase.PhaseType;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
import forge.game.zone.ZoneType;
import forge.util.MyRandom;
@@ -24,7 +25,7 @@ public class ChangeZoneAllAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
// Change Zone All, can be any type moving from one zone to another
final Cost abCost = sa.getPayCosts();
final Card source = sa.getSourceCard();
@@ -167,7 +168,7 @@ public class ChangeZoneAllAi extends SpellAiLogic {
* @return a boolean.
*/
@Override
public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
public boolean chkAIDrawback(SpellAbility sa, AIPlayer aiPlayer) {
// if putting cards from hand to library and parent is drawing cards
// make sure this will actually do something:
@@ -176,7 +177,7 @@ public class ChangeZoneAllAi extends SpellAiLogic {
@Override
protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
// Change Zone All, can be any type moving from one zone to another
final ZoneType destination = ZoneType.smartValueOf(sa.getParam("Destination"));

3
src/main/java/forge/card/abilityfactory/ai/CharmAi.java
View File

@@ -8,13 +8,14 @@ import forge.card.abilityfactory.SpellAiLogic;
import forge.card.abilityfactory.effects.CharmEffect;
import forge.card.spellability.AbilitySub;
import forge.card.spellability.SpellAbility;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
import forge.util.MyRandom;
public class CharmAi extends SpellAiLogic {
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
final Random r = MyRandom.getRandom();
final int num = Integer.parseInt(sa.hasParam("CharmNum") ? sa.getParam("CharmNum") : "1");

6
src/main/java/forge/card/abilityfactory/ai/ChooseCardAi.java
View File

@@ -8,7 +8,7 @@ import forge.Singletons;
import forge.card.abilityfactory.SpellAiLogic;
import forge.card.spellability.SpellAbility;
import forge.card.spellability.Target;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
import forge.game.zone.ZoneType;
public class ChooseCardAi extends SpellAiLogic {
@@ -17,7 +17,7 @@ public class ChooseCardAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
final Card host = sa.getSourceCard();
final Target tgt = sa.getTarget();
@@ -61,7 +61,7 @@ public class ChooseCardAi extends SpellAiLogic {
}
@Override
public boolean chkAIDrawback(SpellAbility sa, Player ai) {
public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
return canPlayAI(ai, sa);
}
}

6
src/main/java/forge/card/abilityfactory/ai/ChooseCardNameAi.java
View File

@@ -4,12 +4,12 @@ import forge.card.abilityfactory.SpellAiLogic;
import forge.card.spellability.SpellAbility;
import forge.card.spellability.Target;
import forge.game.ai.ComputerUtil;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
public class ChooseCardNameAi extends SpellAiLogic {
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
if (sa.hasParam("AILogic")) {
// Don't tap creatures that may be able to block
@@ -32,7 +32,7 @@ public class ChooseCardNameAi extends SpellAiLogic {
}
@Override
protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
// TODO - there is no AILogic implemented yet
return false;
}

6
src/main/java/forge/card/abilityfactory/ai/ChooseColorAi.java
View File

@@ -2,13 +2,13 @@ package forge.card.abilityfactory.ai;
import forge.card.abilityfactory.SpellAiLogic;
import forge.card.spellability.SpellAbility;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
import forge.util.MyRandom;
public class ChooseColorAi extends SpellAiLogic {
@Override
protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
if (!sa.hasParam("AILogic")) {
return false;
}
@@ -17,7 +17,7 @@ public class ChooseColorAi extends SpellAiLogic {
}
@Override
protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
return mandatory || canPlayAI(ai, sa);
}

8
src/main/java/forge/card/abilityfactory/ai/ChoosePlayerAi.java
View File

@@ -2,7 +2,7 @@ package forge.card.abilityfactory.ai;
import forge.card.abilityfactory.SpellAiLogic;
import forge.card.spellability.SpellAbility;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
public class ChoosePlayerAi extends SpellAiLogic {
@@ -10,17 +10,17 @@ public class ChoosePlayerAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
return true;
}
@Override
public boolean chkAIDrawback(SpellAbility sa, Player ai) {
public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
return canPlayAI(ai, sa);
}
@Override
protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
return canPlayAI(ai, sa);
}

4
src/main/java/forge/card/abilityfactory/ai/ChooseSourceAi.java
View File

@@ -17,7 +17,7 @@ import forge.card.spellability.Target;
import forge.game.ai.ComputerUtilCombat;
import forge.game.ai.ComputerUtilCost;
import forge.game.phase.PhaseType;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
import forge.game.zone.ZoneType;
public class ChooseSourceAi extends SpellAiLogic {
@@ -26,7 +26,7 @@ public class ChooseSourceAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(final Player ai, SpellAbility sa) {
protected boolean canPlayAI(final AIPlayer ai, SpellAbility sa) {
// TODO: AI Support! Currently this is copied from AF ChooseCard.
// When implementing AI, I believe AI also needs to be made aware of the damage sources chosen
// to be prevented (e.g. so the AI doesn't attack with a creature that will not deal any damage

5
src/main/java/forge/card/abilityfactory/ai/ChooseTypeAi.java
View File

@@ -4,11 +4,12 @@ import forge.card.abilityfactory.AbilityFactory;
import forge.card.abilityfactory.SpellAiLogic;
import forge.card.spellability.SpellAbility;
import forge.card.spellability.Target;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
public class ChooseTypeAi extends SpellAiLogic {
@Override
protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
if (!sa.hasParam("AILogic")) {
return false;
}
@@ -17,7 +18,7 @@ public class ChooseTypeAi extends SpellAiLogic {
}
@Override
protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
final Target tgt = sa.getTarget();
if (sa.getTarget() != null) {

5
src/main/java/forge/card/abilityfactory/ai/ClashAi.java
View File

@@ -4,6 +4,7 @@ package forge.card.abilityfactory.ai;
import forge.card.abilityfactory.SpellAiLogic;
import forge.card.spellability.SpellAbility;
import forge.card.spellability.Target;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
public class ClashAi extends SpellAiLogic {
@@ -12,7 +13,7 @@ public class ClashAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#doTriggerAINoCost(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility, boolean)
*/
@Override
protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
return true;
}
@@ -20,7 +21,7 @@ public class ClashAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
final Target tgt = sa.getTarget();
final Player opp = ai.getOpponent();
if (tgt != null) {

8
src/main/java/forge/card/abilityfactory/ai/CloneAi.java
View File

@@ -10,12 +10,12 @@ import forge.card.spellability.SpellAbility;
import forge.card.spellability.Target;
import forge.game.phase.PhaseHandler;
import forge.game.phase.PhaseType;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
public class CloneAi extends SpellAiLogic {
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
final Target tgt = sa.getTarget();
final Card source = sa.getSourceCard();
@@ -92,7 +92,7 @@ public class CloneAi extends SpellAiLogic {
} // end cloneCanPlayAI()
@Override
public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
public boolean chkAIDrawback(SpellAbility sa, AIPlayer aiPlayer) {
// AI should only activate this during Human's turn
boolean chance = true;
@@ -105,7 +105,7 @@ public class CloneAi extends SpellAiLogic {
}
@Override
protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
boolean chance = true;

6
src/main/java/forge/card/abilityfactory/ai/ControlExchangeAi.java
View File

@@ -12,7 +12,7 @@ import forge.card.abilityfactory.SpellAiLogic;
import forge.card.cardfactory.CardFactoryUtil;
import forge.card.spellability.SpellAbility;
import forge.card.spellability.Target;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
import forge.game.zone.ZoneType;
import forge.util.MyRandom;
@@ -22,7 +22,7 @@ public class ControlExchangeAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(Player ai, final SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, final SpellAbility sa) {
Card object1 = null;
Card object2 = null;
final Target tgt = sa.getTarget();
@@ -62,7 +62,7 @@ public class ControlExchangeAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#doTriggerAINoCost(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility, boolean)
*/
@Override
protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
return false;
}
}

7
src/main/java/forge/card/abilityfactory/ai/ControlGainAi.java
View File

@@ -33,6 +33,7 @@ import forge.card.cardfactory.CardFactoryUtil;
import forge.card.spellability.SpellAbility;
import forge.card.spellability.Target;
import forge.game.phase.PhaseType;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
import forge.game.zone.ZoneType;
@@ -62,7 +63,7 @@ import forge.game.zone.ZoneType;
*/
public class ControlGainAi extends SpellAiLogic {
@Override
protected boolean canPlayAI(Player ai, final SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, final SpellAbility sa) {
boolean hasCreature = false;
boolean hasArtifact = false;
boolean hasEnchantment = false;
@@ -163,7 +164,7 @@ public class ControlGainAi extends SpellAiLogic {
}
@Override
protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
if (sa.getTarget() == null) {
if (mandatory) {
return true;
@@ -176,7 +177,7 @@ public class ControlGainAi extends SpellAiLogic {
}
@Override
public boolean chkAIDrawback(SpellAbility sa, final Player ai) {
public boolean chkAIDrawback(SpellAbility sa, final AIPlayer ai) {
if ((sa.getTarget() == null) || !sa.getTarget().doesTarget()) {
if (sa.hasParam("AllValid")) {
List<Card> tgtCards = CardLists.filterControlledBy(Singletons.getModel().getGame().getCardsIn(ZoneType.Battlefield), ai.getOpponent());

6
src/main/java/forge/card/abilityfactory/ai/CopyPermanentAi.java
View File

@@ -16,7 +16,7 @@ import forge.card.cardfactory.CardFactoryUtil;
import forge.card.spellability.SpellAbility;
import forge.card.spellability.Target;
import forge.game.phase.PhaseType;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
import forge.game.zone.ZoneType;
import forge.util.MyRandom;
@@ -26,7 +26,7 @@ public class CopyPermanentAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
// Card source = sa.getSourceCard();
// TODO - I'm sure someone can do this AI better
@@ -48,7 +48,7 @@ public class CopyPermanentAi extends SpellAiLogic {
}
@Override
protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
final Card source = sa.getSourceCard();
// ////

8
src/main/java/forge/card/abilityfactory/ai/CounterAi.java
View File

@@ -11,13 +11,13 @@ import forge.card.spellability.Target;
import forge.card.spellability.TargetSelection;
import forge.game.ai.ComputerUtilCost;
import forge.game.ai.ComputerUtilMana;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
import forge.util.MyRandom;
public class CounterAi extends SpellAiLogic {
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
boolean toReturn = true;
final Cost abCost = sa.getPayCosts();
final Card source = sa.getSourceCard();
@@ -100,12 +100,12 @@ public class CounterAi extends SpellAiLogic {
}
@Override
public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
public boolean chkAIDrawback(SpellAbility sa, AIPlayer aiPlayer) {
return doTriggerAINoCost(aiPlayer, sa, true);
}
@Override
protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
final Target tgt = sa.getTarget();
if (tgt != null) {

5
src/main/java/forge/card/abilityfactory/ai/CountersMoveAi.java
View File

@@ -11,13 +11,14 @@ import forge.card.abilityfactory.SpellAiLogic;
import forge.card.cardfactory.CardFactoryUtil;
import forge.card.spellability.SpellAbility;
import forge.card.spellability.Target;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
import forge.game.zone.ZoneType;
import forge.util.MyRandom;
public class CountersMoveAi extends SpellAiLogic {
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
// AI needs to be expanded, since this function can be pretty complex
// based on what
// the expected targets could be
@@ -43,7 +44,7 @@ public class CountersMoveAi extends SpellAiLogic {
} // moveCounterCanPlayAI
@Override
protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
final Card host = sa.getSourceCard();
final Target abTgt = sa.getTarget();
final String type = sa.getParam("CounterType");

8
src/main/java/forge/card/abilityfactory/ai/CountersProliferateAi.java
View File

@@ -10,13 +10,13 @@ import forge.CounterType;
import forge.card.abilityfactory.SpellAiLogic;
import forge.card.cardfactory.CardFactoryUtil;
import forge.card.spellability.SpellAbility;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
import forge.game.zone.ZoneType;
public class CountersProliferateAi extends SpellAiLogic {
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
boolean chance = true;
List<Card> cperms = CardLists.filter(ai.getCardsIn(ZoneType.Battlefield), new Predicate<Card>() {
@@ -50,7 +50,7 @@ public class CountersProliferateAi extends SpellAiLogic {
}
@Override
protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
boolean chance = true;
// TODO Make sure Human has poison counters or there are some counters
@@ -62,7 +62,7 @@ public class CountersProliferateAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#chkAIDrawback(java.util.Map, forge.card.spellability.SpellAbility, forge.game.player.Player)
*/
@Override
public boolean chkAIDrawback(SpellAbility sa, Player ai) {
public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
return canPlayAI(ai, sa);
}

7
src/main/java/forge/card/abilityfactory/ai/CountersPutAi.java
View File

@@ -20,13 +20,14 @@ import forge.game.ai.ComputerUtil;
import forge.game.ai.ComputerUtilCost;
import forge.game.ai.ComputerUtilMana;
import forge.game.phase.PhaseType;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
import forge.game.zone.ZoneType;
import forge.util.MyRandom;
public class CountersPutAi extends SpellAiLogic {
@Override
protected boolean canPlayAI(Player ai, final SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, final SpellAbility sa) {
// AI needs to be expanded, since this function can be pretty complex
// based on
// what the expected targets could be
@@ -165,7 +166,7 @@ public class CountersPutAi extends SpellAiLogic {
} // putCanPlayAI
@Override
public boolean chkAIDrawback(final SpellAbility sa, Player ai) {
public boolean chkAIDrawback(final SpellAbility sa, AIPlayer ai) {
boolean chance = true;
final Target abTgt = sa.getTarget();
final Card source = sa.getSourceCard();
@@ -228,7 +229,7 @@ public class CountersPutAi extends SpellAiLogic {
} // putPlayDrawbackAI
@Override
protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
final Target abTgt = sa.getTarget();
final Card source = sa.getSourceCard();
// boolean chance = true;

5
src/main/java/forge/card/abilityfactory/ai/CountersPutAllAi.java
View File

@@ -18,13 +18,14 @@ import forge.game.ai.ComputerUtilCost;
import forge.game.ai.ComputerUtilMana;
import forge.game.phase.PhaseHandler;
import forge.game.phase.PhaseType;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
import forge.game.zone.ZoneType;
import forge.util.MyRandom;
public class CountersPutAllAi extends SpellAiLogic {
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
// AI needs to be expanded, since this function can be pretty complex
// based on what
// the expected targets could be
@@ -131,7 +132,7 @@ public class CountersPutAllAi extends SpellAiLogic {
}
@Override
public boolean chkAIDrawback(SpellAbility sa, Player ai) {
public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
return canPlayAI(ai, sa);
}
}

6
src/main/java/forge/card/abilityfactory/ai/CountersRemoveAi.java
View File

@@ -11,13 +11,13 @@ import forge.card.spellability.SpellAbility;
import forge.card.spellability.Target;
import forge.game.ai.ComputerUtilCost;
import forge.game.phase.PhaseType;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
import forge.util.MyRandom;
public class CountersRemoveAi extends SpellAiLogic {
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
// AI needs to be expanded, since this function can be pretty complex
// based on what
// the expected targets could be
@@ -83,7 +83,7 @@ public class CountersRemoveAi extends SpellAiLogic {
}
@Override
protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
// AI needs to be expanded, since this function can be pretty complex
// based on what the
// expected targets could be

7
src/main/java/forge/card/abilityfactory/ai/DamageAllAi.java
View File

@@ -17,6 +17,7 @@ import forge.card.spellability.SpellAbility;
import forge.card.spellability.Target;
import forge.game.ai.ComputerUtilCost;
import forge.game.ai.ComputerUtilMana;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
import forge.game.zone.ZoneType;
import forge.util.MyRandom;
@@ -24,7 +25,7 @@ import forge.util.MyRandom;
public class DamageAllAi extends SpellAiLogic {
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
// AI needs to be expanded, since this function can be pretty complex
// based on what the expected targets could be
final Random r = MyRandom.getRandom();
@@ -103,7 +104,7 @@ public class DamageAllAi extends SpellAiLogic {
}
@Override
public boolean chkAIDrawback(SpellAbility sa, Player ai) {
public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
final Card source = sa.getSourceCard();
String validP = "";
@@ -187,7 +188,7 @@ public class DamageAllAi extends SpellAiLogic {
}
@Override
protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
final Card source = sa.getSourceCard();
String validP = "";

7
src/main/java/forge/card/abilityfactory/ai/DamageDealAi.java
View File

@@ -20,13 +20,14 @@ import forge.game.ai.ComputerUtilCost;
import forge.game.ai.ComputerUtilMana;
import forge.game.phase.PhaseHandler;
import forge.game.phase.PhaseType;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
import forge.game.zone.ZoneType;
import forge.util.MyRandom;
public class DamageDealAi extends DamageAiBase {
@Override
public boolean chkAIDrawback(SpellAbility sa, Player ai) {
public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
final String damage = sa.getParam("NumDmg");
int dmg = AbilityFactory.calculateAmount(sa.getSourceCard(), damage, sa);
@@ -44,7 +45,7 @@ public class DamageDealAi extends DamageAiBase {
}
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
final Cost abCost = sa.getPayCosts();
final Card source = sa.getSourceCard();
@@ -378,7 +379,7 @@ public class DamageDealAi extends DamageAiBase {
}
@Override
protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
final Card source = sa.getSourceCard();
final String damage = sa.getParam("NumDmg");

8
src/main/java/forge/card/abilityfactory/ai/DamageEachAi.java
View File

@@ -4,7 +4,7 @@ package forge.card.abilityfactory.ai;
import forge.card.abilityfactory.AbilityFactory;
import forge.card.spellability.SpellAbility;
import forge.card.spellability.Target;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
public class DamageEachAi extends DamageAiBase {
@@ -12,7 +12,7 @@ public class DamageEachAi extends DamageAiBase {
* @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
final Target tgt = sa.getTarget();
if (tgt != null && sa.canTarget(ai.getOpponent())) {
@@ -26,7 +26,7 @@ public class DamageEachAi extends DamageAiBase {
}
@Override
public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
public boolean chkAIDrawback(SpellAbility sa, AIPlayer aiPlayer) {
// check AI life before playing this drawback?
return true;
}
@@ -35,7 +35,7 @@ public class DamageEachAi extends DamageAiBase {
* @see forge.card.abilityfactory.SpellAiLogic#doTriggerAINoCost(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility, boolean)
*/
@Override
protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
return canPlayAI(ai, sa);
}

5
src/main/java/forge/card/abilityfactory/ai/DamagePreventAi.java
View File

@@ -17,13 +17,14 @@ import forge.game.ai.ComputerUtilCombat;
import forge.game.ai.ComputerUtilCost;
import forge.game.phase.PhaseHandler;
import forge.game.phase.PhaseType;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
import forge.game.zone.ZoneType;
public class DamagePreventAi extends SpellAiLogic {
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
final Card hostCard = sa.getSourceCard();
boolean chance = false;
@@ -147,7 +148,7 @@ public class DamagePreventAi extends SpellAiLogic {
}
@Override
protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
boolean chance = false;
final Target tgt = sa.getTarget();
if (tgt == null) {

6
src/main/java/forge/card/abilityfactory/ai/DamagePreventAllAi.java
View File

@@ -8,7 +8,7 @@ import forge.card.cost.Cost;
import forge.card.spellability.SpellAbility;
import forge.game.ai.ComputerUtilCost;
import forge.game.phase.PhaseType;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
public class DamagePreventAllAi extends SpellAiLogic {
@@ -16,7 +16,7 @@ public class DamagePreventAllAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
final Card hostCard = sa.getSourceCard();
boolean chance = false;
@@ -52,7 +52,7 @@ public class DamagePreventAllAi extends SpellAiLogic {
}
@Override
protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
boolean chance = true;
return chance;

7
src/main/java/forge/card/abilityfactory/ai/DebuffAi.java
View File

@@ -19,6 +19,7 @@ import forge.card.spellability.Target;
import forge.game.ai.ComputerUtilCost;
import forge.game.phase.PhaseHandler;
import forge.game.phase.PhaseType;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
import forge.game.zone.ZoneType;
@@ -28,7 +29,7 @@ public class DebuffAi extends SpellAiLogic {
// *************************************************************************
@Override
protected boolean canPlayAI(final Player ai, final SpellAbility sa) {
protected boolean canPlayAI(final AIPlayer ai, final SpellAbility sa) {
// if there is no target and host card isn't in play, don't activate
final Card source = sa.getSourceCard();
if ((sa.getTarget() == null) && !source.isInPlay()) {
@@ -97,7 +98,7 @@ public class DebuffAi extends SpellAiLogic {
}
@Override
public boolean chkAIDrawback(SpellAbility sa, Player ai) {
public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
if ((sa.getTarget() == null) || !sa.getTarget().doesTarget()) {
// TODO - copied from AF_Pump.pumpDrawbackAI() - what should be
// here?
@@ -279,7 +280,7 @@ public class DebuffAi extends SpellAiLogic {
} // pumpMandatoryTarget()
@Override
protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
final List<String> kws = sa.hasParam("Keywords") ? Arrays.asList(sa.getParam("Keywords").split(" & ")) : new ArrayList<String>();
if (sa.getTarget() == null) {

5
src/main/java/forge/card/abilityfactory/ai/DebuffAllAi.java
View File

@@ -12,13 +12,14 @@ import forge.card.abilityfactory.SpellAiLogic;
import forge.card.spellability.SpellAbility;
import forge.game.phase.CombatUtil;
import forge.game.phase.PhaseType;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
import forge.game.zone.ZoneType;
import forge.util.MyRandom;
public class DebuffAllAi extends SpellAiLogic {
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
String valid = "";
final Random r = MyRandom.getRandom();
// final Card source = sa.getSourceCard();
@@ -60,7 +61,7 @@ public class DebuffAllAi extends SpellAiLogic {
} // debuffAllCanPlayAI()
@Override
protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
return true;
}
}

8
src/main/java/forge/card/abilityfactory/ai/DelayedTriggerAi.java
View File

@@ -4,13 +4,13 @@ import forge.card.abilityfactory.AbilityFactory;
import forge.card.abilityfactory.SpellAiLogic;
import forge.card.spellability.AbilitySub;
import forge.card.spellability.SpellAbility;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
public class DelayedTriggerAi extends SpellAiLogic {
private static AbilityFactory tempCreator = new AbilityFactory();
@Override
public boolean chkAIDrawback(SpellAbility sa, Player ai) {
public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
final String svarName = sa.getParam("Execute");
final SpellAbility trigsa = tempCreator.getAbility(sa.getSourceCard().getSVar(svarName), sa.getSourceCard());
trigsa.setActivatingPlayer(ai);
@@ -23,7 +23,7 @@ public class DelayedTriggerAi extends SpellAiLogic {
}
@Override
protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
final String svarName = sa.getParam("Execute");
final SpellAbility trigsa = tempCreator.getAbility(sa.getSourceCard().getSVar(svarName), sa.getSourceCard());
trigsa.setActivatingPlayer(ai);
@@ -36,7 +36,7 @@ public class DelayedTriggerAi extends SpellAiLogic {
}
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
final String svarName = sa.getParam("Execute");
final SpellAbility trigsa = tempCreator.getAbility(sa.getSourceCard().getSVar(svarName), sa.getSourceCard());
trigsa.setActivatingPlayer(ai);

7
src/main/java/forge/card/abilityfactory/ai/DestroyAi.java
View File

@@ -20,6 +20,7 @@ import forge.card.spellability.SpellAbility;
import forge.card.spellability.Target;
import forge.game.ai.ComputerUtil;
import forge.game.ai.ComputerUtilCost;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
import forge.game.zone.ZoneType;
import forge.util.MyRandom;
@@ -30,14 +31,14 @@ public class DestroyAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#chkAIDrawback(java.util.Map, forge.card.spellability.SpellAbility, forge.game.player.Player)
*/
@Override
public boolean chkAIDrawback(SpellAbility sa, Player ai) {
public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
return canPlayAI(ai, sa);
}
/* (non-Javadoc)
* @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(final Player ai, SpellAbility sa) {
protected boolean canPlayAI(final AIPlayer ai, SpellAbility sa) {
// AI needs to be expanded, since this function can be pretty complex
// based on what the expected targets could be
final Random r = MyRandom.getRandom();
@@ -164,7 +165,7 @@ public class DestroyAi extends SpellAiLogic {
}
@Override
protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
final Target tgt = sa.getTarget();
final Card source = sa.getSourceCard();
final boolean noRegen = sa.hasParam("NoRegen");

8
src/main/java/forge/card/abilityfactory/ai/DestroyAllAi.java
View File

@@ -14,7 +14,7 @@ import forge.card.spellability.SpellAbility;
import forge.card.spellability.Target;
import forge.game.ai.ComputerUtilCost;
import forge.game.ai.ComputerUtilMana;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
import forge.game.zone.ZoneType;
import forge.util.MyRandom;
@@ -31,7 +31,7 @@ public class DestroyAllAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#doTriggerAINoCost(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility, boolean)
*/
@Override
protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
final Card source = sa.getSourceCard();
final Target tgt = sa.getTarget();
String valid = "";
@@ -73,13 +73,13 @@ public class DestroyAllAi extends SpellAiLogic {
}
@Override
public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
public boolean chkAIDrawback(SpellAbility sa, AIPlayer aiPlayer) {
//TODO: Check for bad outcome
return true;
}
@Override
protected boolean canPlayAI(final Player ai, SpellAbility sa) {
protected boolean canPlayAI(final AIPlayer ai, SpellAbility sa) {
// AI needs to be expanded, since this function can be pretty complex
// based on what the expected targets could be
final Random r = MyRandom.getRandom();

5
src/main/java/forge/card/abilityfactory/ai/DigAi.java
View File

@@ -8,6 +8,7 @@ import forge.card.abilityfactory.SpellAiLogic;
import forge.card.spellability.SpellAbility;
import forge.card.spellability.Target;
import forge.game.phase.PhaseType;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
import forge.game.zone.ZoneType;
import forge.util.MyRandom;
@@ -18,7 +19,7 @@ public class DigAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
double chance = .4; // 40 percent chance with instant speed stuff
if (AbilityFactory.isSorcerySpeed(sa)) {
chance = .667; // 66.7% chance for sorcery speed (since it will
@@ -60,7 +61,7 @@ public class DigAi extends SpellAiLogic {
}
@Override
protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
final Target tgt = sa.getTarget();
if (sa.getTarget() != null) {

5
src/main/java/forge/card/abilityfactory/ai/DigUntilAi.java
View File

@@ -6,6 +6,7 @@ import forge.card.abilityfactory.AbilityFactory;
import forge.card.abilityfactory.SpellAiLogic;
import forge.card.spellability.SpellAbility;
import forge.card.spellability.Target;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
import forge.game.zone.ZoneType;
import forge.util.MyRandom;
@@ -13,7 +14,7 @@ import forge.util.MyRandom;
public class DigUntilAi extends SpellAiLogic {
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
double chance = .4; // 40 percent chance with instant speed stuff
if (AbilityFactory.isSorcerySpeed(sa)) {
chance = .667; // 66.7% chance for sorcery speed (since it will
@@ -45,7 +46,7 @@ public class DigUntilAi extends SpellAiLogic {
}
@Override
protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
final Target tgt = sa.getTarget();

7
src/main/java/forge/card/abilityfactory/ai/DiscardAi.java
View File

@@ -14,6 +14,7 @@ import forge.game.ai.ComputerUtil;
import forge.game.ai.ComputerUtilCost;
import forge.game.ai.ComputerUtilMana;
import forge.game.phase.PhaseType;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
import forge.game.zone.ZoneType;
import forge.util.MyRandom;
@@ -21,7 +22,7 @@ import forge.util.MyRandom;
public class DiscardAi extends SpellAiLogic {
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
final Target tgt = sa.getTarget();
final Card source = sa.getSourceCard();
final Cost abCost = sa.getPayCosts();
@@ -127,7 +128,7 @@ public class DiscardAi extends SpellAiLogic {
@Override
protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
final Target tgt = sa.getTarget();
if (tgt != null) {
Player opp = ai.getOpponent();
@@ -153,7 +154,7 @@ public class DiscardAi extends SpellAiLogic {
} // discardTrigger()
@Override
public boolean chkAIDrawback(SpellAbility sa, Player ai) {
public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
// Drawback AI improvements
// if parent draws cards, make sure cards in hand + cards drawn > 0
final Target tgt = sa.getTarget();

7
src/main/java/forge/card/abilityfactory/ai/DrainManaAi.java
View File

@@ -8,13 +8,14 @@ import forge.card.abilityfactory.AbilityFactory;
import forge.card.abilityfactory.SpellAiLogic;
import forge.card.spellability.SpellAbility;
import forge.card.spellability.Target;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
import forge.util.MyRandom;
public class DrainManaAi extends SpellAiLogic {
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
// AI cannot use this properly until he can use SAs during Humans turn
final Target tgt = sa.getTarget();
@@ -41,7 +42,7 @@ public class DrainManaAi extends SpellAiLogic {
}
@Override
protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
final Player opp = ai.getOpponent();
final Target tgt = sa.getTarget();
@@ -68,7 +69,7 @@ public class DrainManaAi extends SpellAiLogic {
}
@Override
public boolean chkAIDrawback(SpellAbility sa, Player ai) {
public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
// AI cannot use this properly until he can use SAs during Humans turn
final Target tgt = sa.getTarget();
final Card source = sa.getSourceCard();

6
src/main/java/forge/card/abilityfactory/ai/DrawAi.java
View File

@@ -46,7 +46,7 @@ import forge.util.MyRandom;
public class DrawAi extends SpellAiLogic {
@Override
public boolean chkAIDrawback(SpellAbility sa, Player ai) {
public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
return targetAI(ai, sa, false);
}
@@ -54,7 +54,7 @@ public class DrawAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
final Target tgt = sa.getTarget();
final Card source = sa.getSourceCard();
final Cost abCost = sa.getPayCosts();
@@ -262,7 +262,7 @@ public class DrawAi extends SpellAiLogic {
@Override
protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
return targetAI(ai, sa, mandatory);
}

5
src/main/java/forge/card/abilityfactory/ai/EffectAi.java
View File

@@ -17,13 +17,14 @@ import forge.game.ai.ComputerUtilCombat;
import forge.game.phase.CombatUtil;
import forge.game.phase.PhaseHandler;
import forge.game.phase.PhaseType;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
import forge.game.zone.ZoneType;
import forge.util.MyRandom;
public class EffectAi extends SpellAiLogic {
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
final GameState game = Singletons.getModel().getGame();
final Random r = MyRandom.getRandom();
boolean randomReturn = r.nextFloat() <= .6667;
@@ -121,7 +122,7 @@ public class EffectAi extends SpellAiLogic {
}
@Override
protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
// TODO: Add targeting effects
return true;

8
src/main/java/forge/card/abilityfactory/ai/EndTurnAi.java
View File

@@ -3,7 +3,7 @@ package forge.card.abilityfactory.ai;
import forge.card.abilityfactory.SpellAiLogic;
import forge.card.spellability.SpellAbility;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
/**
* TODO: Write javadoc for this type.
@@ -12,18 +12,18 @@ import forge.game.player.Player;
public class EndTurnAi extends SpellAiLogic {
@Override
protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
return mandatory;
}
@Override
public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) { return false; }
public boolean chkAIDrawback(SpellAbility sa, AIPlayer aiPlayer) { return false; }
/* (non-Javadoc)
* @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
return false;
}
}

6
src/main/java/forge/card/abilityfactory/ai/FightAi.java
View File

@@ -10,7 +10,7 @@ import forge.CardLists;
import forge.card.abilityfactory.SpellAiLogic;
import forge.card.spellability.SpellAbility;
import forge.card.spellability.Target;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
import forge.util.MyRandom;
public class FightAi extends SpellAiLogic {
@@ -19,7 +19,7 @@ public class FightAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
Target tgt = sa.getTarget();
tgt.resetTargets();
@@ -86,7 +86,7 @@ public class FightAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#doTriggerAINoCost(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility, boolean)
*/
@Override
protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
return false;
}

8
src/main/java/forge/card/abilityfactory/ai/FogAi.java
View File

@@ -6,7 +6,7 @@ import forge.card.abilityfactory.SpellAiLogic;
import forge.card.spellability.SpellAbility;
import forge.game.ai.ComputerUtilCombat;
import forge.game.phase.PhaseType;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
public class FogAi extends SpellAiLogic {
@@ -14,7 +14,7 @@ public class FogAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
// AI should only activate this during Human's Declare Blockers phase
if (Singletons.getModel().getGame().getPhaseHandler().isPlayerTurn(sa.getActivatingPlayer())) {
return false;
@@ -38,7 +38,7 @@ public class FogAi extends SpellAiLogic {
}
@Override
public boolean chkAIDrawback(SpellAbility sa, Player ai) {
public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
// AI should only activate this during Human's turn
boolean chance;
@@ -53,7 +53,7 @@ public class FogAi extends SpellAiLogic {
}
@Override
protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
boolean chance;
if (Singletons.getModel().getGame().getPhaseHandler().isPlayerTurn(sa.getActivatingPlayer().getOpponent())) {
chance = Singletons.getModel().getGame().getPhaseHandler().getPhase().isBefore(PhaseType.COMBAT_FIRST_STRIKE_DAMAGE);

5
src/main/java/forge/card/abilityfactory/ai/GameLossAi.java
View File

@@ -3,11 +3,12 @@ package forge.card.abilityfactory.ai;
import forge.card.abilityfactory.SpellAiLogic;
import forge.card.spellability.SpellAbility;
import forge.card.spellability.Target;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
public class GameLossAi extends SpellAiLogic {
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
final Player opp = ai.getOpponent();
if (opp.cantLose()) {
return false;
@@ -28,7 +29,7 @@ public class GameLossAi extends SpellAiLogic {
}
@Override
protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
// Phage the Untouchable
// (Final Fortune would need to attach it's delayed trigger to a

6
src/main/java/forge/card/abilityfactory/ai/GameWinAi.java
View File

@@ -3,14 +3,14 @@ package forge.card.abilityfactory.ai;
import forge.card.abilityfactory.SpellAiLogic;
import forge.card.spellability.SpellAbility;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
public class GameWinAi extends SpellAiLogic {
/* (non-Javadoc)
* @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
if (ai.cantWin()) {
return false;
}
@@ -25,7 +25,7 @@ public class GameWinAi extends SpellAiLogic {
}
@Override
protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
return true;
}

3
src/main/java/forge/card/abilityfactory/ai/LifeExchangeAi.java
View File

@@ -5,6 +5,7 @@ import java.util.Random;
import forge.card.abilityfactory.SpellAiLogic;
import forge.card.spellability.SpellAbility;
import forge.card.spellability.Target;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
import forge.util.MyRandom;
@@ -19,7 +20,7 @@ public class LifeExchangeAi extends SpellAiLogic {
* forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
final Random r = MyRandom.getRandom();
final int myLife = aiPlayer.getLife();
Player opponent = aiPlayer.getOpponent();

6
src/main/java/forge/card/abilityfactory/ai/LifeGainAi.java
View File

@@ -15,7 +15,7 @@ import forge.game.ai.ComputerUtil;
import forge.game.ai.ComputerUtilCost;
import forge.game.ai.ComputerUtilMana;
import forge.game.phase.PhaseType;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
import forge.util.MyRandom;
/**
@@ -29,7 +29,7 @@ public class LifeGainAi extends SpellAiLogic {
* @see forge.card.abilityfactory.AbilityFactoryAlterLife.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
final Random r = MyRandom.getRandom();
final Cost abCost = sa.getPayCosts();
@@ -145,7 +145,7 @@ public class LifeGainAi extends SpellAiLogic {
* @return a boolean.
*/
@Override
protected boolean doTriggerAINoCost(final Player ai, final SpellAbility sa,
protected boolean doTriggerAINoCost(final AIPlayer ai, final SpellAbility sa,
final boolean mandatory) {
// If the Target is gaining life, target self.

7
src/main/java/forge/card/abilityfactory/ai/LifeLoseAi.java
View File

@@ -14,13 +14,14 @@ import forge.game.ai.ComputerUtil;
import forge.game.ai.ComputerUtilCost;
import forge.game.ai.ComputerUtilMana;
import forge.game.phase.PhaseType;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
import forge.util.MyRandom;
public class LifeLoseAi extends SpellAiLogic {
@Override
public boolean chkAIDrawback(SpellAbility sa, Player ai) {
public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
final Target tgt = sa.getTarget();
List<Player> tgtPlayers;
@@ -52,7 +53,7 @@ public class LifeLoseAi extends SpellAiLogic {
* @see forge.card.abilityfactory.AbilityFactoryAlterLife.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
final Random r = MyRandom.getRandom();
final Cost abCost = sa.getPayCosts();
@@ -139,7 +140,7 @@ public class LifeLoseAi extends SpellAiLogic {
}
@Override
protected boolean doTriggerAINoCost(final Player ai, final SpellAbility sa,
protected boolean doTriggerAINoCost(final AIPlayer ai, final SpellAbility sa,
final boolean mandatory) {
final Target tgt = sa.getTarget();
if (tgt != null) {

5
src/main/java/forge/card/abilityfactory/ai/LifeSetAi.java
View File

@@ -11,13 +11,14 @@ import forge.card.spellability.SpellAbility;
import forge.card.spellability.Target;
import forge.game.ai.ComputerUtilMana;
import forge.game.phase.PhaseType;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
import forge.util.MyRandom;
public class LifeSetAi extends SpellAiLogic {
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
final Random r = MyRandom.getRandom();
// Ability_Cost abCost = sa.getPayCosts();
final Card source = sa.getSourceCard();
@@ -102,7 +103,7 @@ public class LifeSetAi extends SpellAiLogic {
}
@Override
protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
final int myLife = ai.getLife();
final Player opponent = ai.getOpponent();
final int hlife = opponent.getLife();

7
src/main/java/forge/card/abilityfactory/ai/MillAi.java
View File

@@ -14,6 +14,7 @@ import forge.game.ai.ComputerUtil;
import forge.game.ai.ComputerUtilCost;
import forge.game.ai.ComputerUtilMana;
import forge.game.phase.PhaseType;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
import forge.game.zone.ZoneType;
import forge.util.MyRandom;
@@ -21,7 +22,7 @@ import forge.util.MyRandom;
public class MillAi extends SpellAiLogic {
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
final Card source = sa.getSourceCard();
final Cost abCost = sa.getPayCosts();
@@ -136,13 +137,13 @@ public class MillAi extends SpellAiLogic {
}
@Override
public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
public boolean chkAIDrawback(SpellAbility sa, AIPlayer aiPlayer) {
return targetAI(aiPlayer, sa, true);
}
@Override
protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
if (!targetAI(aiPlayer, sa, mandatory)) {
return false;
}

8
src/main/java/forge/card/abilityfactory/ai/MustAttackAi.java
View File

@@ -3,18 +3,18 @@ package forge.card.abilityfactory.ai;
import forge.card.abilityfactory.SpellAiLogic;
import forge.card.spellability.SpellAbility;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
public class MustAttackAi extends SpellAiLogic {
@Override
protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
// disabled for the AI for now. Only for Gideon Jura at this time.
return false;
}
@Override
public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
public boolean chkAIDrawback(SpellAbility sa, AIPlayer aiPlayer) {
// AI should only activate this during Human's turn
// TODO - implement AI
return false;
@@ -24,7 +24,7 @@ public class MustAttackAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#doTriggerAINoCost(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility, boolean)
*/
@Override
protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
boolean chance;

8
src/main/java/forge/card/abilityfactory/ai/MustBlockAi.java
View File

@@ -16,25 +16,25 @@ import forge.card.spellability.Target;
import forge.game.ai.ComputerUtilCombat;
import forge.game.phase.CombatUtil;
import forge.game.phase.PhaseType;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
import forge.game.zone.ZoneType;
public class MustBlockAi extends SpellAiLogic {
@Override
protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
// disabled for the AI until he/she can make decisions about who to make
// block
return false;
}
@Override
public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
public boolean chkAIDrawback(SpellAbility sa, AIPlayer aiPlayer) {
return false;
}
@Override
protected boolean doTriggerAINoCost(final Player ai, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(final AIPlayer ai, SpellAbility sa, boolean mandatory) {
final Card source = sa.getSourceCard();
final Target abTgt = sa.getTarget();

4
src/main/java/forge/card/abilityfactory/ai/PeekAndRevealAi.java
View File

@@ -2,7 +2,7 @@ package forge.card.abilityfactory.ai;
import forge.card.abilityfactory.SpellAiLogic;
import forge.card.spellability.SpellAbility;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
/**
* TODO: Write javadoc for this type.
@@ -14,7 +14,7 @@ public class PeekAndRevealAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
// So far this only appears on Triggers, but will expand
// once things get converted from Dig + NoMove
return false;

4
src/main/java/forge/card/abilityfactory/ai/PermanentCreatureAi.java
View File

@@ -13,7 +13,7 @@ import forge.card.spellability.SpellAbility;
import forge.game.GameState;
import forge.game.ai.ComputerUtil;
import forge.game.phase.PhaseType;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
import forge.game.zone.ZoneType;
/**
@@ -26,7 +26,7 @@ public class PermanentCreatureAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
String logic = sa.getParam("AILogic");
GameState game = Singletons.getModel().getGame();

4
src/main/java/forge/card/abilityfactory/ai/PermanentNoncreatureAi.java
View File

@@ -6,7 +6,7 @@ import forge.card.spellability.SpellAbility;
import forge.game.GameState;
import forge.game.ai.ComputerUtil;
import forge.game.phase.PhaseType;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
/**
* AbilityFactory for Creature Spells.
@@ -18,7 +18,7 @@ public class PermanentNoncreatureAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
String logic = sa.getParam("AILogic");
GameState game = Singletons.getModel().getGame();

8
src/main/java/forge/card/abilityfactory/ai/PhasesAi.java
View File

@@ -10,7 +10,7 @@ import forge.card.abilityfactory.AbilityFactory;
import forge.card.abilityfactory.SpellAiLogic;
import forge.card.spellability.SpellAbility;
import forge.card.spellability.Target;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
import forge.game.zone.ZoneType;
import forge.util.MyRandom;
@@ -20,7 +20,7 @@ public class PhasesAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
// This still needs to be fleshed out
final Target tgt = sa.getTarget();
final Card source = sa.getSourceCard();
@@ -50,7 +50,7 @@ public class PhasesAi extends SpellAiLogic {
}
@Override
protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
final Target tgt = sa.getTarget();
if (tgt == null) {
@@ -68,7 +68,7 @@ public class PhasesAi extends SpellAiLogic {
}
@Override
public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
public boolean chkAIDrawback(SpellAbility sa, AIPlayer aiPlayer) {
final Target tgt = sa.getTarget();
boolean randomReturn = true;

4
src/main/java/forge/card/abilityfactory/ai/PlayAi.java
View File

@@ -14,14 +14,14 @@ import forge.card.cost.Cost;
import forge.card.spellability.SpellAbility;
import forge.card.spellability.Target;
import forge.game.ai.ComputerUtilCost;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
import forge.game.zone.ZoneType;
import forge.util.MyRandom;
public class PlayAi extends SpellAiLogic {
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
final Cost abCost = sa.getPayCosts();
final Card source = sa.getSourceCard();

5
src/main/java/forge/card/abilityfactory/ai/PoisonAi.java
View File

@@ -12,6 +12,7 @@ import forge.card.spellability.Target;
import forge.game.ai.ComputerUtil;
import forge.game.ai.ComputerUtilCost;
import forge.game.phase.PhaseType;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
public class PoisonAi extends SpellAiLogic {
@@ -25,7 +26,7 @@ public class PoisonAi extends SpellAiLogic {
* forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
final Cost abCost = sa.getPayCosts();
final Card source = sa.getSourceCard();
// int humanPoison = AllZone.getHumanPlayer().getPoisonCounters();
@@ -71,7 +72,7 @@ public class PoisonAi extends SpellAiLogic {
}
@Override
protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
final Target tgt = sa.getTarget();
if (tgt != null) {

7
src/main/java/forge/card/abilityfactory/ai/ProtectAi.java
View File

@@ -19,6 +19,7 @@ import forge.game.GameState;
import forge.game.ai.ComputerUtilCombat;
import forge.game.ai.ComputerUtilCost;
import forge.game.phase.PhaseType;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
import forge.game.zone.ZoneType;
@@ -110,7 +111,7 @@ public class ProtectAi extends SpellAiLogic {
} // getProtectCreatures()
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
final Card hostCard = sa.getSourceCard();
// if there is no target and host card isn't in play, don't activate
if ((sa.getTarget() == null) && !hostCard.isInPlay()) {
@@ -342,7 +343,7 @@ public class ProtectAi extends SpellAiLogic {
} // protectMandatoryTarget()
@Override
protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
if (sa.getTarget() == null) {
if (mandatory) {
return true;
@@ -355,7 +356,7 @@ public class ProtectAi extends SpellAiLogic {
} // protectTriggerAI
@Override
public boolean chkAIDrawback(SpellAbility sa, Player ai) {
public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
final Card host = sa.getSourceCard();
if ((sa.getTarget() == null) || !sa.getTarget().doesTarget()) {
if (host.isCreature()) {

6
src/main/java/forge/card/abilityfactory/ai/ProtectAllAi.java
View File

@@ -6,12 +6,12 @@ import forge.card.abilityfactory.SpellAiLogic;
import forge.card.cost.Cost;
import forge.card.spellability.SpellAbility;
import forge.game.ai.ComputerUtilCost;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
public class ProtectAllAi extends SpellAiLogic {
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
final Card hostCard = sa.getSourceCard();
// if there is no target and host card isn't in play, don't activate
if ((sa.getTarget() == null) && !hostCard.isInPlay()) {
@@ -42,7 +42,7 @@ public class ProtectAllAi extends SpellAiLogic {
@Override
protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
return true;
}
}

7
src/main/java/forge/card/abilityfactory/ai/PumpAi.java
View File

@@ -21,6 +21,7 @@ import forge.game.ai.ComputerUtilCost;
import forge.game.ai.ComputerUtilMana;
import forge.game.phase.PhaseHandler;
import forge.game.phase.PhaseType;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
import forge.game.zone.ZoneType;
@@ -30,7 +31,7 @@ public class PumpAi extends PumpAiBase {
* @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
final Cost cost = sa.getPayCosts();
final PhaseHandler ph = Singletons.getModel().getGame().getPhaseHandler();
final List<String> keywords = sa.hasParam("KW") ? Arrays.asList(sa.getParam("KW").split(" & ")) : new ArrayList<String>();
@@ -337,7 +338,7 @@ public class PumpAi extends PumpAiBase {
} // pumpMandatoryTarget()
@Override
protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
final Card source = sa.getSourceCard();
final String numDefense = sa.hasParam("NumDef") ? sa.getParam("NumDef") : "";
final String numAttack = sa.hasParam("NumAtt") ? sa.getParam("NumAtt") : "";
@@ -380,7 +381,7 @@ public class PumpAi extends PumpAiBase {
} // pumpTriggerAI
@Override
public boolean chkAIDrawback(SpellAbility sa, Player ai) {
public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
final Card source = sa.getSourceCard();

7
src/main/java/forge/card/abilityfactory/ai/PumpAllAi.java
View File

@@ -17,6 +17,7 @@ import forge.game.ai.ComputerUtilCombat;
import forge.game.ai.ComputerUtil;
import forge.game.phase.CombatUtil;
import forge.game.phase.PhaseType;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
import forge.game.zone.ZoneType;
@@ -26,7 +27,7 @@ public class PumpAllAi extends PumpAiBase {
* @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(final Player ai, final SpellAbility sa) {
protected boolean canPlayAI(final AIPlayer ai, final SpellAbility sa) {
String valid = "";
final Card source = sa.getSourceCard();
@@ -141,7 +142,7 @@ public class PumpAllAi extends PumpAiBase {
} // pumpAllCanPlayAI()
@Override
public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
public boolean chkAIDrawback(SpellAbility sa, AIPlayer aiPlayer) {
return true;
}
@@ -149,7 +150,7 @@ public class PumpAllAi extends PumpAiBase {
* @see forge.card.abilityfactory.SpellAiLogic#doTriggerAINoCost(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility, boolean)
*/
@Override
protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
return true;
}

5
src/main/java/forge/card/abilityfactory/ai/RearrangeTopOfLibraryAi.java
View File

@@ -4,6 +4,7 @@ package forge.card.abilityfactory.ai;
import forge.card.abilityfactory.SpellAiLogic;
import forge.card.spellability.SpellAbility;
import forge.card.spellability.Target;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
public class RearrangeTopOfLibraryAi extends SpellAiLogic {
@@ -11,7 +12,7 @@ public class RearrangeTopOfLibraryAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
return false;
}
@@ -19,7 +20,7 @@ public class RearrangeTopOfLibraryAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#doTriggerAINoCost(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility, boolean)
*/
@Override
protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
final Target tgt = sa.getTarget();

5
src/main/java/forge/card/abilityfactory/ai/RegenerateAi.java
View File

@@ -34,6 +34,7 @@ import forge.card.spellability.Target;
import forge.game.ai.ComputerUtilCombat;
import forge.game.ai.ComputerUtilCost;
import forge.game.phase.PhaseType;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
import forge.game.zone.ZoneType;
@@ -56,7 +57,7 @@ public class RegenerateAi extends SpellAiLogic {
// **************************************************************
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
final Card hostCard = sa.getSourceCard();
boolean chance = false;
final Cost abCost = sa.getPayCosts();
@@ -153,7 +154,7 @@ public class RegenerateAi extends SpellAiLogic {
} // regenerateCanPlayAI
@Override
protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
boolean chance = false;
final Target tgt = sa.getTarget();

6
src/main/java/forge/card/abilityfactory/ai/RegenerateAllAi.java
View File

@@ -14,13 +14,13 @@ import forge.card.spellability.SpellAbility;
import forge.game.ai.ComputerUtilCombat;
import forge.game.ai.ComputerUtilCost;
import forge.game.phase.PhaseType;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
import forge.game.zone.ZoneType;
public class RegenerateAllAi extends SpellAiLogic {
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
final Card hostCard = sa.getSourceCard();
boolean chance = false;
final Cost abCost = sa.getPayCosts();
@@ -83,7 +83,7 @@ public class RegenerateAllAi extends SpellAiLogic {
}
@Override
protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
boolean chance = true;
return chance;

8
src/main/java/forge/card/abilityfactory/ai/RemoveFromCombatAi.java
View File

@@ -3,18 +3,18 @@ package forge.card.abilityfactory.ai;
import forge.card.abilityfactory.SpellAiLogic;
import forge.card.spellability.SpellAbility;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
public class RemoveFromCombatAi extends SpellAiLogic {
@Override
protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
// disabled for the AI for now. Only for Gideon Jura at this time.
return false;
}
@Override
public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
public boolean chkAIDrawback(SpellAbility sa, AIPlayer aiPlayer) {
// AI should only activate this during Human's turn
// TODO - implement AI
@@ -25,7 +25,7 @@ public class RemoveFromCombatAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#doTriggerAINoCost(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility, boolean)
*/
@Override
protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
boolean chance;
// TODO - implement AI

3
src/main/java/forge/card/abilityfactory/ai/RepeatAi.java
View File

@@ -4,12 +4,13 @@ package forge.card.abilityfactory.ai;
import forge.card.abilityfactory.SpellAiLogic;
import forge.card.spellability.SpellAbility;
import forge.card.spellability.Target;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
public class RepeatAi extends SpellAiLogic {
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
final Target tgt = sa.getTarget();
final Player opp = ai.getOpponent();
if (tgt != null) {

3
src/main/java/forge/card/abilityfactory/ai/RepeatEachAi.java
View File

@@ -12,6 +12,7 @@ import forge.CardPredicates.Presets;
import forge.card.abilityfactory.SpellAiLogic;
import forge.card.spellability.SpellAbility;
import forge.card.spellability.Target;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
import forge.game.zone.ZoneType;
@@ -25,7 +26,7 @@ public class RepeatEachAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
String logic = sa.getParam("AILogic");
if ("CloneMyTokens".equals(logic)) {

6
src/main/java/forge/card/abilityfactory/ai/RestartGameAi.java
View File

@@ -2,7 +2,7 @@ package forge.card.abilityfactory.ai;
import forge.card.abilityfactory.SpellAiLogic;
import forge.card.spellability.SpellAbility;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
public class RestartGameAi extends SpellAiLogic {
@@ -15,7 +15,7 @@ public class RestartGameAi extends SpellAiLogic {
* forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
// The only card that uses this is Karn Liberated
// TODO Add Logic, check if AI is losing game state, or life
@@ -26,7 +26,7 @@ public class RestartGameAi extends SpellAiLogic {
}
@Override
protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
// This trigger AI is completely unused, but return true just in case
return true;
}

6
src/main/java/forge/card/abilityfactory/ai/RevealAi.java
View File

@@ -7,12 +7,12 @@ import forge.card.abilityfactory.AbilityFactory;
import forge.card.cost.Cost;
import forge.card.spellability.SpellAbility;
import forge.game.ai.ComputerUtilCost;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
import forge.util.MyRandom;
public class RevealAi extends RevealAiBase {
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
// AI cannot use this properly until he can use SAs during Humans turn
final Cost abCost = sa.getPayCosts();
final Card source = sa.getSourceCard();
@@ -54,7 +54,7 @@ public class RevealAi extends RevealAiBase {
}
@Override
protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
if (!revealHandTargetAI(ai, sa/*, false, mandatory*/)) {
return false;

3
src/main/java/forge/card/abilityfactory/ai/RevealAiBase.java
View File

@@ -4,6 +4,7 @@ package forge.card.abilityfactory.ai;
import forge.card.abilityfactory.SpellAiLogic;
import forge.card.spellability.SpellAbility;
import forge.card.spellability.Target;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
import forge.game.zone.ZoneType;
@@ -37,7 +38,7 @@ public abstract class RevealAiBase extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#chkAIDrawback(java.util.Map, forge.card.spellability.SpellAbility, forge.game.player.Player)
*/
@Override
public boolean chkAIDrawback(SpellAbility sa, Player ai) {
public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
revealHandTargetAI(ai, sa);
return true;
}

6
src/main/java/forge/card/abilityfactory/ai/RevealHandAi.java
View File

@@ -7,7 +7,7 @@ import forge.card.abilityfactory.AbilityFactory;
import forge.card.cost.Cost;
import forge.card.spellability.SpellAbility;
import forge.game.ai.ComputerUtilCost;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
import forge.util.MyRandom;
public class RevealHandAi extends RevealAiBase {
@@ -16,7 +16,7 @@ public class RevealHandAi extends RevealAiBase {
* @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
// AI cannot use this properly until he can use SAs during Humans turn
final Cost abCost = sa.getPayCosts();
final Card source = sa.getSourceCard();
@@ -58,7 +58,7 @@ public class RevealHandAi extends RevealAiBase {
}
@Override
protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
if (!revealHandTargetAI(ai, sa/*, false, mandatory*/)) {
return false;

7
src/main/java/forge/card/abilityfactory/ai/SacrificeAi.java
View File

@@ -9,6 +9,7 @@ import forge.card.cardfactory.CardFactoryUtil;
import forge.card.spellability.SpellAbility;
import forge.card.spellability.Target;
import forge.game.ai.ComputerUtilMana;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
import forge.game.zone.ZoneType;
@@ -18,7 +19,7 @@ public class SacrificeAi extends SpellAiLogic {
// **************************************************************
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
boolean chance = sacrificeTgtAI(ai, sa);
// Some additional checks based on what is being sacrificed, and who is
@@ -58,14 +59,14 @@ public class SacrificeAi extends SpellAiLogic {
}
@Override
public boolean chkAIDrawback(SpellAbility sa, Player ai) {
public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
// AI should only activate this during Human's turn
return sacrificeTgtAI(ai, sa);
}
@Override
protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
// AI should only activate this during Human's turn
boolean chance = sacrificeTgtAI(ai, sa);

6
src/main/java/forge/card/abilityfactory/ai/SacrificeAllAi.java
View File

@@ -11,14 +11,14 @@ import forge.card.cost.Cost;
import forge.card.spellability.SpellAbility;
import forge.game.ai.ComputerUtilCost;
import forge.game.ai.ComputerUtilMana;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
import forge.game.zone.ZoneType;
import forge.util.MyRandom;
public class SacrificeAllAi extends SpellAiLogic {
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
// AI needs to be expanded, since this function can be pretty complex
// based on what the expected targets could be
final Random r = MyRandom.getRandom();
@@ -76,7 +76,7 @@ public class SacrificeAllAi extends SpellAiLogic {
}
@Override
public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
public boolean chkAIDrawback(SpellAbility sa, AIPlayer aiPlayer) {
//TODO: Add checks for bad outcome
return true;
}

8
src/main/java/forge/card/abilityfactory/ai/ScryAi.java
View File

@@ -6,7 +6,7 @@ import forge.card.abilityfactory.AbilityFactory;
import forge.card.abilityfactory.SpellAiLogic;
import forge.card.spellability.SpellAbility;
import forge.card.spellability.Target;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
import forge.util.MyRandom;
public class ScryAi extends SpellAiLogic {
@@ -15,7 +15,7 @@ public class ScryAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#doTriggerAINoCost(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility, boolean)
*/
@Override
protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
final Target tgt = sa.getTarget();
if (tgt != null) { // It doesn't appear that Scry ever targets
@@ -29,13 +29,13 @@ public class ScryAi extends SpellAiLogic {
} // scryTargetAI()
@Override
public boolean chkAIDrawback(SpellAbility sa, Player ai) {
public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
return doTriggerAINoCost(ai, sa, false);
}
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
// Card source = sa.getSourceCard();
double chance = .4; // 40 percent chance of milling with instant speed

8
src/main/java/forge/card/abilityfactory/ai/SetStateAi.java
View File

@@ -3,16 +3,16 @@ package forge.card.abilityfactory.ai;
import forge.card.abilityfactory.SpellAiLogic;
import forge.card.spellability.SpellAbility;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
public class SetStateAi extends SpellAiLogic {
@Override
protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
return false;
}
@Override
public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
public boolean chkAIDrawback(SpellAbility sa, AIPlayer aiPlayer) {
// Gross generalization, but this always considers alternate
// states more powerful
return !sa.getSourceCard().isInAlternateState();
@@ -23,7 +23,7 @@ public class SetStateAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#doTriggerAINoCost(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility, boolean)
*/
@Override
protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
return true;
}
}

8
src/main/java/forge/card/abilityfactory/ai/SetStateAllAi.java
View File

@@ -3,14 +3,14 @@ package forge.card.abilityfactory.ai;
import forge.card.abilityfactory.SpellAiLogic;
import forge.card.spellability.SpellAbility;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
public class SetStateAllAi extends SpellAiLogic {
/* (non-Javadoc)
* @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
return true;
}
@@ -18,7 +18,7 @@ public class SetStateAllAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#chkAIDrawback(java.util.Map, forge.card.spellability.SpellAbility, forge.game.player.Player)
*/
@Override
public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
public boolean chkAIDrawback(SpellAbility sa, AIPlayer aiPlayer) {
// Gross generalization, but this always considers alternate
// states more powerful
if (sa.getSourceCard().isInAlternateState()) {
@@ -32,7 +32,7 @@ public class SetStateAllAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#doTriggerAINoCost(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility, boolean)
*/
@Override
protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
return true;
}

8
src/main/java/forge/card/abilityfactory/ai/ShuffleAi.java
View File

@@ -2,11 +2,11 @@ package forge.card.abilityfactory.ai;
import forge.card.abilityfactory.SpellAiLogic;
import forge.card.spellability.SpellAbility;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
public class ShuffleAi extends SpellAiLogic {
@Override
protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
// not really sure when the compy would use this; maybe only after a
// human
// deliberately put a card on top of their library
@@ -27,7 +27,7 @@ public class ShuffleAi extends SpellAiLogic {
}
@Override
public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
public boolean chkAIDrawback(SpellAbility sa, AIPlayer aiPlayer) {
return shuffleTargetAI(/*sa, false, false*/);
}
@@ -40,7 +40,7 @@ public class ShuffleAi extends SpellAiLogic {
} // shuffleTargetAI()
@Override
protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
if (!shuffleTargetAI(/*sa, false, mandatory*/)) {
return false;
}

6
src/main/java/forge/card/abilityfactory/ai/StoreSVarAi.java
View File

@@ -6,12 +6,12 @@ import forge.card.abilityfactory.SpellAiLogic;
import forge.card.spellability.SpellAbility;
import forge.game.ai.ComputerUtilCombat;
import forge.game.ai.ComputerUtil;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
public class StoreSVarAi extends SpellAiLogic {
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
//Tree of Redemption
final Card source = sa.getSourceCard();
@@ -24,7 +24,7 @@ public class StoreSVarAi extends SpellAiLogic {
}
@Override
protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
return true;
}

7
src/main/java/forge/card/abilityfactory/ai/TapAi.java
View File

@@ -10,12 +10,13 @@ import forge.card.spellability.SpellAbility;
import forge.card.spellability.Target;
import forge.game.phase.PhaseHandler;
import forge.game.phase.PhaseType;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
import forge.util.MyRandom;
public class TapAi extends TapAiBase {
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
final Target tgt = sa.getTarget();
final Card source = sa.getSourceCard();
@@ -58,7 +59,7 @@ public class TapAi extends TapAiBase {
}
@Override
protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
final Target tgt = sa.getTarget();
final Card source = sa.getSourceCard();
@@ -84,7 +85,7 @@ public class TapAi extends TapAiBase {
}
@Override
public boolean chkAIDrawback(SpellAbility sa, Player ai) {
public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
final Target tgt = sa.getTarget();
final Card source = sa.getSourceCard();

5
src/main/java/forge/card/abilityfactory/ai/TapAllAi.java
View File

@@ -13,6 +13,7 @@ import forge.card.abilityfactory.SpellAiLogic;
import forge.card.spellability.SpellAbility;
import forge.card.spellability.Target;
import forge.game.phase.PhaseType;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
import forge.game.zone.ZoneType;
import forge.util.MyRandom;
@@ -23,7 +24,7 @@ public class TapAllAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(final Player ai, SpellAbility sa) {
protected boolean canPlayAI(final AIPlayer ai, SpellAbility sa) {
// If tapping all creatures do it either during declare attackers of AIs
// turn
// or during upkeep/begin combat?
@@ -98,7 +99,7 @@ public class TapAllAi extends SpellAiLogic {
}
@Override
protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
final Card source = sa.getSourceCard();
String valid = "";

8
src/main/java/forge/card/abilityfactory/ai/TapOrUntapAi.java
View File

@@ -7,7 +7,7 @@ import forge.Card;
import forge.card.abilityfactory.AbilityFactory;
import forge.card.spellability.SpellAbility;
import forge.card.spellability.Target;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
import forge.util.MyRandom;
public class TapOrUntapAi extends TapAiBase {
@@ -16,7 +16,7 @@ public class TapOrUntapAi extends TapAiBase {
* @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
final Target tgt = sa.getTarget();
final Card source = sa.getSourceCard();
@@ -48,7 +48,7 @@ public class TapOrUntapAi extends TapAiBase {
}
@Override
protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
final Target tgt = sa.getTarget();
final Card source = sa.getSourceCard();
@@ -73,7 +73,7 @@ public class TapOrUntapAi extends TapAiBase {
}
@Override
public boolean chkAIDrawback(SpellAbility sa, Player ai) {
public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
final Target tgt = sa.getTarget();
final Card source = sa.getSourceCard();

4
src/main/java/forge/card/abilityfactory/ai/TapOrUntapAllAi.java
View File

@@ -2,7 +2,7 @@ package forge.card.abilityfactory.ai;
import forge.card.abilityfactory.SpellAiLogic;
import forge.card.spellability.SpellAbility;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
/**
* TODO: Write javadoc for this type.
@@ -14,7 +14,7 @@ public class TapOrUntapAllAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
// Only Turnabout currently uses this, it's hardcoded to always return false
// Looks like Faces of the Past could also use this
return false;

5
src/main/java/forge/card/abilityfactory/ai/TokenAi.java
View File

@@ -14,6 +14,7 @@ import forge.game.ai.ComputerUtilCost;
import forge.game.ai.ComputerUtilMana;
import forge.game.phase.PhaseHandler;
import forge.game.phase.PhaseType;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
import forge.game.zone.ZoneType;
import forge.util.MyRandom;
@@ -64,7 +65,7 @@ public class TokenAi extends SpellAiLogic {
}
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
final Cost cost = sa.getPayCosts();
readParameters(sa);
@@ -173,7 +174,7 @@ public class TokenAi extends SpellAiLogic {
}
@Override
protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
readParameters(sa);
final Card source = sa.getSourceCard();
final Target tgt = sa.getTarget();

5
src/main/java/forge/card/abilityfactory/ai/TwoPilesAi.java
View File

@@ -9,6 +9,7 @@ import forge.card.abilityfactory.AbilityFactory;
import forge.card.abilityfactory.SpellAiLogic;
import forge.card.spellability.SpellAbility;
import forge.card.spellability.Target;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
import forge.game.zone.ZoneType;
@@ -18,7 +19,7 @@ public class TwoPilesAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
final Card card = sa.getSourceCard();
ZoneType zone = null;
@@ -61,7 +62,7 @@ public class TwoPilesAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#doTriggerAINoCost(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility, boolean)
*/
@Override
protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
return false;
}
}

7
src/main/java/forge/card/abilityfactory/ai/UnattachAllAi.java
View File

@@ -13,6 +13,7 @@ import forge.card.spellability.SpellAbility;
import forge.card.spellability.Target;
import forge.game.ai.ComputerUtilMana;
import forge.game.phase.PhaseType;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
import forge.util.MyRandom;
@@ -22,7 +23,7 @@ public class UnattachAllAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
final Random r = MyRandom.getRandom();
final Cost abCost = sa.getPayCosts();
final Card source = sa.getSourceCard();
@@ -63,7 +64,7 @@ public class UnattachAllAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#doTriggerAINoCost(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility, boolean)
*/
@Override
protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
final Card card = sa.getSourceCard();
final Player opp = ai.getOpponent();
// Check if there are any valid targets
@@ -93,7 +94,7 @@ public class UnattachAllAi extends SpellAiLogic {
}
@Override
public boolean chkAIDrawback(SpellAbility sa, Player ai) {
public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
// AI should only activate this during Human's turn
return canPlayAI(ai, sa);
}

7
src/main/java/forge/card/abilityfactory/ai/UntapAi.java
View File

@@ -14,6 +14,7 @@ import forge.card.cost.Cost;
import forge.card.spellability.SpellAbility;
import forge.card.spellability.Target;
import forge.game.ai.ComputerUtilCost;
import forge.game.player.AIPlayer;
import forge.game.player.Player;
import forge.game.zone.ZoneType;
import forge.util.MyRandom;
@@ -24,7 +25,7 @@ public class UntapAi extends SpellAiLogic {
* @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
*/
@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer ai, SpellAbility sa) {
final Target tgt = sa.getTarget();
final Card source = sa.getSourceCard();
final Cost cost = sa.getPayCosts();
@@ -51,7 +52,7 @@ public class UntapAi extends SpellAiLogic {
}
@Override
protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer ai, SpellAbility sa, boolean mandatory) {
final Target tgt = sa.getTarget();
if (tgt == null) {
@@ -79,7 +80,7 @@ public class UntapAi extends SpellAiLogic {
}
@Override
public boolean chkAIDrawback(SpellAbility sa, Player ai) {
public boolean chkAIDrawback(SpellAbility sa, AIPlayer ai) {
final Target tgt = sa.getTarget();
boolean randomReturn = true;

6
src/main/java/forge/card/abilityfactory/ai/UntapAllAi.java
View File

@@ -3,12 +3,12 @@ package forge.card.abilityfactory.ai;
import forge.card.abilityfactory.SpellAiLogic;
import forge.card.spellability.AbilitySub;
import forge.card.spellability.SpellAbility;
import forge.game.player.Player;
import forge.game.player.AIPlayer;
public class UntapAllAi extends SpellAiLogic {
@Override
protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
protected boolean canPlayAI(AIPlayer aiPlayer, SpellAbility sa) {
// check SubAbilities DoTrigger?
final AbilitySub abSub = sa.getSubAbility();
if (abSub != null) {
@@ -18,7 +18,7 @@ public class UntapAllAi extends SpellAiLogic {
}
@Override
protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
protected boolean doTriggerAINoCost(AIPlayer aiPlayer, SpellAbility sa, boolean mandatory) {
return mandatory;
}