public void CastGroundTarget(Vector3 worldPos)
{
var origin = Self.transform.position;
var boxBaseSize = new Vector2(_pathWidth, 2);
var length = AbilityHelper.GetLineLength(origin, worldPos);
length = Mathf.Min(length, CurrentCastRange);
var boxHalfExtents = new Vector3(boxBaseSize.x, boxBaseSize.y, length) / 2;
var rotation = AbilityHelper.GetRotation(origin, worldPos);
var center = AbilityHelper.GetBoxCenter(origin, boxHalfExtents, rotation);
var colliders = Physics.OverlapBox(center, boxHalfExtents, rotation, (int)LayerMaskFlag.Entity);
var dmg = new Damage(_damage, DamageType.Magical, DamageFlags.Ability);
foreach (var col in colliders)
{
if (!AbilityHelper.TryGetActor(col, out var actor))
{
continue; //Not an actor, ignore
}
if (!CheckBuilder.AllowTarget(actor))
{
continue; //Ignore if allies
}
if (!actor.TryGetModule <IDamageable>(out var damageTarget))
{
continue; //Ignore if cant damage
}
damageTarget.TakeDamage(Self, dmg);
}
}
public void CastNoTarget()
{
//TODO channel
var targets = Physics.OverlapSphere(Self.transform.position, _aoeSearchRange, (int)LayerMaskFlag.Entity);
var damage = new Damage(_aoeDamage, DamageType.Magical, DamageFlags.Ability);
foreach (var target in targets)
{
if (!AbilityHelper.TryGetActor(target, out var actor))
{
continue;
}
if (!CheckBuilder.AllowTarget(actor))
{
continue;
}
if (!actor.TryGetModule <IDamageable>(out var damageTarget))
{
continue;
}
damageTarget.TakeDamage(Self, damage);
}
}
private bool TrySearchTarget(Vector3 area, ICollection <Actor> ignore, out Actor target)
{
var potentialTargets = Physics.OverlapSphere(area, _searchRange, (int)LayerMaskFlag.Entity);
foreach (var potentialTarget in potentialTargets)
{
if (!AbilityHelper.TryGetActor(potentialTarget, out var actor))
{
continue;
}
if (!Checker.AllowTarget(actor))
{
continue;
}
if (ignore.Contains(actor))
{
continue;
}
//TODO when targetable works, add this
// if (!actor.TryGetComponent<ITargetable>(out _))
// continue;
if (!actor.TryGetModule <IDamageable>(out _))
{
continue;
}
target = actor;
return(true);
}
target = default;
return(false);
}
public void CastGroundTarget(Vector3 worldPos)
{
var origin = Self.transform.position;
var length = AbilityHelper.GetLineLength(origin, worldPos);
var boxHalfExtents = new Vector3(_pathWidth, 2f, length);
var rotation = AbilityHelper.GetRotation(origin, worldPos);
var center = AbilityHelper.GetBoxCenter(origin, boxHalfExtents, rotation);
var colliders = Physics.OverlapBox(center, boxHalfExtents, rotation, (int)LayerMaskFlag.Entity);
var atkDamage = Modules.Attackerable.Damage;
var dmg = new Damage(_bonusDamage + atkDamage, DamageType.Physical,
DamageFlags.Ability | DamageFlags.Attack);
foreach (var col in colliders)
{
if (!AbilityHelper.TryGetActor(col, out var actor))
{
continue;
}
if (!Checker.AllowTarget(actor))
{
continue;
}
Modules.Attackerable.RawAttack(actor, dmg);
}
Modules.Movable.WarpTo(worldPos);
Modules.Commandable.ClearCommands();
}
private void OnActorExit(object sender, TriggerEventArgs args)
{
var collider = args.Collider;
if (!AbilityHelper.TryGetActor(collider, out var actor))
{
return;
}
if (!actor.TryGetModule <IAbilitiable>(out var abilitiable))
{
return;
}
abilitiable.AbilityCasted -= OnAbilityCast;
_targetBuffer.Remove(abilitiable);
}
private void Nurture_Exit(object sender, TriggerEventArgs e)
{
var col = e.Collider;
if (!AbilityHelper.TryGetActor(col, out var actor))
{
return;
}
if (!actor.TryGetModule <IHealable>(out var healable))
{
return;
}
healable.HealingModifiers -= NurtrueModifier;
_nurtureTargets.Remove(healable);
}
private void InstantlyRebuildTargets()
{
while (_targets.Count > 0)
{
InternalRemoveActor(_targets[0]);
}
var colliders = Trigger.Trigger.OverlapCollider((int)LayerMaskFlag.Entity);
foreach (var col in colliders)
{
if (AbilityHelper.TryGetActor(col, out var actor))
{
InternalAddActor(actor);
}
}
}
public override void ConfirmCast()
{
if (!Checker.AllowCast())
{
return;
}
var ray = AbilityHelper.GetScreenRay();
if (!AbilityHelper.TryGetWorldOrEntity(ray, out var hit))
{
return;
}
var unitCast = AbilityHelper.TryGetActor(hit.collider, out var actor);
if (actor == Self)
{
return;
}
var position = unitCast
? actor.transform.position
: hit.point;
if (!CastRange.InRange(position))
{
return;
}
if (unitCast)
{
if (!Checker.AllowTarget(actor))
{
return;
}
Checker.DoCast();
CastObjectTarget(actor);
}
else
{
Checker.DoCast();
CastGroundTarget(position);
}
Modules.Abilitiable.NotifyAbilityCast(new AbilityEventArgs(Self, Checker.MagicCost.Cost));
}
private void FixedUpdate()
{
var variant = GetVariant();
var ray = AbilityHelper.GetScreenRay();
bool isHovering = false;
if (Physics.Raycast(ray, out var hit, MaxDistance, Mask))
{
isHovering = AbilityHelper.TryGetActor(hit.collider, out _);
}
var desired = GetCursorIcon(variant, isHovering);
//We cant set the cursor every frame, because it doesnt move when you do
if (desired != _prev)
{
SetCursor(desired, CursorMode.Auto);
_prev = desired;
}
}
private void Nurture_Enter(object sender, TriggerEventArgs e)
{
var col = e.Collider;
if (!AbilityHelper.TryGetActor(col, out var actor))
{
return;
}
if (!actor.TryGetModule <IHealable>(out var healable))
{
return;
}
if (!CheckBuilder.AllowTarget(actor))
{
return;
}
healable.HealingModifiers += NurtrueModifier;
_nurtureTargets.Add(healable);
}
public override void ConfirmCast()
{
if (!Checker.AllowCast())
{
return;
}
var ray = AbilityHelper.GetScreenRay();
if (!AbilityHelper.TryGetWorldOrEntity(ray, out var hit))
{
return;
}
var unitTarget = AbilityHelper.TryGetActor(hit.collider, out var actor);
if (actor == Self)
{
return;
}
if (!unitTarget && !CastRange.InRange(hit.point))
{
return;
}
if (unitTarget && !CastRange.InRange(actor))
{
return;
}
Checker.DoCast();
if (!unitTarget)
{
CastGroundTarget(hit.point);
}
else
{
CastObjectTarget(actor);
}
Modules.Abilitiable.NotifyAbilityCast(new AbilityEventArgs(Self, View.StatCost.Cost));
}
private void RecalculateNurtureTargets()
{
var colliders = _nurtureAura.Collider.OverlapSphere();
foreach (var col in colliders)
{
if (!AbilityHelper.TryGetActor(col, out var actor))
{
return;
}
if (!actor.TryGetModule <IHealable>(out var healable))
{
return;
}
if (!CheckBuilder.AllowTarget(actor))
{
return;
}
healable.HealingModifiers += NurtrueModifier;
_nurtureTargets.Add(healable);
}
}
public void CastVectorTarget(Vector3 worldPos, Vector3 direction)
{
var searchRange = _searchRange;
var minDot = NormalizedSideAngle;
var hasTeamable = Modules.TryGetCached <ITeamable>(out var teamable);
var colliders = Physics.OverlapSphere(worldPos, searchRange, (int)LayerMaskFlag.Entity);
foreach (var col in colliders)
{
//Actor check
if (!AbilityHelper.TryGetActor(col, out var actor))
{
continue;
}
//Outside of angle range check
var fwd = actor.transform.position - worldPos;
if (Vector3.Dot(worldPos, fwd) < minDot)
{
continue;
}
//Ally check
if (hasTeamable)
{
if (actor.TryGetModule <ITeamable>(out var otherTeamable))
{
if (teamable.IsAlly(otherTeamable))
{
continue;
}
}
}
//Valid target, hit the actor
TryHitActor(actor);
}
}
public void CastObjectTarget(Actor target)
{
//Deal damage
var damage = new Damage(_damage, DamageType.Magical, DamageFlags.Ability);
// var targetable = target.GetComponent<ITargetable>();
var damagable = target.GetModule <IDamageable>();
damagable.TakeDamage(Self, damage);
//Gather DOT targets
var dotTargets = new List <Actor> {
target
};
if (IsInOverheat)
{
var colliders = Physics.OverlapSphere(target.transform.position, _overheatSearchRange,
(int)LayerMaskFlag.Entity);
foreach (var collider in colliders)
{
if (!AbilityHelper.TryGetActor(collider, out var actor))
{
continue;
}
if (!CheckBuilder.AllowTarget(actor))
{
continue;
}
if (actor == target) //Already added
{
continue;
}
dotTargets.Add(actor);
}
}
foreach (var actor in dotTargets)
{
if (!actor.TryGetModule <IDamageable>(out var damageTarget))
{
continue;
}
var source = Self;
var dotDamage = new Damage(_tickDamage, DamageType.Magical, DamageFlags.Ability);
void internalFunc()
{
damageTarget.TakeDamage(source, dotDamage);
}
var tickWrapper = new TickAction
{
Callback = internalFunc,
TickCount = _tickCount,
TickInterval = _tickInterval
};
if (actor.TryGetModule <IKillable>(out var killable))
{
killable.Died += RemoveTick;
}
void RemoveTick(object sender, DeathEventArgs args)
{
killable.Died -= RemoveTick;
_ticks.Remove(tickWrapper);
}
_ticks.Add(tickWrapper);
ApplyFX(actor.transform, _tickCount * _tickInterval);
}
}
