Group Sequence with delay

[flo-wolf]

Hey :)

I am often "composing" multiple sequences into each other, where I have one big sequence into which I chain/group lots of other sequences. I often get to the point where I want to start two sequences at once (i.e. group), but one of them should start with some delay. I could do this with an insert, but for that i'd need the current duration of the sequence and computing this delay through adding up the durations of all other chained sequences seems combersome and not maintainable.

My current solution is to chain a delay to the start of the sequence I want to group. It doesn't feel very clean though and is not that easy to work with:

private void CreateBigSequence()
{
    Sequence bigSequence = Sequence.Create();
    bigSequence.Chain(_firstSequence);
    bigSequence.Group(_secondSequence);
    bigSequence.Group(GetMyThirdSequence(0.1f)); // third sequence should start playing 0.1 seconds after first sequence
}

private Sequence GetMyThirdSequence(float delay)
{
    Sequence thirdSequence = CreateDelayedSequence(delay);
    thirdSequence.Chain(...);
    return thirdSequence;
}

public Sequence CreateDelayedSequence(float startDelay)
{
    Sequence sequence = Sequence.Create();
    if (startDelay > 0f)
        sequence.ChainDelay(startDelay);
    return sequence;
}

Doing that with inserts instead is even more complicated, since I can't switch _secondSequence and the third sequence, because then _secondSequence couldn't be grouped with first anymore (also it's odd to read, since practically the second sequence starts before the third).

What would be cool:

private void CreateBigSequence()
{
    Sequence bigSequence = Sequence.Create();
    bigSequence.Chain(_firstSequence);
    bigSequence.Group(_secondSequence);
    bigSequence.Group(GetMyThirdSequence(), delay: 0.1f);
}

[flo-wolf]

Another workaround I found is this - it's not that clean though, since it looks like I create one Sequence too much:

public static Sequence GroupWithDelay(this Sequence mainSequence, float delay, Sequence sequence)
{
	if (delay <= 0f)
	{
		return mainSequence.Group(sequence);
	}

	Sequence delayedSequence = Sequence.Create();
	delayedSequence.ChainDelay(delay);
	delayedSequence.Chain(sequence);
	return mainSequence.Group(delayedSequence);
}

Another similar helper I found useful (not related to my issue though):

/// <summary>
/// Chains a sequence with an overlap time (i.e. "negative delay").
/// This is useful if you want to chain a sequence, but you want the chained sequence to start before the previous one ends.
/// </summary>
public static Sequence ChainWithOverlap(this Sequence mainSequence, float overlap, Sequence sequence)
{
	if (overlap <= 0f)
	{
		return mainSequence.Chain(sequence);
	}
	return mainSequence.Insert(mainSequence.duration - overlap, sequence);
}