/// <summary>
/// Converts a <see cref="RefinementDirection"/> into a <see cref="Vector3"/>.
/// </summary>
/// <param name="direction">
/// The <see cref="RefinementDirection"/> to convert.
/// </param>
/// <returns>
/// The <see cref="Vector3"/> that represents the direction.
/// </returns>
static public Vector3 ToVector(this RefinementDirection direction)
{
switch (direction)
{
case RefinementDirection.Forward:
return(Vector3.forward);
case RefinementDirection.Back:
return(Vector3.back);
case RefinementDirection.Down:
return(Vector3.down);
case RefinementDirection.Left:
return(Vector3.left);
case RefinementDirection.Right:
return(Vector3.right);
case RefinementDirection.Up:
return(Vector3.up);
default:
throw new InvalidOperationException($"Unknown {nameof(RefinementDirection)}: {direction}");
}
}
/// <summary>
/// Nudges the transform in the specified direction.
/// </summary>
/// <param name="direction">
/// The direction to nudge in.
/// </param>
public void Nudge(RefinementDirection direction)
{
// Figure out which actual direction
RefinementDirection actualDireciton = direction.RelativeTo(forwardDirection);
// Create the offset
Vector3 offset = actualDireciton.ToVector() * directionAmount;
// Update the position using the correct coordinate space (local vs world)
TargetTransform.Translate(offset, space);
}
/// <summary>
/// Attempts to convert a <see cref="Vector3"/> into a <see cref="RefinementDirection"/>.
/// </summary>
/// <param name="vector">
/// The <see cref="Vector3"/> to convert.
/// </param>
/// <param name="direction">
/// The output <see cref="RefinementDirection"/> if successfully converted.
/// </param>
/// <returns>
/// <c>true</c> if the conversion was successful; otherwise <c>false</c>.
/// </returns>
static public bool TryGetDirection(this Vector3 vector, out RefinementDirection direction)
{
// Default to forward
direction = RefinementDirection.Forward;
// What is the vector?
if (vector == Vector3.back)
{
direction = RefinementDirection.Back;
return(true);
}
else if (vector == Vector3.down)
{
direction = RefinementDirection.Down;
return(true);
}
else if (vector == Vector3.forward)
{
direction = RefinementDirection.Forward;
return(true);
}
else if (vector == Vector3.left)
{
direction = RefinementDirection.Left;
return(true);
}
else if (vector == Vector3.right)
{
direction = RefinementDirection.Right;
return(true);
}
else if (vector == Vector3.up)
{
direction = RefinementDirection.Up;
return(true);
}
// No conversion possible
return(false);
}
/// <summary>
/// Gets a direction relative to the specified direction.
/// </summary>
/// <param name="direction">
/// The direction used to obtain the relative direction.
/// </param>
/// <returns>
/// The relative direction.
/// </returns>
static public RefinementDirection RelativeTo(this RefinementDirection direction, RefinementDirection relative)
{
switch (relative)
{
case RefinementDirection.Forward: // Facing Forward
switch (direction)
{
case RefinementDirection.Forward:
return(RefinementDirection.Forward); // Facing Forward Looking Forward is Forward
case RefinementDirection.Back:
return(RefinementDirection.Back); // Facing Forward Looking Back is Back
case RefinementDirection.Down:
return(RefinementDirection.Down); // Facing Forward Looking Down is Down
case RefinementDirection.Left:
return(RefinementDirection.Left); // Facing Forward Looking Left is Left
case RefinementDirection.Right:
return(RefinementDirection.Right); // Facing Forward Looking Right is Right
case RefinementDirection.Up:
return(RefinementDirection.Up); // Facing Forward Looking Up is Up
default:
throw new InvalidOperationException($"Unknown {nameof(RefinementDirection)}: {relative}");
}
case RefinementDirection.Back: // Back Looking
switch (direction)
{
case RefinementDirection.Forward:
return(RefinementDirection.Back); // Facing Back Looking Forward is Back
case RefinementDirection.Back:
return(RefinementDirection.Forward); // Facing Back Looking Back is Forward
case RefinementDirection.Down:
return(RefinementDirection.Down); // Facing Back Looking Down is Down
case RefinementDirection.Left:
return(RefinementDirection.Right); // Facing Back Looking Left is Right
case RefinementDirection.Right:
return(RefinementDirection.Left); // Facing Back Looking Right is Left
case RefinementDirection.Up:
return(RefinementDirection.Up); // Facing Back Looking Up is Up
default:
throw new InvalidOperationException($"Unknown {nameof(RefinementDirection)}: {relative}");
}
case RefinementDirection.Down: // Facing Down
switch (direction)
{
case RefinementDirection.Forward:
return(RefinementDirection.Down); // Facing Down Looking Forward is Down
case RefinementDirection.Back:
return(RefinementDirection.Up); // Facing Back Looking Back is Up
case RefinementDirection.Down:
return(RefinementDirection.Back); // Facing Down Looking Down is Back
case RefinementDirection.Left:
return(RefinementDirection.Left); // Facing Down Looking Left is Left
case RefinementDirection.Right:
return(RefinementDirection.Right); // Facing Down Looking Right is Right
case RefinementDirection.Up:
return(RefinementDirection.Forward); // Facing Down Looking Up is Forward
default:
throw new InvalidOperationException($"Unknown {nameof(RefinementDirection)}: {relative}");
}
case RefinementDirection.Left: // Facing Left
switch (direction)
{
case RefinementDirection.Forward:
return(RefinementDirection.Left); // Facing Left Looking Forward is Left
case RefinementDirection.Back:
return(RefinementDirection.Right); // Facing Left Looking Back is Right
case RefinementDirection.Down:
return(RefinementDirection.Down); // Facing Left Looking Down is Down
case RefinementDirection.Left:
return(RefinementDirection.Back); // Facing Left Looking Left is Back
case RefinementDirection.Right:
return(RefinementDirection.Forward); // Facing Left Looking Right is Forward
case RefinementDirection.Up:
return(RefinementDirection.Up); // Facing Left Looking Up is Up
default:
throw new InvalidOperationException($"Unknown {nameof(RefinementDirection)}: {relative}");
}
case RefinementDirection.Right: // Facing Right
switch (direction)
{
case RefinementDirection.Forward:
return(RefinementDirection.Right); // Facing Right Looking Forward is Forward
case RefinementDirection.Back:
return(RefinementDirection.Left); // Facing Right Looking Back is Left
case RefinementDirection.Down:
return(RefinementDirection.Down); // Facing Right Looking Down is Down
case RefinementDirection.Left:
return(RefinementDirection.Forward); // Facing Right Looking Left is Forward
case RefinementDirection.Right:
return(RefinementDirection.Back); // Facing Right Looking Right is Back
case RefinementDirection.Up:
return(RefinementDirection.Up); // Facing Right Looking Up is Up
default:
throw new InvalidOperationException($"Unknown {nameof(RefinementDirection)}: {relative}");
}
case RefinementDirection.Up: // Facing Up
switch (direction)
{
case RefinementDirection.Forward:
return(RefinementDirection.Up); // Facing Up Looking Forward is Up
case RefinementDirection.Back:
return(RefinementDirection.Down); // Facing Up Looking Back is Down
case RefinementDirection.Down:
return(RefinementDirection.Forward); // Facing Up Looking Down is Forward
case RefinementDirection.Left:
return(RefinementDirection.Left); // Facing Up Looking Left is Left
case RefinementDirection.Right:
return(RefinementDirection.Right); // Facing Up Looking Right is Right
case RefinementDirection.Up:
return(RefinementDirection.Back); // Facing Up Looking Up is Back
default:
throw new InvalidOperationException($"Unknown {nameof(RefinementDirection)}: {relative}");
}
default:
throw new InvalidOperationException($"Unknown {nameof(RefinementDirection)}: {direction}");
}
}
