//------------------------------------------------------------------------------------------------------------------/
void OnTileChange(ITileable source)
{
if (source.Navigator.Current != Navigator.Current)
{
return;
}
Apply(source);
}
void OnMoveDone(ITileable tileable)
{
var damageable = Player.Active.GetComponent <EntityDamageable>();
damageable.IsInvulnerable = false;
Player.Active.onMoveDone -= OnMoveDone;
End();
}
void OnMoveEnd(ITileable tileable)
{
tileable.onMoveDone -= OnMoveEnd;
business--;
if (business == 0)
{
End();
}
}
void OnMoveDone(ITileable tileable)
{
isWaiting = false;
if (shouldAttack)
{
Attack();
}
nav.Target.onMoveDone -= OnMoveDone;
Inputs.isLocked = false;
}
protected override void HandleTarget(ITileable target, IAttributeHolder attributes)
{
var component = (Component)target;
if (!component.TryGetComponent <T>(out var mutable))
{
return;
}
base.HandleTarget(target, attributes);
mutable.Dirty();
}
protected override void ApplyTo(Tile source, IEnumerable <Tile> tiles, IReadOnlyDictionary <Id, List <CastArgs> > args)
{
var entities = tiles.SelectMany(tile => tile.Entities);
if (!entities.Any())
{
End();
return;
}
target = entities.First();
Routines.Start(Execute());
}
protected virtual void HandleTarget(ITileable target, IAttributeHolder attributes)
{
var boost = GetBoost();
if (boost is IWrapper <int> wrapper && wrapper.Value != 0)
{
var pool = Repository.Get <SequencerPool>(Pools.Popup);
var popup = pool.RequestSinglePoolable() as Popup;
popup.transform.position = attributes.PopupAnchor.Position;
var prefix = wrapper.Value < 0 ? '-' : '+';
popup.Play($"{prefix}{Mathf.Abs(wrapper.Value)}", Type);
}
attributes.Add(boost);
}
protected virtual void Apply(ITileable source)
{
var map = Repository.Get <Map>(References.Map);
var tile = map.Tilemap.WorldToCell(transform.position).ToTile();
if (tile.Entities.Any(tileable => tileable is Tileable))
{
animator.SetTrigger("Explode");
}
AudioHandler.Play(trapSound);
Routines.Start(Routines.DoAfter(() =>
{
spell.Prepare();
spell.CastFrom(tile, Spellcaster.EmptyArgs);
}, new YieldTime()));
}
protected override void Apply(ITileable source)
{
if (!Navigator.Current.Entities.Any(entity => entity is Tileable))
{
SlideDirection = Vector2Int.zero;
return;
}
foreach (var entity in Navigator.Current.Entities)
{
if (entity is Golem golem)
{
if (golem.HasJustSpawned)
{
return;
}
}
}
if (source is Tileable tileable)
{
Buffer.slideDirections.Enqueue(tileable.LastDirection.ComputeOrientation());
if (tileable.IsMoving)
{
tileable.InterruptMove();
}
}
else
{
if (SlideDirection == Vector2Int.zero)
{
return;
}
Buffer.slideDirections.Enqueue(SlideDirection);
SlideDirection = Vector2Int.zero;
}
Routines.Start(Routines.DoAfter(() =>
{
spell.Prepare();
spell.CastFrom(Navigator.Current, Spellcaster.EmptyArgs);
}, new YieldFrame()));
}
protected virtual Vector2Int GetOrientationFor(ITileable target, int force)
{
var direction = Vector3.Normalize(target.Navigator.Current.GetWorldPosition() - Buffer.caster.Current.GetWorldPosition());
return(direction.xy().ComputeOrientation() * (int)Mathf.Sign(force));
}
public bool visible(ITileable tile)
{
return(currentView.Contains(new Vector2(tile.MyPosition.X, tile.MyPosition.Y)));
}
protected override Vector2Int GetOrientationFor(ITileable target, int force) => Buffer.slideDirections.Dequeue();
//------------------------------------------------------------------------------------------------------------------/
public static bool TryGet <T>(this ITileable tileable, out T output) where T : ITag
{
if (tileable is Component component && component.TryGetComponent <T>(out output))
{
return(true);
}
public virtual void Unregister(ITileable entity) => entities.Remove(entity);
public virtual void Register(ITileable entity) => entities.Add(entity);
