use Vector2 for CameraManager interpolation; preserve tuple API

Author: JaskRendix

pyscroll/camera_manager.py

@@ -2,18 +2,24 @@
 
 from typing import TYPE_CHECKING
 
+from pygame.math import Vector2
+
 if TYPE_CHECKING:
     from pygame.rect import Rect
 
     from pyscroll.camera import BaseCamera
 
 
 class CameraManager:
+    """
+    Manages active cameras and smooth transitions between them.
+    """
+
     def __init__(self, initial_camera: BaseCamera):
         self.current = initial_camera
         self.next_cam: BaseCamera | None = None
-        self.transition_time: float = 0
-        self.transition_duration: float = 0
+        self.transition_time: float = 0.0
+        self.transition_duration: float = 0.0
         self._last_position: tuple[float, float] | None = None
 
     @property
@@ -27,15 +33,15 @@ def is_transitioning(self) -> bool:
         return self.next_cam is not None
 
     def set_camera(self, cam: BaseCamera, duration: float = 0.0) -> None:
-        if duration <= 0:
+        if duration <= 0.0:
             self.current = cam
             self.next_cam = None
-            self.transition_time = 0
+            self.transition_time = 0.0
             return
 
         self.next_cam = cam
         self.transition_duration = duration
-        self.transition_time = 0
+        self.transition_time = 0.0
 
     def update(
         self, current_view: Rect, target_rect: Rect, dt: float
@@ -45,21 +51,22 @@ def update(
             self._last_position = pos
             return pos
 
-        # Both cameras update every frame so their internal state stays current
-        pos_a = self.current.update(current_view, target_rect, dt)
-        pos_b = self.next_cam.update(current_view, target_rect, dt)
+        # Update both cameras to keep internal state in sync
+        pos_a = Vector2(*self.current.update(current_view, target_rect, dt))
+        pos_b = Vector2(*self.next_cam.update(current_view, target_rect, dt))
 
         self.transition_time += dt
         t = min(self.transition_time / self.transition_duration, 1.0)
-        t = t * t * (3 - 2 * t)  # smoothstep
 
-        x = pos_a[0] + (pos_b[0] - pos_a[0]) * t
-        y = pos_a[1] + (pos_b[1] - pos_a[1]) * t
+        # smoothstep
+        t_smooth = t * t * (3.0 - 2.0 * t)
+
+        final_pos = pos_a.lerp(pos_b, t_smooth)
 
         if t >= 1.0:
             self.current = self.next_cam
             self.next_cam = None
 
-        pos = (x, y)
-        self._last_position = pos
-        return pos
+        result = (final_pos.x, final_pos.y)
+        self._last_position = result
+        return result