Implemented proper frame limiting.

I removed the fixed SDL_Delay(75) calls and replaced them with a more
dynamic frame limiting approach based on the actual frame time.

The rendering issues are far from fixed but at least this means things
should theoretically be more consistent across hardware.

This will likely be my last commit for a while as I focus on other
projects and entering open source. I will come back to Meowstro

Author: Hugo-RM

README.md

@@ -92,6 +92,10 @@ After building, run the executable:
 
 > The output directory is always `build/bin/Debug` or `build/bin/Release` depending on the build type, on all platforms.
 
+## Known Issues
+
+**Audio Synchronization:** There are known synchronization issues between the audio, game logic, and rendering that can cause the game to feel slow or off. Due to time constraints and other priorities, this issue remains unresolved. I (Hugo) will get back to it as soon as I feel like I have time to do so. This project will be worked on in the future with the goal of making the game good enough.
+
 ## Additional Tools Used in GitHub Actions
 
 - **cppcheck**

include/AnimationSystem.hpp

@@ -42,6 +42,7 @@ class AnimationSystem {
 
     // Update animation timing (call once per frame)
     void updateTiming();
+    void updateTiming(Uint64 currentTime);
 
     // Hook throwing animation
     void startHookThrow(Sprite& hook, int handX, int handY, int throwDuration);
@@ -69,6 +70,7 @@ class AnimationSystem {
 
 private:
     float m_timeCounter;
+    Uint64 m_animationStartTime;  // For absolute time calculations
 
     // Helper methods for sway calculations
     int calculateSway(float timeOffset = 0.0f) const;

include/Audio.hpp

@@ -11,6 +11,9 @@ class Audio {
 	void playBackgroundMusic(const std::string& filePath);
 	void stopBackgroundMusic();
 	bool isValid() const { return m_valid; }
+	
+	// Get precise audio position for beat synchronization
+	double getMusicPositionMs() const;
 
 private:
 	Mix_Music* bgMusic;

include/RhythmGame.hpp

@@ -54,6 +54,10 @@ class RhythmGame {
     Uint32 m_songStartTime;
     std::vector<bool> m_noteHitFlags;
 
+    // Frame timing for consistent framerates
+    Uint64 m_lastFrameTime;
+    Uint64 m_targetFrameTime;
+    
     // Game entities
     Entity m_ocean;
     Entity m_scoreLabel;
@@ -100,4 +104,7 @@ class RhythmGame {
 
     // Format score helper
     std::string formatScore(int score);
+    
+    // Helper method for precise timing
+    double getCurrentGameTimeMs() const;
 };

src/AnimationSystem.cpp

@@ -4,15 +4,25 @@
 #include <cmath>
 #include <algorithm>
 
-AnimationSystem::AnimationSystem() : m_timeCounter(0.0f) {
+AnimationSystem::AnimationSystem() : m_timeCounter(0.0f), m_animationStartTime(0) {
 }
 
 void AnimationSystem::initialize() {
     m_timeCounter = 0.0f;
+    m_animationStartTime = SDL_GetPerformanceCounter();
 }
 
 void AnimationSystem::updateTiming() {
-    m_timeCounter += 0.05f;
+    // Legacy method - calculate from absolute time
+    Uint64 currentTime = SDL_GetPerformanceCounter();
+    updateTiming(currentTime);
+}
+
+void AnimationSystem::updateTiming(Uint64 currentTime) {
+    // Use absolute time to avoid accumulating errors
+    Uint64 elapsed = currentTime - m_animationStartTime;
+    double elapsedSeconds = (double)elapsed / SDL_GetPerformanceFrequency();
+    m_timeCounter = (float)elapsedSeconds;
 }
 
 void AnimationSystem::startHookThrow(Sprite& hook, int handX, int handY, int throwDuration) {

src/Audio.cpp

@@ -26,6 +26,21 @@ Audio::~Audio() {
     }
     Mix_CloseAudio();
 }
+
+double Audio::getMusicPositionMs() const {
+    if (!m_valid || !bgMusic || Mix_PlayingMusic() == 0) {
+        return 0.0;
+    }
+    
+    // Try to get precise audio position from SDL_mixer 2.8.0+
+    double positionSeconds = Mix_GetMusicPosition(bgMusic);
+    if (positionSeconds >= 0.0) {
+        return positionSeconds * 1000.0; // Convert to milliseconds
+    }
+    
+    // Fallback: return -1 to indicate SDL_GetTicks should be used
+    return -1.0;
+}
 void Audio::playBackgroundMusic(const std::string& filePath) {
     if (!m_valid) {
         Logger::error("Audio::playBackgroundMusic called on invalid Audio system");

src/RhythmGame.cpp

@@ -12,6 +12,8 @@ RhythmGame::RhythmGame()
     : m_resourceManager(nullptr)
     , m_gameStats(nullptr)
     , m_songStartTime(0)
+    , m_lastFrameTime(0)
+    , m_targetFrameTime(0)
     , m_ocean(0, 0, nullptr)
     , m_scoreLabel(0, 0, nullptr)
     , m_scoreNumber(0, 0, nullptr)
@@ -47,6 +49,10 @@ void RhythmGame::initialize(RenderWindow& window, ResourceManager& resourceManag
     m_songStartTime = SDL_GetTicks();
     m_noteHitFlags.assign(gameplayConfig.numBeats * 2, false);
 
+    // Initialize frame timing (60 FPS target)
+    m_targetFrameTime = SDL_GetPerformanceFrequency() / 20;
+    m_lastFrameTime = SDL_GetPerformanceCounter();
+    
     // Initialize animation system
     m_animationSystem.initialize();
 
@@ -142,10 +148,11 @@ bool RhythmGame::update(InputAction action, InputHandler& inputHandler) {
         return false; // Game should end (ESC or window close)
     }
 
-    // Update animation timing
-    m_animationSystem.updateTiming();
+    // Update animation timing with current performance counter
+    Uint64 currentPerformanceTime = SDL_GetPerformanceCounter();
+    m_animationSystem.updateTiming(currentPerformanceTime);
 
-    double currentTime = SDL_GetTicks() - m_songStartTime;
+    double currentTime = getCurrentGameTimeMs();
 
     // Handle rhythm input - simplified logic
     if (action == InputAction::Select) {
@@ -170,8 +177,15 @@ bool RhythmGame::update(InputAction action, InputHandler& inputHandler) {
             return false;
         }
 
-        // Frame delay (only when no input events)
-        SDL_Delay(visualConfig.frameDelay);
+        // Maintain consistent frame rate (only when no input events)
+        Uint64 currentFrameTime = SDL_GetPerformanceCounter();
+        Uint64 frameTime = currentFrameTime - m_lastFrameTime;
+        
+        if (frameTime < m_targetFrameTime) {
+            Uint32 delayMs = (Uint32)((m_targetFrameTime - frameTime) * 1000 / SDL_GetPerformanceFrequency());
+            SDL_Delay(delayMs);
+        }
+        m_lastFrameTime = SDL_GetPerformanceCounter();
     }
 
     return true; // Continue game
@@ -286,7 +300,7 @@ void RhythmGame::updateFishMovement() {
         }
 
         // Move fish left (same as original)
-        m_fish[i].moveLeft(15);
+        m_fish[i].moveLeft(10);
 
         // Update base position after movement (for sway effects)
         m_fishBasePositions[i].first = m_fish[i].getX();
@@ -369,4 +383,15 @@ std::string RhythmGame::formatScore(int score) {
     std::ostringstream ss;
     ss << std::setw(6) << std::setfill('0') << score;
     return ss.str();
+}
+
+double RhythmGame::getCurrentGameTimeMs() const {
+    // Try to get precise audio position first
+    double audioTimeMs = m_audioPlayer.getMusicPositionMs();
+    if (audioTimeMs >= 0.0) {
+        return audioTimeMs;
+    }
+    
+    // Fallback to SDL_GetTicks timing
+    return SDL_GetTicks() - m_songStartTime;
 }