private HashSet <ManaUnit> TryToAllocateAmount(IManaAmount amount, ManaUsage usage) { var restricted = new HashSet <ManaUnit>(); var allocated = new HashSet <ManaUnit>(); foreach (var manaOfSingleColor in amount) { var color = manaOfSingleColor.Color.IsColorless ? 5 : manaOfSingleColor.Color.Indices[0]; var ordered = _groups[color] .OrderBy(GetManaUnitAllocationOrder) .ToList(); for (var i = 0; i < manaOfSingleColor.Count; i++) { var allocatedUnit = ordered .FirstOrDefault(unit => IsAvailable(unit, restricted, usage)); if (allocatedUnit == null) { return(null); } restricted.Add(allocatedUnit); allocated.Add(allocatedUnit); RestrictUsingDifferentSourcesFromSameCard(allocatedUnit, restricted); } } return(allocated); }
public void Consume(IManaAmount amount, ManaUsage usage) { var allocated = TryToAllocateAmount(amount, usage); Asrt.True(allocated != null, "Not enough mana available."); var sources = GetSourcesToActivate(allocated); foreach (var source in sources) { lock (_manaPoolCountLock) { foreach (var unit in source.GetUnits()) { _manaPool.Add(unit); } } source.PayActivationCost(); } lock (_manaPoolCountLock) { foreach (var unit in allocated) { _manaPool.Remove(unit); } } foreach (var unit in allocated.Where(x => !x.HasSource)) { RemovePermanently(unit); } }
public IManaAmount Add(IManaAmount amount) { var dictionary = new Dictionary <ManaColor, int>(); foreach (var singleColorAmount in amount) { dictionary[singleColorAmount.Color] = singleColorAmount.Count; } if (dictionary.Count == 0) { return(this); } foreach (var singleColorAmount in _groups) { if (dictionary.ContainsKey(singleColorAmount.Color)) { dictionary[singleColorAmount.Color] += singleColorAmount.Count; continue; } dictionary[singleColorAmount.Color] = singleColorAmount.Count; } return(new MultiColorManaAmount(dictionary)); }
public IManaAmount Add(IManaAmount amount) { var dictionary = new Dictionary <ManaColor, int>(); foreach (var singleColorAmount in amount) { dictionary[singleColorAmount.Color] = singleColorAmount.Count; } if (dictionary.Count == 0) { return(this); } if (dictionary.ContainsKey(Color)) { dictionary[Color] += Count; } else { dictionary[Color] = Count; } if (dictionary.Count == 1) { return(new SingleColorManaAmount(Color, dictionary[Color])); } return(new MultiColorManaAmount(dictionary)); }
public IManaAmount Remove(IManaAmount amount) { var dictionary = _groups.ToDictionary(x => x.Color, x => x.Count); foreach (var singleColor in amount) { if (dictionary.ContainsKey(singleColor.Color)) { if (dictionary[singleColor.Color] <= singleColor.Count) { dictionary.Remove(singleColor.Color); } else { dictionary[singleColor.Color] -= singleColor.Count; } } } if (dictionary.Count == 0) { return(Mana.Zero); } if (dictionary.Count == 1) { return(new SingleColorManaAmount(dictionary.Keys.First(), dictionary.Values.First())); } return(new MultiColorManaAmount(dictionary)); }
public IManaAmount Add(IManaAmount amount) { var dictionary = new Dictionary<ManaColor, int>(); foreach (var singleColorAmount in amount) { dictionary[singleColorAmount.Color] = singleColorAmount.Count; } if (dictionary.Count == 0) return this; if (dictionary.ContainsKey(Color)) { dictionary[Color] += Count; } else { dictionary[Color] = Count; } if (dictionary.Count == 1) return new SingleColorManaAmount(Color, dictionary[Color]); return new MultiColorManaAmount(dictionary); }
public IManaAmount Add(IManaAmount amount) { var dictionary = new Dictionary<ManaColor, int>(); foreach (var singleColorAmount in amount) { dictionary[singleColorAmount.Color] = singleColorAmount.Count; } if (dictionary.Count == 0) return this; foreach (var singleColorAmount in _groups) { if (dictionary.ContainsKey(singleColorAmount.Color)) { dictionary[singleColorAmount.Color] += singleColorAmount.Count; continue; } dictionary[singleColorAmount.Color] = singleColorAmount.Count; } return new MultiColorManaAmount(dictionary); }
public CardTemplate Pump(IManaAmount cost, string text, int powerIncrease, int toughnessIncrease) { return(ActivatedAbility(p => { p.Text = text; p.Cost = new PayMana(cost, ManaUsage.Abilities, supportsRepetitions: true); p.Effect = () => { var effect = new ApplyModifiersToSelf(() => new AddPowerAndToughness( powerIncrease, toughnessIncrease) { UntilEot = true }); if (toughnessIncrease > 0) { effect.SetTags(EffectTag.IncreaseToughness); } if (powerIncrease > 0) { effect.SetTags(EffectTag.IncreasePower); } return effect; }; p.TimingRule(new PumpOwningCardTimingRule(powerIncrease, toughnessIncrease)); p.RepetitionRule(new RepeatMaxTimes()); }) .CombatRule(() => new PumpCombatRule(powerIncrease, toughnessIncrease, cost))); }
public PayManaOrLooseLife(int lifeAmount, IManaAmount manaAmount, DynParam <Player> player) { _lifeAmount = lifeAmount; _manaAmount = manaAmount; _player = player; RegisterDynamicParameters(player); }
public AddManaToPool(IManaAmount amount, ManaUsage usage = ManaUsage.Any) { _usage = usage; _amount = new DynParam <IManaAmount>(amount); RegisterDynamicParameters(_amount); }
private static IEnumerable <CardColor> GetCardColorsFromManaCost(IManaAmount manaCost) { if (manaCost == null) { yield return(CardColor.None); yield break; } if (manaCost.Converted == 0) { yield return(CardColor.Colorless); yield break; } var existing = new HashSet <CardColor>(); foreach (var mana in manaCost) { if (mana.Color.IsWhite && !existing.Contains(CardColor.White)) { existing.Add(CardColor.White); yield return(CardColor.White); } if (mana.Color.IsBlue && !existing.Contains(CardColor.Blue)) { existing.Add(CardColor.Blue); yield return(CardColor.Blue); } if (mana.Color.IsBlack && !existing.Contains(CardColor.Black)) { existing.Add(CardColor.Black); yield return(CardColor.Black); } if (mana.Color.IsRed && !existing.Contains(CardColor.Red)) { existing.Add(CardColor.Red); yield return(CardColor.Red); } if (mana.Color.IsGreen && !existing.Contains(CardColor.Green)) { existing.Add(CardColor.Green); yield return(CardColor.Green); } } if (existing.Count == 0) { yield return(CardColor.Colorless); } }
public IManaAmount GetActualCost(IManaAmount amount, ManaUsage usage, Card card) { var actualCost = amount; foreach (var costModifier in _costModifiers) { actualCost = costModifier.GetActualCost(actualCost, usage, card); } return actualCost; }
public PayMana( IManaAmount amount, ManaUsage manaUsage, bool hasX = false, bool supportsRepetitions = false) { _amount = amount; _manaUsage = manaUsage; _hasX = hasX; _supportsRepetitions = supportsRepetitions; }
public static IManaAmount Repeat(this IManaAmount amount, int count) { var result = amount; for (var i = 1; i < count; i++) { result = result.Add(amount); } return(result); }
public IManaAmount GetActualCost(IManaAmount amount, ManaUsage usage, Card card) { var actualCost = amount; foreach (var costModifier in _costModifiers) { actualCost = costModifier.GetActualCost(actualCost, usage, card); } return(actualCost); }
public CardTemplate Regenerate(IManaAmount cost, string text) { return(ActivatedAbility(p => { p.Text = text; p.Cost = new PayMana(cost, ManaUsage.Abilities); p.Effect = () => new RegenerateOwner(); p.TimingRule(new RegenerateSelfTimingRule()); }) .CombatRule(() => new RegenerateCombatRule(cost))); }
public override IManaAmount GetActualCost(IManaAmount amount, ManaUsage manaUsage, Card card) { if (manaUsage != ManaUsage.Spells) return amount; if (_filter(card, this)) { return _less ? amount.Remove(_amount) : amount.Add(_amount); } return amount; }
private void AddUnits(IManaAmount amount) { foreach (var singleColor in amount) { for (var i = 0; i < singleColor.Count; i++) { var unit = CreateManaUnit(singleColor.Color); _units.Add(unit); _manaCache.Add(unit); } } }
public override IManaAmount GetActualCost(IManaAmount amount, ManaUsage manaUsage, Card card) { if (manaUsage != ManaUsage.Spells) { return(amount); } if (_filter(card, this)) { return(_less ? amount.Remove(_amount) : amount.Add(_amount)); } return(amount); }
public void AddManaToPool(IManaAmount amount, ManaUsage usage) { lock (_manaPoolCountLock) { foreach (var mana in amount) { for (var i = 0; i < mana.Count; i++) { var unit = new ManaUnit(mana.Color, 0, usageRestriction: usage); Add(unit); _manaPool.Add(unit); } } } }
public IManaAmount Remove(IManaAmount amount) { var count = Count; foreach (var singleColor in amount) { if (singleColor.Color == Color) { count -= singleColor.Count; } } if (count > 0) return new SingleColorManaAmount(Color, count); return Mana.Zero; }
public IManaAmount Remove(IManaAmount amount) { var count = Count; foreach (var singleColor in amount) { if (singleColor.Color == Color) { count -= singleColor.Count; } } if (count > 0) { return(new SingleColorManaAmount(Color, count)); } return(Mana.Zero); }
private void RemoveUnits(IManaAmount amount) { if (_units.Count == 0) { return; } foreach (var singleColor in amount) { for (var i = 0; i < singleColor.Count; i++) { var unit = _units.FirstOrDefault(x => x.Color == singleColor.Color); if (unit == null) { break; } _units.Remove(unit); _manaCache.Remove(unit); } } }
public RegenerateCombatRule(IManaAmount cost) { _cost = cost; }
public void Consume(IManaAmount amount, ManaUsage usage) { var allocated = TryToAllocateAmount(amount, usage); //Asrt.True(allocated != null, "Not enough mana available."); var sources = GetSourcesToActivate(allocated); foreach (var source in sources) { lock (_manaPoolCountLock) { foreach (var unit in source.GetUnits()) { _manaPool.Add(unit); } } source.PayActivationCost(); } lock (_manaPoolCountLock) { foreach (var unit in allocated) { _manaPool.Remove(unit); } } foreach (var unit in allocated.Where(x => !x.HasSource)) { RemovePermanently(unit); } }
public void RemoveAdditional(IManaAmount amount) { _additionalOutput.Value = _additionalOutput.Value.Remove(amount); }
public IManaAmount Remove(IManaAmount amount) { var dictionary = _groups.ToDictionary(x => x.Color, x => x.Count); foreach (var singleColor in amount) { if (dictionary.ContainsKey(singleColor.Color)) { if (dictionary[singleColor.Color] <= singleColor.Count) { dictionary.Remove(singleColor.Color); } else { dictionary[singleColor.Color] -= singleColor.Count; } } } if (dictionary.Count == 0) return Mana.Zero; if (dictionary.Count == 1) return new SingleColorManaAmount(dictionary.Keys.First(), dictionary.Values.First()); return new MultiColorManaAmount(dictionary); }
public CardTemplate Pump(IManaAmount cost, string text, int powerIncrease, int toughnessIncrease) { return ActivatedAbility(p => { p.Text = text; p.Cost = new PayMana(cost, ManaUsage.Abilities, supportsRepetitions: true); p.Effect = () => { var effect = new ApplyModifiersToSelf(() => new AddPowerAndToughness( powerIncrease, toughnessIncrease) {UntilEot = true}); if (toughnessIncrease > 0) effect.SetTags(EffectTag.IncreaseToughness); if (powerIncrease > 0) effect.SetTags(EffectTag.IncreasePower); return effect; }; p.TimingRule(new PumpOwningCardTimingRule(powerIncrease, toughnessIncrease)); p.RepetitionRule(new RepeatMaxTimes()); }) .CombatRule(() => new PumpCombatRule(powerIncrease, toughnessIncrease, cost)); }
private static IEnumerable<CardColor> GetCardColorsFromManaCost(IManaAmount manaCost) { if (manaCost == null) { yield return CardColor.None; yield break; } if (manaCost.Converted == 0) { yield return CardColor.Colorless; yield break; } var existing = new HashSet<CardColor>(); foreach (var mana in manaCost) { if (mana.Color.IsWhite && !existing.Contains(CardColor.White)) { existing.Add(CardColor.White); yield return CardColor.White; } if (mana.Color.IsBlue && !existing.Contains(CardColor.Blue)) { existing.Add(CardColor.Blue); yield return CardColor.Blue; } if (mana.Color.IsBlack && !existing.Contains(CardColor.Black)) { existing.Add(CardColor.Black); yield return CardColor.Black; } if (mana.Color.IsRed && !existing.Contains(CardColor.Red)) { existing.Add(CardColor.Red); yield return CardColor.Red; } if (mana.Color.IsGreen && !existing.Contains(CardColor.Green)) { existing.Add(CardColor.Green); yield return CardColor.Green; } } if (existing.Count == 0) yield return CardColor.Colorless; }
public IManaAmount Add(IManaAmount amount) { return(amount); }
public void RemoveAdditionalAmountAbilityWillProduce(IManaAmount amount) { RemoveUnits(amount); _p.ManaOutput.RemoveAdditional(amount); }
private HashSet<ManaUnit> TryToAllocateAmount(IManaAmount amount, ManaUsage usage) { var restricted = new HashSet<ManaUnit>(); var allocated = new HashSet<ManaUnit>(); foreach (var manaOfSingleColor in amount) { var color = manaOfSingleColor.Color.IsColorless ? 5 : manaOfSingleColor.Color.Indices[0]; var ordered = _groups[color] .OrderBy(GetManaUnitAllocationOrder) .ToList(); for (var i = 0; i < manaOfSingleColor.Count; i++) { var allocatedUnit = ordered .FirstOrDefault(unit => IsAvailable(unit, restricted, usage)); if (allocatedUnit == null) return null; restricted.Add(allocatedUnit); allocated.Add(allocatedUnit); RestrictUsingDifferentSourcesFromSameCard(allocatedUnit, restricted); } } return allocated; }
public IManaAmount Remove(IManaAmount amount) { return Mana.Zero; }
public bool Has(IManaAmount amount, ManaUsage usage) { return(TryToAllocateAmount(amount, usage) != null); }
public IManaAmount Remove(IManaAmount amount) { return(Mana.Zero); }
public SpellCostModifier(IManaAmount amount, Func <Card, CostModifier, bool> filter = null, bool less = true) { _amount = amount; _less = less; _filter = filter ?? delegate { return(true); }; }
public void AddAditional(IManaAmount amount) { _additionalOutput.Value = _additionalOutput.Value.Add(amount); }
public IncreaseManaOutput(IManaAmount amount) { _amount = amount; }
public PumpCombatRule(int power, int toughness, IManaAmount cost) { _power = power; _toughness = toughness; _cost = cost; }
public void ManaAmount(IManaAmount amount) { ManaOutput = new FixedManaOutput(amount); Colors = amount.Colors.ToList(); }
public void AddManaToManaPool(IManaAmount manaAmount, ManaUsage usageRestriction = ManaUsage.Any) { ManaCache.AddManaToPool(manaAmount, usageRestriction); }
public CardTemplate Regenerate(IManaAmount cost, string text) { return ActivatedAbility(p => { p.Text = text; p.Cost = new PayMana(cost, ManaUsage.Abilities); p.Effect = () => new RegenerateOwner(); p.TimingRule(new RegenerateSelfTimingRule()); }) .CombatRule(() => new RegenerateCombatRule(cost)); }
public void Consume(IManaAmount amount, ManaUsage usage) { ManaCache.Consume(amount, usage); }
public void AddAditionalAmountAbilityWillProduce(IManaAmount amount) { AddUnits(amount); _p.ManaOutput.AddAditional(amount); }
public SpellCostModifier(IManaAmount amount, Func<Card, CostModifier, bool> filter = null, bool less = true) { _amount = amount; _less = less; _filter = filter ?? delegate { return true; }; }
public FixedManaOutput(IManaAmount amount) { _amount = amount; }
private void RemoveUnits(IManaAmount amount) { if (_units.Count == 0) return; foreach (var singleColor in amount) { for (var i = 0; i < singleColor.Count; i++) { var unit = _units.FirstOrDefault(x => x.Color == singleColor.Color); if (unit == null) break; _units.Remove(unit); _manaCache.Remove(unit); } } }
public CreaturesOfChosenTypeCostLess(IManaAmount amount) { _amount = amount; }
public DefaultLevelUpTimingRule(IManaAmount cost, params LevelDefinition[] levelDefinitions) { _cost = cost; _levelDefinitions.AddRange(levelDefinitions); }
public abstract IManaAmount GetActualCost(IManaAmount amount, ManaUsage manaUsage, Card card);
public bool Has(IManaAmount amount, ManaUsage usage) { return TryToAllocateAmount(amount, usage) != null; }
public IManaAmount Add(IManaAmount amount) { return amount; }
public bool HasMana(IManaAmount amount, ManaUsage usage = ManaUsage.Any) { return(ManaCache.Has(amount, usage)); }
private void OnOutputDecreased(IManaAmount amount) { RemoveUnits(amount); }
public PayManaOrSacrifice(IManaAmount amount, string message = null) : this(new DynParam <IManaAmount>(amount), message) { }
private void OnOutputIncreased(IManaAmount amount) { AddUnits(amount); }