Kaskade

public class Path
{
    public Belt Belt { get; set; }
    public List<Path> Paths { get; set; }

    public Path(Belt belt)
    {
        Belt = belt;
        Paths = new List<Path>();
    }
}

private class TraversalContext
{
    public bool VisitedCombiner { get; set; }
    public Belt CombinerParent { get; set; }
}

private static Path CalculatePathRecursive(Belt startingBelt, Belt currentBelt, int lineIndex, int beltDepth, bool useSwitchTargets, HashSet<Belt> visited, TraversalContext context)
{
    // Terminate if we've reached the maximum depth or detected a loop.
    if (beltDepth == 0 || visited.Contains(currentBelt))
    {
        return new Path(currentBelt);
    }

    visited.Add(currentBelt);

    Path currentPath = new Path(currentBelt);

    // Early exit if the current belt is the end of the line
    if (currentBelt is BeltLastRow && currentBelt.MyDirection == Direction.South) return currentPath;

    // Early exit if the target is null or is set to deliver to the current belt
    Node targetNeighbour = currentBelt.Director.TargetNeighbour;
    if (targetNeighbour == null) return currentPath;
    if (NodeUtilities.Facing(currentBelt, targetNeighbour)) return currentPath;

    // If using a switch, resolve to the sending neighbour
    if (UseSwitchSendingNeighbours(currentBelt))
    {
        currentBelt = currentBelt.sendingNeighbours[0];
    }

    // Update the traversal context if the current belt is set to Combine
    if (currentBelt.combine.SetToCombiner)
    {
        context.CombinerParent = currentBelt;
        context.VisitedCombiner = true;
    }

    // Get the target neighbours for this belt
    List<Belt> nextBelts = GetTargets(currentBelt, lineIndex, useSwitchTargets);

    foreach (Belt belt in nextBelts)
    {
        // Avoid looping back to the starting belt.
        if (belt == startingBelt) continue;

        // Recursively calculate the path with decreased depth.
        Path nextPath = CalculatePathRecursive(
            startingBelt,
            belt,
            lineIndex,
            beltDepth - 1,
            useSwitchTargets,
            visited,
            context);
        currentPath.Paths.Add(nextPath);
    }

    return currentPath;
}

public class WidgetMover : MonoBehaviour
{
    // REFERENCES (set via Initialize)
    private Widget _widget;
    private BoxCollider _collider;
    private Vector3 _startingScale;
    private WidgetVisuals _visuals;

    [Header("Movement Settings")]
    public Vector3 sinkOffset = new Vector3(0, 4, 0);
    public Transform WidgetMeshTransform { get; private set; }

    [Header("Easing Functions")]
    public EasingFunctions.Ease ease = EasingFunctions.Ease.EaseInCubic;
    public EasingFunctions.Ease jumpEase = EasingFunctions.Ease.EaseInCubic;
    public EasingFunctions.Ease flyEase = EasingFunctions.Ease.EaseInCubic;

    private EasingFunctions.Function _easeFunc;
    private EasingFunctions.Function _jumpEaseFunc;
    private EasingFunctions.Function _flyEaseFunc;

    // STRATEGY PATTERN
    private Coroutine _moveRoutine;
    private Dictionary<MoveType, IMover> _moveStrategies;
    private IMover _standard;

    private void Awake()
    {
        if (transform.childCount > 0)
        {
            WidgetMeshTransform = transform.GetChild(0);
        }
        else
        {
            Debug.Log("Missing child game object on Widget " + name);
        }

        _easeFunc = EasingFunctions.GetEasingFunction(ease);
        _jumpEaseFunc = EasingFunctions.GetEasingFunction(jumpEase);
        _flyEaseFunc = EasingFunctions.GetEasingFunction(flyEase);
    }

    /// <summary>
    /// Initialise the WidgetMover with required dependencies
    /// And set up the strategy pattern dictionary
    /// </summary>
    public void Initialise(Widget widget, BoxCollider boxCollider, WidgetVisuals visuals)
    {
        _widget = widget;
        _collider = boxCollider;
        _visuals = visuals;

        if (_widget == null || _collider == null || _visuals == null)
        {
            Debug.Log("Widget Mover: Unable to initialise movement strategies");
            return;
        }

        InitialiseMoveDictionary();
    }

    private void InitialiseMoveDictionary()
    {
        _standard = new StandardMove(_widget, transform, _collider, _easeFunc, FinalizeMovement);

        _moveStrategies = new Dictionary<MoveType, IMover>
        {
            { MoveType.Standard,
                _standard },
            { MoveType.Jump,
                new JumpMove(_widget, transform, WidgetMeshTransform, _jumpEaseFunc, FinalizeMovement) },
            { MoveType.Teleport,
                new TeleportMove(_widget, transform, _collider, _easeFunc, _startingScale, _standard) },
            { MoveType.EdgeTeleport,
                new EdgeTeleportMove(_widget, transform, _collider, _easeFunc, _startingScale, FinalizeMovement) },
            { MoveType.Sink,
                new SinkMove(_widget, transform, WidgetMeshTransform, _jumpEaseFunc, _visuals, sinkOffset) },
            { MoveType.Fly,
                new FlyMove(_widget, transform, WidgetMeshTransform, _flyEaseFunc, _jumpEaseFunc, FinalizeMovement) }
        };
    }

    /// <summary>
    /// Run a move widget coroutine, selecting the appropriate routine from the dictionary
    /// </summary>
    public void MoveToTheTarget(
        Vector3 targetPosition,
        float moveTime,
        Belt currentBelt,
        Node nextNode,
        MoveType moveType = MoveType.Standard,
        Direction direction = Direction.South)
    {
        if (!_moveStrategies.ContainsKey(moveType))
        {
            Debug.LogError($"Move strategy for {moveType} is not initialized.");
            return;
        }

        if (_moveRoutine != null) StopCoroutine(_moveRoutine);
        _moveRoutine = _moveStrategies[moveType].Move(targetPosition, moveTime, currentBelt, nextNode, direction);
    }

    /// <summary>
    /// Final callback executed when a movement coroutine is completed.
    /// </summary>
    private void FinalizeMovement(Node next, bool jump)
    {
        _moveRoutine = null;

        if (_widget.Status == WidgetStatus.Destroyed) return;

        if (jump) next.PlayWidgetLandVfx();
        _widget.RegisterArrival(next);

#if UNITY_EDITOR
        if (next != null && next.Destroyed)
        {
            Debug.Log("Arrived at a destroyed belt" + next.name);
        }
#endif
    }

    private void OnDisable()
    {
        if (_moveRoutine != null) StopCoroutine(_moveRoutine);
    }
}

public interface IMover
{
    Coroutine Move(
        Vector3 target,
        float moveTime,
        Belt current,
        Node next,
        Direction direction = Direction.South);
}

public class JumpMove : IMover
{
    private readonly Widget _widget;
    private readonly Transform _transform;
    private readonly Transform _widgetMeshTransform;
    private readonly EasingFunctions.Function _easeFunc;
    private readonly Action<Node, bool> _finaliseMovement;

    public JumpMove(Widget widget, Transform transform, Transform widgetMeshTransform, EasingFunctions.Function easeFunc, Action<Node, bool> finaliseMovement)
    {
        _widget = widget;
        _transform = transform;
        _widgetMeshTransform = widgetMeshTransform;
        _easeFunc = easeFunc;
        _finaliseMovement = finaliseMovement;
    }

    public Coroutine Move(Vector3 target, float moveTime, Belt current, Node next, Direction direction = Direction.South)
    {
        return _widget.StartCoroutine(JumpWidget(target, moveTime, current, next, direction));
    }

    private IEnumerator JumpWidget(Vector3 target, float moveTime, Belt current, Node next, Direction direction)
    {
        float t = 0;
        Vector3 startPos = _transform.position;
        Vector3 axis = NodeUtilities.GetWidgetAxisFromDirection(direction);

        _widget.SetJumping(true);
        while (t < moveTime)
        {
            if (Speed.Paused)
            {
                yield return null;
                continue;
            }

            if (_widget.Jumping == false || _widget.Status == WidgetStatus.Destroyed) yield break;
            float f = _easeFunc(0, 1, t / moveTime);

            // POSITION
            _transform.position = NodeUtilities.BezierCurveLerp(startPos, target, PlayerSettingsData.JumpControlPointHeight, f);

            // ROTATION
            float angle = Mathf.Lerp(0, -180, f);
            _widgetMeshTransform.localRotation = Quaternion.AngleAxis(angle, axis);

            t += Time.deltaTime;
            yield return null;
        }

        _transform.position = target;
        _widgetMeshTransform.localRotation = Quaternion.AngleAxis(-180f, axis);

        _widget.RegisterMoveComplete(MoveType.Jump);
        _widget.SetJumping(false);

        if (_widget.Status != WidgetStatus.Enabled) yield break;
        _finaliseMovement(next, true);
    }
}

public static class NodeUtilities
{
    public static Vector3 GetWidgetAxisFromDirection(Direction direction)
    {
        return direction switch
        {
            Direction.North => Vector3.left,
            Direction.East => Vector3.forward,
            Direction.South => Vector3.right,
            Direction.West => Vector3.back,
            _ => throw new ArgumentOutOfRangeException(nameof(direction), direction, null)
        };
    }

    public static Vector3 BezierCurveLerp(Vector3 start, Vector3 end, float controlPointHeight, float t)
    {
        Vector3 p1 = Vector3.Lerp(start, end, 0.333f);
        Vector3 p2 = Vector3.Lerp(start, end, 0.666f);

        p1.y += controlPointHeight;
        p2.y += controlPointHeight;

        return (((-start + 3 * (p1 - p2) + end) * t + (3 * (start + p2) - 6 * p1)) * t + 3 * (p1 - start)) * t + start;
    }
}