PrimeTween Documentation

A Sequence is a container for grouping tweens, callbacks, and other sequences. It allows you to orchestrate complex animations that can overlap, run sequentially, or run in parallel.

Sequence Composition Methods:

• Insert(float atTime, Tween/Sequence animation): Places an animation at a specific time, overlapping with existing animations. This may increase the total sequence duration.
• Chain(Tween/Sequence animation): Places an animation after all previously added animations. Chained animations run sequentially.
• Group(Tween/Sequence animation): Groups an animation with the preceding animation in the sequence. Grouped animations start at the same time and run in parallel.

To apply cycles to a Sequence, use Sequence.Create(cycles: numCycles, cycleMode: CycleMode.Yoyo).

Sequence.Create(cycles: 10, CycleMode.Yoyo)
    // PositionX and Scale tweens are 'grouped', so they will run in parallel
    .Group(Tween.PositionX(transform, endValue: 10f, duration: 1.5f))
    .Group(Tween.Scale(transform, endValue: 2f, duration: 0.5f, startDelay: 1))
    // Rotation tween is 'chained' so it will start when both previous tweens are finished (after 1.5 seconds)
    .Chain(Tween.Rotation(transform, endValue: new Vector3(0f, 0f, 45f), duration: 1f)) 
    .ChainDelay(1)
    .ChainCallback(() => Debug.Log("Sequence cycle completed"))
    // Insert color animation at time of '0.5' seconds
    // Inserted animations overlap with other animations in the sequence
    .Insert(atTime: 0.5f, Tween.Color(image, Color.red, duration: 0.5f));

The TweenAnimation class (available in PrimeTween PRO) allows you to create and tweak complex animations directly in the Unity Inspector without writing code.

Key Features

• Inspector Workflow: Add multiple animations using the '+' button. Chain, delay, or insert animations at specific times.
• Edit Mode Preview: Use the preview controls at the top of the Inspector to test animations without entering Play Mode.
• Trigger(): Plays the animation. For simple/infinite animations, it plays from the start; for reversible animations, it changes direction.
• state { get; set; }: Manages the logical state.
  • Simple: true if playing.
  • Infinite: true if playing and not interrupted.
  • Reversible: true if moving forward or at the end. Setting this changes direction.
• isReversible: A boolean property useful for toggle animations (e.g., open/close). Setting state = true plays forward, state = false reverses.

// Add TweenAnimation to your script, then set the animation up in the Inspector.
[SerializeField] TweenAnimation doorAnimation = new();

void Update() {
    if (Input.GetKeyDown(KeyCode.Space)) {
        // Play the animation in response to gameplay events.
        doorAnimation.Trigger();

        // Or set the state directly.
        doorAnimation.state = true;
    }
}

If you are moving from DOTween to PrimeTween, use the following mapping for common operations:

Virtual and Custom Tweens

• DOVirtual.DelayedCall() $\rightarrow$ Tween.Delay()
• DOTween.To() $\rightarrow$ Tween.Custom()
• DOVirtual.Vector3() $\rightarrow$ Tween.Custom()

Sequences

• DOTween.Sequence() $\rightarrow$ Sequence.Create()
• sequence.Join() $\rightarrow$ sequence.Group()
• sequence.Append() $\rightarrow$ sequence.Chain()
• sequence.AppendCallback() $\rightarrow$ sequence.ChainCallback()
• seq.Insert(1.5f, trans.DOMoveX(...)) $\rightarrow$ seq.Insert(1.5f, Tween.PositionX(trans, ...)) or use seq.Group(Tween.PositionX(..., startDelay: 1.5f)) before the first Chain() operation.
• seq.InsertCallback(1f, callback) $\rightarrow$ seq.InsertCallback(1f, callback)

Lifecycle and Control

• DOTween.Kill(target, false) $\rightarrow$ Tween.StopAll(onTarget: target)
• DOTween.Kill(target, true) $\rightarrow$ Tween.CompleteAll(onTarget: target)

Coroutines and Async/Await

• yield return tween.WaitForCompletion() $\rightarrow$ yield return tween.ToYieldInstruction()
• yield return sequence.WaitForCompletion() $\rightarrow$ yield return sequence.ToYieldInstruction()
• await tween.AsyncWaitForCompletion() $\rightarrow$ await tween (PrimeTween supports await directly on tweens and sequences, even on WebGL)

Transform and Property Tweens

• transform.DOMoveX(to, 1).From(from) $\rightarrow$ Tween.PositionX(transform, from, to, 1)
• trans.DOMove(pos, speed).SetSpeedBased() $\rightarrow$ Tween.PositionAtSpeed(trans, pos, speed)
• tween.SetDelay(1f).OnStart(callback) $\rightarrow$ Tween.Delay(1, callback).Chain(tween)
• sequence.OnStart(callback) $\rightarrow$ sequence.ChainCallback(callback) (at the beginning of the sequence)

Other Mappings

• tween.SetId() $\rightarrow$ See GitHub Discussion
• target.DOBlendable___(...) $\rightarrow$ Tween.___Additive(target, ...) (experimental)