@Override
protected boolean canPlayAI(Player ai, SpellAbility sa) {
final String svarName = sa.getParam("Execute");
final SpellAbility trigsa = AbilityFactory.getAbility(sa.getSVar(svarName), sa.getHostCard());
trigsa.setActivatingPlayer(ai);
return AiPlayDecision.WillPlay
== ((PlayerControllerAi) ai.getController()).getAi().canPlaySa(trigsa);
}
@Override
public void resolve(SpellAbility sa) {
final Card host = sa.getHostCard();
final String[] choices = sa.getParam("Choices").split(",");
final List<SpellAbility> abilities = new ArrayList<SpellAbility>();
for (String s : choices) {
abilities.add(AbilityFactory.getAbility(host.getSVar(s), host));
}
final List<Player> tgtPlayers = getDefinedPlayersOrTargeted(sa);
final TargetRestrictions tgt = sa.getTargetRestrictions();
for (final Player p : tgtPlayers) {
if (tgt != null && !p.canBeTargetedBy(sa)) {
continue;
}
int idxChosen = 0;
String chosenName;
if (sa.hasParam("AtRandom")) {
idxChosen = MyRandom.getRandom().nextInt(choices.length);
chosenName = choices[idxChosen];
} else {
SpellAbility saChosen =
p.getController().chooseSingleSpellForEffect(abilities, sa, "Choose one");
idxChosen = abilities.indexOf(saChosen);
chosenName = choices[idxChosen];
}
SpellAbility chosenSA = AbilityFactory.getAbility(host.getSVar(chosenName), host);
if (sa.hasParam("ShowChoice")) {
p.getGame()
.getAction()
.nofityOfValue(sa, p, abilities.get(idxChosen).getDescription(), null);
}
chosenSA.setActivatingPlayer(sa.getActivatingPlayer());
((AbilitySub) chosenSA).setParent(sa);
AbilityUtils.resolve(chosenSA);
}
}
@Override
protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
final String svarName = sa.getParam("Execute");
final SpellAbility trigsa =
AbilityFactory.getAbility(sa.getHostCard().getSVar(svarName), sa.getHostCard());
AiController aic = ((PlayerControllerAi) ai.getController()).getAi();
trigsa.setActivatingPlayer(ai);
if (!sa.hasParam("OptionalDecider")) {
return aic.doTrigger(trigsa, true);
} else {
return aic.doTrigger(trigsa, !sa.getParam("OptionalDecider").equals("You"));
}
}
@Override
public boolean chkAIDrawback(SpellAbility sa, Player ai) {
if ("Always".equals(sa.getParam("AILogic"))) {
// TODO: improve ai
return true;
}
final String svarName = sa.getParam("Execute");
final SpellAbility trigsa =
AbilityFactory.getAbility(sa.getHostCard().getSVar(svarName), sa.getHostCard());
trigsa.setActivatingPlayer(ai);
if (trigsa instanceof AbilitySub) {
return SpellApiToAi.Converter.get(((AbilitySub) trigsa).getApi())
.chkDrawbackWithSubs(ai, (AbilitySub) trigsa);
} else {
return AiPlayDecision.WillPlay
== ((PlayerControllerAi) ai.getController()).getAi().canPlaySa(trigsa);
}
}
private static void registerDelayedTrigger(
final SpellAbility sa, final String location, final List<Card> crds) {
String delTrig =
"Mode$ Phase | Phase$ End Of Turn | TriggerDescription$ "
+ location
+ " "
+ crds
+ " at the beginning of the next end step.";
final Trigger trig = TriggerHandler.parseTrigger(delTrig, sa.getHostCard(), true);
for (final Card c : crds) {
trig.addRemembered(c);
}
String trigSA = "";
if (location.equals("Sacrifice")) {
trigSA = "DB$ SacrificeAll | Defined$ DelayTriggerRemembered | Controller$ You";
} else if (location.equals("Exile")) {
trigSA =
"DB$ ChangeZone | Defined$ DelayTriggerRemembered | Origin$ Battlefield | Destination$ Exile";
}
trig.setOverridingAbility(AbilityFactory.getAbility(trigSA, sa.getHostCard()));
sa.getActivatingPlayer().getGame().getTriggerHandler().registerDelayedTrigger(trig);
}
private boolean pumpTgtAI(
final Player ai,
final SpellAbility sa,
final int defense,
final int attack,
final boolean mandatory) {
final List<String> keywords =
sa.hasParam("KW") ? Arrays.asList(sa.getParam("KW").split(" & ")) : new ArrayList<String>();
final Game game = ai.getGame();
final Card source = sa.getHostCard();
if (!mandatory
&& !sa.isTrigger()
&& game.getPhaseHandler().getPhase().isAfter(PhaseType.COMBAT_DECLARE_BLOCKERS)
&& !(sa.isCurse() && defense < 0)
&& !this.containsNonCombatKeyword(keywords)
&& !sa.hasParam("UntilYourNextTurn")) {
return false;
}
final Player opp = ai.getOpponent();
final TargetRestrictions tgt = sa.getTargetRestrictions();
sa.resetTargets();
if (sa.hasParam("TargetingPlayer") && sa.getActivatingPlayer().equals(ai) && !sa.isTrigger()) {
Player targetingPlayer =
AbilityUtils.getDefinedPlayers(source, sa.getParam("TargetingPlayer"), sa).get(0);
sa.setTargetingPlayer(targetingPlayer);
return targetingPlayer.getController().chooseTargetsFor(sa);
}
List<Card> list = new ArrayList<Card>();
if (sa.hasParam("AILogic")) {
if (sa.getParam("AILogic").equals("HighestPower")) {
list =
CardLists.getValidCards(
CardLists.filter(game.getCardsIn(ZoneType.Battlefield), Presets.CREATURES),
tgt.getValidTgts(),
ai,
source);
list = CardLists.getTargetableCards(list, sa);
CardLists.sortByPowerDesc(list);
if (!list.isEmpty()) {
sa.getTargets().add(list.get(0));
return true;
} else {
return false;
}
}
if (sa.getParam("AILogic").equals("Fight") || sa.getParam("AILogic").equals("PowerDmg")) {
final AbilitySub tgtFight = sa.getSubAbility();
List<Card> aiCreatures = ai.getCreaturesInPlay();
aiCreatures = CardLists.getTargetableCards(aiCreatures, sa);
aiCreatures = ComputerUtil.getSafeTargets(ai, sa, aiCreatures);
ComputerUtilCard.sortByEvaluateCreature(aiCreatures);
// sort is suboptimal due to conflicting needs depending on game state:
// -deathtouch for deal damage
// -max power for damage to player
// -survivability for generic "fight"
// -no support for "heroic"
List<Card> humCreatures = ai.getOpponent().getCreaturesInPlay();
humCreatures = CardLists.getTargetableCards(humCreatures, tgtFight);
ComputerUtilCard.sortByEvaluateCreature(humCreatures);
if (humCreatures.isEmpty() || aiCreatures.isEmpty()) {
return false;
}
int buffedAtk = attack, buffedDef = defense;
for (Card humanCreature : humCreatures) {
for (Card aiCreature : aiCreatures) {
if (sa.isSpell()) { // heroic triggers adding counters
for (Trigger t : aiCreature.getTriggers()) {
if (t.getMode() == TriggerType.SpellCast) {
final Map<String, String> params = t.getMapParams();
if ("Card.Self".equals(params.get("TargetsValid"))
&& "You".equals(params.get("ValidActivatingPlayer"))
&& params.containsKey("Execute")) {
SpellAbility heroic =
AbilityFactory.getAbility(
aiCreature.getSVar(params.get("Execute")), aiCreature);
if ("Self".equals(heroic.getParam("Defined"))
&& "P1P1".equals(heroic.getParam("CounterType"))) {
int amount =
AbilityUtils.calculateAmount(
aiCreature, heroic.getParam("CounterNum"), heroic);
buffedAtk += amount;
buffedDef += amount;
}
break;
}
}
}
}
if (sa.getParam("AILogic").equals("PowerDmg")) {
if (FightAi.canKill(aiCreature, humanCreature, buffedAtk)) {
sa.getTargets().add(aiCreature);
tgtFight.getTargets().add(humanCreature);
return true;
}
} else {
if (FightAi.shouldFight(aiCreature, humanCreature, buffedAtk, buffedDef)) {
sa.getTargets().add(aiCreature);
tgtFight.getTargets().add(humanCreature);
return true;
}
}
}
}
}
return false;
} else if (sa.isCurse()) {
if (sa.canTarget(opp)) {
sa.getTargets().add(opp);
return true;
}
list = this.getCurseCreatures(ai, sa, defense, attack, keywords);
} else {
if (!tgt.canTgtCreature()) {
ZoneType zone = tgt.getZone().get(0);
list = game.getCardsIn(zone);
} else {
list = this.getPumpCreatures(ai, sa, defense, attack, keywords);
}
if (sa.canTarget(ai)) {
sa.getTargets().add(ai);
return true;
}
}
list = CardLists.getValidCards(list, tgt.getValidTgts(), ai, source);
if (game.getStack().isEmpty()) {
// If the cost is tapping, don't activate before declare
// attack/block
if (sa.getPayCosts() != null && sa.getPayCosts().hasTapCost()) {
if (game.getPhaseHandler().getPhase().isBefore(PhaseType.COMBAT_DECLARE_ATTACKERS)
&& game.getPhaseHandler().isPlayerTurn(ai)) {
list.remove(sa.getHostCard());
}
if (game.getPhaseHandler().getPhase().isBefore(PhaseType.COMBAT_DECLARE_BLOCKERS)
&& game.getPhaseHandler().isPlayerTurn(opp)) {
list.remove(sa.getHostCard());
}
}
}
if (list.isEmpty()) {
return mandatory && this.pumpMandatoryTarget(ai, sa, mandatory);
}
if (!sa.isCurse()) {
// Don't target cards that will die.
list = ComputerUtil.getSafeTargets(ai, sa, list);
}
while (sa.getTargets().getNumTargeted() < tgt.getMaxTargets(source, sa)) {
Card t = null;
// boolean goodt = false;
if (list.isEmpty()) {
if ((sa.getTargets().getNumTargeted() < tgt.getMinTargets(source, sa))
|| (sa.getTargets().getNumTargeted() == 0)) {
if (mandatory) {
return this.pumpMandatoryTarget(ai, sa, mandatory);
}
sa.resetTargets();
return false;
} else {
// TODO is this good enough? for up to amounts?
break;
}
}
t = ComputerUtilCard.getBestAI(list);
// option to hold removal instead only applies for single targeted removal
if (!sa.isTrigger() && tgt.getMaxTargets(source, sa) == 1 && sa.isCurse()) {
if (!ComputerUtilCard.useRemovalNow(sa, t, -defense, ZoneType.Graveyard)) {
return false;
}
}
sa.getTargets().add(t);
list.remove(t);
}
return true;
} // pumpTgtAI()
@Override
public void resolve(final SpellAbility sa) {
final Card host = sa.getHostCard();
final Map<String, String> svars = host.getSVars();
// AF specific sa
int power = -1;
if (sa.hasParam("Power")) {
power = AbilityUtils.calculateAmount(host, sa.getParam("Power"), sa);
}
int toughness = -1;
if (sa.hasParam("Toughness")) {
toughness = AbilityUtils.calculateAmount(host, sa.getParam("Toughness"), sa);
}
final Game game = sa.getActivatingPlayer().getGame();
// Every Animate event needs a unique time stamp
final long timestamp = game.getNextTimestamp();
final boolean permanent = sa.hasParam("Permanent");
final CardType types = new CardType();
if (sa.hasParam("Types")) {
types.addAll(Arrays.asList(sa.getParam("Types").split(",")));
}
final CardType removeTypes = new CardType();
if (sa.hasParam("RemoveTypes")) {
removeTypes.addAll(Arrays.asList(sa.getParam("RemoveTypes").split(",")));
}
// allow ChosenType - overrides anything else specified
if (types.hasSubtype("ChosenType")) {
types.clear();
types.add(host.getChosenType());
}
final List<String> keywords = new ArrayList<String>();
if (sa.hasParam("Keywords")) {
keywords.addAll(Arrays.asList(sa.getParam("Keywords").split(" & ")));
}
final List<String> removeKeywords = new ArrayList<String>();
if (sa.hasParam("RemoveKeywords")) {
removeKeywords.addAll(Arrays.asList(sa.getParam("RemoveKeywords").split(" & ")));
}
final List<String> hiddenKeywords = new ArrayList<String>();
if (sa.hasParam("HiddenKeywords")) {
hiddenKeywords.addAll(Arrays.asList(sa.getParam("HiddenKeywords").split(" & ")));
}
// allow SVar substitution for keywords
for (int i = 0; i < keywords.size(); i++) {
final String k = keywords.get(i);
if (svars.containsKey(k)) {
keywords.add(svars.get(k));
keywords.remove(k);
}
}
// colors to be added or changed to
String tmpDesc = "";
if (sa.hasParam("Colors")) {
final String colors = sa.getParam("Colors");
if (colors.equals("ChosenColor")) {
tmpDesc = CardUtil.getShortColorsString(host.getChosenColors());
} else {
tmpDesc =
CardUtil.getShortColorsString(new ArrayList<String>(Arrays.asList(colors.split(","))));
}
}
final String finalDesc = tmpDesc;
// abilities to add to the animated being
final List<String> abilities = new ArrayList<String>();
if (sa.hasParam("Abilities")) {
abilities.addAll(Arrays.asList(sa.getParam("Abilities").split(",")));
}
// replacement effects to add to the animated being
final List<String> replacements = new ArrayList<String>();
if (sa.hasParam("Replacements")) {
replacements.addAll(Arrays.asList(sa.getParam("Replacements").split(",")));
}
// triggers to add to the animated being
final List<String> triggers = new ArrayList<String>();
if (sa.hasParam("Triggers")) {
triggers.addAll(Arrays.asList(sa.getParam("Triggers").split(",")));
}
// sVars to add to the animated being
final List<String> sVars = new ArrayList<String>();
if (sa.hasParam("sVars")) {
sVars.addAll(Arrays.asList(sa.getParam("sVars").split(",")));
}
String valid = "";
if (sa.hasParam("ValidCards")) {
valid = sa.getParam("ValidCards");
}
CardCollectionView list;
List<Player> tgtPlayers = getTargetPlayers(sa);
if (!sa.usesTargeting() && !sa.hasParam("Defined")) {
list = game.getCardsIn(ZoneType.Battlefield);
} else {
list = tgtPlayers.get(0).getCardsIn(ZoneType.Battlefield);
}
list = CardLists.getValidCards(list, valid.split(","), host.getController(), host);
for (final Card c : list) {
doAnimate(
c,
sa,
power,
toughness,
types,
removeTypes,
finalDesc,
keywords,
removeKeywords,
hiddenKeywords,
timestamp);
// give abilities
final List<SpellAbility> addedAbilities = new ArrayList<SpellAbility>();
if (abilities.size() > 0) {
for (final String s : abilities) {
final String actualAbility = host.getSVar(s);
final SpellAbility grantedAbility = AbilityFactory.getAbility(actualAbility, c);
addedAbilities.add(grantedAbility);
c.addSpellAbility(grantedAbility);
}
}
// remove abilities
final List<SpellAbility> removedAbilities = new ArrayList<SpellAbility>();
if (sa.hasParam("OverwriteAbilities") || sa.hasParam("RemoveAllAbilities")) {
for (final SpellAbility ab : c.getSpellAbilities()) {
if (ab.isAbility()) {
c.removeSpellAbility(ab);
removedAbilities.add(ab);
}
}
}
// give replacement effects
final List<ReplacementEffect> addedReplacements = new ArrayList<ReplacementEffect>();
if (replacements.size() > 0) {
for (final String s : replacements) {
final String actualReplacement = host.getSVar(s);
final ReplacementEffect parsedReplacement =
ReplacementHandler.parseReplacement(actualReplacement, c, false);
addedReplacements.add(c.addReplacementEffect(parsedReplacement));
}
}
// Grant triggers
final List<Trigger> addedTriggers = new ArrayList<Trigger>();
if (triggers.size() > 0) {
for (final String s : triggers) {
final String actualTrigger = host.getSVar(s);
final Trigger parsedTrigger = TriggerHandler.parseTrigger(actualTrigger, c, false);
addedTriggers.add(c.addTrigger(parsedTrigger));
}
}
// suppress triggers from the animated card
final List<Trigger> removedTriggers = new ArrayList<Trigger>();
if (sa.hasParam("OverwriteTriggers") || sa.hasParam("RemoveAllAbilities")) {
final FCollectionView<Trigger> triggersToRemove = c.getTriggers();
for (final Trigger trigger : triggersToRemove) {
trigger.setSuppressed(true);
removedTriggers.add(trigger);
}
}
// suppress static abilities from the animated card
final List<StaticAbility> removedStatics = new ArrayList<StaticAbility>();
if (sa.hasParam("OverwriteStatics") || sa.hasParam("RemoveAllAbilities")) {
final FCollectionView<StaticAbility> staticsToRemove = c.getStaticAbilities();
for (final StaticAbility stAb : staticsToRemove) {
stAb.setTemporarilySuppressed(true);
removedStatics.add(stAb);
}
}
// suppress static abilities from the animated card
final List<ReplacementEffect> removedReplacements = new ArrayList<ReplacementEffect>();
if (sa.hasParam("OverwriteReplacements") || sa.hasParam("RemoveAllAbilities")) {
final FCollectionView<ReplacementEffect> replacementsToRemove = c.getReplacementEffects();
for (final ReplacementEffect re : replacementsToRemove) {
re.setTemporarilySuppressed(true);
removedReplacements.add(re);
}
}
// give sVars
if (sVars.size() > 0) {
for (final String s : sVars) {
final String actualsVar = host.getSVar(s);
c.setSVar(s, actualsVar);
}
}
game.fireEvent(new GameEventCardStatsChanged(c));
final GameCommand unanimate =
new GameCommand() {
private static final long serialVersionUID = -5861759814760561373L;
@Override
public void run() {
doUnanimate(
c,
sa,
finalDesc,
hiddenKeywords,
addedAbilities,
addedTriggers,
addedReplacements,
false,
removedAbilities,
timestamp);
// give back suppressed triggers
for (final Trigger t : removedTriggers) {
t.setSuppressed(false);
}
// give back suppressed static abilities
for (final StaticAbility s : removedStatics) {
s.setTemporarilySuppressed(false);
}
// give back suppressed replacement effects
for (final ReplacementEffect re : removedReplacements) {
re.setTemporarilySuppressed(false);
}
game.fireEvent(new GameEventCardStatsChanged(c));
}
};
if (!permanent) {
if (sa.hasParam("UntilEndOfCombat")) {
game.getEndOfCombat().addUntil(unanimate);
} else {
game.getEndOfTurn().addUntil(unanimate);
}
}
}
} // animateAllResolve
@Override
public void resolve(SpellAbility sa) {
final Card card = sa.getHostCard();
// final int min = sa.containsKey("Min") ? Integer.parseInt(sa.get("Min")) : 0;
// final int max = sa.containsKey("Max") ? Integer.parseInt(sa.get("Max")) : 99;
final boolean random = sa.hasParam("Random");
final boolean anyNumber = sa.hasParam("ChooseAnyNumber");
final boolean secretlyChoose = sa.hasParam("SecretlyChoose");
final String sMin = sa.getParamOrDefault("Min", "0");
final int min = AbilityUtils.calculateAmount(card, sMin, sa);
final String sMax = sa.getParamOrDefault("Max", "99");
final int max = AbilityUtils.calculateAmount(card, sMax, sa);
final List<Player> tgtPlayers = getTargetPlayers(sa);
final TargetRestrictions tgt = sa.getTargetRestrictions();
final Map<Player, Integer> chooseMap = new HashMap<Player, Integer>();
for (final Player p : tgtPlayers) {
if ((tgt == null) || p.canBeTargetedBy(sa)) {
int chosen;
if (random) {
final Random randomGen = new Random();
chosen = randomGen.nextInt(max - min) + min;
p.getGame().getAction().nofityOfValue(sa, p, Integer.toString(chosen), null);
} else {
String title = sa.hasParam("ListTitle") ? sa.getParam("ListTitle") : "Choose a number";
if (anyNumber) {
chosen = p.getController().announceRequirements(sa, title, true);
} else {
chosen = p.getController().chooseNumber(sa, title, min, max);
}
// don't notify here, because most scripts I've seen don't store that number in a long
// term
}
if (secretlyChoose) {
chooseMap.put(p, chosen);
} else {
card.setChosenNumber(chosen);
}
if (sa.hasParam("Notify")) {
p.getGame().getAction().nofityOfValue(sa, card, p.getName() + " picked " + chosen, p);
}
}
}
if (secretlyChoose) {
StringBuilder sb = new StringBuilder();
List<Player> highestNum = new ArrayList<Player>();
List<Player> lowestNum = new ArrayList<Player>();
int highest = 0;
int lowest = Integer.MAX_VALUE;
for (Entry<Player, Integer> ev : chooseMap.entrySet()) {
int num = ev.getValue();
Player player = ev.getKey();
sb.append(player).append(" chose ").append(num);
sb.append("\r\n");
if (num > highest) {
highestNum.clear();
highest = num;
}
if (num == highest) {
highestNum.add(player);
}
if (num < lowest) {
lowestNum.clear();
lowest = num;
}
if (num == lowest) {
lowestNum.add(player);
}
}
card.getGame().getAction().nofityOfValue(sa, card, sb.toString(), null);
if (sa.hasParam("ChooseNumberSubAbility")) {
SpellAbility sub =
AbilityFactory.getAbility(card.getSVar(sa.getParam("ChooseNumberSubAbility")), card);
sub.setActivatingPlayer(sa.getActivatingPlayer());
((AbilitySub) sub).setParent(sa);
for (Player p : chooseMap.keySet()) {
card.addRemembered(p);
card.setChosenNumber(chooseMap.get(p));
AbilityUtils.resolve(sub);
card.clearRemembered();
}
}
if (sa.hasParam("Lowest")) {
SpellAbility action = AbilityFactory.getAbility(card.getSVar(sa.getParam("Lowest")), card);
action.setActivatingPlayer(sa.getActivatingPlayer());
((AbilitySub) action).setParent(sa);
for (Player p : lowestNum) {
card.addRemembered(p);
card.setChosenNumber(lowest);
AbilityUtils.resolve(action);
card.clearRemembered();
}
}
if (sa.hasParam("Highest")) {
SpellAbility action = AbilityFactory.getAbility(card.getSVar(sa.getParam("Highest")), card);
action.setActivatingPlayer(sa.getActivatingPlayer());
((AbilitySub) action).setParent(sa);
for (Player p : highestNum) {
card.addRemembered(p);
card.setChosenNumber(highest);
AbilityUtils.resolve(action);
card.clearRemembered();
}
if (sa.hasParam("RememberHighest")) {
card.addRemembered(highestNum);
}
}
}
}