public bool HasMana(
int amount,
ManaUsage usage = ManaUsage.Any,
ConvokeAndDelveOptions convokeAndDelveOptions = null)
{
return(HasMana(amount.Colorless(), usage, convokeAndDelveOptions));
}
public AddManaToPool(DynParam <IManaAmount> amount, ManaUsage usage = ManaUsage.Any)
{
_amount = amount;
_usage = usage;
RegisterDynamicParameters(amount);
}
public ManaUnit(ManaColor color, int rank, IManaSource source = null, ManaUsage usageRestriction = ManaUsage.Any)
{
Color = color;
Rank = rank;
Source = source;
_usageRestriction = usageRestriction;
}
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);
}
}
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 ManaUnit(ManaColor color, int rank, IManaSource source = null, ManaUsage usageRestriction = ManaUsage.Any)
{
Color = color;
Rank = rank;
Source = source;
_usageRestriction = usageRestriction;
}
public AddManaToPool(IManaAmount amount, ManaUsage usage = ManaUsage.Any)
{
_usage = usage;
_amount = new DynParam <IManaAmount>(amount);
RegisterDynamicParameters(_amount);
}
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 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 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 bool Has(
ManaAmount amount,
ManaUsage usage,
ConvokeAndDelveOptions convokeAndDelveOptions)
{
var allocated = TryToAllocateAmount(
amount,
usage,
convokeAndDelveOptions);
return(allocated != null && allocated.Lifeloss < _controller.Life);
}
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(ManaAmount 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 int GetAvailableConvertedMana(ManaUsage usage)
{
var restricted = new HashSet <ManaUnit>();
var allocated = new List <ManaUnit>();
foreach (var manaUnit in _units)
{
if (IsAvailable(manaUnit, restricted, usage))
{
restricted.Add(manaUnit);
allocated.Add(manaUnit);
RestrictUsingDifferentSourcesFromSameCard(manaUnit, restricted);
}
}
return(allocated.Count);
}
private bool IsAvailable(ManaUnit unit, HashSet <ManaUnit> restricted, ManaUsage usage)
{
if (restricted.Contains(unit))
{
return(false);
}
if (unit.CanActivateSource() == false && _manaPool.Contains(unit) == false)
{
return(false);
}
if (unit.CanBeUsed(usage) == false)
{
return(false);
}
return(true);
}
public void Consume(
ManaAmount amount,
ManaUsage usage,
ConvokeAndDelveOptions convokeAndDelveOptions)
{
var allocated = TryToAllocateAmount(amount, usage, convokeAndDelveOptions);
Asrt.True(allocated != null, "Not enough mana available.");
var sources = GetSourcesToActivate(allocated.Units);
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.Units)
{
_manaPool.Remove(unit);
}
}
foreach (var unit in allocated.Units.Where(x => !x.HasSource))
{
RemovePermanently(unit);
}
_controller.Life -= allocated.Lifeloss;
}
public List <ManaColor> GetAvailableMana(ManaUsage usage, ConvokeAndDelveOptions convokeAndDelve)
{
var restricted = new HashSet <ManaUnit>();
var allocated = new List <ManaUnit>();
var units = _units
.Concat(GetAdditionalManaSources(convokeAndDelve))
.ToList();
foreach (var manaUnit in units)
{
if (IsAvailable(manaUnit, restricted, usage))
{
restricted.Add(manaUnit);
allocated.Add(manaUnit);
RestrictUsingDifferentSourcesFromSameCard(manaUnit, restricted, units);
}
}
return(allocated.Select(x => x.Color).ToList());
}
public int GetAvailableConvertedMana(ManaUsage usage = ManaUsage.Any)
{
return(ManaCache.GetAvailableConvertedMana(usage));
}
public int GetAvailableConvertedMana(ManaUsage usage = ManaUsage.Any)
{
return ManaCache.GetAvailableConvertedMana(usage);
}
public void AddManaToManaPool(IManaAmount manaAmount, ManaUsage usageRestriction = ManaUsage.Any)
{
ManaCache.AddManaToPool(manaAmount, usageRestriction);
}
private bool IsAvailable(ManaUnit unit, HashSet<ManaUnit> restricted, ManaUsage usage)
{
if (restricted.Contains(unit))
return false;
if (unit.CanActivateSource() == false && _manaPool.Contains(unit) == false)
return false;
if (unit.CanBeUsed(usage) == false)
return false;
return true;
}
public int GetAvailableConvertedMana(ManaUsage usage)
{
var restricted = new HashSet<ManaUnit>();
var allocated = new List<ManaUnit>();
foreach (var manaUnit in _units)
{
if (IsAvailable(manaUnit, restricted, usage))
{
restricted.Add(manaUnit);
allocated.Add(manaUnit);
RestrictUsingDifferentSourcesFromSameCard(manaUnit, restricted);
}
}
return allocated.Count;
}
public abstract IManaAmount GetActualCost(IManaAmount amount, ManaUsage manaUsage, Card card);
public bool HasMana(int amount, ManaUsage usage = ManaUsage.Any)
{
return(ManaCache.Has(amount.Colorless(), usage));
}
public List <ManaColor> GetAvailableMana(
ConvokeAndDelveOptions convokeAndDelveOptions = null,
ManaUsage usage = ManaUsage.Any)
{
return(ManaCache.GetAvailableMana(usage, convokeAndDelveOptions));
}
public abstract IManaAmount GetActualCost(IManaAmount amount, ManaUsage manaUsage, Card card);
public IManaAmount GetActualCost(IManaAmount amount, ManaUsage usage, Card card)
{
return(_costModifiers.GetActualCost(amount, usage, card));
}
public bool CanBeUsed(ManaUsage usage)
{
return _usageRestriction == ManaUsage.Any ||
_usageRestriction == usage;
}
public bool CanBeUsed(ManaUsage usage)
{
return(_usageRestriction == ManaUsage.Any ||
_usageRestriction == usage);
}
public bool HasMana(ManaAmount amount, ManaUsage usage = ManaUsage.Any,
ConvokeAndDelveOptions convokeAndDelveOptions = null)
{
return(ManaCache.Has(amount, usage, convokeAndDelveOptions));
}
public void AddManaToManaPool(IManaAmount manaAmount, ManaUsage usageRestriction = ManaUsage.Any)
{
ManaCache.AddManaToPool(manaAmount, usageRestriction);
}
public void Consume(IManaAmount amount, ManaUsage usage)
{
ManaCache.Consume(amount, usage);
}
public int GetAvailableManaCount(
ConvokeAndDelveOptions convokeAndDelveOptions = null,
ManaUsage usage = ManaUsage.Any)
{
return(GetAvailableMana(convokeAndDelveOptions, usage).Count);
}
public bool HasMana(IManaAmount amount, ManaUsage usage = ManaUsage.Any)
{
return(ManaCache.Has(amount, usage));
}
public bool HasMana(IManaAmount amount, ManaUsage usage = ManaUsage.Any)
{
return ManaCache.Has(amount, usage);
}
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 Consume(IManaAmount amount, ManaUsage usage)
{
ManaCache.Consume(amount, usage);
}
public bool Has(IManaAmount amount, ManaUsage usage)
{
return TryToAllocateAmount(amount, usage) != null;
}
private AllocatedAmount TryToAllocateAmount(
ManaAmount amount,
ManaUsage usage,
ConvokeAndDelveOptions convokeAndDelveOptions)
{
var restricted = new HashSet <ManaUnit>();
var allocated = new AllocatedAmount();
var additional = GetAdditionalManaSources(convokeAndDelveOptions);
var additionalGrouped = GroupAdditionalSources(additional);
var units = _units.Concat(additional).ToList();
var checkAmount = amount
.Select(x => new
{
Color = GetColorIndex(x),
Count = x.Count,
IsPhyrexian = x.Color.IsPhyrexian
})
// first check for mana which has only few mana sources
.OrderBy(x => _groups[x.Color].Count)
.ToArray();
var allocatedPhyrexian = new List <ManaUnit>();
foreach (var manaOfSingleColor in checkAmount)
{
var ordered = _groups[manaOfSingleColor.Color]
.Concat(additionalGrouped[manaOfSingleColor.Color])
.OrderBy(GetManaUnitAllocationOrder)
.ToList();
for (var i = 0; i < manaOfSingleColor.Count; i++)
{
var allocatedUnit = ordered.FirstOrDefault(unit => IsAvailable(unit, restricted, usage));
// allocation failed
if (allocatedUnit == null)
{
if (manaOfSingleColor.IsPhyrexian)
{
allocated.Lifeloss += 2;
continue;
}
// if pyrexian is holding the slot, release it and pay life
if (allocatedPhyrexian.Count > 0)
{
var restrictedWithoutPhyrexian = restricted.Where(x => !allocatedPhyrexian.Contains(x)).ToHashSet();
allocatedUnit = ordered.FirstOrDefault(unit => IsAvailable(unit, restrictedWithoutPhyrexian, usage));
if (allocatedUnit != null)
{
allocated.Lifeloss += 2;
allocatedPhyrexian.Remove(allocatedUnit);
continue;
}
}
return(null);
}
if (manaOfSingleColor.IsPhyrexian)
{
allocatedPhyrexian.Add(allocatedUnit);
}
restricted.Add(allocatedUnit);
allocated.Units.Add(allocatedUnit);
RestrictUsingDifferentSourcesFromSameCard(allocatedUnit, restricted, units);
}
}
return(allocated);
}
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(ManaAmount amount, ManaUsage usage, ConvokeAndDelveOptions convokeAndDelveOptions = null)
{
ManaCache.Consume(amount, usage, convokeAndDelveOptions);
}
public bool Has(IManaAmount amount, ManaUsage usage)
{
return(TryToAllocateAmount(amount, usage) != null);
}
public bool HasMana(int amount, ManaUsage usage = ManaUsage.Any)
{
return ManaCache.Has(amount.Colorless(), usage);
}
