public void Transform(bool canAction, Unit originalForm = null)
{
if (originalForm == null)
{
ResourceConvert(Classes.GetClassData(Owner.PlayerClass).GetResourceOfType(ClassResourceType.ResourceTypes.Dominant));
}
else
{
OriginalTransformForm = originalForm;
CurrentStatusEffects.Add(StatusEffects.Transformed);
}
if (originalForm != null && originalForm.IsHero)
{
GameManager.instance.uiManager.RefreshHeroStats(Owner.Id, this);
}
if (canAction)
{
RefreshActions();
}
RefreshCounter();
}
public void Spellbind()
{
if (HasStatusEffect(StatusEffects.Transformed))
{
ReturnToOriginalForm();
OriginalTransformForm.Spellbind();
}
else
{
if (HasKeyword(Keywords.Summon))
{
RemoveUnit(true);
}
else
{
foreach (var enchantment in Enchantments)
{
if (enchantment.Enchantment.Status != UnitEnchantment.EnchantmentStatus.Passive)
{
enchantment.IsActive = false;
}
}
UpdateOwnerStats(false);
ConfiscatedCards.Clear();
ImprisonedUnits.Clear();
CurrentStatusEffects.Clear();
CurrentStatusEffects.Add(StatusEffects.Spellbound);
UpdateEnchantments();
}
}
}
public void Unstealth()
{
if (HasStatusEffect(StatusEffects.Stealthed))
{
CurrentStatusEffects.Remove(StatusEffects.Stealthed);
}
RefreshCounter();
}
public void AddStatusEffect(IStatusEffect effect)
{
if (HasStatusEffect(effect.Name))
{
CurrentStatusEffects.First(x => x.Name == effect.Name).RemainingTime = effect.Duration;
}
else
{
CurrentStatusEffects.Add(effect.Copy());
}
}
public void RemoveEnchantmentsOfStatus(List <UnitEnchantment.EnchantmentStatus> enchantmentStatuses)
{
var removeEnchantments = Enchantments.Where(x => enchantmentStatuses.Contains(x.Enchantment.Status));
foreach (var statusEffectList in removeEnchantments.Select(x => x.Enchantment.StatusEffects))
{
CurrentStatusEffects.RemoveAll(x => statusEffectList.Contains(x));
}
Enchantments.RemoveAll(x => removeEnchantments.Contains(x));
UpdateEnchantments();
RefreshCounter();
}
/// <summary>
///
/// DEPRICATED: DO NOT USE
///
/// </summary>
public void RestoreEnchantments()
{
if (CurrentStatusEffects.Contains(StatusEffects.Spellbound))
{
foreach (var enchantment in Enchantments)
{
if (!enchantment.IsActive)
{
enchantment.IsActive = true;
enchantment.IsApplied = false;
}
}
CurrentStatusEffects.Remove(StatusEffects.Spellbound);
UpdateEnchantments();
}
}
public void FlyOrLand()
{
if (HasStatusEffect(StatusEffects.Airborne))
{
if (CheckOccupancy(UnitCounter.Cell, true))
{
CanFlyOrLand = false;
CurrentStatusEffects.Remove(StatusEffects.Airborne);
}
}
else
{
CanFlyOrLand = false;
CurrentStatusEffects.Add(StatusEffects.Airborne);
}
RefreshCounter();
}
public void TickStatusEffects()
{
List <IStatusEffect> endedEffects = new List <IStatusEffect>();
foreach (IStatusEffect effect in CurrentStatusEffects)
{
effect.RemainingTime--;
if (effect.RemainingTime <= 0)
{
endedEffects.Add(effect);
}
else
{
effect.DoEffect(this);
}
}
CurrentStatusEffects.RemoveAll(x => endedEffects.Contains(x));
}
public bool CheckWarden()
{
if (CurrentStatusEffects.Contains(StatusEffects.Warded))
{
CurrentStatusEffects.Remove(StatusEffects.Warded);
UnitCounter.RefreshUnitCounter();
}
if (!HasKeyword(Keywords.Stalker) && !UnitCounter.Cell.IsSurveyed(Owner.Id))
{
foreach (var adjCell in UnitCounter.Cell.adjCell)
{
if (adjCell.occupantCounter != null)
{
var adjUnit = adjCell.occupantCounter.Unit;
if (adjUnit.Owner.Id != Owner.Id)
{
if (adjUnit.HasKeyword(Keywords.Warden))
{
if (!adjUnit.HasStatusEffect(StatusEffects.Stunned))
{
if (CheckWardenMatchingKeywords(adjUnit, Keywords.Ethereal) && CheckWardenMatchingKeywords(adjUnit, Keywords.Flying))
{
CurrentStatusEffects.Add(StatusEffects.Warded);
RefreshCounter();
return(true);
}
}
}
}
}
}
}
return(false);
}
public bool HasStatusEffect(StatusEffects statusEffect)
{
return(CurrentStatusEffects.Contains(statusEffect));
}
public void DeleteEnchantment(AppliedEnchantment enchantment)
{
Enchantments.Remove(enchantment);
CurrentStatusEffects.RemoveAll(x => enchantment.Enchantment.StatusEffects.Contains(x));
UpdateEnchantments();
}
public void UpdateEnchantments()
{
ResetStats();
CurrentKeywords.Clear();
foreach (var enchantment in Enchantments.OrderBy(x => x.Enchantment.Status))
{
if (enchantment.Enchantment.Status != UnitEnchantment.EnchantmentStatus.None)
{
if (enchantment.IsActive)
{
if (enchantment.Enchantment.Status == UnitEnchantment.EnchantmentStatus.OverloadPassive)
{
var totalOverload = 0;
if (Owner.UsedResources.Contains(CardResources.Mana))
{
totalOverload = ((PlayerMana)Owner.Resources.Single(x => x.ResourceType == CardResources.Mana)).TotalOverload;
}
var currentAttack = GetStat(StatTypes.Attack);
int attackModifier;
if (currentAttack > 0)
{
attackModifier = Mathf.Min(totalOverload, currentAttack - 1);
}
else
{
attackModifier = 0;
}
enchantment.Enchantment.AddStatModifier(StatTypes.Attack, StatModifierTypes.Modify, -attackModifier);
}
foreach (var statModifier in enchantment.Enchantment.StatModifiers)
{
ModifyStat(statModifier.ModType, statModifier.StatType, statModifier.Value);
if (!enchantment.IsApplied)
{
switch (statModifier.ModType)
{
case StatModifierTypes.Modify:
if (statModifier.StatType == StatTypes.MaxHealth)
{
CurrentHealth += statModifier.Value;
}
if (statModifier.StatType == StatTypes.Speed && (Status != UnitStatuses.Preparing || Status != UnitStatuses.Enemy))
{
RemainingSpeed += statModifier.Value;
if (CanMove && Status != UnitStatuses.Enemy && Status != UnitStatuses.Start)
{
Status = UnitStatuses.Middle;
}
}
break;
case StatModifierTypes.Set:
if (statModifier.StatType == StatTypes.MaxHealth)
{
CurrentHealth = GetStat(StatTypes.MaxHealth);
}
if (statModifier.StatType == StatTypes.Speed && (Status != UnitStatuses.Preparing || Status != UnitStatuses.Enemy))
{
RemainingSpeed = GetStat(StatTypes.Speed);
if (CanMove && Status != UnitStatuses.Enemy && Status != UnitStatuses.Start)
{
Status = UnitStatuses.Middle;
}
}
break;
default:
break;
}
if (statModifier.StatType == StatTypes.Empowered && IsDeployed)
{
Owner.ModifyEmpowered(statModifier.Value);
}
}
}
foreach (var keyword in enchantment.Enchantment.Keywords)
{
if (!HasKeyword(keyword))
{
CurrentKeywords.Add(keyword);
}
}
foreach (var statusEffect in enchantment.Enchantment.StatusEffects)
{
if (!enchantment.IsApplied)
{
if (!HasStatusEffect(statusEffect))
{
CurrentStatusEffects.Add(statusEffect);
}
}
}
enchantment.IsApplied = true;
}
}
else
{
throw new Exception("Not a valid enchantment");
}
}
//Resets the health and speed to cap them out at their max
CurrentHealth = currentHealth;
RemainingSpeed = remainingSpeed;
if (GetStat(StatTypes.Attack) < 0)
{
ModifyStat(StatModifierTypes.Set, StatTypes.Attack, 0);
}
GameManager.instance.CheckWarden();
RefreshCounter();
}
public bool HasStatusEffect(string name)
{
return(CurrentStatusEffects.Any(x => x.Name == name));
}
public void AddStatusEffect(IStatusEffect effect)
{
CurrentStatusEffects.Add(effect);
}