miniworld-maze 1.0.0__py3-none-any.whl

miniworld_maze/core/miniworld_gymnasium/utils.py

@@ -0,0 +1,37 @@
+import os
+
+
+def get_subdir_path(sub_dir):
+    # Get the directory this module is located in
+    abs_path_module = os.path.realpath(__file__)
+    module_dir, _ = os.path.split(abs_path_module)
+
+    dir_path = os.path.join(module_dir, sub_dir)
+
+    return dir_path
+
+
+def get_file_path(sub_dir, file_name, default_ext):
+    """
+    Get the absolute path of a resource file, which may be relative to
+    the gym_duckietown module directory, or an absolute path.
+
+    This function is necessary because the simulator may be imported by
+    other packages, and we need to be able to load resources no matter
+    what the current working directory is.
+    """
+
+    assert "." not in default_ext
+    assert "/" not in default_ext
+
+    # If this is already a real path
+    if os.path.exists(file_name):
+        return file_name
+
+    subdir_path = get_subdir_path(sub_dir)
+    file_path = os.path.join(subdir_path, file_name)
+
+    if "." not in file_name:
+        file_path += "." + default_ext
+
+    return file_path

miniworld_maze/core/miniworld_gymnasium/wrappers.py

@@ -0,0 +1,2 @@
+# This file was cleaned up - unused wrapper classes removed
+# Active wrappers are located in wrappers/image_transforms.py

miniworld_maze/core/observation_types.py

@@ -0,0 +1,32 @@
+"""Observation type definitions for Nine Rooms environments."""
+
+from enum import IntEnum
+
+
+class ObservationLevel(IntEnum):
+    """Defines the different observation levels available in the environments.
+
+    Each level provides a different perspective and amount of information:
+    - TOP_DOWN_PARTIAL: Agent-centered partial top-down view (POMDP)
+    - TOP_DOWN_FULL: Complete environment top-down view
+    - FIRST_PERSON: 3D first-person view from agent's perspective
+    """
+
+    TOP_DOWN_PARTIAL = 1  # Top-down POMDP view (agent-centered, limited range)
+    TOP_DOWN_FULL = 2  # Full top-down view of entire environment
+    FIRST_PERSON = 3  # First-person 3D view from agent's perspective
+
+    def __str__(self):
+        """Return descriptive string representation."""
+        names = {1: "TOP_DOWN_PARTIAL", 2: "TOP_DOWN_FULL", 3: "FIRST_PERSON"}
+        return names[self.value]
+
+    @property
+    def description(self):
+        """Return detailed description of this observation level."""
+        descriptions = {
+            1: "Agent-centered partial top-down view with limited visibility range",
+            2: "Complete top-down view showing the entire environment",
+            3: "First-person 3D perspective view from the agent's current position",
+        }
+        return descriptions[self.value]

miniworld_maze/environments/__init__.py

@@ -0,0 +1,16 @@
+"""Nine Rooms environment implementations."""
+
+from .base_grid_rooms import GridRoomsEnvironment
+from .factory import NineRoomsEnvironmentWrapper, create_nine_rooms_env
+from .nine_rooms import NineRooms
+from .spiral_nine_rooms import SpiralNineRooms
+from .twenty_five_rooms import TwentyFiveRooms
+
+__all__ = [
+    "GridRoomsEnvironment",
+    "create_nine_rooms_env",
+    "NineRoomsEnvironmentWrapper",
+    "NineRooms",
+    "SpiralNineRooms",
+    "TwentyFiveRooms",
+]

miniworld_maze/environments/base_grid_rooms.py

@@ -0,0 +1,204 @@
+"""Base Grid Rooms environment implementation."""
+
+from typing import List, Optional, Tuple, Union
+
+from gymnasium import spaces
+
+from ..core import COLORS, Box, ObservationLevel
+from ..core.constants import (
+    AGENT_START_POSITION,
+    BOX_GRID_SIZE,
+    BOX_OFFSET_FRACTION,
+    BOX_SIZE_FRACTION,
+    BOXES_PER_ROOM,
+    DEFAULT_DOOR_SIZE,
+    DEFAULT_OBS_HEIGHT,
+    DEFAULT_OBS_WIDTH,
+    DEFAULT_ROOM_SIZE,
+    MAX_EPISODE_STEPS,
+    ROOM_BOUNDARY_MARGIN,
+    ROOM_CENTER_FRACTION,
+)
+from ..core.miniworld_gymnasium.unified_env import UnifiedMiniWorldEnv
+
+
+class GridRoomsEnvironment(UnifiedMiniWorldEnv):
+    """
+    Base class for grid-based room environments.
+
+    Supports different grid sizes and connection patterns.
+    Subclasses pass their specific configurations directly to __init__.
+    """
+
+    def __init__(
+        self,
+        grid_size: int,
+        connections: List[Tuple[int, int]],
+        textures: List[str],
+        placed_room: Optional[int] = None,
+        obs_level: ObservationLevel = ObservationLevel.TOP_DOWN_PARTIAL,
+        continuous: bool = False,
+        room_size: Union[int, float] = DEFAULT_ROOM_SIZE,
+        door_size: Union[int, float] = DEFAULT_DOOR_SIZE,
+        agent_mode: Optional[str] = None,
+        obs_width: int = DEFAULT_OBS_WIDTH,
+        obs_height: int = DEFAULT_OBS_HEIGHT,
+        **kwargs,
+    ):
+        """
+        Initialize a grid-based room environment.
+
+        Args:
+            grid_size: Size of the grid (e.g., 3 for 3x3 grid)
+            connections: List of (room1, room2) tuples for connections
+            textures: List of texture names for each room
+            placed_room: Initial room index (defaults to 0)
+            obs_level: Observation level (defaults to 1)
+            continuous: Whether to use continuous actions (defaults to False)
+            room_size: Size of each room in environment units (defaults to 5)
+            door_size: Size of doors between rooms (defaults to 2)
+            agent_mode: Agent rendering mode ('triangle', 'circle', 'empty')
+            obs_width: Observation width in pixels (defaults to DEFAULT_OBS_WIDTH)
+            obs_height: Observation height in pixels (defaults to DEFAULT_OBS_HEIGHT)
+            **kwargs: Additional arguments passed to parent class
+        """
+
+        # Set grid configuration
+        self.grid_size = grid_size
+        self.total_rooms = self.grid_size * self.grid_size
+
+        # Validate and set connections
+        assert len(connections) > 0, "Connection between rooms should be more than 1"
+        self.connections = connections
+
+        # Validate and set textures
+        assert len(textures) == self.total_rooms, (
+            f"Textures for floor should be same as the number of the rooms ({self.total_rooms})"
+        )
+        self.textures = textures
+
+        # Set placed room
+        if placed_room is None:
+            self.placed_room = 0  # Start in the first room
+        else:
+            assert 0 <= placed_room < self.total_rooms, (
+                f"placing point should be in 0~{self.total_rooms - 1}"
+            )
+            self.placed_room = placed_room
+
+        # Set agent mode
+        if agent_mode is None:
+            self.agent_mode = "empty"
+        else:
+            assert agent_mode in ["triangle", "circle", "empty"], (
+                "configuration cannot be done"
+            )
+            self.agent_mode = agent_mode
+
+        self.room_size = room_size
+        self.door_size = door_size
+
+        # Mark this as a custom environment for background color handling
+        self._is_custom_env = True
+
+        super().__init__(
+            obs_level=obs_level,
+            max_episode_steps=MAX_EPISODE_STEPS,
+            continuous=continuous,
+            agent_mode=self.agent_mode,
+            obs_width=obs_width,
+            obs_height=obs_height,
+            **kwargs,
+        )
+
+        if not self.continuous:
+            self.action_space = spaces.Discrete(self.actions.move_forward + 1)
+
+    def _generate_world_layout(self, pos=None):
+        rooms = []
+
+        # Create rooms in grid layout
+        for i in range(self.grid_size):
+            for j in range(self.grid_size):
+                rooms.append(
+                    self.add_rect_room(
+                        min_x=self.room_size * j,
+                        max_x=self.room_size * (j + (1 - ROOM_BOUNDARY_MARGIN)),
+                        min_z=self.room_size * i,
+                        max_z=self.room_size * (i + (1 - ROOM_BOUNDARY_MARGIN)),
+                        floor_tex=self.textures[self.grid_size * i + j],
+                    )
+                )
+
+        # Connect rooms based on connection list
+        for connection in self.connections:
+            if rooms[connection[0]].mid_x == rooms[connection[1]].mid_x:
+                self.connect_rooms(
+                    rooms[connection[0]],
+                    rooms[connection[1]],
+                    min_x=rooms[connection[0]].mid_x - self.door_size,
+                    max_x=rooms[connection[0]].mid_x + self.door_size,
+                )
+            else:
+                self.connect_rooms(
+                    rooms[connection[0]],
+                    rooms[connection[1]],
+                    min_z=rooms[connection[0]].mid_z - self.door_size,
+                    max_z=rooms[connection[0]].mid_z + self.door_size,
+                )
+
+        # Place agent
+        if pos is None:
+            self.place_agent(pos=list(AGENT_START_POSITION))
+        else:
+            self.place_agent(pos=[pos[0], 0, pos[1]])
+
+        # Place box entities in each room in a 3x3 grid pattern
+        self._place_room_boxes()
+
+    def _place_room_boxes(self):
+        """Place colored box entities in each room using a 3x3 grid pattern."""
+        available_colors = list(COLORS.keys())
+        num_colors = len(available_colors)
+
+        for room_row in range(self.grid_size):
+            for room_col in range(self.grid_size):
+                room_start_x = self.room_size * room_col
+                room_start_z = self.room_size * room_row
+
+                # Place boxes in a 3x3 grid within each room
+                for box_index in range(BOXES_PER_ROOM):
+                    box_row = box_index // BOX_GRID_SIZE
+                    box_col = box_index % BOX_GRID_SIZE
+
+                    # Calculate unique color index for variety
+                    color_index = (
+                        box_index + 1 + (room_row + 1) * (room_col + 1)
+                    ) % num_colors
+                    box_color = available_colors[color_index]
+
+                    # Calculate box position within room
+                    box_x = (
+                        room_start_x
+                        + ROOM_CENTER_FRACTION * self.room_size * box_col
+                        + BOX_OFFSET_FRACTION * self.room_size
+                    )
+                    box_z = (
+                        room_start_z
+                        + ROOM_CENTER_FRACTION * self.room_size * box_row
+                        + BOX_OFFSET_FRACTION * self.room_size
+                    )
+
+                    # Create and place the box
+                    box = Box(
+                        color=box_color,
+                        transparentable=True,
+                        size=BOX_SIZE_FRACTION * self.room_size,
+                        static=True,
+                    )
+
+                    self.place_entity(ent=box, pos=[box_x, 0, box_z], dir=0)
+
+    def step(self, action):
+        obs, reward, terminated, truncated, info = super().step(action)
+        return obs, reward, terminated, truncated, info

miniworld_maze/environments/factory.py

@@ -0,0 +1,155 @@
+"""Factory for creating Nine Rooms environment variants."""
+
+import gymnasium as gym
+import numpy as np
+
+from ..core import ObservationLevel
+from ..core.constants import FACTORY_DOOR_SIZE, FACTORY_ROOM_SIZE
+from ..wrappers.image_transforms import ImageToPyTorch
+from .nine_rooms import NineRooms
+from .spiral_nine_rooms import SpiralNineRooms
+from .twenty_five_rooms import TwentyFiveRooms
+
+
+class NineRoomsEnvironmentWrapper(gym.Wrapper):
+    """Unified wrapper for all Nine Rooms environment variants."""
+
+    def __init__(
+        self,
+        variant="NineRooms",
+        obs_level=ObservationLevel.TOP_DOWN_PARTIAL,
+        continuous=False,
+        size=64,
+        room_size=FACTORY_ROOM_SIZE,
+        door_size=FACTORY_DOOR_SIZE,
+        agent_mode=None,
+    ):
+        """
+        Create a Nine Rooms environment variant.
+
+        Args:
+            variant: Environment variant ("NineRooms", "SpiralNineRooms", "TwentyFiveRooms")
+            obs_level: Observation level (ObservationLevel enum)
+            continuous: Whether to use continuous actions
+            size: Observation image size (rendered directly at this size to avoid resizing)
+            room_size: Size of each room in environment units
+            door_size: Size of doors between rooms
+            agent_mode: Agent rendering mode ('empty', 'circle', 'triangle', or None for default)
+        """
+        self.variant = variant
+
+        # Select the appropriate environment class
+        env_classes = {
+            "NineRooms": NineRooms,
+            "SpiralNineRooms": SpiralNineRooms,
+            "TwentyFiveRooms": TwentyFiveRooms,
+        }
+
+        if variant not in env_classes:
+            raise ValueError(
+                f"Unknown variant '{variant}'. Available: {list(env_classes.keys())}"
+            )
+
+        env_class = env_classes[variant]
+
+        # Create base environment with direct rendering size
+        base_env = env_class(
+            room_size=room_size,
+            door_size=door_size,
+            obs_level=obs_level,
+            continuous=continuous,
+            obs_width=size,
+            obs_height=size,
+            agent_mode=agent_mode,
+        )
+
+        # Apply wrappers - no resize needed since we render at target size
+        env = ImageToPyTorch(base_env)
+
+        # Initialize gym.Wrapper with the wrapped environment
+        super().__init__(env)
+
+    def render_on_pos(self, pos):
+        """Render observation from a specific position."""
+        # Get access to the base environment
+        base_env = self.env
+        while hasattr(base_env, "env") or hasattr(base_env, "_env"):
+            if hasattr(base_env, "env"):
+                base_env = base_env.env
+            elif hasattr(base_env, "_env"):
+                base_env = base_env._env
+            else:
+                break
+
+        # Store original position
+        original_pos = base_env.agent.pos.copy()
+
+        # Move agent to target position
+        base_env.place_agent(pos=pos)
+
+        # Get first-person observation from the agent's perspective at this position
+        obs = base_env.render_obs()
+
+        # Restore original position
+        base_env.place_agent(pos=original_pos)
+
+        # Apply wrapper transformations manually for consistency
+        # Convert to PyTorch format (CHW) - no resize needed since we render at target size
+        obs = np.transpose(obs, (2, 0, 1))
+
+        return obs
+
+
+def create_drstrategy_env(variant="NineRooms", **kwargs):
+    """
+    Factory function to create DrStrategy environment variants.
+
+    Args:
+        variant: Environment variant ("NineRooms", "SpiralNineRooms", "TwentyFiveRooms")
+        **kwargs: Additional arguments passed to NineRoomsEnvironmentWrapper
+
+    Returns:
+        NineRoomsEnvironmentWrapper instance
+    """
+    return NineRoomsEnvironmentWrapper(variant=variant, **kwargs)
+
+
+# Backward compatibility alias
+def create_nine_rooms_env(variant="NineRooms", **kwargs):
+    """
+    Legacy factory function for backward compatibility.
+
+    Deprecated: Use create_drstrategy_env() instead.
+    """
+    import warnings
+
+    warnings.warn(
+        "create_nine_rooms_env() is deprecated. Use create_drstrategy_env() instead.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    return create_drstrategy_env(variant=variant, **kwargs)
+
+
+# Legacy function - deprecated
+def NineRoomsFullyPureGymnasium(
+    name="NineRooms",
+    obs_level=ObservationLevel.TOP_DOWN_PARTIAL,
+    continuous=False,
+    size=64,
+):
+    """
+    Legacy function for backward compatibility.
+
+    Deprecated: Use create_drstrategy_env() instead.
+    """
+    import warnings
+
+    warnings.warn(
+        "NineRoomsFullyPureGymnasium() is deprecated. Use create_drstrategy_env() instead.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    return create_drstrategy_env(
+        variant="NineRooms", obs_level=obs_level, continuous=continuous, size=size
+    )

miniworld_maze/environments/nine_rooms.py

@@ -0,0 +1,74 @@
+"""NineRooms environment implementation."""
+
+from ..core import ObservationLevel
+from .base_grid_rooms import GridRoomsEnvironment
+
+
+class NineRooms(GridRoomsEnvironment):
+    """
+    Traverse the 9 rooms
+
+    -------------
+    | 0 | 1 | 2 |
+    -------------
+    | 3 | 4 | 5 |
+    -------------
+    | 6 | 7 | 8 |
+    -------------
+    """
+
+    def __init__(
+        self,
+        connections=None,
+        textures=None,
+        placed_room=None,
+        obs_level=ObservationLevel.TOP_DOWN_PARTIAL,
+        continuous=False,
+        room_size=5,
+        door_size=2,
+        agent_mode=None,
+        obs_width=80,
+        obs_height=80,
+        **kwargs,
+    ):
+        # Default configuration for NineRooms
+        default_connections = [
+            (0, 1),
+            (0, 3),
+            (1, 2),
+            (1, 4),
+            (2, 5),
+            (3, 4),
+            (3, 6),
+            (4, 5),
+            (4, 7),
+            (5, 8),
+            (6, 7),
+            (7, 8),
+        ]
+        default_textures = [
+            "beige",
+            "lightbeige",
+            "lightgray",
+            "copperred",
+            "skyblue",
+            "lightcobaltgreen",
+            "oakbrown",
+            "navyblue",
+            "cobaltgreen",
+        ]
+
+        super().__init__(
+            grid_size=3,
+            connections=connections or default_connections,
+            textures=textures or default_textures,
+            placed_room=placed_room,
+            obs_level=obs_level,
+            continuous=continuous,
+            room_size=room_size,
+            door_size=door_size,
+            agent_mode=agent_mode,
+            obs_width=obs_width,
+            obs_height=obs_height,
+            **kwargs,
+        )

miniworld_maze/environments/spiral_nine_rooms.py

@@ -0,0 +1,70 @@
+"""SpiralNineRooms environment implementation."""
+
+from ..core import ObservationLevel
+from .base_grid_rooms import GridRoomsEnvironment
+
+
+class SpiralNineRooms(GridRoomsEnvironment):
+    """
+    Traverse the 9 rooms in spiral
+
+    -------------
+    | 0 | 1 | 2 |
+    -------------
+    | 3 | 4 | 5 |
+    -------------
+    | 6 | 7 | 8 |
+    -------------
+    """
+
+    def __init__(
+        self,
+        connections=None,
+        textures=None,
+        placed_room=None,
+        obs_level=ObservationLevel.TOP_DOWN_PARTIAL,
+        continuous=False,
+        room_size=5,
+        door_size=2,
+        agent_mode=None,
+        obs_width=80,
+        obs_height=80,
+        **kwargs,
+    ):
+        # Default configuration for SpiralNineRooms
+        default_connections = [
+            (0, 1),
+            (0, 3),
+            (1, 2),
+            (2, 5),
+            (3, 6),
+            (4, 5),
+            (6, 7),
+            (7, 8),
+        ]
+        default_textures = [
+            "beige",
+            "lightbeige",
+            "lightgray",
+            "copperred",
+            "skyblue",
+            "lightcobaltgreen",
+            "oakbrown",
+            "navyblue",
+            "cobaltgreen",
+        ]
+
+        super().__init__(
+            grid_size=3,
+            connections=connections or default_connections,
+            textures=textures or default_textures,
+            placed_room=placed_room,
+            obs_level=obs_level,
+            continuous=continuous,
+            room_size=room_size,
+            door_size=door_size,
+            agent_mode=agent_mode,
+            obs_width=obs_width,
+            obs_height=obs_height,
+            **kwargs,
+        )