Anatomy of a Custom Environment

import numpy as np
import gymnasium as gym
from gymnasium import spaces

class CorridorEnv(gym.Env):
    """
    A 10-cell 1D corridor. Agent starts at 0, goal is 9.
    Actions: 0=left, 1=right.
    Observation: current position (integer 0-9).
    """

    # metadata tells wrappers what render modes this env supports.
    metadata = {"render_modes": ["ansi"]}

    def __init__(self, render_mode=None):
        super().__init__()

        # The spaces MUST be defined in __init__.
        # Discrete(10) means the observation is an integer in {0, ..., 9}.
        self.observation_space = spaces.Discrete(10)
        # Discrete(2) means the agent can do action 0 (left) or 1 (right).
        self.action_space = spaces.Discrete(2)

        self.render_mode = render_mode
        self.position = 0    # current agent position

    def reset(self, *, seed=None, options=None):
        # Call super().reset(seed=seed) to let Gymnasium handle the RNG.
        # This gives you self.np_random for reproducible environment randomness.
        super().reset(seed=seed)

        self.position = 0    # always start at the left
        observation = self.position

        # reset() MUST return (observation, info).
        # info is a dict — empty is fine.
        return observation, {}

    def step(self, action):
        # Apply the action
        if action == 0:   # move left
            self.position -= 1
        elif action == 1: # move right
            self.position += 1

        # Determine outcome
        hit_wall = self.position < 0 or self.position >= 10
        reached_goal = self.position == 9

        # Compute reward
        if hit_wall:
            reward = -5.0
            self.position = max(0, min(9, self.position))  # clamp position
        elif reached_goal:
            reward = 10.0
        else:
            reward = -0.1   # small cost per step to encourage speed

        # terminated: goal reached or wall hit
        terminated = reached_goal or hit_wall
        # truncated: never — this env has no time limit of its own
        truncated = False

        observation = self.position

        # step() MUST return (observation, reward, terminated, truncated, info).
        return observation, reward, terminated, truncated, {}

    def render(self):
        if self.render_mode == "ansi":
            # Build a simple text representation
            cells = ["."] * 10
            cells[self.position] = "A"   # agent
            cells[9] = "G"               # goal
            return "[" + " ".join(cells) + "]"

from gymnasium.utils.env_checker import check_env

env = CorridorEnv()
check_env(env)
print("CorridorEnv passed check_env!")

env = CorridorEnv(render_mode="ansi")
obs, info = env.reset(seed=0)

print(env.render())   # [A . . . . . . . . G]

done = False
total_reward = 0
steps = 0

while not done:
    action = 1   # always move right
    obs, reward, terminated, truncated, info = env.step(action)
    total_reward += reward
    steps += 1
    done = terminated or truncated

print(env.render())   # [. . . . . . . . . G] — agent is at goal
print(f"Steps: {steps}, Total reward: {total_reward:.1f}")
# Steps: 9, Total reward: 9.1 (9 steps at -0.1 + 10.0 for goal)
env.close()

def reset(self, *, seed=None, options=None):
    # BAD: no super() call
    self.position = 0
    return self.position, {}

def reset(self, *, seed=None, options=None):
    super().reset(seed=seed)
    self.position = 0
    return self.position, {}   # int, not np.int64

return np.int64(self.position), {}

# BAD: positions are 0-9 but space says only 9 values
self.observation_space = spaces.Discrete(9)
# position=9 (the goal) is outside this space!