/// <summary>
/// Constructs movement data.
/// </summary>
/// <param name="walk">Must be a valid movement. CANNOT be a noop.</param>
/// <param name="run">Optional, if set, movement is will be interpreted as running.</param>
public MoveMessage(DirectionDelta walk, DirectionDelta run)
{
Debug.Assert(!walk.IsNoop());
Dir1 = walk;
Dir2 = run;
IsWalking = Dir2.IsNoop();
}
/// <summary>
/// Generates direction deltas to move an entity from the beginning position <see cref="us"/> to the target ending position <see cref="target"/>.
/// This algorithm does not generate deltas which navigate around obsticles.
/// This algorithim will cause undefined behaviour if any other <see cref="DirectionDelta"/> were to be applied to entity for which directions are being generated.
/// If <see cref="us"/> and <see cref="target"/> are equal, this algorithm will return noop directions.
/// </summary>
/// <param name="us">The starting position.</param>
/// <param name="target">The goal.</param>
/// <returns>A lazy <see cref="IEnumerable{T}"/> containing DirectionDeltas that lead to <see cref="target"/></returns>
public static IEnumerable <DirectionDelta> WalkTo(IPosition us, IPosition target)
{
/*
* Starting position is only used once to initialize a starting location,
* to which the algorithm will add to during each evaluation of the IEnumerable
* in order to keep track of where the entity is.
*/
var x = us.X;
var y = us.Y;
var z = us.Z;
// "while we still need to move"
while (x != target.X || y != target.Y)
{
if (z != target.Z)
{
yield return(DirectionDelta.Noop);
}
else
{
/* if target is higher than us, we have to walk up
* and if the target is lower than us, then we have to walk down.
*/
/* We do this comparison for both X and Y axis so we know in which
* direction we will have to walk for both of them
*/
var diffX = x < target.X ? (sbyte)1 : (sbyte)-1;
var diffY = y < target.Y ? (sbyte)1 : (sbyte)-1;
// We return the delta that will get us closer to the target.
/* We do have to check if one of the axis coordinates is the same for us and the target,
* since if we do share a mutual coordinate, we do not have to move.
* Therefore we return 0 if we have mututal coordinates and the diff of that axis if we do not (in order to get closer to it)
*/
var delta = new DirectionDelta(
target.X == x ? (sbyte)0 : diffX,
target.Y == y ? (sbyte)0 : diffY);
// sync local x y's
x += delta.X;
y += delta.Y;
yield return(delta);
}
}
// we've arrived, no further work needs to be done.
while (true)
{
yield return(DirectionDelta.Noop);
}
}
public void TestCtorConsistency()
{
foreach (var dir in Enum.GetValues(typeof(Direction)).Cast <Direction>())
{
var dirFromDir = new DirectionDelta(dir);
var dirFromDelta = new DirectionDelta(dirFromDir.X, dirFromDir.Y);
Assert.AreEqual(dirFromDir.Direction, dir);
Assert.AreEqual(dirFromDelta.Direction, dir);
Assert.AreEqual(dirFromDir.X, dirFromDelta.X);
Assert.AreEqual(dirFromDir.Y, dirFromDelta.Y);
}
}
public GeneratedDirections(DirectionDelta walk, DirectionDelta run)
{
// if walk is noop but run isin't, swap places
if (walk.IsNoop() && !run.IsNoop())
{
Walk = run;
Run = walk;
}
else
{
Walk = walk;
Run = run;
}
}
public bool TryConvertToDelta(out DirectionDelta delta)
{
delta = DirectionDelta.Noop;
return(false);
}
public bool TryConvertToDelta(out DirectionDelta delta) => _default.TryConvertToDelta(out delta);
public DirecionFacingState(DirectionDelta dir, ITransform transform)
{
_dir = dir;
_transform = transform;
}
public bool TryConvertToDelta(out DirectionDelta delta)
{
delta = _dir;
return(true);
}
