private void HandleAuraEffects(AuraApplication auraApplication, bool added)
{
if (added)
{
for (int i = 0; i < auraApplication.Aura.Effects.Count; i++)
{
if (auraApplication.EffectsToApply.HasBit(i) && !auraApplication.AppliedEffectMask.HasBit(i))
{
auraEffectsByAuraType.Insert(auraApplication.Aura.Effects[i].EffectInfo.AuraEffectType, auraApplication.Aura.Effects[i]);
tempAuraEffectsToHandle.Add(i);
}
}
}
else
{
for (int i = 0; i < auraApplication.Aura.EffectsInfos.Count; i++)
{
if (auraApplication.AppliedEffectMask.HasBit(i))
{
auraEffectsByAuraType.Delete(auraApplication.Aura.Effects[i].EffectInfo.AuraEffectType, auraApplication.Aura.Effects[i]);
tempAuraEffectsToHandle.Add(i);
}
}
}
for (int i = 0; i < tempAuraEffectsToHandle.Count; i++)
{
auraApplication.HandleEffect(tempAuraEffectsToHandle[i], added, tempAuraHandleGroups);
}
tempAuraEffectsToHandle.Clear();
tempAuraHandleGroups.Clear();
}
private void HandleAuraEffects(AuraApplication auraApplication, bool added)
{
var auraEffectsToHandle = new List <int>();
var auraHandleGroups = new HashSet <AuraEffectHandleGroup>();
if (added)
{
for (int i = 0; i < auraApplication.Aura.Effects.Count; i++)
{
if (auraApplication.EffectsToApply.HasBit(i) && !auraApplication.AppliedEffectMask.HasBit(i))
{
auraEffectsByAuraType.Insert(auraApplication.Aura.Effects[i].EffectInfo.AuraEffectType, auraApplication.Aura.Effects[i]);
auraEffectsToHandle.Add(i);
}
}
}
else
{
for (int i = 0; i < auraApplication.Aura.EffectsInfos.Count; i++)
{
if (auraApplication.AppliedEffectMask.HasBit(i))
{
auraEffectsByAuraType.Delete(auraApplication.Aura.Effects[i].EffectInfo.AuraEffectType, auraApplication.Aura.Effects[i]);
auraEffectsToHandle.Add(i);
}
}
}
for (int i = 0; i < auraEffectsToHandle.Count; i++)
{
auraApplication.HandleEffect(auraEffectsToHandle[i], added, auraHandleGroups);
}
}
void IUnitBehaviour.DoUpdate(int deltaTime)
{
if (!NeedUpdate)
{
return;
}
NeedUpdate = false;
for (int i = 0; i < applicationSlots.Length; i++)
{
AuraApplication applicationInSlot = applicationSlots[i];
if (applicationInSlot == null)
{
unitState.VisibleAuras[i].AuraId = 0;
}
else
{
unitState.VisibleAuras[i].AuraId = applicationInSlot.Aura.AuraInfo.Id;
unitState.VisibleAuras[i].RefreshFrame = applicationInSlot.Aura.RefreshServerFrame;
unitState.VisibleAuras[i].Duration = applicationInSlot.Aura.RefreshDuration;
unitState.VisibleAuras[i].MaxDuration = applicationInSlot.Aura.MaxDuration;
}
}
}
private void RemoveAuraWithApplication(AuraApplication application, AuraRemoveMode mode)
{
if (auraApplicationSet.Contains(application))
{
UnapplyAuraApplication(application, mode);
if (application.Aura.Owner == unit)
{
application.Aura.Remove(mode);
}
}
}
internal void Remove(AuraRemoveMode removeMode = AuraRemoveMode.Default)
{
Assert.IsFalse(IsRemoved, $"Aura {AuraInfo.Id} is removed twice!");
IsRemoved = true;
Charges = 0;
while (applications.Count > 0)
{
AuraApplication applicationToRemove = applications[0];
applicationToRemove.Target.Auras.UnapplyAuraApplication(applicationToRemove, removeMode);
}
Owner.Auras.RemoveOwnedAura(this, removeMode);
}
internal void HandleAuraApplication(AuraApplication auraApplication, bool applied)
{
if (auraApplication.Aura.SpellInfo.IsPassive)
{
return;
}
if (applied)
{
if (availableSlots.Count == 0)
{
unslottedApplications.Add(auraApplication);
}
else
{
visibleSlotsByApplication[auraApplication] = availableSlots[0];
applicationSlots[availableSlots[0]] = auraApplication;
availableSlots.RemoveAt(0);
}
}
else
{
if (visibleSlotsByApplication.TryGetValue(auraApplication, out int occupiedSlotIndex))
{
visibleSlotsByApplication.Remove(auraApplication);
if (unslottedApplications.Count == 0)
{
availableSlots.Add(occupiedSlotIndex);
applicationSlots[occupiedSlotIndex] = null;
}
else
{
applicationSlots[occupiedSlotIndex] = unslottedApplications[0];
visibleSlotsByApplication[unslottedApplications[0]] = occupiedSlotIndex;
unslottedApplications.RemoveAt(0);
}
}
else
{
unslottedApplications.Remove(auraApplication);
}
}
NeedUpdate = true;
}
public override void AuraApplicationRemoved(AuraApplication application)
{
base.AuraApplicationRemoved(application);
if (application.Aura.Caster == null)
{
return;
}
if (application.RemoveMode == AuraRemoveMode.Death || application.RemoveMode == AuraRemoveMode.Expired)
{
var explicitTargets = new SpellExplicitTargets {
Target = application.Aura.Owner
};
var castingOptions = new SpellCastingOptions(explicitTargets, SpellCastFlags.TriggeredByAura);
application.Aura.Caster.Spells.CastSpell(livingBombExplosion, castingOptions);
}
}
private void HandleStateContainingAura(AuraApplication auraApplication, bool added)
{
AuraStateType stateType = auraApplication.Aura.AuraInfo.StateType;
if (stateType == AuraStateType.None)
{
return;
}
if (added)
{
auraApplicationsByAuraState.Insert(stateType, auraApplication);
ModifyAuraState(stateType, true);
}
else
{
auraApplicationsByAuraState.Delete(stateType, auraApplication);
ModifyAuraState(stateType, auraApplicationsByAuraState.ContainsKey(stateType));
}
}
internal void UnapplyAuraApplication(AuraApplication auraApplication, AuraRemoveMode removeMode)
{
auraApplicationsByAuraId.Delete(auraApplication.Aura.AuraInfo.Id, auraApplication);
auraApplications.Remove(auraApplication);
auraApplicationSet.Remove(auraApplication);
HandleInterruptableAura(auraApplication, false);
HandleStateContainingAura(auraApplication, false);
HandleAuraEffects(auraApplication, false);
auraApplication.Aura.UnregisterForTarget(unit, auraApplication);
auraApplication.RemoveMode = removeMode;
unit.VisibleAuras.HandleAuraApplication(auraApplication, false);
for (int i = 0; i < auraApplication.Aura.AuraInfo.AuraScriptables.Count; i++)
{
auraApplication.Aura.AuraInfo.AuraScriptables[i].AuraApplicationRemoved(auraApplication);
}
Logging.LogAura($"Unapplied application for target: {unit.Name} for aura: {auraApplication.Aura.AuraInfo.name}");
}
internal void DamageBySpell(SpellDamageInfo damageInfo, Spell spell = null)
{
unit.Spells.CalculateSpellDamageTaken(ref damageInfo, spell);
EventHandler.ExecuteEvent(EventHandler.GlobalDispatcher, GameEvents.ServerDamageDone, damageInfo);
for (int i = unit.Auras.AuraApplications.Count - 1; i >= 0; i--)
{
AuraApplication application = unit.Auras.AuraApplications[i];
for (int j = 0; j < application.Aura.AuraInfo.AuraScriptables.Count; j++)
{
AuraScriptable auraScriptable = application.Aura.AuraInfo.AuraScriptables[j];
if (auraScriptable is IAuraScriptSpellDamageHandler spellDamageHandler)
{
spellDamageHandler.OnSpellDamageDone(damageInfo);
}
}
}
unit.DealDamage(damageInfo.Target, (int)damageInfo.Damage, damageInfo.SpellDamageType);
}
internal void ApplyAuraApplication(AuraApplication auraApplication)
{
Logging.LogAura($"Applying application for target: {unit.Name} for aura: {auraApplication.Aura.AuraInfo.name}");
RemoveNonStackableAuras(auraApplication.Aura);
auraApplications.Add(auraApplication);
auraApplicationSet.Add(auraApplication);
auraApplicationsByAuraId.Insert(auraApplication.Aura.AuraInfo.Id, auraApplication);
HandleStateContainingAura(auraApplication, true);
HandleInterruptableAura(auraApplication, true);
HandleAuraEffects(auraApplication, true);
auraApplication.Aura.RegisterForTarget(unit, auraApplication);
unit.VisibleAuras.HandleAuraApplication(auraApplication, true);
for (int i = 0; i < auraApplication.Aura.AuraInfo.AuraScriptables.Count; i++)
{
auraApplication.Aura.AuraInfo.AuraScriptables[i].AuraApplicationApplied(auraApplication);
}
}
private void HandleInterruptableAura(AuraApplication auraApplication, bool added)
{
if (!auraApplication.Aura.AuraInfo.HasInterruptFlags)
{
return;
}
if (added)
{
interruptableAuraApplications.Add(auraApplication);
auraInterruptFlags |= auraApplication.Aura.AuraInfo.InterruptFlags;
}
else
{
interruptableAuraApplications.Remove(auraApplication);
auraInterruptFlags = 0;
foreach (AuraApplication interruptableAura in interruptableAuraApplications)
{
auraInterruptFlags |= interruptableAura.Aura.AuraInfo.InterruptFlags;
}
}
}
internal void UnregisterForTarget(Unit target, AuraApplication auraApplication)
{
applications.Remove(auraApplication);
applicationsByTargetId.Remove(target.Id);
}
internal void RegisterForTarget(Unit target, AuraApplication auraApplication)
{
applications.Add(auraApplication);
applicationsByTargetId.Add(target.Id, auraApplication);
}
public virtual void HandleEffect(AuraApplication auraApplication, AuraEffectHandleMode mode, bool apply)
{
Logging.LogAura($"Handle aura effect {EffectInfo.name} for target: {auraApplication.Target.Name} in mode {mode}, applying: {apply}");
}
public virtual void AuraApplicationRemoved(AuraApplication application)
{
}
public virtual void AuraApplicationApplied(AuraApplication application)
{
}
