Fix Game Start bug

app.py

@@ -26,34 +26,52 @@ class GameResults:
 class GameState:
     def __init__(self):
         self.lock = Lock()
-        self.reset()
+        self._reset()
+    
+    def _reset(self):
+        """Internal reset method - should be called within a lock"""
+        self.user_score = 0
+        self.model_score = 0
+        self.current_round = 0
+        self.total_rounds = NUM_ROUNDS
+        self.game_images: List[str] = []
+        self.is_game_active = False
+        self.last_results: Optional[GameResults] = None
+        self.processing_submission = False
     
     def reset(self):
+        """Public reset method with lock protection"""
         with self.lock:
-            self.user_score = 0
-            self.model_score = 0
-            self.current_round = 0
-            self.total_rounds = NUM_ROUNDS
-            self.game_images: List[str] = []
-            self.is_game_active = False
-            self.last_results: Optional[GameResults] = None
-            self.processing_submission = False
+            self._reset()
     
-    def start_new_game(self) -> bool:
+    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
-            self.reset()
-            self.game_images = load_images()
-            self.is_game_active = True
-            return True
+                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 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
+                self.current_round < self.total_rounds and
+                len(self.game_images) > self.current_round
             )
     
     def start_submission(self) -> bool:
@@ -83,6 +101,18 @@ class GameState:
                 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
+            }
+    
     def get_game_over_message(self) -> str:
         with self.lock:
             if self.user_score > self.model_score:
@@ -163,8 +193,6 @@ def process_image(image):
 
     return sorted_probs
 
-game_state = GameState()
-
 def load_images():
     real_image_folder = "real_images"
     fake_image_folder = "fake_images"
@@ -174,69 +202,81 @@ def load_images():
     random.shuffle(selected_images)
     return selected_images
 
-def create_score_html():
-    with game_state.lock:
-        results_html = ""
-        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: {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>
-            """
+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']
+        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>
+        </div>
+        """
 
-        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;'>
-            <h3 style='margin-bottom: 1rem; color: #333;'>Score Board</h3>
-            <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.user_score}</p>
-                </div>
-                <div>
-                    <h4 style='color: #333;'>AI Model</h4>
-                    <p style='font-size: 1.5rem; color: #333;'>{game_state.model_score}</p>
-                </div>
+    current_display_round = min(game_state_snapshot['current_round'] + 1, game_state_snapshot['total_rounds'])
+    
+    return f"""
+    <div style='padding: 1rem; background-color: #f0f0f0; border-radius: 8px; color: #333;'>
+        <h3 style='margin-bottom: 1rem; color: #333;'>Score Board</h3>
+        <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>
             </div>
-            <div style='margin-top: 1rem;'>
-                <p style='color: #333;'>Round: {current_display_round}/{game_state.total_rounds}</p>
+            <div>
+                <h4 style='color: #333;'>AI Model</h4>
+                <p style='font-size: 1.5rem; color: #333;'>{game_state_snapshot['model_score']}</p>
             </div>
-            {results_html}
         </div>
-        """
+        <div style='margin-top: 1rem;'>
+            <p style='color: #333;'>Round: {current_display_round}/{game_state_snapshot['total_rounds']}</p>
+        </div>
+        {results_html}
+    </div>
+    """
+
+game_state = GameState()
 
 def start_game():
-    if not game_state.start_new_game():
-        return [gr.update()] * 6
+    """Initialize a new game"""
+    success, first_image_path = game_state.start_new_game()
     
-    current_image = Image.open(game_state.get_current_image())
+    if not success or not first_image_path:
+        print("Failed to start new game")
+        return [gr.update()] * 6
     
-    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)
-    )
+    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
 
 def submit_guess(user_guess: str):
-    # Early return if we can't submit a guess
+    """Handle user guess submission"""
     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)
@@ -244,11 +284,9 @@ 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),
@@ -259,7 +297,6 @@ 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
@@ -275,9 +312,9 @@ def submit_guess(user_guess: str):
             gr.update(visible=False)
         )
     except Exception as e:
-        # If any error occurs, reset the processing flag
+        print(f"Error processing guess: {e}")
         game_state.processing_submission = False
-        raise e
+        return [gr.update()] * 6
 
 # Custom CSS
 custom_css = """