add observation state

airports/VOCB.json

@@ -197,7 +197,14 @@
         "IAF_RWY_1",
         "FAF_RWY_1"
       ]
+    },
+    "N": {
+      "RWY_1_REV": [
+        "c3a2fccd-7b0f-45ab-8e0c-f9bcf1031cee",
+        "IAF_RWY_1_REV",
+        "FAF_RWY_1_REV"
+      ]
     }
   },
-  "time_scale": 1.0
+  "time_scale": 8.0
 }

package-lock.json

@@ -0,0 +1,6 @@
+{
+  "name": "atc_rl_api",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {}
+}

rl_env/atc_gym.py

@@ -3,6 +3,7 @@
 from openenv_core import Environment, Space
 import numpy as np
 from core.engine import SimulationEngine
+import math
 
 class ATCEnv(Environment):
     """
@@ -43,10 +44,107 @@ class ATCEnv(Environment):
         return obs, reward, done, truncated, {}
 
     def get_observation(self):
-        """Get flattened observation vector"""
-        state = self.engine.get_full_state()
-        # Flatten and return as numpy array
-        return np.array([0.0]) # Placeholder
+        """Get structured observation for LLM/Agent consumption"""
+        
+        segments_labels = ["North", "North-East", "East", "South-East", 
+                           "South", "South-West", "West", "North-West"]
+                           
+        obs = {
+            "aircraft": [],
+            "airport_status": {
+                "active_runways": list(self.engine.active_runways),
+                "runway_occupancy": {},
+                "wind": {
+                    "heading": int(self.engine.wind_heading),
+                    "speed": int(self.engine.wind_speed)
+                }
+            }
+        }
+        
+        for rw, status in self.engine.runway_status.items():
+            obs["airport_status"]["runway_occupancy"][rw] = status.get("occupied_by")
+            
+        aircraft_list = list(self.engine.aircrafts.values())
+        
+        for i, ac in enumerate(aircraft_list):
+            # Compute position
+            distance = round(math.sqrt(ac.x**2 + ac.y**2), 2)
+            if ac.x == 0 and ac.y == 0:
+                bearing = 0.0
+            else:
+                bearing = (90 - math.degrees(math.atan2(ac.y, ac.x))) % 360
+            segment_idx = round(bearing / 45) % 8
+            segment_name = segments_labels[segment_idx]
+            
+            # Compute separation
+            closest_callsign = None
+            closest_dist = float('inf')
+            conflict_risk = "none"
+            
+            for j, other_ac in enumerate(aircraft_list):
+                if i != j:
+                    dist_km = math.sqrt((ac.x - other_ac.x)**2 + (ac.y - other_ac.y)**2)
+                    if dist_km < closest_dist:
+                        closest_dist = dist_km
+                        closest_callsign = other_ac.callsign
+                        alt_diff = abs(ac.altitude - other_ac.altitude)
+                        if dist_km < 5.0 and alt_diff < 1500:
+                            conflict_risk = "high"
+                        elif dist_km < 10.0 and alt_diff < 3000 and conflict_risk != "high":
+                            conflict_risk = "medium"
+
+            if closest_dist == float('inf'):
+                closest_dist_val = None
+            else:
+                closest_dist_val = round(closest_dist, 2)
+                
+            # Compute alerts
+            alerts = []
+            if ac.fuel_level < 10 or ac.emergency_index >= 1:
+                alerts.append("low_fuel")
+            if ac.emergency_index == 3:
+                alerts.append("critical_emergency")
+                
+            # Intent block additions
+            dist_to_thresh = None
+            if ac.runway_threshold:
+                tx, ty = ac.runway_threshold["x"], ac.runway_threshold["y"]
+                dist_to_thresh = round(math.sqrt((tx - ac.x)**2 + (ty - ac.y)**2), 2)
+
+            next_wp = ac.active_star if ac.active_star else "None"
+            if hasattr(ac, "direct_to_wp") and ac.direct_to_wp:
+                next_wp = ac.direct_to_wp.get("name", "Direct")
+                
+            ac_obj = {
+                "callsign": ac.callsign,
+                "position": {
+                    "segment": segment_name, 
+                    "distance": distance, 
+                    "altitude": int(ac.altitude),
+                    "target_altitude": int(ac.target_alt)
+                },
+                "motion": {
+                    "heading": round(ac.heading, 1), 
+                    "target_heading": round(ac.target_heading, 1),
+                    "speed": int(ac.speed),
+                    "target_speed": int(ac.target_speed)
+                },
+                "intent": {
+                    "state": ac.state,
+                    "assigned_runway": ac.target_runway_id,
+                    "distance_to_threshold": dist_to_thresh,
+                    "next_waypoint": next_wp
+                },
+                "alerts": alerts,
+                "separation": {
+                    "closest_traffic": closest_callsign,
+                    "distance": closest_dist_val,
+                    "conflict_risk": conflict_risk
+                }
+            }
+            obs["aircraft"].append(ac_obj)
+            
+        return obs
 
     def compute_reward(self):
         """Reward function: +1 for distance to runway, -100 for collision"""

run_server.py

@@ -32,11 +32,13 @@ def run_server():
     parent_dir = os.path.dirname(script_dir)
     ui_dir = os.path.join(script_dir, "visualizer")
 
+    # Helper to run npm commands robustly
+    npm_exe = "npm.cmd" if os.name == 'nt' else "npm"
+    
     if args.only_ui:
         print("Starting ONLY Frontend (Vite)...")
         try:
-            # Use shell=True for 'npm' on Windows
-            subprocess.run(["npm", "run", "dev"], cwd=ui_dir, shell=True)
+            subprocess.run([npm_exe, "run", "dev"], cwd=ui_dir)
         except KeyboardInterrupt:
             print("\nStopping UI...")
         return
@@ -48,7 +50,7 @@ def run_server():
     if args.ui:
         print("Starting Frontend (Vite)...")
         try:
-            ui_process = subprocess.Popen(["npm", "run", "dev"], cwd=ui_dir, shell=True)
+            ui_process = subprocess.Popen([npm_exe, "run", "dev"], cwd=ui_dir)
             print(f"Frontend process started (PID: {ui_process.pid})")
         except Exception as e:
             print(f"Error starting frontend: {e}")

visualizer/package-lock.json

@@ -2497,9 +2497,9 @@
       }
     },
     "node_modules/vite": {
-      "version": "8.0.3",
-      "resolved": "https://registry.npmjs.org/vite/-/vite-8.0.3.tgz",
-      "integrity": "sha512-B9ifbFudT1TFhfltfaIPgjo9Z3mDynBTJSUYxTjOQruf/zHH+ezCQKcoqO+h7a9Pw9Nm/OtlXAiGT1axBgwqrQ==",
+      "version": "8.0.5",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-8.0.5.tgz",
+      "integrity": "sha512-nmu43Qvq9UopTRfMx2jOYW5l16pb3iDC1JH6yMuPkpVbzK0k+L7dfsEDH4jRgYFmsg0sTAqkojoZgzLMlwHsCQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -2524,7 +2524,7 @@
       "peerDependencies": {
         "@types/node": "^20.19.0 || >=22.12.0",
         "@vitejs/devtools": "^0.1.0",
-        "esbuild": "^0.27.0",
+        "esbuild": "^0.27.0 || ^0.28.0",
         "jiti": ">=1.21.0",
         "less": "^4.0.0",
         "sass": "^1.70.0",