Use normalized movement settings

Assets/Scripts/Core/Settings/DivingMinigameSettings.cs

@@ -64,6 +64,10 @@ namespace AppleHills.Core.Settings
         [Tooltip("How long to continue spawning tiles after surfacing begins (seconds)")]
         [SerializeField] private float surfacingSpawnDelay = 5.0f;
         
+        [Header("Normalized Movement")]
+        [Tooltip("Reference screen height for normalized velocity calculations")]
+        [SerializeField] private float referenceScreenHeight = 1080f;
+        
         [Header("Tile Generation")]
         [Tooltip("Initial number of tiles to create at start")]
         [SerializeField] private int initialTileCount = 3;
@@ -71,17 +75,21 @@ namespace AppleHills.Core.Settings
         [Tooltip("Buffer distance for spawning new tiles")]
         [SerializeField] private float tileSpawnBuffer = 1f;
         
-        [Tooltip("Base movement speed for tiles")]
-        [SerializeField] private float moveSpeed = 3f;
+        [Tooltip("Base movement speed for tiles in screen units per second (normalized)")]
+        [SerializeField] private float normalizedTileMoveSpeed = 0.3f;
         
         [Tooltip("Factor to increase speed by each interval")]
-        [SerializeField] private float speedUpFactor = 0.2f;
+        [SerializeField] private float speedUpFactor = 0.05f;
         
         [Tooltip("Time interval between speed increases (seconds)")]
         [SerializeField] private float speedUpInterval = 10f;
         
-        [Tooltip("Maximum movement speed allowed")]
-        [SerializeField] private float maxMoveSpeed = 12f;
+        [Tooltip("Maximum normalized movement speed allowed for tiles")]
+        [SerializeField] private float maxNormalizedTileMoveSpeed = 1.2f;
+        
+        // Legacy settings - keeping for backward compatibility
+        [HideInInspector] [SerializeField] private float moveSpeed = 3f;
+        [HideInInspector] [SerializeField] private float maxMoveSpeed = 12f;
         
         [Tooltip("Interval for velocity calculations (seconds)")]
         [SerializeField] private float velocityCalculationInterval = 0.5f;
@@ -99,11 +107,11 @@ namespace AppleHills.Core.Settings
         [Tooltip("Radius around obstacle spawn point to check for tile collisions")]
         [SerializeField] private float obstacleSpawnCollisionRadius = 1f;
         
-        [Tooltip("Minimum movement speed for spawned obstacles")]
-        [SerializeField] private float obstacleMinMoveSpeed = 1f;
+        [Tooltip("Minimum normalized movement speed for obstacles (screen units per second)")]
+        [SerializeField] private float normalizedObstacleMinMoveSpeed = 0.1f;
         
-        [Tooltip("Maximum movement speed for spawned obstacles")]
-        [SerializeField] private float obstacleMaxMoveSpeed = 4f;
+        [Tooltip("Maximum normalized movement speed for obstacles (screen units per second)")]
+        [SerializeField] private float normalizedObstacleMaxMoveSpeed = 0.4f;
         
         [Header("Collision Handling")]
         [Tooltip("Duration in seconds of damage immunity after being hit")]
@@ -148,10 +156,11 @@ namespace AppleHills.Core.Settings
         // IDivingMinigameSettings implementation - Tile Generation
         public int InitialTileCount => initialTileCount;
         public float TileSpawnBuffer => tileSpawnBuffer;
-        public float MoveSpeed => moveSpeed;
+        public float ReferenceScreenHeight => referenceScreenHeight;
+        public float NormalizedMoveSpeed => normalizedTileMoveSpeed;
         public float SpeedUpFactor => speedUpFactor;
         public float SpeedUpInterval => speedUpInterval;
-        public float MaxMoveSpeed => maxMoveSpeed;
+        public float MaxNormalizedMoveSpeed => maxNormalizedTileMoveSpeed;
         public float VelocityCalculationInterval => velocityCalculationInterval;
 
         // IDivingMinigameSettings implementation - Obstacles
@@ -159,8 +168,8 @@ namespace AppleHills.Core.Settings
         public float ObstacleSpawnIntervalVariation => obstacleSpawnIntervalVariation;
         public int ObstacleMaxSpawnAttempts => obstacleMaxSpawnAttempts;
         public float ObstacleSpawnCollisionRadius => obstacleSpawnCollisionRadius;
-        public float ObstacleMinMoveSpeed => obstacleMinMoveSpeed;
-        public float ObstacleMaxMoveSpeed => obstacleMaxMoveSpeed;
+        public float ObstacleMinMoveSpeed => normalizedObstacleMinMoveSpeed;
+        public float ObstacleMaxMoveSpeed => normalizedObstacleMaxMoveSpeed;
 
         // IDivingMinigameSettings implementation - Collision Handling
         public float DamageImmunityDuration => damageImmunityDuration;
@@ -211,10 +220,10 @@ namespace AppleHills.Core.Settings
             // Validate tile generation
             initialTileCount = Mathf.Max(1, initialTileCount);
             tileSpawnBuffer = Mathf.Max(0f, tileSpawnBuffer);
-            moveSpeed = Mathf.Max(0.1f, moveSpeed);
+            normalizedTileMoveSpeed = Mathf.Max(0.01f, normalizedTileMoveSpeed);
             speedUpFactor = Mathf.Max(0f, speedUpFactor);
             speedUpInterval = Mathf.Max(0.1f, speedUpInterval);
-            maxMoveSpeed = Mathf.Max(moveSpeed, maxMoveSpeed);
+            maxNormalizedTileMoveSpeed = Mathf.Max(normalizedTileMoveSpeed, maxNormalizedTileMoveSpeed);
             velocityCalculationInterval = Mathf.Max(0.01f, velocityCalculationInterval);
 
             // Validate obstacle values
@@ -222,8 +231,8 @@ namespace AppleHills.Core.Settings
             obstacleSpawnIntervalVariation = Mathf.Max(0f, obstacleSpawnIntervalVariation);
             obstacleMaxSpawnAttempts = Mathf.Max(1, obstacleMaxSpawnAttempts);
             obstacleSpawnCollisionRadius = Mathf.Max(0.1f, obstacleSpawnCollisionRadius);
-            obstacleMinMoveSpeed = Mathf.Max(0.1f, obstacleMinMoveSpeed);
-            obstacleMaxMoveSpeed = Mathf.Max(obstacleMinMoveSpeed, obstacleMaxMoveSpeed);
+            normalizedObstacleMinMoveSpeed = Mathf.Max(0.1f, normalizedObstacleMinMoveSpeed);
+            normalizedObstacleMaxMoveSpeed = Mathf.Max(normalizedObstacleMinMoveSpeed, normalizedObstacleMaxMoveSpeed);
 
             // Validate collision settings
             damageImmunityDuration = Mathf.Max(0.1f, damageImmunityDuration);

Assets/Scripts/Core/Settings/SettingsInterfaces.cs

@@ -79,19 +79,24 @@ namespace AppleHills.Core.Settings
         // Tile Generation
         int InitialTileCount { get; }
         float TileSpawnBuffer { get; }
-        float MoveSpeed { get; }
         float SpeedUpFactor { get; }
         float SpeedUpInterval { get; }
-        float MaxMoveSpeed { get; }
         float VelocityCalculationInterval { get; }
         
+        // Normalized Movement
+        float ReferenceScreenHeight { get; } // Screen height reference for normalized velocities
+        
+        // Normalized Tile Movement
+        float NormalizedMoveSpeed { get; } // Gets normalizedTileMoveSpeed
+        float MaxNormalizedMoveSpeed { get; } // Gets maxNormalizedTileMoveSpeed
+        
         // Obstacles
         float ObstacleSpawnInterval { get; }
         float ObstacleSpawnIntervalVariation { get; }
         int ObstacleMaxSpawnAttempts { get; }
         float ObstacleSpawnCollisionRadius { get; }
-        float ObstacleMinMoveSpeed { get; }
-        float ObstacleMaxMoveSpeed { get; }
+        float ObstacleMinMoveSpeed { get; } // Gets normalizedObstacleMinMoveSpeed 
+        float ObstacleMaxMoveSpeed { get; } // Gets normalizedObstacleMaxMoveSpeed
         
         // Collision Handling
         float DamageImmunityDuration { get; }