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 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 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;
}
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 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 void ManaAmount(IManaAmount amount)
{
ManaOutput = new FixedManaOutput(amount);
Colors = amount.Colors.ToList();
}
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);
}
