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);
}

[KyryloKuzyk]

Hey @flo-wolf, it's fine to create many empty sequences with PrimeTween, and it should not hurt performance :)

So, your proposal is to add a new delay parameter:

bigSequence.Group(GetMyThirdSequence(), delay: 0.1f);

But for me, it looks very similar to what the Insert method does. So, your sample code could be written like this:

private void CreateBigSequence()
{
    Sequence bigSequence = Sequence.Create();
    bigSequence.Chain(_firstSequence);
    bigSequence.Group(_secondSequence);
    bigSequence.Insert(atTime: 0.1f, GetMyThirdSequence());
    // To continue grouping, insert the next sequence at 0f:
    bigSequence.Insert(atTime: 0f, _forthSequence);
    bigSequence.Group(_fifthSequence);
}

Or you can add all the grouped sequences first, then insert sequences that should be delayed.

[flo-wolf]

Thank you for the reply! bigSequence.Insert(atTime: 0.1f, GetMyThirdSequence()); indeed does seem similar, but the problem is that I do not know the time at that point, I just know what "offset" i want relative to the previous element in the sequence. In your example you know that atTime is 0.1, but say the sequence is much bigger, and you simply don't know that exact insertion time.

So say this sequence contains 20 elements before the one I want to group with a delay. This means I need to know the duration of the whole sequence, excluding the one I want to group with, plus my delay. This seems like a lot of number juggeling, not directly adding other tweens/sequences to the main sequence, but caching them in some variable to get their duration so I can use it to compute my insertion time

It is good to know though that Sequence.Create() won't create much overhead, so my helper function solution might do for now :)

Or you can add all the grouped sequences first, then insert sequences that should be delayed.

This would work, but it does create some extra lines of code that makes it harder to maintain, which is why I opted for some extension methods to get that "group with delay" in a single line