Camera Snapping instead of panning

Here's a potentially over-engineered approach, but it's one that can scale robustly as you make your camera behaviours more complex.

Instead of the camera script implementing every follow behaviour, we'll delegate the logic of how to choose the position to a separate object (this is a form of the State Pattern). We'll start with an interface describing what's common to all follow behaviours:

public interface ICameraFollowBehaviour {
    Vector2 GetFollowPosition(Vector2 targetPos);
}

Then we can make concrete types for each behaviour we want:

(This may look like an unnecessary explosion of boilerplate code at first, but it will pay off...)

public class ExactFollowBehaviour : ICameraFollowBehaviour {
    // Since this version has no state parameters, we can make
    // just one instance and recycle it, rather than constructing copies.
    public static readonly ExactFollowBehaviour Instance = new();

    public Vector2 GetFollowPosition(Vector2 targetPos) => targetPos;
}

public class HorizontalFollowBehaviour : ICameraFollowBehaviour {
    readonly float _yCoordinate;

    public HorizontalFollowBehaviour(float yCoordinate) {
        _yCoordinate = yCoordinate;
    }

    public Vector2 GetFollowPosition(Vector2 targetPos) {
        targetPos.y = _yCoordinate;
        return targetPos;
    }
}

public class StaticFollowBehaviour : ICameraFollowBehaviour {
    readonly Vector2 _position;
    
    public StaticFollowBehaviour(Vector2 position) {
        _position = position;
    }

    public Vector2 GetFollowPosition(Vector2 targetPos) => _position;
}

Once each bit of following logic is its own object, we can compose those objects in very flexible ways to get more complex behaviours.

In particular: we can treat a blend-in-progress between two different camera follow behaviours as its own follow behaviour!

public class CrossfadeFollowBehaviour : ICameraFollowBehaviour {
    ICameraFollowBehaviour _previous, _current;
    float _blendProgress;
    float _blendSpeed;

    public CrossfadeFollowBehaviour(
        ICameraFollowBehaviour previous,
        ICameraFollowBehaviour current,
        float blendSeconds
    ) {
        _previous = previous; _current = current; _blendSpeed = 1f/blendSeconds;
    }

    public Vector2 GetFollowPosition(Vector2 targetPos) {

        targetPos = _current.GetFollowPosition(targetPos);

        // Skip blending if we've finished the cross-fade.
        if (_blendProgress < 1f) {
            var prev = _previous.GetFollowPosition(targetPos);

            _blendProgress = Mathf.Min(_blendProgress + Time.time * _blendSpeed, 1f);

            float blendWeight = Mathf.SmoothStep(0, 1, _blendProgress);

            targetPos = Vector2.Lerp(prev, targetPos, blendWeight);

            // Once it's faded out, let the garbage collector
            // eat the previous camera follow behaviour.
            if (_blendProgress == 1f) {
                _previous = null;
            }
        }

        return targetPos;
    }

    public CrossfadeFollowBehaviour CrossFadeTo(ICameraFollowBehaviour newBehaviour, float blendSeconds) {
        // If we're mid-blend, start a new cross-fade over this one.
        if (_blendProgress < 1f) {
            return new CrossfadeFollowBehaviour(this, newBehaviour, blendSeconds);
        }

        // If we're not mid-blend, recycle the current cross-fader.
        // (Saves a little garbage collection overhead)
        _previous = _current;
        _blendProgress = 0f;
        _blendSpeed = 1f / blendSeconds;
        return this;
    }
}

What we gain from this is that the exact logic of where the camera should go and any state-tracking around a blend in-progress has been delegated to the follow behaviours, so the component we put on the camera itself doesn't need to know any of this. It just needs to handle the logic for when to switch between behaviours.

The LateUpdate() call is dead simple: it just executes whatever follow behaviour is current.

public class CameraFollowSwitcher : MonoBehaviour {
    [SerializeField] Transform _target;   
    [SerializeField] CamMode _mode;
    [SerializeField] Vector2 _followPosition;

    [SerializeField] float _defaultBlendSeconds = 0.5f;

    CrossfadeFollowBehaviour _currentBehaviour;

    public void FollowExact(float blendSeconds = -1f) {
        // Ignore redundant requests to switch to the behaviour we're using.
        if (_mode == CamMode.Exact) return;

        _mode = CamMode.Exact;
        SetBehaviour(ExactFollowBehaviour.Instance, blendSeconds);
    }

    public void FollowHorizontal(float yCoordinate, float blendSeconds = -1f) {
        // Ignore redundant requests to switch to the behaviour we're using.
        if (_mode == CamMode.Horizontal && Mathf.Approximately(yCoordinate, _followPosition.y))
            return;

        _mode = CamMode.Horizontal;
        _followPosition.y = yCoordinate;
        SetBehaviour(new HorizontalFollowBehaviour(yCoordinate), blendSeconds);
    }

    public void FollowStatic(Vector2 holdPosition, float blendSeconds = -1f) {
        // Ignore redundant requests to switch to the behaviour we're using.
        if (_mode == CamMode.Static && holdPosition == _followPosition)
            return;

        _mode = CamMode.Horizontal;
        _followPosition = holdPosition;
        SetBehaviour(new StaticFollowBehaviour(holdPosition), blendSeconds);
    }

    void SetBehaviour(ICameraFollowBehaviour newBehaviour, float blendSeconds) {
        if (blendSeconds <= 0f) blendSeconds = _defaultBlendSeconds;
        _currentBehaviour = _currentBehaviour.CrossFadeTo(newBehaviour, blendSeconds);
    }

    void Awake() {
        ICameraFollowBehaviour initialFollow = _mode switch {
            CamMode.Horizontal => new HorizontalFollowBehaviour(_followPosition.y),
            CamMode.Static => new StaticFollowBehaviour(_followPosition),
            _ => ExactFollowBehaviour.Instance
        };
        _currentBehaviour = new CrossfadeFollowBehaviour(initialFollow, initialFollow, 0.001f);
    }

    void LateUpdate() {
        Vector2 targetPos = _target.position;
        targetPos = _currentBehaviour.GetFollowPosition(targetPos);

        Vector3 withZ = targetPos;
        withZ.z = transform.position.z;
        transform.position = withZ;
    }
}

This will work even if you start a new blend while an old blend is still in progress - you can blend from a blend from a blend...

The downside of this flexibility is that you incur a (very small) heap allocation each time you change to a new camera follow behaviour (plus one if you were mid-blend at the time). The memory for the previous behaviour/blend-in-progress can be garbage collected once the blend is finished. Since you're usually only changing blending modes every few seconds to minutes, not every frame, you're unlikely to experience any negative impacts from this small OOP overhead.

Just make sure you implement a little hysteresis in the transition zones/logic. You don't want the player to be able to straddle or vibrate across a threshold, where you're calling "Switch to follow behaviour A", "No, switch to follow behaviour B!" every few frames. That's why I have the methods above that validate we're not trying to switch to a state identical to the one we're in.

For example, if you have a boss room that uses a static camera, and outside that room you want to go back to the exact follow, you can place two trigger objects near the entrances/exits:

• The trigger to switch to the static camera should be positioned just inside the room

• The trigger to switch back to exact following should be positioned just outside the room

Make the player backtrack a few steps to get from one trigger to the other, demonstrating a deliberate attempt to enter / leave. This both avoids stacking up blends needlessly, and will look smoother to the player - the camera will move decisively when switching modes, rather than hesitating.