Fix view angle control and add frame synchronization

- Move state publishing to after_frame hook so published state
  reflects our view angles instead of bot AI's angles
- Add state_frame_id for debugging sync issues
- Add frame synchronization in client (wait for new frame_id)
- Track decision tick timing in env (avg_step_dt_ms, decision_hz)
- Tune settings for 40 Hz: VIEW_SENSITIVITY=3.0, max_engagement_reward=0.2
- Add set_view_angles command for direct testing

Author: cainky

QuakeLiveInterface/client.py

@@ -19,17 +19,62 @@ def __init__(self, redis_host='localhost', redis_port=6379, redis_db=0):
         self.game_state_channel = 'ql:game:state'
         self.game_state_pubsub = self.connection.subscribe(self.game_state_channel)
 
-    def update_game_state(self):
+        # Frame synchronization - ensure we only process each server frame once
+        self._last_frame_id = -1
+        self._last_state_time_ms = 0
+
+    def update_game_state(self, timeout_ms=250, require_new_frame=True):
         """
         Gets the latest game state from Redis and updates the local game state.
         Uses GET on ql:agent:last_state for reliable polling instead of pubsub.
+
+        Args:
+            timeout_ms: Maximum time to wait for a new frame (default 250ms)
+            require_new_frame: If True, wait until state_frame_id changes
+
+        Returns:
+            True if state was updated, False on timeout
         """
-        # Poll the stored state instead of using pubsub (more reliable)
-        state_data = self.connection.get('ql:agent:last_state')
-        if state_data:
-            self.game_state.update_from_redis(state_data)
-            return True
-        return False
+        import time
+        start_time = time.time()
+        timeout_sec = timeout_ms / 1000.0
+
+        while True:
+            state_data = self.connection.get('ql:agent:last_state')
+            if state_data:
+                # Parse to check frame_id before full update
+                import json
+                try:
+                    raw_state = json.loads(state_data)
+                    frame_id = raw_state.get('state_frame_id', 0)
+
+                    # If we require a new frame, check if this is different
+                    if require_new_frame and frame_id == self._last_frame_id:
+                        # Same frame, keep waiting (unless timeout)
+                        if time.time() - start_time > timeout_sec:
+                            logger.warning(f"Frame sync timeout: stuck on frame {frame_id}")
+                            return False
+                        time.sleep(0.005)  # 5ms poll interval
+                        continue
+
+                    # New frame (or we don't require new frame)
+                    self._last_frame_id = frame_id
+                    self._last_state_time_ms = raw_state.get('server_time_ms', 0)
+                    self.game_state.update_from_redis(state_data)
+                    return True
+
+                except json.JSONDecodeError:
+                    logger.error("Failed to parse game state JSON")
+                    return False
+
+            # No state data yet
+            if time.time() - start_time > timeout_sec:
+                return False
+            time.sleep(0.005)
+
+    def get_frame_timing(self):
+        """Returns (last_frame_id, last_state_time_ms) for debugging."""
+        return self._last_frame_id, self._last_state_time_ms
 
     def send_command(self, channel, command, args=None):
         """

QuakeLiveInterface/env.py

@@ -20,7 +20,8 @@
 ]
 
 # View sensitivity: degrees per frame at max input
-VIEW_SENSITIVITY = 5.0  # Max degrees to turn per step
+# At 40 Hz: 3°/step = 120°/sec max turn rate (reasonable for Quake, less jitter)
+VIEW_SENSITIVITY = 3.0
 
 
 class QuakeLiveEnv(gym.Env):
@@ -101,20 +102,32 @@ def __init__(self, redis_host='localhost', redis_port=6379, redis_db=0,
         self._consecutive_bad_states = 0  # Track consecutive "terminated" conditions
         self._BAD_STATE_THRESHOLD = 3     # Require N bad states before terminating
 
+        # Decision tick timing for monitoring
+        self._last_step_time = None
+        self._step_dt_sum = 0.0
+        self._step_dt_count = 0
+
     def step(self, action):
         """
         Run one timestep of the environment's dynamics.
         """
+        # Track decision tick timing
+        step_start = time.time()
+        if self._last_step_time is not None:
+            dt = step_start - self._last_step_time
+            self._step_dt_sum += dt
+            self._step_dt_count += 1
+        self._last_step_time = step_start
+
         self.last_action = action
         self._apply_action(action)
         self.step_count += 1
 
-        # Wait for the next game state update
+        # Wait for the next game state update (blocks until new frame_id)
         if not self.client.update_game_state():
-            # Handle case where no update is received
-            # For now, we'll just return the current state with no reward
+            # Handle case where no update is received (timeout)
             obs = self._get_observation()
-            return obs, 0, False, False, {}
+            return obs, 0, False, False, {'frame_sync_timeout': True}
 
         new_game_state = self.client.get_game_state()
 
@@ -147,6 +160,10 @@ def step(self, action):
         info = {}
         if terminated or truncated:
             tracker = self.performance_tracker
+            # Calculate decision tick rate
+            avg_dt_ms = (self._step_dt_sum / self._step_dt_count * 1000) if self._step_dt_count > 0 else 0
+            decision_hz = 1000 / avg_dt_ms if avg_dt_ms > 0 else 0
+
             info['terminal_info'] = {
                 'damage_dealt': tracker.damage_dealt,
                 'damage_taken': tracker.damage_taken,
@@ -159,11 +176,13 @@ def step(self, action):
                 'health_pickups': tracker.items_collected.get('Health', 0),
                 'armor_pickups': tracker.items_collected.get('Armor', 0),
                 'distance_traveled': tracker.total_distance_traveled,
+                'avg_step_dt_ms': avg_dt_ms,
+                'decision_hz': decision_hz,
             }
             # Quick validation print
             logger.info(f"Episode {self.episode_num} end: frags={tracker.kills} deaths={tracker.deaths} "
                        f"dmg_dealt={tracker.damage_dealt} dmg_taken={tracker.damage_taken} "
-                       f"accuracy={info['terminal_info']['accuracy']:.1f}%")
+                       f"accuracy={info['terminal_info']['accuracy']:.1f}% hz={decision_hz:.1f}")
 
         return obs, reward, terminated, truncated, info
 
@@ -196,6 +215,9 @@ def reset(self, seed=None, options=None, reset_timeout=15.0):
         self.performance_tracker.reset()
         self.game_state = GameState()  # Reset game state
         self._consecutive_bad_states = 0  # Reset termination counter
+        self._last_step_time = None  # Reset timing stats
+        self._step_dt_sum = 0.0
+        self._step_dt_count = 0
 
         import time as time_module
 

QuakeLiveInterface/rewards.py

@@ -37,7 +37,7 @@ def __init__(self, reward_weights=None, high_value_items=None):
 
         # Engagement shaping (prevents wandering)
         self.engagement_scale = 0.01    # Small reward for closing distance
-        self.max_engagement_reward = 0.5  # Cap per step
+        self.max_engagement_reward = 0.2  # Cap per step (lowered to avoid "distance farming")
 
         # Item/map control (secondary objectives)
         self.item_pickup_scale = 0.1    # Reduced from before