case REDIRECTION: ReplacementEffect newReplacementEffect = (ReplacementEffect) effect; replacementEffects.addEffect(newReplacementEffect, source); break; case PREVENTION: PreventionEffect newPreventionEffect = (PreventionEffect) effect; preventionEffects.addEffect(newPreventionEffect, source); break; case RESTRICTION: RestrictionEffect newRestrictionEffect = (RestrictionEffect) effect; restrictionEffects.addEffect(newRestrictionEffect, source); break; case RESTRICTION_UNTAP_NOT_MORE_THAN: RestrictionUntapNotMoreThanEffect newRestrictionUntapNotMoreThanEffect = (RestrictionUntapNotMoreThanEffect) effect; restrictionUntapNotMoreThanEffects.addEffect(newRestrictionUntapNotMoreThanEffect, source); break; case REQUIREMENT: RequirementEffect newRequirementEffect = (RequirementEffect) effect; requirementEffects.addEffect(newRequirementEffect, source); break; case ASTHOUGH: AsThoughEffect newAsThoughEffect = (AsThoughEffect) effect; if (!asThoughEffectsMap.containsKey(newAsThoughEffect.getAsThoughEffectType())) { ContinuousEffectsList<AsThoughEffect> list = new ContinuousEffectsList<>(); allEffectsLists.add(list); asThoughEffectsMap.put(newAsThoughEffect.getAsThoughEffectType(), list); asThoughEffectsMap.get(newAsThoughEffect.getAsThoughEffectType()).addEffect(newAsThoughEffect, source); break;
public ContinuousEffectsList(final ContinuousEffectsList<T> effects) { this.ensureCapacity(effects.size()); for (ContinuousEffect cost : effects) { this.add((T) cost.copy()); } for (Map.Entry<UUID, Set<Ability>> entry : effects.effectAbilityMap.entrySet()) { Set<Ability> newSet = new HashSet<>(); for (Ability ability : entry.getValue()) { newSet.add(ability.copy()); } effectAbilityMap.put(entry.getKey(), newSet); } }
public synchronized void clear() { for (ContinuousEffectsList effectsList : allEffectsLists) { effectsList.clear(); } temporaryEffects.clear(); }
public void removeInactiveEffects(Game game) { for (Iterator<T> i = this.iterator(); i.hasNext();) { T entry = i.next(); if (isInactive(entry, game)) { i.remove(); effectAbilityMap.remove(entry.getId()); } } }
public Set<Ability> getLayeredEffectAbilities(ContinuousEffect effect) { return layeredEffects.getAbility(effect.getId()); }
for (Iterator<ReplacementEffect> iterator = replacementEffects.iterator(); iterator.hasNext();) { ReplacementEffect effect = iterator.next(); if (!effect.checksEventType(event, game)) { Set<Ability> abilities = replacementEffects.getAbility(effect.getId()); Set<Ability> applicableAbilities = new HashSet<>(); for (Ability ability : abilities) { for (Iterator<PreventionEffect> iterator = preventionEffects.iterator(); iterator.hasNext();) { PreventionEffect effect = iterator.next(); if (!effect.checksEventType(event, game)) { Set<Ability> abilities = preventionEffects.getAbility(effect.getId()); Set<Ability> applicableAbilities = new HashSet<>(); for (Ability ability : abilities) {
public void removeEndOfCombatEffects() { for (Iterator<T> i = this.iterator(); i.hasNext();) { T entry = i.next(); if (entry.getDuration() == Duration.EndOfCombat) { i.remove(); effectAbilityMap.remove(entry.getId()); } } }
public ContinuousEffectsList<T> copy() { return new ContinuousEffectsList<>(this); }
public boolean existRequirementEffects() { return !requirementEffects.isEmpty(); }
public ContinuousEffects(final ContinuousEffects effect) { this.applyCounters = effect.applyCounters.copy(); // this.planeswalkerRedirectionEffect = effect.planeswalkerRedirectionEffect.copy(); this.auraReplacementEffect = effect.auraReplacementEffect.copy(); layeredEffects = effect.layeredEffects.copy(); continuousRuleModifyingEffects = effect.continuousRuleModifyingEffects.copy(); replacementEffects = effect.replacementEffects.copy(); preventionEffects = effect.preventionEffects.copy(); requirementEffects = effect.requirementEffects.copy(); restrictionEffects = effect.restrictionEffects.copy(); restrictionUntapNotMoreThanEffects = effect.restrictionUntapNotMoreThanEffects.copy(); for (Map.Entry<AsThoughEffectType, ContinuousEffectsList<AsThoughEffect>> entry : effect.asThoughEffectsMap.entrySet()) { asThoughEffectsMap.put(entry.getKey(), entry.getValue().copy()); } costModificationEffects = effect.costModificationEffects.copy(); spliceCardEffects = effect.spliceCardEffects.copy(); for (Map.Entry<ContinuousEffect, Set<Ability>> entry : effect.temporaryEffects.entrySet()) { temporaryEffects.put(entry.getKey().copy(), entry.getValue()); } collectAllEffects(); order = effect.order; }
/** * Adds an effect and its connected ability to the list. For each effect * will be stored, which abilities are connected to the effect. So an effect * can be connected to multiple abilities. * * @param effect - effect to add * @param source - connected ability */ public void addEffect(T effect, Ability source) { if (effectAbilityMap.containsKey(effect.getId())) { Set<Ability> set = effectAbilityMap.get(effect.getId()); for (Ability ability : set) { if (ability.getId().equals(source.getId()) && ability.getSourceId().equals(source.getSourceId())) { return; } } set.add(source); return; } Set<Ability> set = new HashSet<>(); set.add(source); this.effectAbilityMap.put(effect.getId(), set); this.add(effect); }
public Map<RestrictionEffect, Set<Ability>> getApplicableRestrictionEffects(Permanent permanent, Game game) { Map<RestrictionEffect, Set<Ability>> effects = new HashMap<>(); for (RestrictionEffect effect : restrictionEffects) { Set<Ability> abilities = restrictionEffects.getAbility(effect.getId()); Set<Ability> applicableAbilities = new HashSet<>(); for (Ability ability : abilities) { if (!(ability instanceof StaticAbility) || ability.isInUseableZone(game, ability instanceof MageSingleton ? permanent : null, null)) { if (effect.applies(permanent, ability, game)) { applicableAbilities.add(ability); } } } if (!applicableAbilities.isEmpty()) { effects.put(effect, abilities); } } return effects; }
public void removeEffects(UUID effectIdToRemove, Set<Ability> abilitiesToRemove) { Set<Ability> abilities = effectAbilityMap.get(effectIdToRemove); if (abilitiesToRemove != null && abilities != null) { abilities.removeAll(abilitiesToRemove); } if (abilities == null || abilities.isEmpty()) { for (Iterator<T> iterator = this.iterator(); iterator.hasNext();) { ContinuousEffect effect = iterator.next(); if (effect.getId().equals(effectIdToRemove)) { iterator.remove(); break; } } effectAbilityMap.remove(effectIdToRemove); } }
public Map<RestrictionUntapNotMoreThanEffect, Set<Ability>> getApplicableRestrictionUntapNotMoreThanEffects(Player player, Game game) { Map<RestrictionUntapNotMoreThanEffect, Set<Ability>> effects = new HashMap<>(); for (RestrictionUntapNotMoreThanEffect effect : restrictionUntapNotMoreThanEffects) { Set<Ability> abilities = restrictionUntapNotMoreThanEffects.getAbility(effect.getId()); Set<Ability> applicableAbilities = new HashSet<>(); for (Ability ability : abilities) { if (!(ability instanceof StaticAbility) || ability.isInUseableZone(game, null, null)) { if (effect.applies(player, ability, game)) { applicableAbilities.add(ability); } } } if (!applicableAbilities.isEmpty()) { effects.put(effect, abilities); } } return effects; }
public void removeEndOfTurnEffects() { for (Iterator<T> i = this.iterator(); i.hasNext();) { T entry = i.next(); if (entry.getDuration() == Duration.EndOfTurn) { i.remove(); effectAbilityMap.remove(entry.getId()); } } }
public synchronized List<ContinuousEffect> getLayeredEffects(Game game) { List<ContinuousEffect> layerEffects = new ArrayList<>(); for (ContinuousEffect effect : layeredEffects) { switch (effect.getDuration()) { case WhileOnBattlefield: case WhileOnStack: case WhileInGraveyard: Set<Ability> abilities = layeredEffects.getAbility(effect.getId()); if (!abilities.isEmpty()) { for (Ability ability : abilities) { // If e.g. triggerd abilities (non static) created the effect, the ability must not be in usable zone (e.g. Unearth giving Haste effect) if (!(ability instanceof StaticAbility) || ability.isInUseableZone(game, null, null)) { layerEffects.add(effect); break; } } } else { logger.error("No abilities for continuous effect: " + effect.toString()); } break; default: layerEffects.add(effect); } } updateTimestamps(layerEffects); Collections.sort(layerEffects, Comparator.comparingLong(ContinuousEffect::getOrder)); return layerEffects; }
public Map<RequirementEffect, Set<Ability>> getApplicableRequirementEffects(Permanent permanent, boolean playerRealted, Game game) { Map<RequirementEffect, Set<Ability>> effects = new HashMap<>(); for (RequirementEffect effect : requirementEffects) { if (playerRealted == effect.isPlayerRelated()) { Set<Ability> abilities = requirementEffects.getAbility(effect.getId()); Set<Ability> applicableAbilities = new HashSet<>(); for (Ability ability : abilities) { if (!(ability instanceof StaticAbility) || ability.isInUseableZone(game, ability instanceof MageSingleton ? permanent : null, null)) { if (effect.applies(permanent, ability, game)) { applicableAbilities.add(ability); } } } if (!applicableAbilities.isEmpty()) { effects.put(effect, abilities); } } } return effects; }
/** * Filters out asThough effects that are not active. * * @param type type * @param game * @return */ public List<AsThoughEffect> getApplicableAsThoughEffects(AsThoughEffectType type, Game game) { List<AsThoughEffect> asThoughEffectsList = new ArrayList<>(); if (asThoughEffectsMap.containsKey(type)) { for (AsThoughEffect effect : asThoughEffectsMap.get(type)) { Set<Ability> abilities = asThoughEffectsMap.get(type).getAbility(effect.getId()); for (Ability ability : abilities) { if (!(ability instanceof StaticAbility) || ability.isInUseableZone(game, null, null)) { if (effect.getDuration() != Duration.OneUse || !effect.isUsed()) { asThoughEffectsList.add(effect); break; } } } } } return asThoughEffectsList; }
private void applyContinuousEffect(ContinuousEffect effect, Layer currentLayer, Game game) { Set<Ability> abilities = layeredEffects.getAbility(effect.getId()); for (Ability ability : abilities) { //effect.apply(currentLayer, SubLayer.NA, ability, game); if (isAbilityStillExists(game, ability, effect)) { effect.apply(currentLayer, SubLayer.NA, ability, game); } } }
private void setControllerForEffect(ContinuousEffectsList<?> effects, UUID sourceId, UUID controllerId) { for (Effect effect : effects) { Set<Ability> abilities = effects.getAbility(effect.getId()); for (Ability ability : abilities) { if (ability.getSourceId() != null) { if (ability.getSourceId().equals(sourceId)) { ability.setControllerId(controllerId); } } else if (ability.getZone() != Zone.COMMAND) { logger.fatal("Continuous effect for ability with no sourceId Ability: " + ability); } } } }