Update env.py

env.py

@@ -1,83 +1,55 @@
 # env.py
 
 from pathlib import Path
-import yaml
-from huggingface_hub import snapshot_download
 import os
+import errno
+import yaml
 import gymnasium as gym
 from gymnasium import spaces
 import numpy as np
 
 from sim.simulator_factory import SimulatorFactory, init_channel
 
-# global state to ensure we only start the simulator once per process
-_SIM_STARTED = False
-_SIM_INSTANCE = None
+# lock file shared across processes
+_LOCK_PATH = Path.home() / ".unitree_g1_mujoco_sim.lock"
 
 
-def _launch_simulator_once(publish_images=True, camera_port=5555, cameras=None):
+def _acquire_lock():
     """
-    create and start the simulator only once per python process.
-    subsequent calls are no-ops and just return the same sim.
+    try to create a lock file.
+    returns True if this process acquired the lock (i.e. we should start the sim),
+    False if some other process already did.
     """
-    global _SIM_STARTED, _SIM_INSTANCE
-
-    if _SIM_STARTED:
-        return _SIM_INSTANCE
-
-    # load config
-    config_path = Path(__file__).parent / "config.yaml"
-    with open(config_path) as f:
-        config = yaml.safe_load(f)
-
-    # override with defaults from make_env
-    enable_offscreen = publish_images or config.get("ENABLE_OFFSCREEN", False)
-
-    print("=" * 60)
-    print("🤖 starting unitree g1 mujoco simulator")
-    print("=" * 60)
-    print(f"📁 scene: {config['ROBOT_SCENE']}")
-    print(f"⏱️  timestep: {config['SIMULATE_DT']}s ({int(1 / config['SIMULATE_DT'])} hz)")
-    print(f"👁️  visualization: {'ON' if config.get('ENABLE_ONSCREEN', True) else 'OFF'}")
-
-    # configure cameras if requested
-    camera_configs = {}
-    if enable_offscreen:
-        camera_list = cameras or ["head_camera"]
-        for cam_name in camera_list:
-            camera_configs[cam_name] = {"height": 480, "width": 640}
-        print(f"📷 cameras: {', '.join(camera_list)} → zmq port {camera_port}")
-
-    print("=" * 60)
-
-    # init dds channel
-    init_channel(config=config)
-
-    # create simulator
-    sim = SimulatorFactory.create_simulator(
-        config=config,
-        env_name="default",
-        onscreen=config.get("ENABLE_ONSCREEN", True),
-        offscreen=enable_offscreen,
-        camera_configs=camera_configs,
-    )
-
-    # start simulator in a background thread so make_env can return
-    # (if you really want blocking, set as_thread=False and don't return DummyEnv)
-    print("\nsimulator running (background thread). press ctrl+c in main script to exit.")
-    if enable_offscreen and publish_images:
-        print(f"camera images publishing on tcp://localhost:{camera_port}")
-
-    SimulatorFactory.start_simulator(
-        sim,
-        as_thread=True,
-        enable_image_publish=publish_images,
-        camera_port=camera_port,
-    )
-
-    _SIM_STARTED = True
-    _SIM_INSTANCE = sim
-    return sim
+    try:
+        fd = os.open(str(_LOCK_PATH), os.O_CREAT | os.O_EXCL | os.O_WRONLY)
+        os.close(fd)
+        return True
+    except OSError as e:
+        if e.errno == errno.EEXIST:
+            # lock already exists -> another process started the sim
+            return False
+        raise
+
+
+def _release_lock():
+    try:
+        _LOCK_PATH.unlink()
+    except FileNotFoundError:
+        pass
+
+
+class DummyEnv(gym.Env):
+    def __init__(self):
+        super().__init__()
+        self.action_space = spaces.Box(-1, 1, shape=(1,), dtype=np.float32)
+        self.observation_space = spaces.Box(-1, 1, shape=(1,), dtype=np.float32)
+
+    def reset(self, seed=None, options=None):
+        super().reset(seed=seed)
+        return np.zeros(1, dtype=np.float32), {}
+
+    def step(self, action):
+        return np.zeros(1, dtype=np.float32), 0.0, False, False, {}
 
 
 def make_env(
@@ -89,39 +61,78 @@ def make_env(
     **kwargs,
 ):
     """
-    factory used by your runner:
-        from env import make_env
-        env = make_env()
-    calling this multiple times in the same process will NOT start multiple sims.
+    first caller (in any process) behaves exactly like run_sim.main():
+      - loads config
+      - prints banner
+      - init_channel
+      - creates simulator
+      - starts simulator (blocking, as_thread=False)
+
+    other callers in other processes see the lock and **do not** start the sim again,
+    they just return DummyEnv().
     """
-
-    # force defaults if you want
+    # hard-override to the same defaults as run_sim.py
     publish_images = True
     camera_port = 5555
     cameras = None
 
-    # ensure simulator is running (only once)
-    _launch_simulator_once(
-        publish_images=publish_images,
-        camera_port=camera_port,
-        cameras=cameras,
-    )
-
-    class DummyEnv(gym.Env):
-        def __init__(self):
-            super().__init__()
-            self.action_space = spaces.Box(-1, 1, shape=(1,), dtype=np.float32)
-            self.observation_space = spaces.Box(-1, 1, shape=(1,), dtype=np.float32)
-
-        def reset(self, seed=None, options=None):
-            super().reset(seed=seed)
-            return np.zeros(1, dtype=np.float32), {}
-
-        def step(self, action):
-            return np.zeros(1, dtype=np.float32), 0.0, False, False, {}
-
-        def run(self):
-            # optional: expose sim control here later if you want
-            pass
-
+    # only the process that acquires the lock starts the simulator
+    is_owner = _acquire_lock()
+    if is_owner:
+        try:
+            # --- run_sim.py: main() body ---
+
+            config_path = Path(__file__).parent / "config.yaml"
+            with open(config_path) as f:
+                config = yaml.safe_load(f)
+
+            enable_offscreen = publish_images or config.get("ENABLE_OFFSCREEN", False)
+
+            print("=" * 60)
+            print("🤖 Starting Unitree G1 MuJoCo Simulator")
+            print("=" * 60)
+            print(f"📁 Scene: {config['ROBOT_SCENE']}")
+            print(f"⏱️  Timestep: {config['SIMULATE_DT']}s ({int(1/config['SIMULATE_DT'])} Hz)")
+            print(f"👁️  Visualization: {'ON' if config.get('ENABLE_ONSCREEN', True) else 'OFF'}")
+
+            camera_configs = {}
+            if enable_offscreen:
+                camera_list = cameras or ["head_camera"]
+                for cam_name in camera_list:
+                    camera_configs[cam_name] = {"height": 480, "width": 640}
+                print(f"📷 Cameras: {', '.join(camera_list)} → ZMQ port {camera_port}")
+
+            print("=" * 60)
+
+            init_channel(config=config)
+
+            sim = SimulatorFactory.create_simulator(
+                config=config,
+                env_name="default",
+                onscreen=config.get("ENABLE_ONSCREEN", True),
+                offscreen=enable_offscreen,
+                camera_configs=camera_configs,
+            )
+
+            print("\nSimulator running. Press Ctrl+C to exit.")
+            if enable_offscreen and publish_images:
+                print(f"Camera images publishing on tcp://localhost:{camera_port}")
+
+            try:
+                SimulatorFactory.start_simulator(
+                    sim,
+                    as_thread=False,  # blocking, identical to run_sim.py
+                    enable_image_publish=publish_images,
+                    camera_port=camera_port,
+                )
+            except KeyboardInterrupt:
+                print("\nShutting down simulator...")
+                sim.close()
+        finally:
+            _release_lock()
+    else:
+        # another process already started the simulator; do nothing here
+        pass
+
+    # after (or while) the sim is running/exited, return a dummy env
     return DummyEnv()