/// <summary>
/// Attempt to parse input as a distance. Text inputs must be a number, followed by an optional unit, to be parsed as
/// a distance.
/// </summary>
/// <param name="text">Input to parse</param>
/// <param name="mob"></param>
/// <param name="distance">Distance to move, in millimeters. If -1, then parsing failed.</param>
/// <param name="startIndex">Where the distance is expected to be.</param>
/// <returns>Number of words successfully parsed. 0 if failed, up to 2 if succeeded. </returns>
public static int ParseAsDistance(StringWords text, out int distance, out MovementUnit unit, int startIndex = 0, int endIndex = 0)
{
distance = -1;
unit = MovementUnit.NoDistance;
if (startIndex >= text.Segments.Length)
{
return(0);
}
string firstWord, secondWord = null;
firstWord = text.Segments[startIndex];
if (startIndex < text.Segments.Length - 1)
{
secondWord = text.Segments[startIndex + 1];
}
int magnitude, distanceType;
if (!int.TryParse(firstWord, out magnitude))
{
if (secondWord == null || !int.TryParse(secondWord, out magnitude))
{
return(0);
}
//firstWord MUST be a valid distance enum.
if (FindAPreposition(text, typeof(Distances), out distanceType, startIndex, startIndex + 1) == -1)
{
return(0);
}
}
else
{
if (secondWord == null || FindAPreposition(text, typeof(Distances), out distanceType, startIndex + 1, startIndex + 2) == -1)
{
distanceType = (int)Distances.Default;
secondWord = null;
}
}
if (distanceType >= (int)Distances.Default)
{
distance = magnitude;
unit = distanceType == (int)Distances.Default ? MovementUnit.Unspecified :
distanceType == (int)Distances.Step ? MovementUnit.Step :
MovementUnit.NoDistance;
}
else
{
distance = (int)((magnitude * (long)distanceConversions[distanceType]) / 10);
unit = MovementUnit.Absolute;
}
return(secondWord == null ? 2 : 1);
}
private void Move(double amount, MovementUnit unit, int[][] sequences)
{
//1revolution = 512steps
int steps = (int)Math.Floor(amount * (unit == MovementUnit.Step ? 1 : 512));
for (int step = 0; step < steps; step++)
{
foreach (var sequence in sequences)
{
for (int i = 0; i < Pins.Length; i++)
{
Pins[i].Write(sequence[i] == 0 ? GpioPinValue.Low : GpioPinValue.High);
}
Task.Delay(1).Wait(); //Sleep(0.001)
}
}
}
private void Move(double amount, MovementUnit unit, int[][] sequences)
{
//1revolution = 512steps
int steps = (int)Math.Floor(amount * (unit == MovementUnit.Step ? 1 : 512));
for (int step = 0; step < steps; step++)
{
foreach (var sequence in sequences)
{
for (int i = 0; i < Pins.Length; i++)
{
Pins[i].Write(sequence[i] == 0 ? GpioPinValue.Low : GpioPinValue.High);
}
Task.Delay(1).Wait(); //Sleep(0.001)
}
}
}
/// <summary>
/// Attempt to parse user's input text as a direction / distance.
/// </summary>
/// <param name="text">Full input to parse</param>
/// <param name="startIndex">Index of first word to try to parse (inclusive). </param>
/// <param name="endIndex">Index of last word to try to parse (exclusive). If the text is found, this will be updated
/// to after the last word found (first index not belonging to the MovementDirection)</param>
/// <param name="requireDirection">If true, parsing will return failure if no direction component is found.</param>
/// <param name="requireDistance">If true, parsing will return failure if no distance component is found.</param>
/// <param name="getDistance">If true, distance may be parsed. This is ignored (assumed true) if requireDistance is true.</param>
/// <returns>The direction and distance parsed from the input text.</returns>
public static MovementDirection ParseAsDirection(StringWords text, int startIndex, ref int endIndex, bool requireDirection = false, bool requireDistance = false, bool getDirection = true, bool getDistance = true)
{
text.ValidateEndIndex(ref endIndex);
getDistance |= requireDistance;
Directions foundDirection = Directions.NoDirection;
//List<Directions> directions = new List<Directions>();
KeyValuePair <string[][], Directions[]> directionOptions = DirectionCommand.GetDirectionOptions();
string[][] directionStrings = directionOptions.Key;
Directions[] directionValues = directionOptions.Value;
int foundDistance = -1;
MovementUnit foundUnit = MovementUnit.NoDistance;
int i = startIndex;
for (; i < endIndex; i++)
{
string word = text.Segments[i];
if (foundDirection == Directions.NoDirection)
{
int found = MatchString(directionStrings, text.Segments, ref i);
if (found != -1)
{
foundDirection = directionValues[found];
//Loop will increment but i is already the correct value after MatchString,
i--; //decrement here to 'skip' the increment.
continue;
}
}
if (getDistance && foundUnit == MovementUnit.NoDistance)
{
int distanceWords = ParseAsDistance(text, out foundDistance, out foundUnit, i, Math.Min(i + 1, endIndex - 1));
if (distanceWords != 0)
{
if (distanceWords == 2)
{
i++;
}
continue;
}
}
break;
}
if (foundDirection == Directions.NoDirection && requireDirection)
{
return(null);
}
if (foundUnit == MovementUnit.NoDistance && requireDistance)
{
return(null);
}
if (foundDirection == Directions.NoDirection && foundUnit == MovementUnit.NoDistance)
{
return(null);
}
endIndex = i;
return(new MovementDirection()
{
direction = foundDirection,
distanceCount = foundDistance,
distanceUnit = foundUnit
});
}
public void Forward(double amount, MovementUnit unit)
{
Move(amount < 0 ? 0 : amount, unit, ClockwiseSequences);
}
public void Backward(double amount, MovementUnit unit)
{
Move(amount > 0 ? 0 : amount, unit, AntiClockwiseSequences);
}
public void Forward(double amount, MovementUnit unit)
{
Move(amount < 0 ? 0 : amount, unit, ClockwiseSequences);
}
public void Backward(double amount, MovementUnit unit)
{
Move(amount > 0 ? 0 : amount, unit, AntiClockwiseSequences);
}