Make sure camera zoom is not lower than minimal allowed zoom when smooth tracking is disabled.

See #65

Author: veger

changelog.txt

@@ -1,4 +1,9 @@
 ---------------------------------------------------------------------------------------------------
+Version: 2.0.2
+
+  Bugfixes:
+    - Make sure camera zoom is not lower than minimal allowed zoom when smooth tracking is disabled.
+---------------------------------------------------------------------------------------------------
 Version: 2.0.1
 Date: 22-10-204
   Bugfixes:

scripts/camera.lua

@@ -166,6 +166,7 @@ function Camera.followTracker(playerSettings, player, camera, tracker, disableSm
     else
         camera.centerPos = tracker.centerPos
         camera.zoom = Camera.zoom(camera, tracker)
+        Camera.sanitizeZoom(camera, playerSettings, player)
     end
 
     Camera.refreshChartTags(player, camera, captureBox, camera.centerPos, camera.zoom)
@@ -196,19 +197,7 @@ function Camera.followTrackerSmooth(playerSettings, player, camera, tracker)
         transitionData.transitionTicksLeft = transitionData.transitionTicksLeft - 1
 
         camera.centerPos, camera.zoom = Camera.CameraTransition.lerp(transitionData)
-
-        if camera.zoom < minZoom then
-            if playerSettings.noticeMaxZoom == nil then
-                player.print({ "max-zoom" }, { r = 1 })
-                player.print({ "msg-once" })
-                playerSettings.noticeMaxZoom = true
-            end
-
-            camera.zoom = minZoom
-        else
-            -- Max (min actually) zoom is not reached (anymore)
-            playerSettings.noticeMaxZoom = nil
-        end
+        Camera.sanitizeZoom(camera, playerSettings, player)
 
         if transitionData.transitionTicksLeft <= 0 then
             -- Transition finished
@@ -241,6 +230,25 @@ function Camera.zoom(camera, tracker)
     return math.min(zoomX, zoomY, maxZoom)
 end
 
+-- Check if the camera zoom is valid
+--- @param camera Camera.camera
+--- @param playerSettings playerSettings
+--- @param player LuaPlayer
+function Camera.sanitizeZoom(camera, playerSettings, player)
+    if camera.zoom < minZoom then
+        if playerSettings.noticeMaxZoom == nil then
+            player.print({ "max-zoom" }, { r = 1 })
+            player.print({ "msg-once" })
+            playerSettings.noticeMaxZoom = true
+        end
+
+        camera.zoom = minZoom
+    else
+        -- Max (min actually) zoom is not reached (anymore)
+        playerSettings.noticeMaxZoom = nil
+    end
+end
+
 ---@param camera Camera.camera
 ---@param activeTracker Tracker.tracker
 function Camera.getScreenshotInterval(camera, activeTracker)
@@ -254,7 +262,12 @@ function Camera.getScreenshotInterval(camera, activeTracker)
     return camera.screenshotInterval
 end
 
-function Camera.setWidth(camera, width)
+-- Set the camera (resolution) width
+--- @param playerSettings playerSettings
+--- @param player LuaPlayer
+--- @param camera Camera.camera
+--- @param width any Camera (resolution) width
+function Camera.setWidth(playerSettings, player, camera, width)
     width = tonumber(width)
 
     if width == nil or width < 320 then
@@ -268,13 +281,17 @@ function Camera.setWidth(camera, width)
         local _, activeTracker = Tracker.findActiveTracker(camera.trackers, camera.surfaceName)
         if activeTracker ~= nil then
             -- Force update zoom level to make sure the tracked area stays the same
-            ---@diagnostic disable-next-line: param-type-mismatch player(Data) can be nil when disableSmooth is true
-            Camera.followTracker(nil, nil, camera, activeTracker, true)
+            Camera.followTracker(playerSettings, player, camera, activeTracker, true)
         end
     end
 end
 
-function Camera.setHeight(camera, height)
+-- Set the camera (resolution) height
+--- @param playerSettings playerSettings
+--- @param player LuaPlayer
+--- @param camera Camera.camera
+--- @param height any Camera (resolution) height
+function Camera.setHeight(playerSettings, player, camera, height)
     height = tonumber(height)
 
     if height == nil or height < 240 then
@@ -288,8 +305,7 @@ function Camera.setHeight(camera, height)
         local _, activeTracker = Tracker.findActiveTracker(camera.trackers, camera.surfaceName)
         if activeTracker ~= nil then
             -- Force update zoom level to make sure the tracked area stays the same
-            ---@diagnostic disable-next-line: param-type-mismatch player(Data) can be nil when disableSmooth is true
-            Camera.followTracker(nil, nil, camera, activeTracker, true)
+            Camera.followTracker(playerSettings, player, camera, activeTracker, true)
         end
     end
 end

scripts/gui.lua

@@ -549,11 +549,13 @@ function GUI.onTextChanged(event)
             playerSettings.cameras[playerSettings.guiPersist.selectedCamera]
         )
     elseif event.element.name == "camera-resolution-x" then
-        Camera.setWidth(playerSettings.cameras[playerSettings.guiPersist.selectedCamera], event.element.text)
+        Camera.setWidth(playerSettings, playerSettings.cameras[playerSettings.guiPersist.selectedCamera],
+            event.element.text)
         GUI.updateCameraInfo(playerSettings.gui.cameraInfo,
             playerSettings.cameras[playerSettings.guiPersist.selectedCamera])
     elseif event.element.name == "camera-resolution-y" then
-        Camera.setHeight(playerSettings.cameras[playerSettings.guiPersist.selectedCamera], event.element.text)
+        Camera.setHeight(playerSettings, playerSettings.cameras[playerSettings.guiPersist.selectedCamera],
+            event.element.text)
         GUI.updateCameraInfo(playerSettings.gui.cameraInfo,
             playerSettings.cameras[playerSettings.guiPersist.selectedCamera])
     elseif event.element.name == "camera-frame-rate" then

tests/camera.lua

@@ -82,6 +82,7 @@ function TestCamera:SetUp()
     -- Make cameras easier to test
     self.testCameraPlayer1 = storage.playerSettings[1].cameras[1]
     self.testCameraPlayer2 = storage.playerSettings[2].cameras[1]
+    self.testPlayer1 = storage.playerSettings[1]
     for _, playerSettings in pairs(storage.playerSettings) do
         for _, camera in pairs(playerSettings.cameras) do
             for k, v in pairs(
@@ -191,12 +192,14 @@ function TestCamera:TestResolutionChange()
 
     -- force set camera position and zoom
     ---@diagnostic disable-next-line: param-type-mismatch player(Data) can be nil when disableSmooth is true
-    TLBE.Camera.followTracker(nil, nil, self.testCameraPlayer1, baseTracker, true)
+    TLBE.Camera.followTracker(self.testPlayer1, nil, self.testCameraPlayer1, baseTracker, true)
     local oldZoom = self.testCameraPlayer1.zoom;
     local oldCenterPos = self.testCameraPlayer1.centerPos;
 
-    TLBE.Camera.setWidth(self.testCameraPlayer1, self.testCameraPlayer1.width * 2)
-    TLBE.Camera.setHeight(self.testCameraPlayer1, self.testCameraPlayer1.height * 2)
+    ---@diagnostic disable-next-line: param-type-mismatch player(Data) can be nil when minZoom is not reached
+    TLBE.Camera.setWidth(self.testPlayer1, nil, self.testCameraPlayer1, self.testCameraPlayer1.width * 2)
+    ---@diagnostic disable-next-line: param-type-mismatch player(Data) can be nil when minZoom is not reached
+    TLBE.Camera.setHeight(self.testPlayer1, nil, self.testCameraPlayer1, self.testCameraPlayer1.height * 2)
 
     lu.assertEquals(self.testCameraPlayer1.centerPos.x, oldCenterPos.x, "expected centerpos to be the same")
     lu.assertEquals(self.testCameraPlayer1.centerPos.y, oldCenterPos.y, "expected centerpos to be the same")

tests/camera_follow-tracker.lua

@@ -97,6 +97,33 @@ function TestCameraFollowTracker:TestZoom()
     lu.assertEquals(self.testCamera.zoom, 0.5, "expected that zoom halved")
 end
 
+function TestCameraFollowTracker:TestMinZoom()
+    self.testTracker.smooth = false
+    self.testTracker.size = { -- Large enough to hit the minZoom
+        x = self.testCamera.width / tileSize * 2000,
+        y = self.testCamera.height / tileSize * 2000
+    }
+
+    local ticks = ConvergenceTester({}, { print = function() end }, self.testCamera, self.testTracker)
+
+    lu.assertEquals(ticks, 1, "expected to converge immediately")
+
+    lu.assertEquals(self.testCamera.zoom, 0.03125, "expected that zoom is at minZoom")
+end
+
+function TestCameraFollowTracker:TestMinZoomSmooth()
+    self.testTracker.size = { -- Large enough to hit the minZoom
+        x = self.testCamera.width / tileSize * 2000,
+        y = self.testCamera.height / tileSize * 2000
+    }
+
+    local ticks = ConvergenceTester({}, { print = function() end }, self.testCamera, self.testTracker)
+
+    lu.assertEquals(ticks, self.testCamera.transitionTicks, "couldn't converge in expected 14 ticks")
+
+    lu.assertEquals(self.testCamera.zoom, 0.03125, "expected that zoom is at minZoom")
+end
+
 function TestCameraFollowTracker:TestConvergenceDiagonal()
     self.testTracker.centerPos = { x = 10, y = 6 }