public void AuraApplied(IVisibleAura visibleAura)
{
aurasByAuraId.Insert(visibleAura.AuraId, visibleAura);
if (effectByAuraId.ContainsKey(visibleAura.AuraId))
{
return;
}
if (!unitRenderer.rendering.AuraVisuals.TryGetValue(visibleAura.AuraId, out AuraVisualsInfo settings))
{
return;
}
if (settings.PreventAnimation)
{
HandleAnimationPreventingAuras(visibleAura, true);
}
if (settings.EffectSettings == null)
{
return;
}
Vector3 effectDirection = Vector3.ProjectOnPlane(unitRenderer.transform.forward, Vector3.up);
Quaternion effectRotation = Quaternion.LookRotation(effectDirection);
IEffectEntity newEffect = settings.EffectSettings.PlayEffect(unitRenderer.transform.position, effectRotation, out long playId);
if (newEffect != null)
{
unitRenderer.TagContainer.ApplyPositioning(newEffect, settings);
effectByAuraId[visibleAura.AuraId] = new SpellVisualAuraState(playId, newEffect);
}
}
protected override void OnUpdate(IEffectEntity effectEntity, ref bool keepAlive)
{
base.OnUpdate(effectEntity, ref keepAlive);
if (cameraReference.WarcraftCamera != null)
{
Quaternion lookDirectionOffset = Quaternion.Euler(rotationOffset);
Vector3 projectedCameraDirection = Vector3.ProjectOnPlane(cameraReference.WarcraftCamera.transform.forward, Vector3.up);
transformToRotate.rotation = Quaternion.LookRotation(projectedCameraDirection) * lookDirectionOffset;
}
}
protected override void OnUpdate(IEffectEntity effectEntity, ref bool keepAlive)
{
base.OnUpdate(effectEntity, ref keepAlive);
if (effectEntity.IsPlaying(PlayId))
{
keepAlive = true;
}
else if (hasFadeState && effectEntity.IsFading(PlayId) && fadeHash == animator.GetCurrentAnimatorStateInfo(0).shortNameHash)
{
keepAlive = true;
}
}
private void OnSpellLaunch(Unit caster, int spellId, SpellProcessingToken processingToken)
{
if (!balance.SpellInfosById.TryGetValue(spellId, out SpellInfo spellInfo))
{
return;
}
if (!unitRendererController.TryFind(caster.Id, out UnitRenderer casterRenderer))
{
return;
}
if (!spellInfo.HasAttribute(SpellCustomAttributes.CastWithoutAnimation))
{
casterRenderer.TriggerInstantCast();
}
if (!SpellVisuals.TryGetValue(spellId, out SpellVisualsInfo spellVisuals))
{
return;
}
if (spellVisuals.VisualsByUsage.TryGetValue(EffectSpellSettings.UsageType.Projectile, out EffectSpellSettings settings))
{
foreach (var entry in processingToken.ProcessingEntries)
{
if (unitRendererController.TryFind(entry.Item1, out UnitRenderer targetRenderer))
{
spellVisualController.SpawnVisual(casterRenderer, targetRenderer, settings, processingToken.ServerFrame, entry.Item2);
}
}
}
if (spellVisuals.VisualsByUsage.TryGetValue(EffectSpellSettings.UsageType.Cast, out EffectSpellSettings spellVisualEffect))
{
IEffectEntity effectEntity = spellVisualEffect.EffectSettings.PlayEffect(processingToken.Source + Vector3.up, caster.Rotation);
if (effectEntity != null && !spellInfo.HasAttribute(SpellCustomAttributes.LaunchSourceIsExplicit))
{
effectEntity.ApplyPositioning(casterRenderer.TagContainer, spellVisualEffect);
}
}
if (spellInfo.ExplicitTargetType == SpellExplicitTargetType.Destination)
{
if (spellVisuals.VisualsByUsage.TryGetValue(EffectSpellSettings.UsageType.Destination, out EffectSpellSettings destinationEffect))
{
destinationEffect.EffectSettings.PlayEffect(processingToken.Destination + Vector3.up, caster.Rotation);
}
}
}
protected override void OnUpdate(IEffectEntity effectEntity, ref bool keepAlive)
{
base.OnUpdate(effectEntity, ref keepAlive);
if (effectEntity.IsPlaying(PlayId) && effectEntity.KeepAliveWithNoParticles)
{
keepAlive = true;
}
else
{
foreach (ParticleSystem system in trackedParticleSystems)
{
keepAlive |= system.IsAlive(false);
}
}
}
public bool HandleLaunch(UnitRenderer caster)
{
Vector3 forward = TargetRenderer.transform.position - caster.transform.position;
projectile = Settings.EffectSettings.PlayEffect(Vector3.zero, Quaternion.LookRotation(forward), out long newPlayId);
if (projectile != null)
{
casterLaunchPosition = caster.TagContainer.FindDefaultLaunchTag();
caster.TagContainer.ApplyPositioning(projectile, Settings);
playId = newPlayId;
return(true);
}
return(false);
}
private void OnSpellHit(Unit target, int spellId)
{
if (!unitRendererController.TryFind(target.Id, out UnitRenderer targetRenderer))
{
return;
}
if (!SpellVisuals.TryGetValue(spellId, out SpellVisualsInfo spellVisuals))
{
return;
}
if (spellVisuals.VisualsByUsage.TryGetValue(EffectSpellSettings.UsageType.Impact, out EffectSpellSettings spellVisualEffect))
{
IEffectEntity effectEntity = spellVisualEffect.EffectSettings.PlayEffect(target.Position, target.Rotation);
effectEntity?.ApplyPositioning(targetRenderer.TagContainer, spellVisualEffect);
}
}
public void ApplyPositioning(IEffectEntity effectEntity, IEffectPositionerSettings settings)
{
Transform targetTag;
switch (settings.EffectTagType)
{
case EffectTagType.Bottom:
targetTag = bottomTag ?? defaultTag;
break;
case EffectTagType.Foot:
targetTag = footTag ?? defaultTag;
break;
case EffectTagType.Impact:
targetTag = impactTag ?? defaultTag;
break;
case EffectTagType.ImpactStatic:
targetTag = impactStaticTag ?? defaultTag;
break;
case EffectTagType.RightHand:
targetTag = rightHandTag ?? defaultTag;
break;
case EffectTagType.LeftHand:
targetTag = leftHandTag ?? defaultTag;
break;
default:
throw new ArgumentOutOfRangeException(nameof(settings.EffectTagType));
}
if (settings.AttachToTag)
{
effectEntity.Transform.SetParent(targetTag);
}
effectEntity.KeepAliveWithNoParticles = settings.KeepAliveWithNoParticles;
effectEntity.KeepOriginalRotation = settings.KeepOriginalRotation;
effectEntity.Transform.position = targetTag.position;
}
protected virtual void OnUpdate(IEffectEntity effectEntity, ref bool keepAlive)
{
}
internal void DoUpdate(IEffectEntity effectEntity, ref bool keepAlive) => OnUpdate(effectEntity, ref keepAlive);
public SpellVisualAuraState(long playId, IEffectEntity effectEntity)
{
PlayId = playId;
EffectEntity = effectEntity;
}
public static void ApplyPositioning(this IEffectEntity effectEntity, IEffectPositioner positioner, IEffectPositionerSettings settings)
{
positioner.ApplyPositioning(effectEntity, settings);
}
