Upload 3 files

app.py

@@ -27,7 +27,10 @@ SIMULATION_FPS = 120  # Fixed simulation FPS, matching training
 RENDER_FPS = 30
 DT = 1.0 / SIMULATION_FPS  # Fixed time step
 DT_DISPLAY = 1/RENDER_FPS
-DIFFICULTY = 1
+DIFFICULTY = 2
+
+# Global variable to store the training environment instance
+training_env = None
 
 class AdaptiveFrameQueue:
     def __init__(self, maxsize=3):
@@ -87,7 +90,8 @@ def point_to_line_distance(point, line_p0, line_p1):
 class TrainingEnvironment:
     def __init__(self, action_space=8):
         self.action_space = action_space
-        self.map_generator = MapGenerator(SCREEN_WIDTH, SCREEN_HEIGHT, DIFFICULTY, 18)  # Difficulty 2 = lvl 3 in training
+        self.current_difficulty = DIFFICULTY  # Store current difficulty
+        self.map_generator = MapGenerator(SCREEN_WIDTH, SCREEN_HEIGHT, self.current_difficulty, 18)
         
         # Initialize a dummy display for headless operation
         try:
@@ -124,7 +128,16 @@ class TrainingEnvironment:
         self.last_ray_update_time = 0
         self.reset()
 
+    def update_difficulty(self, new_difficulty):
+        """Update difficulty and regenerate map if needed"""
+        if self.current_difficulty != new_difficulty:
+            self.current_difficulty = new_difficulty
+            self.map_generator.difficulty = new_difficulty
+            print(f"Environment difficulty updated to: {new_difficulty}")
+
     def generate_new_map(self):
+        # Update difficulty before generating new map
+        self.map_generator.difficulty = self.current_difficulty
         start_pos, start_dir = self.map_generator.update()
         self.start_pos = pygame.math.Vector2(start_pos)
         self.start_dir = pygame.math.Vector2(start_dir).normalize()
@@ -150,7 +163,8 @@ class TrainingEnvironment:
         self.last_action = 0
 
     def reset(self):
-        self.map_generator.difficulty = 2  # Ensure difficulty matches training
+        # Use current difficulty instead of hardcoding
+        self.map_generator.difficulty = self.current_difficulty
         self.generate_new_map()
         self.reset_car()
 
@@ -401,11 +415,12 @@ class TrainingEnvironment:
 
 def optimized_game_loop():
     """Ultra-optimized game loop with 120 FPS simulation and 30 FPS rendering"""
+    global training_env
     try:
         # Initialize without display
         screen = pygame.Surface((SCREEN_WIDTH, SCREEN_HEIGHT))
-        env = TrainingEnvironment(ACTION_SPACE)
-        env.reset()
+        training_env = TrainingEnvironment(ACTION_SPACE)  # Store globally
+        training_env.reset()
         agent = PPOAgent(state_size, ACTION_SPACE)
         
         # Check if model file exists before loading
@@ -440,15 +455,15 @@ def optimized_game_loop():
                 simulation_start = time.perf_counter()
                 
                 # Game logic
-                state = env.get_state()
+                state = training_env.get_state()
                 action, _ = agent.select_action(state)
                 action_int = int(action)
                 
-                env.execute_action_dispatch(action_int, simulation_dt)
-                reward, collision, all_goals_completed = env.calculate_reward()
+                training_env.execute_action_dispatch(action_int, simulation_dt)
+                reward, collision, all_goals_completed = training_env.calculate_reward()
                 
                 if collision or all_goals_completed:
-                    env.reset()
+                    training_env.reset()
                 
                 last_simulation_time = current_time
                 simulation_counter += 1
@@ -465,16 +480,16 @@ def optimized_game_loop():
                 screen.fill((255, 255, 255))
                 
                 # Draw environment components
-                env.map_generator.draw(screen)
-                env.car.draw(screen)
+                training_env.map_generator.draw(screen)
+                training_env.car.draw(screen)
                 
                 # Optimized ray drawing - draw to separate surface first
                 ray_surface.fill((0, 0, 0, 0))  # Clear with transparency
                 for i, (angle, offset) in enumerate(zip([-60, -30, -15, 0, 15, 30, 60], [14, 22, 27, 26, 27, 22, 14])):
-                    if i < len(env.rays.last_collisions):
-                        ray_dir = env.car.direction.rotate(angle).normalize()
-                        origin = env.car.pos + ray_dir * offset
-                        end_point = env.rays.last_collisions[i]
+                    if i < len(training_env.rays.last_collisions):
+                        ray_dir = training_env.car.direction.rotate(angle).normalize()
+                        origin = training_env.car.pos + ray_dir * offset
+                        end_point = training_env.rays.last_collisions[i]
                         pygame.draw.line(ray_surface, (255, 255, 0), 
                                          (int(origin.x), int(origin.y)),
                                          (int(end_point.x), int(end_point.y)), 2)
@@ -537,9 +552,16 @@ css = """#game-image {
 }"""
 
 def update_difficulty(input_diff_lvl):
-    global DIFFICULTY
+    """Updated difficulty function that communicates with the running environment"""
+    global DIFFICULTY, training_env
     DIFFICULTY = input_diff_lvl
-    print(f"Difficulty updated to: {DIFFICULTY}")
+    
+    # Update the running environment's difficulty
+    if training_env is not None:
+        training_env.update_difficulty(input_diff_lvl)
+    
+    print(f"Difficulty updated to: {input_diff_lvl}")
+    return f"Difficulty set to: {input_diff_lvl} (will apply on next track)"
 
 def execute_interference():
     game_thread = threading.Thread(target=optimized_game_loop)
@@ -550,7 +572,14 @@ def execute_interference():
         with gr.Column():
             img = gr.Image(type="pil", label="Game Stream", elem_id="game-image", scale=1, min_width=0)
             difficulty_slider = gr.Slider(minimum=1, maximum=2, step=1, value=2, label="Difficulty Level")
-            difficulty_slider.change(fn=update_difficulty, inputs=difficulty_slider)
+            difficulty_output = gr.Textbox(label="Status", interactive=False)
+            
+            # Connect the slider to the update function with output
+            difficulty_slider.change(
+                fn=update_difficulty, 
+                inputs=difficulty_slider, 
+                outputs=difficulty_output
+            )
         
         timer = gr.Timer(value=DT_DISPLAY)  # ~30 FPS
         timer.tick(fn=get_frame_for_gradio, inputs=None, outputs=img)