/// <summary>
/// Attempt to perform the next stride in the list
/// </summary>
/// <param name="cycleTime">The current cycle time</param>
/// <returns>True if the next stride has started, false otherwise</returns>
public bool AttemptNextStride(float cycleTime)
{
bool strideStarted = false;
if (!IsStriding && _nextStrideIndex < _strides.Count)
{
if (_strides[_nextStrideIndex].Within(cycleTime))
{
float startTime = 0.0f; //May do something with this in the future
float availableStrideTime = _strides[_nextStrideIndex].End - cycleTime;
if (availableStrideTime >= _strides[_nextStrideIndex].StrideLength * MIN_STRIDE_PERCENT)
{
int next = (_nextStrideIndex + 1) % _strides.Count;
_nextStanceDuration = GaitStride.StanceLength(_strides[_nextStrideIndex], _strides[next]);
float stanceOffsetScale = _nextStanceDuration / LongestStance;
//Trigger Stride
BeginStride(0.0f, Height + PeakHeight, MAX_DISPLACEMENT * stanceOffsetScale, availableStrideTime + startTime, startTime);
_nextStrideIndex += 1;
strideStarted = true;
}
else
{
_nextStrideIndex += 1;
Debug.Log("Stride Skipped");
}
}
}
return(strideStarted);
}
/// <summary>
/// Calculates the duration of the longest stance any leg in this gait will experience
/// </summary>
/// <returns>The maximum stance</returns>
public float MaxStance()
{
float maxStance = 0.0f;
foreach (List <GaitStride> strides in _strideSets)
{
for (int i = 0; i < strides.Count; i++)
{
int next = (i + 1) % strides.Count;
maxStance = Mathf.Max(GaitStride.StanceLength(strides[i], strides[next]), maxStance);
}
}
return(maxStance);
}
//--------------------------------------------------
// Methods
//--------------------------------------------------
/// <summary>
/// Assign a new list of strides to this channel
/// </summary>
/// <param name="newStrides">The strides to assign, replacing the current list of strides</param>
/// <param name="cycleTime">The current cycle time</param>
public void AssignStrides(List <GaitStride> newStrides, float cycleTime)
{
_strides = new List <GaitStride>(newStrides);
_nextStrideIndex = 0;
//Depending on the cycle time, the first stride may not be the best one to start with
do
{
//Check if the stride start has already been passed
GaitStride nextStride = _strides[_nextStrideIndex % _strides.Count];
_nextStanceDuration = nextStride.Start - cycleTime;
if (_nextStanceDuration < 0.0f)
{
//If the stride isn't one cycle ahead
if (_nextStrideIndex < _strides.Count)
{
//See if there's enough time to do a worthwhile stride
float availableStrideTime = nextStride.End - cycleTime;
if (availableStrideTime >= nextStride.StrideLength * MIN_STRIDE_PERCENT)
{
_nextStanceDuration = 0.0f; //There is so zero the stance duration
}
else
{
_nextStrideIndex++; //There isn't so move on to the next stride
}
}
else
{
//We're back to the first stride so add a whole cycle to the stance preceding it
_nextStanceDuration += 1.0f;
}
}
} while (_nextStanceDuration < 0.0f);
LongestStance = 0.0f;
for (int i = 0; i < _strides.Count; i++)
{
int next = (i + 1) % _strides.Count;
LongestStance = Mathf.Max(GaitStride.StanceLength(_strides[i], _strides[next]), LongestStance);
}
NextAvailableStancePercent = _nextStanceDuration / (Displacement + MAX_DISPLACEMENT);
}
/// <summary>
/// Calculates the time between the end of the first provided stride and the start of the second provided stride.
/// These two strides should be neighbours
/// </summary>
/// <param name="first">The first stride</param>
/// <param name="second">The second stride</param>
/// <returns>The stance length</returns>
public static float StanceLength(GaitStride first, GaitStride second)
{
return(((second.Start >= first.TrueEnd) ? second.Start : second.Start + 1.0f) - first.TrueEnd);
}
//--------------------------------------------------
// Methods
//--------------------------------------------------
/// <summary>
/// Adds a GaitStride for the specified leg
/// </summary>
/// <param name="legIndex">The leg to add the stride to</param>
/// <param name="stride">The stride definition to add</param>
public void AddStride(int legIndex, GaitStride stride)
{
_strideSets[legIndex].Add(stride);
}
