/** * Returns the mode by index. For modal spells with eachModeMoreThanOnce, * the index returns the n selected mode * * @param index * @return */ public UUID getModeId(int index) { int idx = 0; if (eachModeMoreThanOnce) { for (UUID modeId : this.selectedModes) { idx++; if (idx == index) { return modeId; } } } else { for (Mode mode : this.values()) { idx++; if (idx == index) { return mode.getId(); } } } return null; }
/** * Returns all (still) available modes of the ability * * @param source * @param game * @return */ public List<Mode> getAvailableModes(Ability source, Game game) { List<Mode> availableModes = new ArrayList<>(); Set<UUID> nonAvailableModes; if (isEachModeMoreThanOnce()) { nonAvailableModes = new HashSet<>(); } else { nonAvailableModes = getAlreadySelectedModes(source, game); } for (Mode mode : this.values()) { if (isEachModeOnlyOnce() && nonAvailableModes != null && nonAvailableModes.contains(mode.getId())) { continue; } availableModes.add(mode); } return availableModes; }
public Modes(final Modes modes) { for (Map.Entry<UUID, Mode> entry : modes.entrySet()) { this.put(entry.getKey(), entry.getValue().copy()); } for (Map.Entry<UUID, Mode> entry : modes.duplicateModes.entrySet()) { this.put(entry.getKey(), entry.getValue().copy()); } this.minModes = modes.minModes; this.maxModes = modes.maxModes; this.selectedModes.addAll(modes.getSelectedModes()); if (modes.getSelectedModes().isEmpty()) { this.currentMode = values().iterator().next(); } else { this.currentMode = get(modes.getMode().getId()); } this.modeChooser = modes.modeChooser; this.eachModeOnlyOnce = modes.eachModeOnlyOnce; this.eachModeMoreThanOnce = modes.eachModeMoreThanOnce; this.optionalAdditionalModeSourceCosts = modes.optionalAdditionalModeSourceCosts; this.maxModesFilter = modes.maxModesFilter; // can't change so no copy needed }
@Override public Effects getAllEffects() { Effects allEffects = new Effects(); for (Mode mode : getModes().values()) { allEffects.addAll(mode.getEffects()); } return allEffects; }
sb.append("—<br>"); for (Mode mode : this.values()) { sb.append("&bull "); sb.append(mode.getEffects().getTextStartingUpperCase(mode));
@Override public boolean apply(MageObject input, Game game) { boolean canTargetOnlyWalls = false; StackObject stackObject = game.getStack().getSpell(input.getId()); if (stackObject != null) { for (Mode mode : stackObject.getStackAbility().getModes().values()) { for (Target target : mode.getTargets()) { Filter filter = target.getFilter(); if (filter != null && filter instanceof FilterPermanent) { for (Object predicate : filter.getPredicates()) { if (predicate instanceof SubtypePredicate) { if (predicate.toString().equals("Subtype(Wall)")) { canTargetOnlyWalls = true; // can target a Wall } else { return false; // can target a non-Wall permanent } } // no return statement here, as different predicates might still apply (e.g. "blocking Wall") } } else { return false; // can target non-permanents (i.e. not Walls) } } } } return canTargetOnlyWalls; }
private void addModeOptions(List<Ability> options, Ability option, Game game) { // TODO: Support modal spells with more than one selectable mode for (Mode mode : option.getModes().values()) { Ability newOption = option.copy(); newOption.getModes().getSelectedModes().clear(); newOption.getModes().getSelectedModes().add(mode.getId()); newOption.getModes().setActiveMode(mode); if (!newOption.getTargets().getUnchosen().isEmpty()) { if (!newOption.getManaCosts().getVariableCosts().isEmpty()) { addVariableXOptions(options, newOption, 0, game); } else { addTargetOptions(options, newOption, 0, game); } } else if (!newOption.getCosts().getTargets().getUnchosen().isEmpty()) { addCostTargetOptions(options, newOption, 0, game); } else { options.add(newOption); } } }
Mode selectedMode = spellModes.get(selectedModeId); int item = 0; for (Mode mode : spellModes.values()) { item++; if (mode.getId().equals(selectedMode.getId())) {
@Override public boolean apply(ObjectSourcePlayer<Spell> input, Game game) { Permanent sourceObject = game.getPermanent(input.getSourceId()); if (sourceObject == null || input.getObject() == null) { return false; } for (SpellAbility spellAbility : input.getObject().getSpellAbilities()) { for (Mode mode : spellAbility.getModes().values()) { for (Target target : spellAbility.getTargets()) { if (target.getTargets().contains(input.getSourceId())) { return true; } } } } return false; } }
private static boolean canChooseTargetAbility(Ability ability, Game game, UUID controllerId) { int found = 0; for (Mode mode : ability.getModes().values()) { if (mode.getTargets().canChoose(ability.getSourceId(), ability.getControllerId(), game)) { found++; if (ability.getModes().isEachModeMoreThanOnce()) { return true; } if (found >= ability.getModes().getMinModes()) { return true; } } } return false; }
if (spell != null) { SpellAbility spellAbility = spell.getSpellAbility(); for (Mode mode : spellAbility.getModes().values()) { for (Target target : mode.getTargets()) { if (!target.isNotTarget()) {
private static int isRemoval(Card card) { if (card.isEnchantment() || card.isInstant() || card.isSorcery()) { for (Ability ability : card.getAbilities()) { for (Effect effect : ability.getEffects()) { if (isEffectRemoval(card, ability, effect) == 1) { return 1; } } for (Mode mode : ability.getModes().values()) { for (Effect effect : mode.getEffects()) { if (isEffectRemoval(card, ability, effect) == 1) { return 1; } } } } } return 0; }
onceSelectedModes = getAlreadySelectedModes(source, game); for (Mode mode : this.values()) { if ((!isEachModeOnlyOnce() || onceSelectedModes == null || !onceSelectedModes.contains(mode.getId())) && mode.getTargets().canChoose(source.getSourceId(), source.getControllerId(), game)) { if (currentMode == null) { this.selectedModes.clear(); Mode mode = this.values().iterator().next(); this.addSelectedMode(mode.getId()); this.setActiveMode(mode);