platform-lander 0.1.0__py3-none-any.whl

platform_lander/__init__.py

@@ -0,0 +1,12 @@
+"""Standalone SpaceX-style platform landing environment.
+
+This package is intentionally independent from Gymnasium. It keeps the familiar
+``reset``/``step``/``render`` API and lightweight ``Box``/``Discrete`` spaces so
+it can be used by RL code without importing ``gymnasium``.
+"""
+
+from platform_lander.platform_lander import PlatformLander, heuristic
+from platform_lander.spaces import Box, Discrete
+
+__all__ = ["PlatformLander", "heuristic", "Box", "Discrete"]
+

platform_lander/core.py

@@ -0,0 +1,88 @@
+"""Small Gymnasium-compatible core helpers used by :mod:`platform_lander`.
+
+The environment code is adapted from Gymnasium's LunarLander v3, but this file
+contains the minimal runtime support needed to use it without importing
+Gymnasium.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+
+
+class DependencyNotInstalled(ImportError):
+    """Raised when an optional rendering or physics dependency is missing."""
+
+
+class Error(Exception):
+    """Base package exception."""
+
+
+def np_random(seed: int | None = None) -> tuple[np.random.Generator, int]:
+    """Return a NumPy random generator and the seed used to create it."""
+
+    if seed is not None and not (isinstance(seed, int) and seed >= 0):
+        raise Error(f"Seed must be a non-negative python integer, got {seed!r}")
+
+    seed_seq = np.random.SeedSequence(seed)
+    rng = np.random.Generator(np.random.PCG64(seed_seq))
+    return rng, int(seed_seq.entropy)
+
+
+class Env:
+    """Minimal environment base class with Gymnasium-style seeding."""
+
+    metadata: dict[str, Any] = {"render_modes": []}
+    render_mode: str | None = None
+
+    _np_random: np.random.Generator | None = None
+    _np_random_seed: int | None = None
+
+    def reset(self, *, seed: int | None = None, options: dict | None = None):
+        if seed is not None:
+            self._np_random, self._np_random_seed = np_random(seed)
+
+    @property
+    def np_random(self) -> np.random.Generator:
+        if self._np_random is None:
+            self._np_random, self._np_random_seed = np_random()
+        return self._np_random
+
+    @np_random.setter
+    def np_random(self, value: np.random.Generator) -> None:
+        self._np_random = value
+        self._np_random_seed = -1
+
+    @property
+    def np_random_seed(self) -> int:
+        if self._np_random_seed is None:
+            self._np_random, self._np_random_seed = np_random()
+        return self._np_random_seed
+
+    @property
+    def unwrapped(self):
+        return self
+
+    def close(self) -> None:
+        pass
+
+
+class EzPickle:
+    """Pickle objects by replaying their constructor arguments."""
+
+    def __init__(self, *args: object, **kwargs: object) -> None:
+        self._ezpickle_args = args
+        self._ezpickle_kwargs = kwargs
+
+    def __getstate__(self) -> dict[str, Any]:
+        return {
+            "_ezpickle_args": self._ezpickle_args,
+            "_ezpickle_kwargs": self._ezpickle_kwargs,
+        }
+
+    def __setstate__(self, state: dict[str, Any]) -> None:
+        obj = type(self)(*state["_ezpickle_args"], **state["_ezpickle_kwargs"])
+        self.__dict__.update(obj.__dict__)
+

platform_lander/platform_lander.py

@@ -0,0 +1,834 @@
+"""Standalone moving-platform booster landing environment.
+
+The physics and API are adapted from Gymnasium's LunarLander v3 under the MIT
+license, then modified to model a vertical booster landing on a floating
+left-right moving platform.
+"""
+
+from __future__ import annotations
+
+import math
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+from platform_lander.core import DependencyNotInstalled, Env, EzPickle
+from platform_lander.spaces import Box, Discrete
+
+try:
+    import Box2D
+    from Box2D.b2 import (
+        circleShape,
+        contactListener,
+        edgeShape,
+        fixtureDef,
+        polygonShape,
+    )
+except ImportError as exc:  # pragma: no cover - import-time dependency check
+    raise DependencyNotInstalled(
+        "Box2D is not installed. Install it with `pip install swig box2d-py`."
+    ) from exc
+
+if TYPE_CHECKING:
+    import pygame
+
+
+FPS = 50
+SCALE = 30.0
+
+VIEWPORT_W = 600
+VIEWPORT_H = 400
+
+BOTTOM_ENGINE_POWER = 18.0
+TOP_ENGINE_POWER = 1.25
+INITIAL_RANDOM = 700.0
+
+BOOSTER_HALF_WIDTH = 8
+BOOSTER_TOP = 52
+BOOSTER_BOTTOM = 56
+BOOSTER_START_CLEARANCE = 0.06
+TOP_ENGINE_Y = 43
+TOP_ENGINE_AWAY = 9
+BOTTOM_ENGINE_Y = 54
+
+PLATFORM_WIDTH = 118
+PLATFORM_HEIGHT = 14
+PLATFORM_SPEED = 1.15
+MAX_JET_FIRES = 200
+LANDING_ANGLE = math.radians(8.0)
+LANDING_VX = 0.45
+LANDING_VY = 0.65
+LANDING_ANGULAR_V = 0.55
+
+
+class ContactDetector(contactListener):
+    """Track booster contacts with the platform and ocean."""
+
+    def __init__(self, env: "PlatformLander") -> None:
+        contactListener.__init__(self)
+        self.env = env
+
+    @staticmethod
+    def _data(contact) -> tuple[object, object]:
+        return contact.fixtureA.userData, contact.fixtureB.userData
+
+    def BeginContact(self, contact) -> None:
+        a, b = self._data(contact)
+        labels = {a, b}
+        booster_labels = {"booster_body", "left_foot", "right_foot"}
+
+        if "ocean" in labels and labels.intersection(booster_labels):
+            self.env.ocean_contact = True
+            return
+
+        if "platform" not in labels:
+            return
+
+        if "booster_body" in labels:
+            self.env.body_platform_contact = True
+            self.env.platform_contact = True
+        if "left_foot" in labels:
+            self.env.left_foot_contact = True
+            self.env.platform_contact = True
+        if "right_foot" in labels:
+            self.env.right_foot_contact = True
+            self.env.platform_contact = True
+
+    def EndContact(self, contact) -> None:
+        a, b = self._data(contact)
+        labels = {a, b}
+        if "platform" not in labels:
+            return
+        if "left_foot" in labels:
+            self.env.left_foot_contact = False
+        if "right_foot" in labels:
+            self.env.right_foot_contact = False
+        if "booster_body" in labels:
+            self.env.body_platform_contact = False
+        self.env.platform_contact = (
+            self.env.left_foot_contact
+            or self.env.right_foot_contact
+            or self.env.body_platform_contact
+        )
+
+
+class PlatformLander(Env, EzPickle):
+    """Land a reusable booster vertically on a moving ocean platform.
+
+    Actions are ``Discrete(4)`` by default:
+
+    - 0: do nothing
+    - 1: fire the upper-left attitude jet
+    - 2: fire the bottom engine
+    - 3: fire the upper-right attitude jet
+
+    With ``continuous=True``, actions are ``Box(-1, 1, shape=(2,))`` where the
+    first value controls the bottom engine and the second controls the top jets.
+
+    Observations contain eleven float values:
+    relative x/y to the platform landing point, x/y velocity, booster angle,
+    angular velocity, left/right foot contact flags, platform x, and platform
+    velocity, and the fraction of jet fires remaining. Wind is applied from
+    ``wind_direction`` with force ``wind_power``. If ``variable_wind=True`` the
+    force varies over time using LunarLander v3's deterministic wind pattern.
+    """
+
+    metadata = {"render_modes": ["human", "rgb_array"], "render_fps": FPS}
+
+    def __init__(
+        self,
+        render_mode: str | None = None,
+        continuous: bool = False,
+        gravity: float = -10.0,
+        enable_wind: bool = False,
+        wind_power: float = 15.0,
+        wind_direction: float | tuple[float, float] = 0.0,
+        turbulence_power: float = 1.5,
+        variable_wind: bool = True,
+        platform_speed: float = PLATFORM_SPEED,
+        max_jet_fires: int = MAX_JET_FIRES,
+    ) -> None:
+        EzPickle.__init__(
+            self,
+            render_mode,
+            continuous,
+            gravity,
+            enable_wind,
+            wind_power,
+            wind_direction,
+            turbulence_power,
+            variable_wind,
+            platform_speed,
+            max_jet_fires,
+        )
+        if not -12.0 < gravity < 0.0:
+            raise ValueError(f"gravity must be between -12 and 0, got {gravity}")
+
+        self.gravity = gravity
+        self.continuous = continuous
+        self.enable_wind = enable_wind
+        self.wind_power = float(wind_power)
+        self.wind_direction = wind_direction
+        self.turbulence_power = float(turbulence_power)
+        self.variable_wind = variable_wind
+        self.platform_speed = float(platform_speed)
+        self.max_jet_fires = int(max_jet_fires)
+        self.render_mode = render_mode
+
+        self.screen: pygame.Surface | None = None
+        self.clock = None
+        self.isopen = True
+
+        self.world = Box2D.b2World(gravity=(0, gravity))
+        self.booster: Box2D.b2Body | None = None
+        self.platform: Box2D.b2Body | None = None
+        self.ocean: Box2D.b2Body | None = None
+        self.bottom_flame_power = 0.0
+        self.top_flame_power = 0.0
+        self.top_flame_direction = 0
+        self.jet_fires_used = 0
+        self.prev_shaping = None
+
+        low = np.array(
+            [-2.5, -2.5, -10.0, -10.0, -2 * math.pi, -10.0, 0.0, 0.0, -1.0, -2.0, 0.0],
+            dtype=np.float32,
+        )
+        high = np.array(
+            [2.5, 2.5, 10.0, 10.0, 2 * math.pi, 10.0, 1.0, 1.0, 1.0, 2.0, 1.0],
+            dtype=np.float32,
+        )
+        self.observation_space = Box(low, high, dtype=np.float32)
+        self.action_space = (
+            Box(-1.0, 1.0, shape=(2,), dtype=np.float32)
+            if continuous
+            else Discrete(4)
+        )
+
+    def _destroy(self) -> None:
+        self.world.contactListener = None
+        for body_name in ("booster", "platform", "ocean"):
+            body = getattr(self, body_name)
+            if body is not None:
+                self.world.DestroyBody(body)
+                setattr(self, body_name, None)
+
+    def reset(self, *, seed: int | None = None, options: dict | None = None):
+        super().reset(seed=seed)
+        self._destroy()
+
+        self.world = Box2D.b2World(gravity=(0, self.gravity))
+        self.world.contactListener_keepref = ContactDetector(self)
+        self.world.contactListener = self.world.contactListener_keepref
+
+        self.ocean_contact = False
+        self.platform_contact = False
+        self.body_platform_contact = False
+        self.left_foot_contact = False
+        self.right_foot_contact = False
+        self.failure_reason: str | None = None
+        self.prev_shaping = None
+        self.bottom_flame_power = 0.0
+        self.top_flame_power = 0.0
+        self.top_flame_direction = 0
+        self.jet_fires_used = 0
+
+        w = VIEWPORT_W / SCALE
+        h = VIEWPORT_H / SCALE
+        self.platform_y = h / 4
+        self.platform_half_width = PLATFORM_WIDTH / SCALE / 2
+        self.platform_half_height = PLATFORM_HEIGHT / SCALE / 2
+        self.platform_min_x = self.platform_half_width + 0.25
+        self.platform_max_x = w - self.platform_half_width - 0.25
+        self.platform_direction = int(self.np_random.choice([-1, 1]))
+
+        platform_x = float(self.np_random.uniform(self.platform_min_x, self.platform_max_x))
+        self.platform = self.world.CreateKinematicBody(position=(platform_x, self.platform_y))
+        platform_fixture = self.platform.CreateFixture(
+            fixtureDef(
+                shape=polygonShape(box=(self.platform_half_width, self.platform_half_height)),
+                density=0.0,
+                friction=0.9,
+                restitution=0.0,
+                categoryBits=0x0001,
+            )
+        )
+        platform_fixture.userData = "platform"
+        self.platform.color1 = (38, 42, 48)
+        self.platform.color2 = (235, 235, 235)
+
+        self.ocean_y = self.platform_y - self.platform_half_height * 0.75
+        self.ocean = self.world.CreateStaticBody()
+        ocean_fixture = self.ocean.CreateFixture(
+            fixtureDef(
+                shape=edgeShape(vertices=[(0, self.ocean_y), (w, self.ocean_y)]),
+                isSensor=True,
+                categoryBits=0x0001,
+            )
+        )
+        ocean_fixture.userData = "ocean"
+
+        initial_x = w / 2
+        initial_y = h + BOOSTER_BOTTOM / SCALE + BOOSTER_START_CLEARANCE
+        self.booster = self.world.CreateDynamicBody(position=(initial_x, initial_y), angle=0.0)
+        body_fixture = self.booster.CreateFixture(
+            fixtureDef(
+                shape=polygonShape(
+                    vertices=[
+                        (-BOOSTER_HALF_WIDTH / SCALE, -48 / SCALE),
+                        (-BOOSTER_HALF_WIDTH / SCALE, 43 / SCALE),
+                        (-5 / SCALE, BOOSTER_TOP / SCALE),
+                        (5 / SCALE, BOOSTER_TOP / SCALE),
+                        (BOOSTER_HALF_WIDTH / SCALE, 43 / SCALE),
+                        (BOOSTER_HALF_WIDTH / SCALE, -48 / SCALE),
+                    ]
+                ),
+                density=4.5,
+                friction=0.25,
+                categoryBits=0x0010,
+                maskBits=0x0001,
+                restitution=0.0,
+            )
+        )
+        body_fixture.userData = "booster_body"
+
+        left_foot_fixture = self.booster.CreateFixture(
+            fixtureDef(
+                shape=polygonShape(box=(8 / SCALE, 2 / SCALE, (-7 / SCALE, -54 / SCALE), 0.0)),
+                density=0.7,
+                friction=1.0,
+                categoryBits=0x0010,
+                maskBits=0x0001,
+                restitution=0.0,
+            )
+        )
+        left_foot_fixture.userData = "left_foot"
+
+        right_foot_fixture = self.booster.CreateFixture(
+            fixtureDef(
+                shape=polygonShape(box=(8 / SCALE, 2 / SCALE, (7 / SCALE, -54 / SCALE), 0.0)),
+                density=0.7,
+                friction=1.0,
+                categoryBits=0x0010,
+                maskBits=0x0001,
+                restitution=0.0,
+            )
+        )
+        right_foot_fixture.userData = "right_foot"
+
+        self.booster.color1 = (230, 232, 235)
+        self.booster.color2 = (40, 44, 52)
+
+        self.booster.ApplyForceToCenter(
+            (
+                self.np_random.uniform(-INITIAL_RANDOM, INITIAL_RANDOM),
+                self.np_random.uniform(-INITIAL_RANDOM, INITIAL_RANDOM),
+            ),
+            True,
+        )
+
+        if self.enable_wind:
+            self.wind_idx = int(self.np_random.integers(-9999, 9999))
+            self.torque_idx = int(self.np_random.integers(-9999, 9999))
+
+        self.drawlist = [self.platform, self.booster]
+
+        if self.render_mode == "human":
+            self.render()
+        return self.step(np.array([0.0, 0.0], dtype=np.float32) if self.continuous else 0)[0], {}
+
+    def _wind_unit(self) -> tuple[float, float]:
+        if isinstance(self.wind_direction, tuple):
+            x, y = self.wind_direction
+            norm = math.hypot(x, y)
+            return (0.0, 0.0) if norm == 0 else (x / norm, y / norm)
+        return math.cos(float(self.wind_direction)), math.sin(float(self.wind_direction))
+
+    def _wind_scale(self) -> float:
+        if not self.variable_wind:
+            return 1.0
+        scale = math.tanh(
+            math.sin(0.02 * self.wind_idx)
+            + math.sin(math.pi * 0.01 * self.wind_idx)
+        )
+        self.wind_idx += 1
+        return scale
+
+    def set_wind(
+        self,
+        *,
+        power: float | None = None,
+        direction: float | tuple[float, float] | None = None,
+        enabled: bool | None = None,
+    ) -> None:
+        """Adjust wind during an episode."""
+
+        if power is not None:
+            self.wind_power = float(power)
+        if direction is not None:
+            self.wind_direction = direction
+        if enabled is not None:
+            self.enable_wind = bool(enabled)
+
+    def _update_platform(self) -> None:
+        assert self.platform is not None
+        x = self.platform.position.x
+        if x <= self.platform_min_x + 1e-6 and self.platform_direction < 0:
+            self.platform_direction = 1
+        elif x >= self.platform_max_x - 1e-6 and self.platform_direction > 0:
+            self.platform_direction = -1
+        self.platform.linearVelocity = (self.platform_speed * self.platform_direction, 0.0)
+
+    def _clamp_platform(self) -> None:
+        assert self.platform is not None
+        x = min(max(self.platform.position.x, self.platform_min_x), self.platform_max_x)
+        if x != self.platform.position.x:
+            if x <= self.platform_min_x + 1e-6:
+                self.platform_direction = 1
+            elif x >= self.platform_max_x - 1e-6:
+                self.platform_direction = -1
+            self.platform.position = (x, self.platform.position.y)
+            self.platform.linearVelocity = (self.platform_speed * self.platform_direction, 0.0)
+
+    def _apply_wind(self) -> None:
+        assert self.booster is not None
+        if not self.enable_wind or self.platform_contact:
+            return
+        wx, wy = self._wind_unit()
+        wind_mag = self.wind_power * self._wind_scale()
+        self.booster.ApplyForceToCenter((wx * wind_mag, wy * wind_mag), True)
+
+        torque_mag = math.tanh(
+            math.sin(0.02 * self.torque_idx)
+            + math.sin(math.pi * 0.01 * self.torque_idx)
+        ) * self.turbulence_power
+        self.torque_idx += 1
+        self.booster.ApplyTorque(torque_mag, True)
+
+    def _apply_engines(self, action) -> tuple[float, float]:
+        assert self.booster is not None
+
+        if self.continuous:
+            action = np.clip(action, -1, +1).astype(np.float64)
+        else:
+            if not self.action_space.contains(action):
+                raise AssertionError(f"{action!r} ({type(action)}) is not a valid action")
+
+        tip = (math.sin(self.booster.angle), math.cos(self.booster.angle))
+        side = (-tip[1], tip[0])
+        dispersion = [self.np_random.uniform(-1.0, 1.0) / SCALE for _ in range(2)]
+
+        bottom_power = 0.0
+        if (self.continuous and action[0] > 0.0) or (not self.continuous and action == 2):
+            if self.jet_fires_used < self.max_jet_fires:
+                bottom_power = (np.clip(action[0], 0.0, 1.0) + 1.0) * 0.5 if self.continuous else 1.0
+                self.jet_fires_used += 1
+                ox = -tip[0] * (BOTTOM_ENGINE_Y / SCALE + dispersion[0]) + side[0] * dispersion[1]
+                oy = -tip[1] * (BOTTOM_ENGINE_Y / SCALE + dispersion[0]) + side[1] * dispersion[1]
+                impulse_pos = (self.booster.position[0] + ox, self.booster.position[1] + oy)
+                impulse = (tip[0] * BOTTOM_ENGINE_POWER * bottom_power, tip[1] * BOTTOM_ENGINE_POWER * bottom_power)
+                self.booster.ApplyLinearImpulse(impulse, impulse_pos, True)
+
+        top_power = 0.0
+        top_direction = 0
+        if self.continuous and abs(action[1]) > 0.5:
+            top_direction = -1 if action[1] < 0 else 1
+            top_power = float(np.clip(abs(action[1]), 0.5, 1.0))
+        elif not self.continuous and action in (1, 3):
+            top_direction = -1 if action == 1 else 1
+            top_power = 1.0
+
+        if top_direction and self.jet_fires_used < self.max_jet_fires:
+            # top_direction < 0 means upper-left jet, > 0 means upper-right jet.
+            self.jet_fires_used += 1
+            local_side = TOP_ENGINE_AWAY / SCALE * (-top_direction)
+            impulse_sign = top_direction
+            ox = tip[0] * (TOP_ENGINE_Y / SCALE + dispersion[0]) + side[0] * local_side
+            oy = tip[1] * (TOP_ENGINE_Y / SCALE + dispersion[0]) + side[1] * local_side
+            impulse_pos = (self.booster.position[0] + ox, self.booster.position[1] + oy)
+            impulse = (
+                side[0] * impulse_sign * TOP_ENGINE_POWER * top_power,
+                side[1] * impulse_sign * TOP_ENGINE_POWER * top_power,
+            )
+            self.booster.ApplyLinearImpulse(impulse, impulse_pos, True)
+        elif top_direction:
+            top_power = 0.0
+
+        self.bottom_flame_power = max(bottom_power, self.bottom_flame_power * 0.68)
+        if top_direction:
+            self.top_flame_direction = top_direction
+        self.top_flame_power = max(top_power, self.top_flame_power * 0.68)
+
+        return float(bottom_power), float(top_power)
+
+    def _get_state(self) -> np.ndarray:
+        assert self.booster is not None
+        assert self.platform is not None
+
+        pos = self.booster.position
+        vel = self.booster.linearVelocity
+        platform_pos = self.platform.position
+        platform_vel = self.platform.linearVelocity
+        target_y = self.platform_y + self.platform_half_height + BOOSTER_BOTTOM / SCALE
+        half_w = VIEWPORT_W / SCALE / 2
+        half_h = VIEWPORT_H / SCALE / 2
+
+        state = np.array(
+            [
+                (pos.x - platform_pos.x) / half_w,
+                (pos.y - target_y) / half_h,
+                (vel.x - platform_vel.x) * half_w / FPS,
+                vel.y * half_h / FPS,
+                self._normalized_angle(self.booster.angle),
+                20.0 * self.booster.angularVelocity / FPS,
+                1.0 if self.left_foot_contact else 0.0,
+                1.0 if self.right_foot_contact else 0.0,
+                (platform_pos.x - half_w) / half_w,
+                platform_vel.x,
+                max(0.0, (self.max_jet_fires - self.jet_fires_used) / self.max_jet_fires),
+            ],
+            dtype=np.float32,
+        )
+        return state
+
+    @staticmethod
+    def _normalized_angle(angle: float) -> float:
+        return (angle + math.pi) % (2 * math.pi) - math.pi
+
+    def _is_standing_landing(self, state: np.ndarray) -> bool:
+        assert self.booster is not None
+        return bool(
+            self.left_foot_contact
+            and self.right_foot_contact
+            and abs(state[0]) < (self.platform_half_width - 0.15) / (VIEWPORT_W / SCALE / 2)
+            and abs(state[2]) < LANDING_VX
+            and abs(state[3]) < LANDING_VY
+            and abs(state[4]) < LANDING_ANGLE
+            and abs(self.booster.angularVelocity) < LANDING_ANGULAR_V
+        )
+
+    def _terminal_status(self, state: np.ndarray) -> tuple[bool, bool, str | None]:
+        assert self.booster is not None
+        if self.ocean_contact or self.booster.position.y < self.ocean_y - 0.5:
+            return True, False, "ocean"
+        if abs(state[0]) > 2.0:
+            return True, False, "out_of_bounds"
+        if self.body_platform_contact:
+            return True, False, "booster_body_hit_platform"
+        if self.platform_contact and abs(state[4]) >= LANDING_ANGLE:
+            return True, False, "non_vertical_platform_contact"
+        if self._is_standing_landing(state) and (not self.booster.awake or abs(state[3]) < 0.08):
+            return True, True, None
+        if not self.booster.awake:
+            return True, False, "settled_not_vertical"
+        return False, False, None
+
+    def _settle_successful_landing(self) -> None:
+        assert self.booster is not None
+        assert self.platform is not None
+        target_y = self.platform_y + self.platform_half_height + BOOSTER_BOTTOM / SCALE
+        platform_x = self.platform.position.x
+        half_width = self.platform_half_width - 0.15
+        x = float(np.clip(self.booster.position.x, platform_x - half_width, platform_x + half_width))
+
+        self.booster.position = (x, target_y)
+        self.booster.angle = 0.0
+        self.booster.linearVelocity = self.platform.linearVelocity
+        self.booster.angularVelocity = 0.0
+        self.booster.awake = False
+        self.left_foot_contact = True
+        self.right_foot_contact = True
+        self.body_platform_contact = False
+        self.platform_contact = True
+
+    def step(self, action):
+        if self.booster is None:
+            raise AssertionError("You forgot to call reset()")
+
+        self._update_platform()
+        self._apply_wind()
+        bottom_power, top_power = self._apply_engines(action)
+
+        self.world.Step(1.0 / FPS, 6 * 30, 2 * 30)
+        self._clamp_platform()
+
+        state = self._get_state()
+        shaping = (
+            -100 * math.sqrt(state[0] * state[0] + state[1] * state[1])
+            -100 * math.sqrt(state[2] * state[2] + state[3] * state[3])
+            -120 * abs(state[4])
+            + 12 * state[6]
+            + 12 * state[7]
+        )
+        reward = 0.0 if self.prev_shaping is None else float(shaping - self.prev_shaping)
+        self.prev_shaping = shaping
+        reward -= bottom_power * 0.30
+        reward -= top_power * 0.03
+
+        terminated, success, failure_reason = self._terminal_status(state)
+        self.failure_reason = failure_reason
+        if terminated:
+            reward = 100.0 if success else -100.0
+            if success:
+                self._settle_successful_landing()
+                state = self._get_state()
+
+        if self.render_mode == "human":
+            self.render()
+
+        info = {
+            "success": success,
+            "failure_reason": failure_reason,
+            "platform_x": float(self.platform.position.x) if self.platform else None,
+            "wind_power": self.wind_power if self.enable_wind else 0.0,
+            "wind_direction": self.wind_direction,
+            "jet_fires_used": self.jet_fires_used,
+            "jet_fires_remaining": max(0, self.max_jet_fires - self.jet_fires_used),
+        }
+        return state, reward, terminated, False, info
+
+    def render(self):
+        if self.render_mode is None:
+            return None
+
+        try:
+            import pygame
+            from pygame import gfxdraw
+        except ImportError as exc:  # pragma: no cover - optional rendering dependency
+            raise DependencyNotInstalled("pygame is not installed. Install it with `pip install pygame`.") from exc
+
+        if self.screen is None and self.render_mode == "human":
+            pygame.init()
+            pygame.display.init()
+            self.screen = pygame.display.set_mode((VIEWPORT_W, VIEWPORT_H))
+        if self.clock is None:
+            self.clock = pygame.time.Clock()
+
+        surf = pygame.Surface((VIEWPORT_W, VIEWPORT_H))
+        surf.fill((186, 220, 235))
+        w = VIEWPORT_W / SCALE
+        h = VIEWPORT_H / SCALE
+
+        ocean_top = (self.ocean_y if hasattr(self, "ocean_y") else h / 4) * SCALE
+        ocean_rect = pygame.Rect(0, 0, VIEWPORT_W, ocean_top)
+        pygame.draw.rect(surf, (31, 91, 133), ocean_rect)
+        for i in range(0, VIEWPORT_W, 48):
+            pygame.draw.arc(surf, (62, 132, 176), (i, ocean_top - 8, 56, 18), 0, math.pi, 2)
+
+        self._draw_flames(surf, pygame, gfxdraw)
+
+        for obj in self.drawlist:
+            for fixture in obj.fixtures:
+                if fixture.userData == "ocean":
+                    continue
+                trans = fixture.body.transform
+                if type(fixture.shape) is circleShape:
+                    center = trans * fixture.shape.pos * SCALE
+                    radius = max(2, int(fixture.shape.radius * SCALE))
+                    pygame.draw.circle(surf, obj.color1, center, radius)
+                    pygame.draw.circle(surf, obj.color2, center, max(1, radius - 1))
+                    continue
+
+                path = [trans * vertex * SCALE for vertex in fixture.shape.vertices]
+                color = obj.color1
+                outline = obj.color2
+                if fixture.userData == "platform":
+                    color = (45, 48, 54)
+                    outline = (235, 235, 235)
+                elif fixture.userData in {"left_foot", "right_foot"}:
+                    color = (42, 46, 54)
+                    outline = (245, 245, 245)
+                pygame.draw.polygon(surf, color, path)
+                gfxdraw.aapolygon(surf, path, color)
+                pygame.draw.aalines(surf, outline, True, path)
+
+        self._draw_booster_details(surf, pygame)
+        surf = pygame.transform.flip(surf, False, True)
+
+        if self.render_mode == "human":
+            assert self.screen is not None
+            self.screen.blit(surf, (0, 0))
+            pygame.event.pump()
+            self.clock.tick(self.metadata["render_fps"])
+            pygame.display.flip()
+            return None
+        if self.render_mode == "rgb_array":
+            return np.transpose(np.array(pygame.surfarray.pixels3d(surf)), axes=(1, 0, 2))
+        return None
+
+    def _draw_flames(self, surf, pygame, gfxdraw) -> None:
+        if self.booster is None:
+            return
+
+        layer = pygame.Surface((VIEWPORT_W, VIEWPORT_H), pygame.SRCALPHA)
+
+        if self.bottom_flame_power > 0.03:
+            nozzle, direction = self._local_flame_anchor(
+                (0.0, -BOTTOM_ENGINE_Y / SCALE),
+                (0.0, -(BOTTOM_ENGINE_Y + 1.0) / SCALE),
+            )
+            self._draw_flame_cone(
+                layer,
+                pygame,
+                gfxdraw,
+                nozzle=nozzle,
+                direction=direction,
+                power=self.bottom_flame_power,
+                length_px=34,
+                base_width_px=7,
+                end_width_px=20,
+            )
+
+        if self.top_flame_power > 0.03 and self.top_flame_direction:
+            local_x = TOP_ENGINE_AWAY / SCALE * (-self.top_flame_direction)
+            nozzle, direction = self._local_flame_anchor(
+                (local_x, TOP_ENGINE_Y / SCALE),
+                (
+                    local_x - self.top_flame_direction / SCALE,
+                    TOP_ENGINE_Y / SCALE,
+                ),
+            )
+            self._draw_flame_cone(
+                layer,
+                pygame,
+                gfxdraw,
+                nozzle=nozzle,
+                direction=direction,
+                power=self.top_flame_power,
+                length_px=18,
+                base_width_px=4,
+                end_width_px=10,
+            )
+
+        surf.blit(layer, (0, 0))
+
+    def _local_flame_anchor(
+        self,
+        nozzle_local: tuple[float, float],
+        direction_local: tuple[float, float],
+    ) -> tuple[tuple[float, float], tuple[float, float]]:
+        assert self.booster is not None
+        nozzle_world = self.booster.transform * nozzle_local
+        direction_world = self.booster.transform * direction_local
+        nozzle = (nozzle_world[0] * SCALE, nozzle_world[1] * SCALE)
+        direction = (
+            direction_world[0] * SCALE - nozzle[0],
+            direction_world[1] * SCALE - nozzle[1],
+        )
+        return nozzle, direction
+
+    @staticmethod
+    def _draw_flame_cone(
+        layer,
+        pygame,
+        gfxdraw,
+        *,
+        nozzle: tuple[float, float],
+        direction: tuple[float, float],
+        power: float,
+        length_px: float,
+        base_width_px: float,
+        end_width_px: float,
+    ) -> None:
+        direction_vec = np.array(direction, dtype=np.float64)
+        norm = np.linalg.norm(direction_vec)
+        if norm == 0:
+            return
+
+        direction_vec /= norm
+        perp = np.array([-direction_vec[1], direction_vec[0]])
+        power = float(np.clip(power, 0.0, 1.0))
+        start = np.array(nozzle, dtype=np.float64)
+        end = start + direction_vec * length_px * (0.45 + 0.55 * power)
+
+        def poly(base_width: float, end_width: float, length_scale: float) -> list[tuple[int, int]]:
+            scaled_end = start + (end - start) * length_scale
+            return [
+                tuple(np.round(start + perp * base_width / 2).astype(int)),
+                tuple(np.round(start - perp * base_width / 2).astype(int)),
+                tuple(np.round(scaled_end - perp * end_width / 2).astype(int)),
+                tuple(np.round(scaled_end + perp * end_width / 2).astype(int)),
+            ]
+
+        alpha = int(210 * power)
+        outer = poly(base_width_px, end_width_px, 1.0)
+        middle = poly(base_width_px * 0.65, end_width_px * 0.58, 0.78)
+        inner = poly(base_width_px * 0.32, end_width_px * 0.24, 0.48)
+
+        pygame.draw.polygon(layer, (69, 39, 24, int(120 * power)), outer)
+        gfxdraw.aapolygon(layer, outer, (69, 39, 24, int(120 * power)))
+        pygame.draw.polygon(layer, (255, 112, 28, alpha), middle)
+        gfxdraw.aapolygon(layer, middle, (255, 112, 28, alpha))
+        pygame.draw.polygon(layer, (255, 235, 132, int(245 * power)), inner)
+        gfxdraw.aapolygon(layer, inner, (255, 235, 132, int(245 * power)))
+
+    def _draw_booster_details(self, surf, pygame) -> None:
+        if self.booster is None:
+            return
+        trans = self.booster.transform
+        stripe_points = [
+            (-6 / SCALE, 20 / SCALE),
+            (6 / SCALE, 20 / SCALE),
+            (6 / SCALE, 28 / SCALE),
+            (-6 / SCALE, 28 / SCALE),
+        ]
+        stripe = [trans * point * SCALE for point in stripe_points]
+        pygame.draw.polygon(surf, (35, 40, 48), stripe)
+
+        logo_center = trans * (0, 35 / SCALE) * SCALE
+        font_rect = pygame.Rect(0, 0, 18, 7)
+        font_rect.center = logo_center
+        pygame.draw.rect(surf, (35, 40, 48), font_rect, border_radius=1)
+
+    def close(self) -> None:
+        if self.screen is not None:
+            import pygame
+
+            pygame.display.quit()
+            pygame.quit()
+            self.isopen = False
+
+
+def heuristic(env: PlatformLander, state: np.ndarray):
+    """A simple controller for quick smoke tests and demos."""
+
+    angle_target = state[0] * 0.55 + state[2] * 0.9
+    angle_target = float(np.clip(angle_target, -0.35, 0.35))
+    hover_target = 0.45 * abs(state[0])
+
+    angle_todo = (angle_target - state[4]) * 0.55 - state[5] * 0.85
+    hover_todo = (hover_target - state[1]) * 0.55 - state[3] * 0.55
+
+    if state[6] or state[7]:
+        angle_todo = -state[4] * 0.9 - state[5] * 0.5
+        hover_todo = -state[3] * 0.5
+
+    if env.unwrapped.continuous:
+        action = np.array([hover_todo * 18 - 1, angle_todo * 18], dtype=np.float32)
+        return np.clip(action, -1, +1)
+
+    action = 0
+    if hover_todo > abs(angle_todo) and hover_todo > 0.04:
+        action = 2
+    elif angle_todo < -0.04:
+        action = 1
+    elif angle_todo > 0.04:
+        action = 3
+    return action
+
+
+def demo_heuristic_lander(seed: int | None = None, render: bool = False) -> float:
+    env = PlatformLander(render_mode="human" if render else None)
+    total_reward = 0.0
+    state, _ = env.reset(seed=seed)
+    for _ in range(1000):
+        action = heuristic(env, state)
+        state, reward, terminated, truncated, _ = env.step(action)
+        total_reward += reward
+        if terminated or truncated:
+            break
+    env.close()
+    return total_reward
+
+
+if __name__ == "__main__":
+    demo_heuristic_lander(render=True)

platform_lander/spaces.py

@@ -0,0 +1,136 @@
+"""Minimal action and observation spaces for the standalone environment."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Sequence
+from typing import Any
+
+import numpy as np
+
+from platform_lander.core import np_random
+
+
+class Space:
+    """Small subset of Gymnasium's Space API."""
+
+    def __init__(
+        self,
+        shape: Sequence[int] | None = None,
+        dtype: type | np.dtype | None = None,
+        seed: int | np.random.Generator | None = None,
+    ) -> None:
+        self._shape = None if shape is None else tuple(int(x) for x in shape)
+        self.dtype = None if dtype is None else np.dtype(dtype)
+        self._np_random: np.random.Generator | None = None
+        if isinstance(seed, np.random.Generator):
+            self._np_random = seed
+        elif seed is not None:
+            self.seed(seed)
+
+    @property
+    def shape(self) -> tuple[int, ...] | None:
+        return self._shape
+
+    @property
+    def np_random(self) -> np.random.Generator:
+        if self._np_random is None:
+            self.seed()
+        assert self._np_random is not None
+        return self._np_random
+
+    def seed(self, seed: int | None = None) -> int:
+        self._np_random, rng_seed = np_random(seed)
+        return rng_seed
+
+    def sample(self):
+        raise NotImplementedError
+
+    def contains(self, x: Any) -> bool:
+        raise NotImplementedError
+
+    def __contains__(self, x: Any) -> bool:
+        return self.contains(x)
+
+
+class Box(Space):
+    """A closed box in Euclidean space."""
+
+    def __init__(
+        self,
+        low: int | float | np.ndarray,
+        high: int | float | np.ndarray,
+        shape: Sequence[int] | None = None,
+        dtype: type | np.dtype = np.float32,
+        seed: int | np.random.Generator | None = None,
+    ) -> None:
+        self.dtype = np.dtype(dtype)
+        if shape is not None:
+            if not isinstance(shape, Iterable):
+                raise TypeError("Box shape must be iterable")
+            shape = tuple(int(dim) for dim in shape)
+        elif isinstance(low, np.ndarray):
+            shape = low.shape
+        elif isinstance(high, np.ndarray):
+            shape = high.shape
+        else:
+            shape = (1,)
+
+        self.low = np.full(shape, low, dtype=self.dtype) if np.isscalar(low) else np.asarray(low, dtype=self.dtype)
+        self.high = np.full(shape, high, dtype=self.dtype) if np.isscalar(high) else np.asarray(high, dtype=self.dtype)
+        if self.low.shape != tuple(shape) or self.high.shape != tuple(shape):
+            raise ValueError("Box low/high shapes must match the provided shape")
+        if np.any(self.low > self.high):
+            raise ValueError("Box low values must be less than or equal to high values")
+        super().__init__(shape=shape, dtype=self.dtype, seed=seed)
+
+    def sample(self) -> np.ndarray:
+        sample = self.np_random.uniform(self.low, self.high)
+        return sample.astype(self.dtype)
+
+    def contains(self, x: Any) -> bool:
+        try:
+            arr = np.asarray(x, dtype=self.dtype)
+        except (TypeError, ValueError):
+            return False
+        return arr.shape == self.shape and bool(np.all(arr >= self.low) and np.all(arr <= self.high))
+
+    def __repr__(self) -> str:
+        return f"Box({self.low}, {self.high}, {self.shape}, {self.dtype})"
+
+
+class Discrete(Space):
+    """A finite set of integers ``{start, ..., start + n - 1}``."""
+
+    def __init__(
+        self,
+        n: int,
+        seed: int | np.random.Generator | None = None,
+        start: int = 0,
+        dtype: type | np.dtype = np.int64,
+    ) -> None:
+        if int(n) <= 0:
+            raise ValueError("Discrete n must be positive")
+        self.dtype = np.dtype(dtype)
+        if not np.issubdtype(self.dtype, np.integer):
+            raise TypeError("Discrete dtype must be an integer dtype")
+        self.n = self.dtype.type(n)
+        self.start = self.dtype.type(start)
+        super().__init__(shape=(), dtype=self.dtype, seed=seed)
+
+    def sample(self):
+        return self.start + self.np_random.integers(self.n, dtype=self.dtype.type)
+
+    def contains(self, x: Any) -> bool:
+        if isinstance(x, int):
+            value = x
+        elif isinstance(x, np.generic) and np.issubdtype(x.dtype, np.integer):
+            value = int(x)
+        elif isinstance(x, np.ndarray) and x.shape == () and np.issubdtype(x.dtype, np.integer):
+            value = int(x)
+        else:
+            return False
+        return int(self.start) <= value < int(self.start + self.n)
+
+    def __repr__(self) -> str:
+        return f"Discrete({int(self.n)})"
+

platform_lander-0.1.0.dist-info/LICENSE

@@ -0,0 +1,22 @@
+The MIT License
+
+Copyright (c) 2016 OpenAI
+Copyright (c) 2022 Farama Foundation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

platform_lander-0.1.0.dist-info/METADATA

@@ -0,0 +1,202 @@
+Metadata-Version: 2.1
+Name: platform-lander
+Version: 0.1.0
+Summary: Standalone reusable-booster landing environment for reinforcement learning.
+Author: Andriy Burkov
+License: The MIT License
+        
+        Copyright (c) 2016 OpenAI
+        Copyright (c) 2022 Farama Foundation
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in
+        all copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+        THE SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/aburkov/theDRLbook/tree/main/test_environments/platform_lander
+Project-URL: Source, https://github.com/aburkov/theDRLbook/tree/main/test_environments/platform_lander
+Project-URL: Repository, https://github.com/aburkov/theDRLbook
+Keywords: reinforcement-learning,rl,box2d,lander,environment
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21
+Requires-Dist: box2d-py>=2.3.5
+Requires-Dist: pygame>=2.1
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Provides-Extra: train
+Requires-Dist: torch>=2; extra == "train"
+
+# Platform Lander
+
+A standalone reusable-booster landing environment based on Gymnasium LunarLander v3 physics, but without importing Gymnasium. The task is to land a SpaceX-style booster upright on a moving floating platform. Missing the platform and falling into the ocean, or contacting the platform in a non-vertical position, terminates the episode as failure.
+
+## Install
+
+After the package has been published to PyPI:
+
+```bash
+pip install platform_lander
+```
+
+Before the PyPI release is available, install the same package directly from
+the book repository subdirectory:
+
+```bash
+pip install "platform_lander @ git+https://github.com/aburkov/theDRLbook.git#subdirectory=test_environments/platform_lander"
+```
+
+For local development from this folder:
+
+```bash
+pip install -e .
+```
+
+## Google Colab
+
+Use the same install command in the first notebook cell. Colab usually needs `swig` before Box2D builds:
+
+```python
+!apt-get -qq install swig
+!pip install -q platform_lander
+```
+
+Then import normally:
+
+```python
+from platform_lander import PlatformLander
+
+env = PlatformLander(render_mode="rgb_array", enable_wind=True, wind_power=5.0)
+obs, info = env.reset(seed=0)
+obs, reward, terminated, truncated, info = env.step(2)
+frame = env.render()
+```
+
+Display a rendered frame in Colab:
+
+```python
+import matplotlib.pyplot as plt
+
+plt.imshow(frame)
+plt.axis("off")
+plt.show()
+```
+
+## Local Script
+
+To watch the booster in a local Pygame window, install the package in editable
+mode and run the demo:
+
+```bash
+pip install -e .
+python examples/demo.py
+```
+
+The test file is headless, so running `pytest` or `python tests/test_platform_lander.py`
+will not open an animation window.
+
+To train a discrete policy with the textbook single-trajectory REINFORCE
+algorithm and then show three animated runs:
+
+```bash
+pip install -e ".[train]"
+python vanilla_reinforce.py
+```
+
+The repository also includes incremental REINFORCE variants:
+
+```bash
+python rtg_reinforce.py                                  # vanilla + per-timestep reward-to-go
+python average_reinforcement_baseline_reinforce.py       # reward-to-go + running scalar RTG baseline
+python value_function_baseline_reinforce.py              # reward-to-go + learned value-function baseline
+python batch_reinforce.py                                # vanilla + trajectory batches
+python full_reinforce.py                                 # batches + reward-to-go + selectable scalar baseline
+```
+
+Each training script writes a log, per-episode CSV data, and a checkpoint under
+`runs/` by default, for example `runs/full_reinforce.log`,
+`runs/full_reinforce.csv`, and `runs/full_reinforce.pt`. Override those paths
+with `--log-file`, `--csv-file`, and `--model-file`.
+
+To load the hardcoded `runs/full_reinforce.pt` checkpoint and watch several
+animated policy rollouts:
+
+```bash
+python watch_trained_policy.py
+```
+
+To generate one side-by-side results graph per variant from the saved CSV
+files:
+
+```bash
+python plot_reinforce_results.py
+```
+
+For a quick smoke test without opening the animation window:
+
+```bash
+python vanilla_reinforce.py --episodes 3 --max-steps 20 --no-animation
+```
+
+```python
+from platform_lander import PlatformLander
+
+env = PlatformLander(enable_wind=True, wind_direction=(1, 0.2), wind_power=5.0)
+obs, info = env.reset(seed=0)
+
+for _ in range(1000):
+    action = env.action_space.sample()
+    obs, reward, terminated, truncated, info = env.step(action)
+    if terminated or truncated:
+        print(info)
+        break
+
+env.close()
+```
+
+## API Notes
+
+- `PlatformLander(continuous=False)` uses `Discrete(4)` actions.
+- Actions: `0` no-op, `1` upper-left attitude jet, `2` bottom engine, `3` upper-right attitude jet.
+- `continuous=True` uses a two-value `Box(-1, 1, shape=(2,))` action.
+- Wind is controlled with `enable_wind`, `wind_power`, `wind_direction`, and `set_wind(...)`.
+- The booster has 100 available jet fires by default. After they are exhausted,
+  engine commands have no effect and the booster continues ballistically.
+- The observation includes the fraction of jet fires remaining.
+- The package provides local `Box` and `Discrete` spaces and does not import Gymnasium.
+
+## Publishing
+
+Build the package from this directory:
+
+```bash
+python -m build
+```
+
+Upload the generated `dist/platform_lander-*.tar.gz` and
+`dist/platform_lander-*.whl` files to PyPI with a PyPI account that owns the
+`platform_lander` project name:
+
+```bash
+python -m twine upload dist/*
+```

platform_lander-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+platform_lander/__init__.py,sha256=lUiruv3t2_46dbWc4d38XftrKBkg_MVMrt3D8FU56UA,465
+platform_lander/core.py,sha256=bqmJyoeA_iClTlWSn88c368v0UE94-743FotLFkHim4,2616
+platform_lander/platform_lander.py,sha256=DM53Cn1Zg0DliTtc8NPCt41wcXRgclck5IgmekAcDnw,31301
+platform_lander/spaces.py,sha256=rLw10Bzuvu-zuzQaZ5OazROjOKJNmP7YOPCh9UDU1LY,4613
+platform_lander-0.1.0.dist-info/LICENSE,sha256=fayql3LoVq7mlDsy72Y9NjTZHXLse7x00TaUNnP5Hhg,1104
+platform_lander-0.1.0.dist-info/METADATA,sha256=A0NtnvuuWsAQzFeA35x-YtNQvTJupmfmZEpE8kgptcM,6862
+platform_lander-0.1.0.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+platform_lander-0.1.0.dist-info/top_level.txt,sha256=uLxoi4U_a9YT4dVtkyH-7OHQ1soVjmCqtAZ9jxXK6_c,16
+platform_lander-0.1.0.dist-info/RECORD,,

platform_lander-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.45.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

platform_lander-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+platform_lander