/// <summary>
/// Get an Aura that is incompatible with the one represented by the given spell
/// </summary>
/// <returns>Whether or not another Aura may be applied</returns>
public Aura GetAura(ObjectReference caster, AuraIndexId id, Spell spell)
{
Aura aura1 = this[id];
if (aura1 != null)
{
return(aura1);
}
if (spell.AuraCasterGroup != null)
{
int num = 0;
foreach (Aura aura2 in this.m_AuraArray)
{
if (aura2.CasterReference.EntityId == caster.EntityId &&
spell.AuraCasterGroup == aura2.Spell.AuraCasterGroup)
{
++num;
if (num >= spell.AuraCasterGroup.MaxCount)
{
return(aura2);
}
}
}
}
return((Aura)null);
}
/// <summary>
/// Get an Aura that is incompatible with the one represented by the given spell
/// </summary>
/// <returns>Whether or not another Aura may be applied</returns>
public Aura GetAura(ObjectReference caster, AuraIndexId id, Spell spell)
{
var oldAura = this[id];
if (oldAura != null)
{
return(oldAura);
}
else
{
// no aura found
// check for per-caster-restrictions
if (spell.AuraCasterGroup != null)
{
var count = 0;
foreach (var aura in m_AuraArray)
{
if (aura.CasterReference.EntityId == caster.EntityId && spell.AuraCasterGroup == aura.Spell.AuraCasterGroup)
{
count++;
if (count >= spell.AuraCasterGroup.MaxCount)
{
return(aura);
}
}
}
}
}
return(null);
}
public bool Remove(uint auraUID, bool positive)
{
var id = new AuraIndexId {
AuraUID = auraUID, IsPositive = positive
};
return(Remove(id));
}
public Aura this[AuraIndexId auraId]
{
get
{
Aura aura;
this.m_auras.TryGetValue(auraId, out aura);
return(aura);
}
}
/// <summary>
/// Stack or removes the Aura represented by the given spell, if possible.
/// Returns true if there is no incompatible Aura or if the Aura could be removed.
/// <param name="err">Ok, if stacked or no incompatible Aura is blocking a new Aura</param>
/// </summary>
internal bool PrepareStackOrOverride(ObjectReference caster, AuraIndexId id, Spell spell, ref SpellFailedReason err, SpellCast triggeringCast = null)
{
var oldAura = GetAura(caster, id, spell);
if (oldAura != null)
{
return(PrepareStackOrOverride(caster, oldAura, spell, ref err, triggeringCast));
}
return(true);
}
public bool Remove(AuraIndexId auraId)
{
Aura aura;
if (!this.m_auras.TryGetValue(auraId, out aura))
{
return(false);
}
aura.Remove(true);
return(true);
}
internal Aura(AuraCollection auras, ObjectReference caster, AuraRecord record, List <AuraEffectHandler> handlers,
byte index)
{
m_record = record;
m_auras = auras;
m_spell = record.Spell;
m_beneficial = record.IsBeneficial;
Id = m_spell.GetAuraUID(m_beneficial);
m_handlers = handlers;
m_CasterReference = caster;
m_index = index;
m_auraLevel = (byte)record.Level;
m_stackCount = record.StackCount;
SetupValues();
m_duration = record.MillisLeft;
SetupTimer();
}
/// <summary>Creates a new Aura</summary>
/// <param name="auras"></param>
/// <param name="casterReference">Information about who casted</param>
/// <param name="spell">The spell that this Aura represents</param>
/// <param name="handlers">All handlers must have the same AuraUID</param>
internal Aura(AuraCollection auras, ObjectReference casterReference, Spell spell,
List <AuraEffectHandler> handlers, byte index, bool beneficial)
{
m_auras = auras;
m_spell = spell;
m_beneficial = beneficial;
Id = spell.GetAuraUID(beneficial);
m_handlers = handlers;
m_CasterReference = casterReference;
m_index = index;
m_auraLevel = (byte)casterReference.Level;
m_stackCount = (byte)m_spell.InitialStackCount;
if (m_stackCount > 0 && casterReference.UnitMaster != null)
{
m_stackCount =
casterReference.UnitMaster.Auras.GetModifiedInt(SpellModifierType.Charges, m_spell,
m_stackCount);
}
SetupValues();
}
/// <summary>
/// Applies the given spell as a buff or debuff.
/// Does not necessarily create
/// Also, initializes new Auras.
/// </summary>
/// <returns>null if Spell is not an Aura or an already existing version of the Aura that was refreshed</returns>
public Aura CreateAura(ObjectReference caster, Spell spell, WCell.RealmServer.Entities.Item usedItem = null)
{
try
{
bool flag = spell.IsBeneficialFor(caster, (WorldObject)this.m_owner);
AuraIndexId auraUid = spell.GetAuraUID(flag);
SpellFailedReason err = SpellFailedReason.Ok;
Aura aura1 = this.GetAura(caster, auraUid, spell);
if (aura1 != null && !this.PrepareStackOrOverride(caster, aura1, spell, ref err, (SpellCast)null))
{
if (err == SpellFailedReason.Ok)
{
return(aura1);
}
if (caster.Object is Character)
{
SpellHandler.SendCastFailed((IPacketReceiver)caster.Object, spell, err);
}
return((Aura)null);
}
List <AuraEffectHandler> auraEffectHandlers = spell.CreateAuraEffectHandlers(caster, this.m_owner, flag);
if (auraEffectHandlers != null)
{
Aura aura2 = this.CreateAura(caster, spell, auraEffectHandlers, usedItem, flag);
if (aura2 != null)
{
this.OnCreated(aura2);
}
return(aura2);
}
}
catch (Exception ex)
{
LogUtil.ErrorException(ex, "Unable to add new Aura \"{0}\" by \"{1}\" to: {2}", (object)spell,
(object)caster, (object)this.m_owner);
}
return((Aura)null);
}
/// <summary>Adds an already created Aura and optionally starts it</summary>
public virtual void AddAura(Aura aura, bool start = true)
{
AuraIndexId id = aura.Id;
if (this.m_auras.ContainsKey(aura.Id))
{
LogManager.GetCurrentClassLogger()
.Warn("Tried to add Aura \"{0}\" by \"{1}\" when it was already added, to: {2}", (object)aura,
(object)aura.CasterReference, (object)this.Owner);
}
else
{
foreach (Aura aura1 in this.m_auras.Values)
{
if ((int)aura1.Spell.RealId == (int)aura.Spell.RealId)
{
aura1.Remove(true);
break;
}
}
this.m_auras.Add(id, aura);
if (!aura.Spell.IsPassive)
{
this.m_visibleAuras[(int)aura.Index] = aura;
++this.m_visAuraCount;
}
this.InvalidateAurasCopy();
aura.IsAdded = true;
if (!start)
{
return;
}
aura.Start();
}
}
public Aura this[AuraIndexId auraId]
{
get
{
Aura aura;
m_auras.TryGetValue(auraId, out aura);
return aura;
}
}
public bool Contains(AuraIndexId id)
{
return this[id] != null;
}
public bool Contains(AuraIndexId id)
{
return(this[id] != null);
}
/// <summary>
/// Stack or removes the Aura represented by the given spell, if possible.
/// Returns true if there is no incompatible Aura or if it could be removed.
/// <param name="err">Ok, if stacked or no incompatible Aura is blocking a new Aura</param>
/// </summary>
public bool CheckStackOrOverride(CasterInfo caster, AuraIndexId id, Spell spell, ref SpellFailedReason err)
{
var oldAura = GetAura(caster, id, spell);
if (oldAura != null)
{
return CheckStackOrOverride(oldAura, caster, spell, ref err);
}
return true;
}
public bool Cancel(uint auraUID, bool positive)
{
var id = new AuraIndexId { AuraUID = auraUID, IsPositive = positive };
return Cancel(id);
}
/// <summary>
/// Get an Aura that is incompatible with the one represented by the given spell.
/// </summary>
/// <returns>Whether or not another Aura may be applied</returns>
public Aura GetAura(CasterInfo caster, AuraIndexId id, Spell spell)
{
var oldAura = this[id];
if (oldAura != null)
{
return oldAura;
}
else
{
// no aura found
// check for per-caster-restrictions
if (spell.AuraCasterGroup != null)
{
var count = 0;
foreach (var aura in m_AuraArray)
{
if (aura.CasterInfo.CasterId == caster.CasterId && spell.AuraCasterGroup == aura.Spell.AuraCasterGroup)
{
count++;
if (count >= spell.AuraCasterGroup.MaxCount)
{
return aura;
}
}
}
}
}
return null;
}
public bool Cancel(AuraIndexId auraId)
{
Aura aura;
if (m_auras.TryGetValue(auraId, out aura))
{
aura.Cancel();
return true;
}
return false;
}