private void Cast(Actor caster, Actor target)
{
//Deal damage
var damagePerTick = new Damage(_tickDamage, DamageType.Magical, DamageFlags.Ability);
var damage = new SourcedDamage(caster, damagePerTick);
var damageable = target.GetModule <IDamageable>();
void InternalTick()
{
damageable.TakeDamage(damage);
}
var tickWrapper = new TickAction
{
Callback = InternalTick,
TickCount = _tickCount,
TickInterval = _tickInterval
};
if (target.TryGetModule <IKillable>(out var killable))
{
killable.Died += RemoveTick;
}
void RemoveTick(object sender, DeathEventArgs args)
{
killable.Died -= RemoveTick;
Ticks.Remove(tickWrapper);
}
Ticks.Add(tickWrapper);
ApplyFX(target.transform, _tickInterval * _tickCount);
}
public void Queue(TickAction action, double milliseconds)
{
System.Timers.Timer timer;
if (FreeTimers.Count == 0)
{
timer = new System.Timers.Timer(milliseconds);
timer.AutoReset = false;
timer.SynchronizingObject = owner;
BusyTimers.Add(timer);
}
else
{
int i = FreeTimers.Count - 1;
timer = FreeTimers[i];
FreeTimers.RemoveAt(i);
timer.Interval = milliseconds;
}
System.Timers.ElapsedEventHandler handler = delegate(object sender, System.Timers.ElapsedEventArgs e) {
HandleTimerTick(timer, action);
};
timer.Elapsed += handler;
}
public void FocusCameraToPos(Vector3 _focalPos, float _focusDuration, Graph _focusGraph)
{
_focalPos.y -= mfCenterYOffset;
_focalPos = ConstrainVectorToCameraBounds(_focalPos);
MoveToAction focusToPos = new MoveToAction(camTransform, _focusGraph, _focalPos, _focusDuration);
TickAction updateMiniMap = new TickAction(_focusDuration, UpdateMiniMap);
ActionHandler.RunAction(focusToPos, updateMiniMap);
}
internal static bool RemoveTick(TickAction action)
{
if (_ticking)
{
var index = _tickActions.IndexOf(action);
if (index < 0)
{
return(false);
}
if (index <= _tickingIndex)
{
_tickingIndex--;
}
return(_tickActions.Remove(action));
}
else
{
return(_tickActions.Remove(action));
}
}
/// <summary>
/// Can be called from any thread. Releases the specified timer and invokes the
/// specified action on the owning thread.
/// </summary>
private void HandleTimerTick(System.Timers.Timer timer, TickAction action)
{
// Marshal to main thread if required
if (owner.InvokeRequired)
{
owner.Invoke((TickAction) delegate() { HandleTimerTick(timer, action); }, null);
}
else
{
BusyTimers.Remove(timer);
if (FreeTimers.Count >= MaxTimerReserve)
{
timer.Dispose();
}
else
{
FreeTimers.Add(timer);
}
action();
}
}
// ================================================================================
// constructor
// --------------------------------------------------------------------------------
public Ticker(TickAction tickHandler, float interval = 1.0f)
{
_tickEvent = tickHandler;
_interval = interval;
}
internal static void AddTick(TickAction action)
{
_tickActions.Add(action);
}
// ================================================================================
// constructor
// --------------------------------------------------------------------------------
public Ticker(TickAction tickHandler, float interval = 1.0f)
{
_tickEvent = tickHandler;
_interval = interval;
}
public void RemoveTicker(TickAction tickAction)
{
tickActions.Remove(tickAction);
}
public void RegisterTicker(TickAction tickAction)
{
tickActions.Add(tickAction);
}
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);
}
}