Remove Lock on Game Start

app.py

@@ -25,11 +25,11 @@ class GameResults:
 
 class GameState:
     def __init__(self):
-        self.lock = Lock()
-        self._reset()
+        # Lock only used for round transitions
+        self.round_lock = Lock()
+        self.reset()
     
-    def _reset(self):
-        """Internal reset method - should be called within a lock"""
+    def reset(self):
         self.user_score = 0
         self.model_score = 0
         self.current_round = 0
@@ -39,50 +39,30 @@ class GameState:
         self.last_results: Optional[GameResults] = None
         self.processing_submission = False
     
-    def reset(self):
-        """Public reset method with lock protection"""
-        with self.lock:
-            self._reset()
-    
-    def start_new_game(self) -> tuple[bool, Optional[str]]:
-        """
-        Starts a new game and returns (success, first_image_path)
-        """
-        with self.lock:
-            if self.is_game_active:
-                return False, None
-            
-            try:
-                self._reset()
-                self.game_images = load_images()
-                if not self.game_images:
-                    return False, None
-                
-                self.is_game_active = True
-                return True, self.game_images[0]
-            except Exception as e:
-                print(f"Error starting new game: {e}")
-                self._reset()
-                return False, None
+    def start_new_game(self) -> bool:
+        if self.is_game_active:
+            return False
+        self.reset()
+        self.game_images = load_images()
+        self.is_game_active = True
+        return True
     
     def can_submit_guess(self) -> bool:
-        with self.lock:
-            return (
-                self.is_game_active and 
-                not self.processing_submission and 
-                self.current_round < self.total_rounds and
-                len(self.game_images) > self.current_round
-            )
+        return (
+            self.is_game_active and 
+            not self.processing_submission and 
+            self.current_round < self.total_rounds
+        )
     
     def start_submission(self) -> bool:
-        with self.lock:
+        with self.round_lock:
             if not self.can_submit_guess():
                 return False
             self.processing_submission = True
             return True
     
     def finish_submission(self, results: GameResults):
-        with self.lock:
+        with self.round_lock:
             if results.user_guess == results.correct_answer:
                 self.user_score += 1
             if results.model_guess == results.correct_answer:
@@ -96,49 +76,35 @@ class GameState:
                 self.is_game_active = False
     
     def get_current_image(self) -> Optional[str]:
-        with self.lock:
-            if not self.is_game_active or self.current_round >= len(self.game_images):
-                return None
-            return self.game_images[self.current_round]
-    
-    def get_game_state(self):
-        """Get a snapshot of the current game state"""
-        with self.lock:
-            return {
-                'is_active': self.is_game_active,
-                'current_round': self.current_round,
-                'total_rounds': self.total_rounds,
-                'user_score': self.user_score,
-                'model_score': self.model_score,
-                'last_results': self.last_results
-            }
+        if not self.is_game_active or self.current_round >= len(self.game_images):
+            return None
+        return self.game_images[self.current_round]
     
     def get_game_over_message(self) -> str:
-        with self.lock:
-            if self.user_score > self.model_score:
-                return """
-                <div style='text-align: center; margin-top: 20px; font-size: 1.2em;'>
-                    🎉 Congratulations! You won! 🎉<br>
-                    You've outperformed SuSy in detecting AI-generated images.<br>
-                    Click 'Start New Game' to play again.
-                </div>
-                """
-            elif self.user_score < self.model_score:
-                return """
-                <div style='text-align: center; margin-top: 20px; font-size: 1.2em;'>
-                    Better luck next time! SuSy won this round.<br>
-                    Keep practicing to improve your detection skills.<br>
-                    Click 'Start New Game' to try again.
-                </div>
-                """
-            else:
-                return """
-                <div style='text-align: center; margin-top: 20px; font-size: 1.2em;'>
-                    It's a tie! You matched SuSy's performance!<br>
-                    You're getting good at this.<br>
-                    Click 'Start New Game' to play again.
-                </div>
-                """
+        if self.user_score > self.model_score:
+            return """
+            <div style='text-align: center; margin-top: 20px; font-size: 1.2em;'>
+                🎉 Congratulations! You won! 🎉<br>
+                You've outperformed SuSy in detecting AI-generated images.<br>
+                Click 'Start New Game' to play again.
+            </div>
+            """
+        elif self.user_score < self.model_score:
+            return """
+            <div style='text-align: center; margin-top: 20px; font-size: 1.2em;'>
+                Better luck next time! SuSy won this round.<br>
+                Keep practicing to improve your detection skills.<br>
+                Click 'Start New Game' to try again.
+            </div>
+            """
+        else:
+            return """
+            <div style='text-align: center; margin-top: 20px; font-size: 1.2em;'>
+                It's a tie! You matched SuSy's performance!<br>
+                You're getting good at this.<br>
+                Click 'Start New Game' to play again.
+            </div>
+            """
 
 def process_image(image):
     # Set Parameters
@@ -193,7 +159,9 @@ def process_image(image):
 
     return sorted_probs
 
-def load_images():
+game_state = GameState()
+
+def load_images() -> List[str]:
     real_image_folder = "real_images"
     fake_image_folder = "fake_images"
     real_images = [os.path.join(real_image_folder, img) for img in os.listdir(real_image_folder)]
@@ -203,21 +171,18 @@ def load_images():
     return selected_images
 
 def create_score_html() -> str:
-    game_state_snapshot = game_state.get_game_state()
-    
     results_html = ""
-    if game_state_snapshot['last_results']:
-        results = game_state_snapshot['last_results']
+    if game_state.last_results:
         results_html = f"""
         <div style='margin-top: 1rem; padding: 1rem; background-color: #e0e0e0; border-radius: 8px; color: #333;'>
             <h4 style='color: #333; margin-bottom: 0.5rem;'>Last Round Results:</h4>
-            <p style='color: #333;'>Your guess: {results.user_guess}</p>
-            <p style='color: #333;'>Model's guess: {results.model_guess}</p>
-            <p style='color: #333;'>Correct answer: {results.correct_answer}</p>
+            <p style='color: #333;'>Your guess: {game_state.last_results.user_guess}</p>
+            <p style='color: #333;'>Model's guess: {game_state.last_results.model_guess}</p>
+            <p style='color: #333;'>Correct answer: {game_state.last_results.correct_answer}</p>
         </div>
         """
 
-    current_display_round = min(game_state_snapshot['current_round'] + 1, game_state_snapshot['total_rounds'])
+    current_display_round = min(game_state.current_round + 1, game_state.total_rounds)
     
     return f"""
     <div style='padding: 1rem; background-color: #f0f0f0; border-radius: 8px; color: #333;'>
@@ -225,58 +190,48 @@ def create_score_html() -> str:
         <div style='display: flex; justify-content: space-around;'>
             <div>
                 <h4 style='color: #333;'>You</h4>
-                <p style='font-size: 1.5rem; color: #333;'>{game_state_snapshot['user_score']}</p>
+                <p style='font-size: 1.5rem; color: #333;'>{game_state.user_score}</p>
             </div>
             <div>
                 <h4 style='color: #333;'>AI Model</h4>
-                <p style='font-size: 1.5rem; color: #333;'>{game_state_snapshot['model_score']}</p>
+                <p style='font-size: 1.5rem; color: #333;'>{game_state.model_score}</p>
             </div>
         </div>
         <div style='margin-top: 1rem;'>
-            <p style='color: #333;'>Round: {current_display_round}/{game_state_snapshot['total_rounds']}</p>
+            <p style='color: #333;'>Round: {current_display_round}/{game_state.total_rounds}</p>
         </div>
         {results_html}
     </div>
     """
 
-game_state = GameState()
-
 def start_game():
-    """Initialize a new game"""
-    success, first_image_path = game_state.start_new_game()
-    
-    if not success or not first_image_path:
-        print("Failed to start new game")
+    if not game_state.start_new_game():
         return [gr.update()] * 6
     
-    try:
-        current_image = Image.open(first_image_path)
-        
-        return (
-            gr.update(value=current_image, visible=True),
-            gr.update(visible=False),
-            gr.update(visible=True, interactive=True),
-            gr.update(visible=True, interactive=True),
-            create_score_html(),
-            gr.update(visible=False)
-        )
-    except Exception as e:
-        print(f"Error starting game: {e}")
-        game_state.reset()
-        return [gr.update()] * 6
+    current_image = Image.open(game_state.get_current_image())
+    
+    return (
+        gr.update(value=current_image, visible=True),
+        gr.update(visible=False),
+        gr.update(visible=True, interactive=True),
+        gr.update(visible=True, interactive=True),
+        create_score_html(),
+        gr.update(visible=False)
+    )
 
 def submit_guess(user_guess: str):
-    """Handle user guess submission"""
+    # Early return if we can't submit a guess
     if not game_state.can_submit_guess():
         return [gr.update()] * 6
     
+    # Mark submission as being processed
     if not game_state.start_submission():
         return [gr.update()] * 6
     
     try:
+        # Get current image and process it
         current_image_path = game_state.get_current_image()
         if not current_image_path:
-            game_state.processing_submission = False
             return [gr.update()] * 6
         
         current_image = Image.open(current_image_path)
@@ -284,9 +239,11 @@ def submit_guess(user_guess: str):
         model_guess = "Real" if model_prediction['Authentic'] > PROB_THRESHOLD else "Fake"
         correct_answer = "Real" if "real_images" in current_image_path else "Fake"
         
+        # Update game state with results
         results = GameResults(user_guess, model_guess, correct_answer)
         game_state.finish_submission(results)
         
+        # Check if game is over
         if not game_state.is_game_active:
             return (
                 gr.update(value=None, visible=False),
@@ -297,6 +254,7 @@ def submit_guess(user_guess: str):
                 gr.update(visible=True, value=game_state.get_game_over_message())
             )
         
+        # Get next image for the next round
         next_image_path = game_state.get_current_image()
         if not next_image_path:
             return [gr.update()] * 6
@@ -312,9 +270,9 @@ def submit_guess(user_guess: str):
             gr.update(visible=False)
         )
     except Exception as e:
-        print(f"Error processing guess: {e}")
+        # If any error occurs, reset the processing flag
         game_state.processing_submission = False
-        return [gr.update()] * 6
+        raise e
 
 # Custom CSS
 custom_css = """