Stable-Retro

https://stable-retro.farama.org/
Admin
Stable-Retro is a maintained fork of OpenAI's Retro library, enabling the use of classic video games...
Tokens:102,040
Snippets:393
Trust Score:9.2
Update:1 year ago
Show doc for...
Tokens:
Raw
### Game Integration: metadata.json Example

Source: https://stable-retro.farama.org/main/integration

Specifies the default starting state and includes miscellaneous debugging information, such as a whitelist for data.json.

```JSON
{
  "default_state": "Level1",
  "whitelist": {
    "data.json": [
      "suspicious type >u2 for lives"
    ]
  }
}
```

--------------------------------

### Game Integration: metadata.json Example

Source: https://stable-retro.farama.org/v0.9.3/integration

Specifies the default starting state and includes miscellaneous debugging information, such as a whitelist for data.json.

```JSON
{
  "default_state": "Level1",
  "whitelist": {
    "data.json": [
      "suspicious type >u2 for lives"
    ]
  }
}
```

--------------------------------

### Game Integration: metadata.json Example

Source: https://stable-retro.farama.org/integration

Specifies the default starting state and includes miscellaneous debugging information, such as a whitelist for data.json.

```JSON
{
  "default_state": "Level1",
  "whitelist": {
    "data.json": [
      "suspicious type >u2 for lives"
    ]
  }
}
```

--------------------------------

### Install Retro UI from Source (macOS)

Source: https://stable-retro.farama.org/developing

Steps to build the Retro UI from source on macOS. This includes a note about potential SDK header installation for Mojave and enabling Qt.

```bash
=/usr/local/opt/qt=ON$(sysctl|) open"Gym Retro Integration.app"
```

--------------------------------

### Game Integration: metadata.json Example

Source: https://stable-retro.farama.org/v0.9.4/integration

Specifies the default starting state and includes miscellaneous debugging information, such as a whitelist for data.json.

```JSON
{
  "default_state": "Level1",
  "whitelist": {
    "data.json": [
      "suspicious type >u2 for lives"
    ]
  }
}
```

--------------------------------

### Install Retro from Source (Windows)

Source: https://stable-retro.farama.org/v0.9.3/developing

Instructions for building Stable Retro on Windows using Docker. This involves running a container, copying a .whl file, and then installing it via pip.

```bash
cd
```

--------------------------------

### Install Retro UI from Source (Linux)

Source: https://stable-retro.farama.org/v0.9.3/developing

Instructions for building the Gym Retro Integration UI from source on Linux systems.

```bash
=ON$(grep)
./gym-retro-integration
```

--------------------------------

### Game Integration: Metadata

Source: https://stable-retro.farama.org/v0.9.2/integration

Specifies the default starting state and miscellaneous debugging information for a game integration. This JSON file helps manage the initial environment setup.

```JSON
{
  "default_state": "Level1",
  "whitelist": {
    "data.json": [
      "suspicious type >u2 for lives"
    ]
  }
}
```

--------------------------------

### Game Integration: Metadata

Source: https://stable-retro.farama.org/v0.9.1/integration

Specifies the default starting state and miscellaneous debugging information for a game integration. This JSON file helps manage the initial environment setup.

```JSON
{
  "default_state": "Level1",
  "whitelist": {
    "data.json": [
      "suspicious type >u2 for lives"
    ]
  }
}
```

--------------------------------

### Install Retro from Source (Linux/Mac)

Source: https://stable-retro.farama.org/developing

Instructions for building Stable Retro from source on Linux and macOS. This involves navigating to the project directory.

```bash
cd
```

--------------------------------

### Install Retro from Source (Linux/Mac)

Source: https://stable-retro.farama.org/v0.9.1/developing

Instructions for building Stable Retro from source on Linux and macOS. This involves navigating to the project directory.

```bash
cd
```

--------------------------------

### Install Retro from Source (Linux/Mac)

Source: https://stable-retro.farama.org/v0.9.4/developing

Instructions for building Stable Retro from source on Linux and macOS. This involves navigating to the project directory.

```bash
cd
```

--------------------------------

### Install Retro from Source (Windows)

Source: https://stable-retro.farama.org/v0.9.4/developing

Instructions for building Stable Retro from source on Windows using Docker. This involves copying a .whl file out of a container and installing it via pip.

```bash
cd
```

--------------------------------

### Install Retro from Source (Windows)

Source: https://stable-retro.farama.org/developing

Instructions for building Stable Retro from source on Windows using Docker. This involves copying a wheel file out of a container and installing it via pip.

```bash
cd
```

--------------------------------

### Stable-Retro Development Guide

Source: https://stable-retro.farama.org/v0.9.1/_modules/retro/retro_env

Information for developers contributing to Stable-Retro, including release notes, how to access the GitHub repository, and guidelines for contributing to the documentation.

```APIDOC
Development:
  - Release Notes: Information on project updates and changes.
  - Github: Link to the official Stable-Retro GitHub repository for source code and collaboration.
  - Contribute to the Docs: Guidelines for improving and expanding the project documentation.
```

--------------------------------

### Install Retro UI from Source (macOS)

Source: https://stable-retro.farama.org/v0.9.4/developing

Instructions for building the Retro UI from source on macOS. This may require installing macOS SDK headers for specific versions like Mojave.

```bash
=/usr/local/opt/qt=ON$(sysctl|) open"Gym Retro Integration.app"
```

--------------------------------

### Stable-Retro Development Guide

Source: https://stable-retro.farama.org/main/_modules/retro/retro_env

Information for developers contributing to Stable-Retro, including release notes, how to access the GitHub repository, and guidelines for contributing to the documentation.

```APIDOC
Development:
  - Release Notes: Information on project updates and changes.
  - Github: Link to the official Stable-Retro GitHub repository for source code and collaboration.
  - Contribute to the Docs: Guidelines for improving and expanding the project documentation.
```

--------------------------------

### Stable-Retro Development Guide

Source: https://stable-retro.farama.org/v0.9.2/_modules/retro/retro_env

Information for developers contributing to Stable-Retro, including release notes, how to access the GitHub repository, and guidelines for contributing to the documentation.

```APIDOC
Development:
  - Release Notes: Information on project updates and changes.
  - Github: Link to the official Stable-Retro GitHub repository for source code and collaboration.
  - Contribute to the Docs: Guidelines for improving and expanding the project documentation.
```

--------------------------------

### Stable-Retro Development Guide

Source: https://stable-retro.farama.org/v0.9.3/_modules/retro/retro_env

Information for developers contributing to Stable-Retro, including release notes, how to access the GitHub repository, and guidelines for contributing to the documentation.

```APIDOC
Development:
  - Release Notes: Information on project updates and changes.
  - Github: Link to the official Stable-Retro GitHub repository for source code and collaboration.
  - Contribute to the Docs: Guidelines for improving and expanding the project documentation.
```

--------------------------------

### Install Retro from Source (Linux/Mac)

Source: https://stable-retro.farama.org/v0.9.3/developing

Instructions for building Stable Retro from source on Linux and macOS systems. This typically involves navigating to the project directory.

```bash
cd
```

--------------------------------

### Random Agent Example

Source: https://stable-retro.farama.org/v0.9.4/getting_started

Provides an example of a random agent that interacts with a Stable Retro environment by taking random actions. It includes resetting the environment, stepping through actions, rendering the game state, and handling episode termination.

```Python
import retro

def main():
    env = retro.make(game="Airstriker-Genesis")
    env.reset()
    while True:
        action = env.action_space.sample()
        observation, reward, terminated, truncated, info = env.step(action)
        env.render()
        if terminated or truncated:
            env.reset()
    env.close()

if __name__ == "__main__":
    main()
```

--------------------------------

### Data Type Examples

Source: https://stable-retro.farama.org/v0.9.3/integration

Provides examples of valid data type specifications, combining endianness, format, and byte size, including cases with non-power of two byte sizes.

```APIDOC
Valid Type Examples:
  * `<u2`: Little endian two-byte unsigned value
  * `<>u4`: Middle endian (little/big) four-byte unsigned value
  * `>d2`: Big endian two-byte binary-coded decimal value
  * `|u1`: Single unsigned byte
  * `<u3`: Non-power of two bytes
  * `=n2`: Native endian two-byte low-nybble binary-coded decimal value
```

--------------------------------

### Random Agent Example

Source: https://stable-retro.farama.org/v0.9.3/getting_started

Provides an example of a random agent that interacts with a Stable Retro environment by taking random actions. It includes resetting the environment, stepping through actions, rendering the game state, and handling episode termination.

```Python
import retro

def main():
    env = retro.make(game="Airstriker-Genesis")
    env.reset()
    while True:
        action = env.action_space.sample()
        observation, reward, terminated, truncated, info = env.step(action)
        env.render()
        if terminated or truncated:
            env.reset()
    env.close()

if __name__ == "__main__":
    main()
```

--------------------------------

### Random Agent Example

Source: https://stable-retro.farama.org/main/getting_started

Provides an example of a random agent that interacts with a Stable Retro environment by taking random actions. It includes resetting the environment, stepping through actions, rendering the game state, and handling episode termination.

```Python
import retro

def main():
    env = retro.make(game="Airstriker-Genesis")
    env.reset()
    while True:
        action = env.action_space.sample()
        observation, reward, terminated, truncated, info = env.step(action)
        env.render()
        if terminated or truncated:
            env.reset()
    env.close()

if __name__ == "__main__":
    main()
```

--------------------------------

### Random Agent Example

Source: https://stable-retro.farama.org/getting_started

Provides an example of a random agent that interacts with a Stable Retro environment by taking random actions. It includes resetting the environment, stepping through actions, rendering the game state, and handling episode termination.

```Python
import retro

def main():
    env = retro.make(game="Airstriker-Genesis")
    env.reset()
    while True:
        action = env.action_space.sample()
        observation, reward, terminated, truncated, info = env.step(action)
        env.render()
        if terminated or truncated:
            env.reset()
    env.close()

if __name__ == "__main__":
    main()
```

--------------------------------

### Install Retro UI from Source (Linux)

Source: https://stable-retro.farama.org/v0.9.4/developing

Instructions for building the Retro UI from source on Linux. This involves setting a CMake option and executing a script.

```bash
=ON$(grep) ./gym-retro-integration
```

--------------------------------

### Multiplayer Example - Pong

Source: https://stable-retro.farama.org/v0.9.3/python

Demonstrates how to set up and run a multiplayer environment for Pong, controlling multiple paddles using a MultiBinary action space.

```Python
import retro


def main():
    env = retro.make(game="Pong-Atari2600", players=2)
    env.reset()
    while True:
        # action_space will by MultiBinary(16) now instead of MultiBinary(8)
        # the bottom half of the actions will be for player 1 and the top half for player 2
        obs, rew, done, info = env.step(env.action_space.sample())
        # rew will be a list of [player_1_rew, player_2_rew]
        # done and info will remain the same
        env.render()
        if done:
            env.reset()
    env.close()


if __name__ == "__main__":
    main()
```

--------------------------------

### Multiplayer Example - Pong

Source: https://stable-retro.farama.org/main/python

Demonstrates how to set up and run a multiplayer environment for Pong, controlling multiple paddles using a MultiBinary action space.

```Python
import retro


def main():
    env = retro.make(game="Pong-Atari2600", players=2)
    env.reset()
    while True:
        # action_space will by MultiBinary(16) now instead of MultiBinary(8)
        # the bottom half of the actions will be for player 1 and the top half for player 2
        obs, rew, done, info = env.step(env.action_space.sample())
        # rew will be a list of [player_1_rew, player_2_rew]
        # done and info will remain the same
        env.render()
        if done:
            env.reset()
    env.close()


if __name__ == "__main__":
    main()
```

--------------------------------

### Multiplayer Example - Pong

Source: https://stable-retro.farama.org/v0.9.4/python

Demonstrates how to set up and run a multiplayer environment for Pong, controlling multiple paddles using a MultiBinary action space.

```Python
import retro


def main():
    env = retro.make(game="Pong-Atari2600", players=2)
    env.reset()
    while True:
        # action_space will by MultiBinary(16) now instead of MultiBinary(8)
        # the bottom half of the actions will be for player 1 and the top half for player 2
        obs, rew, done, info = env.step(env.action_space.sample())
        # rew will be a list of [player_1_rew, player_2_rew]
        # done and info will remain the same
        env.render()
        if done:
            env.reset()
    env.close()


if __name__ == "__main__":
    main()
```

--------------------------------

### Multiplayer Example - Pong

Source: https://stable-retro.farama.org/python

Demonstrates how to set up and run a multiplayer environment for Pong, controlling multiple paddles using a MultiBinary action space.

```Python
import retro


def main():
    env = retro.make(game="Pong-Atari2600", players=2)
    env.reset()
    while True:
        # action_space will by MultiBinary(16) now instead of MultiBinary(8)
        # the bottom half of the actions will be for player 1 and the top half for player 2
        obs, rew, done, info = env.step(env.action_space.sample())
        # rew will be a list of [player_1_rew, player_2_rew]
        # done and info will remain the same
        env.render()
        if done:
            env.reset()
    env.close()


if __name__ == "__main__":
    main()
```

--------------------------------

### Random Agent Example

Source: https://stable-retro.farama.org/v0.9.2/getting_started

An example of a random agent that takes random actions in a Stable-Retro environment. It resets the environment when a game ends and closes it upon script termination. Useful for testing environment setup and reward functions.

```Python
import retro

def main():
    env = retro.make(game="Airstriker-Genesis")
    env.reset()
    while True:
        obs, rew, done, info = env.step(env.action_space.sample())
        env.render()
        if done:
            env.reset()
    env.close()

if __name__ == "__main__":
    main()
```

--------------------------------

### Random Agent Example

Source: https://stable-retro.farama.org/v0.9.1/getting_started

An example of a random agent that takes random actions in a Stable-Retro environment. It resets the environment when a game ends and closes it upon script termination. Useful for testing environment setup and reward functions.

```Python
import retro

def main():
    env = retro.make(game="Airstriker-Genesis")
    env.reset()
    while True:
        obs, rew, done, info = env.step(env.action_space.sample())
        env.render()
        if done:
            env.reset()
    env.close()

if __name__ == "__main__":
    main()
```

--------------------------------

### Install Retro UI from Source (Linux)

Source: https://stable-retro.farama.org/developing

Instructions for building the Retro UI from source on Linux. This involves enabling a specific build option and executing the integration binary.

```bash
=ON$(grep) ./gym-retro-integration
```

--------------------------------

### Variable Locations: data.json Example (Score)

Source: https://stable-retro.farama.org/v0.9.4/integration

An example of a data.json manifest specifying a 'score' variable located at byte 128, with a 4-byte unsigned big-endian format.

```JSON
{
"info":{
"score":{
"address":128,
"type":">u4"
}
}
}
```

--------------------------------

### Variable Locations: data.json Example (Score)

Source: https://stable-retro.farama.org/v0.9.3/integration

An example of a data.json manifest specifying a 'score' variable located at byte 128, with a 4-byte unsigned big-endian format.

```JSON
{
"info":{
"score":{
"address":128,
"type":">u4"
}
}
}
```

--------------------------------

### Variable Locations: data.json Example (Score)

Source: https://stable-retro.farama.org/integration

An example of a data.json manifest specifying a 'score' variable located at byte 128, with a 4-byte unsigned big-endian format.

```JSON
{
"info":{
"score":{
"address":128,
"type":">u4"
}
}
}
```

--------------------------------

### Variable Locations: data.json Example (Score)

Source: https://stable-retro.farama.org/main/integration

An example of a data.json manifest specifying a 'score' variable located at byte 128, with a 4-byte unsigned big-endian format.

```JSON
{
"info":{
"score":{
"address":128,
"type":">u4"
}
}
}
```

--------------------------------

### Create a Retro Environment

Source: https://stable-retro.farama.org/v0.9.4/getting_started

Demonstrates how to create a Gymnasium environment for a specific game using the retro.make function. It highlights that ROMs for some games are included by default, while others must be obtained separately.

```Python
import retro
env = retro.make(game='Airstriker-Genesis')
```

--------------------------------

### Create a Retro Environment

Source: https://stable-retro.farama.org/v0.9.3/getting_started

Demonstrates how to create a Gymnasium environment for a specific game using the retro.make function. It highlights that ROMs for some games are included by default, while others must be obtained separately.

```Python
import retro
env = retro.make(game='Airstriker-Genesis')
```

--------------------------------

### Install Retro from Source (Windows)

Source: https://stable-retro.farama.org/v0.9.1/developing

Instructions for building Stable Retro on Windows using Docker. This involves running a command and then copying the generated .whl file out of the container.

```bash
cd
# Once complete use docker cp to copy the whl file out of the container.
# Then you may pip install
```

--------------------------------

### Data Type Examples

Source: https://stable-retro.farama.org/v0.9.4/integration

Provides examples of valid data type specifications, combining endianness, format, and byte size, including cases with non-power of two byte sizes.

```APIDOC
Valid Type Examples:
  * `<u2`: Little endian two-byte unsigned value
  * `<>u4`: Middle endian (little/big) four-byte unsigned value
  * `>d2`: Big endian two-byte binary-coded decimal value
  * `|u1`: Single unsigned byte
  * `<u3`: Non-power of two bytes
  * `=n2`: Native endian two-byte low-nybble binary-coded decimal value
```

--------------------------------

### Data Type Examples

Source: https://stable-retro.farama.org/integration

Provides examples of valid data type specifications, combining endianness, format, and byte size, including cases with non-power of two byte sizes.

```APIDOC
Valid Type Examples:
  * `<u2`: Little endian two-byte unsigned value
  * `<>u4`: Middle endian (little/big) four-byte unsigned value
  * `>d2`: Big endian two-byte binary-coded decimal value
  * `|u1`: Single unsigned byte
  * `<u3`: Non-power of two bytes
  * `=n2`: Native endian two-byte low-nybble binary-coded decimal value
```

--------------------------------

### Data Type Examples

Source: https://stable-retro.farama.org/main/integration

Provides examples of valid data type specifications, combining endianness, format, and byte size, including cases with non-power of two byte sizes.

```APIDOC
Valid Type Examples:
  * `<u2`: Little endian two-byte unsigned value
  * `<>u4`: Middle endian (little/big) four-byte unsigned value
  * `>d2`: Big endian two-byte binary-coded decimal value
  * `|u1`: Single unsigned byte
  * `<u3`: Non-power of two bytes
  * `=n2`: Native endian two-byte low-nybble binary-coded decimal value
```

--------------------------------

### Build Retro UI on Linux

Source: https://stable-retro.farama.org/main/developing

Commands to build the Retro UI on Linux.

```bash
=ON$(grep)
./gym-retro-integration
```

--------------------------------

### Install Retro UI from Source (macOS)

Source: https://stable-retro.farama.org/v0.9.3/developing

Steps to build the Gym Retro Integration UI from source on macOS. It includes a note about potential SDK header requirements for specific macOS versions like Mojave.

```bash
=/usr/local/opt/qt=ON$(sysctl|)
open"Gym Retro Integration.app"
```

--------------------------------

### Build Retro UI on macOS

Source: https://stable-retro.farama.org/main/developing

Steps to build the Retro UI on macOS, including a note about installing macOS SDK headers for Mojave and a command to open the application.

```bash
=/usr/local/opt/qt=ON$(sysctl|)
open"Gym Retro Integration.app"
```

--------------------------------

### Stable Retro Data Type Examples

Source: https://stable-retro.farama.org/v0.9.2/integration

Provides examples of valid data type definitions combining endianness, format, and byte size, including non-power of two byte sizes.

```APIDOC
Valid Data Type Examples:
  <u2: Little endian two-byte unsigned value
  <>u4: Middle endian (little/big) four-byte unsigned value
  >d2: Big endian two-byte binary-coded decimal value
  |u1: Single unsigned byte
  <u3: Non-power of two bytes
  =n2: Native endian two-byte low-nybble binary-coded decimal value
```

--------------------------------

### Build Retro UI from Source (Linux)

Source: https://stable-retro.farama.org/v0.9.1/developing

Instructions for building the Retro UI from source on Linux. This involves running a build command and executing the integration binary.

```bash
=ON$(grep) ./gym-retro-integration
```

--------------------------------

### Stable Retro Data Type Examples

Source: https://stable-retro.farama.org/v0.9.1/integration

Provides examples of valid data type definitions combining endianness, format, and byte size, including non-power of two byte sizes.

```APIDOC
Valid Data Type Examples:
  <u2: Little endian two-byte unsigned value
  <>u4: Middle endian (little/big) four-byte unsigned value
  >d2: Big endian two-byte binary-coded decimal value
  |u1: Single unsigned byte
  <u3: Non-power of two bytes
  =n2: Native endian two-byte low-nybble binary-coded decimal value
```

--------------------------------

### Create a Retro Environment

Source: https://stable-retro.farama.org/main/getting_started

Demonstrates how to create a Gymnasium environment for a specific game using the retro.make function. It highlights that ROMs for some games are included by default, while others must be obtained separately.

```Python
import retro
env = retro.make(game='Airstriker-Genesis')
```

--------------------------------

### Create a Retro Environment

Source: https://stable-retro.farama.org/getting_started

Demonstrates how to create a Gymnasium environment for a specific game using the retro.make function. It highlights that ROMs for some games are included by default, while others must be obtained separately.

```Python
import retro
env = retro.make(game='Airstriker-Genesis')
```

--------------------------------

### ROM SHA1 Hash Example

Source: https://stable-retro.farama.org/v0.9.4/integration

Provides the SHA1 hash for a ROM file, used for importing ROMs into Stable-Retro.

```plaintext
c67af162391fff4a63432be5a156eb9ca7b4da5a
```

--------------------------------

### Game Integration: scenario.json Example

Source: https://stable-retro.farama.org/v0.9.4/integration

Defines the reward function and done condition using variables specified in data.json.

```JSON
{
  "done": {
    "condition": "all",
    "variables": {
      "gameover": {
        "op": "equal",
        "reference": 1
      },
      "lives": {
        "op": "zero"
      }
    }
  },
  "reward": {
    "variables": {
      "score": {
        "reward": 1.0
      }
    }
  }
}
```

--------------------------------

### RetroEnv Initialization

Source: https://stable-retro.farama.org/v0.9.2/_modules/retro/retro_env

Initializes the RetroEnv class, setting up the game environment, state, scenarios, and observation/action spaces. It handles loading ROMs, game data, and configuring the emulator.

```Python
import gc
import gzip
import json
import os

import gymnasium as gym
import numpy as np

import retro
import retro.data

__all__ = ["RetroEnv"]




class RetroEnv(gym.Env):
    """
    Gym Retro environment class

    Provides a Gym interface to classic video games
    """

    metadata = {"render_modes": ["human", "rgb_array"], "video.frames_per_second": 60.0}

    def __init__(
        self,
        game,
        state=retro.State.DEFAULT,
        scenario=None,
        info=None,
        use_restricted_actions=retro.Actions.FILTERED,
        record=False,
        players=1,
        inttype=retro.data.Integrations.STABLE,
        obs_type=retro.Observations.IMAGE,
        render_mode="human",
    ):
        if not hasattr(self, "spec"):
            self.spec = None
        self._obs_type = obs_type
        self.img = None
        self.ram = None
        self.viewer = None
        self.gamename = game
        self.statename = state
        self.initial_state = None
        self.players = players

        # Don't return multiple rewards in multiplayer mode by default
        # as stable-baselines3 vectorized environments doesn't support it
        self.multi_rewards = False

        metadata = {}
        rom_path = retro.data.get_romfile_path(game, inttype)
        metadata_path = retro.data.get_file_path(game, "metadata.json", inttype)

        if state == retro.State.NONE:
            self.statename = None
        elif state == retro.State.DEFAULT:
            self.statename = None
            try:
                with open(metadata_path) as f:
                    metadata = json.load(f)
                if "default_player_state" in metadata and self.players <= len(
                    metadata["default_player_state"],
                ):
                    self.statename = metadata["default_player_state"][self.players - 1]
                elif "default_state" in metadata:
                    self.statename = metadata["default_state"]
                else:
                    self.statename = None
            except (OSError, json.JSONDecodeError):
                pass

        if self.statename:
            self.load_state(self.statename, inttype)

        self.data = retro.data.GameData()

        if info is None:
            info = "data"

        if info.endswith(".json"):
            # assume it's a path
            info_path = info
        else:
            info_path = retro.data.get_file_path(game, info + ".json", inttype)

        if scenario is None:
            scenario = "scenario"

        if scenario.endswith(".json"):
            # assume it's a path
            scenario_path = scenario
        else:
            scenario_path = retro.data.get_file_path(game, scenario + ".json", inttype)

        self.system = retro.get_romfile_system(rom_path)

        # We can't have more than one emulator per process. Before creating an
        # emulator, ensure that unused ones are garbage-collected
        gc.collect()
        self.em = retro.RetroEmulator(rom_path)
        self.em.configure_data(self.data)
        self.em.step()

        core = retro.get_system_info(self.system)
        self.buttons = core["buttons"]
        self.num_buttons = len(self.buttons)

        try:
            assert self.data.load(
                info_path,
                scenario_path,
            ), "Failed to load info ({}) or scenario ({})".format(
                info_path,
                scenario_path,
            )
        except Exception:
            del self.em
            raise

        self.button_combos = self.data.valid_actions()
        if use_restricted_actions == retro.Actions.DISCRETE:
            combos = 1
            for combo in self.button_combos:
                combos *= len(combo)
            self.action_space = gym.spaces.Discrete(combos**players)
        elif use_restricted_actions == retro.Actions.MULTI_DISCRETE:
            self.action_space = gym.spaces.MultiDiscrete(
                [len(combos) for combos in self.button_combos] * players,
            )
        else:
            self.action_space = gym.spaces.MultiBinary(self.num_buttons * players)

        if self._obs_type == retro.Observations.RAM:
            shape = self.get_ram().shape
        else:
            img = [self.get_screen(p) for p in range(players)]
            shape = img[0].shape
        self.observation_space = gym.spaces.Box(
            low=0,
            high=255,
            shape=shape,
            dtype=np.uint8,
        )

        self.use_restricted_actions = use_restricted_actions
        self.movie = None
        self.movie_id = 0
        self.movie_path = None
        if record is True:
            self.auto_record()
        elif record is not False:
            self.auto_record(record)

        self.render_mode = render_mode

    def _update_obs(self):
        if self._obs_type == retro.Observations.RAM:
            self.ram = self.get_ram()

```

--------------------------------

### ROM SHA1 Hash Example

Source: https://stable-retro.farama.org/v0.9.3/integration

Provides the SHA1 hash for a ROM file, used for importing ROMs into Stable-Retro.

```plaintext
c67af162391fff4a63432be5a156eb9ca7b4da5a
```

--------------------------------

### Game Integration: scenario.json Example

Source: https://stable-retro.farama.org/v0.9.3/integration

Defines the reward function and done condition using variables specified in data.json.

```JSON
{
  "done": {
    "condition": "all",
    "variables": {
      "gameover": {
        "op": "equal",
        "reference": 1
      },
      "lives": {
        "op": "zero"
      }
    }
  },
  "reward": {
    "variables": {
      "score": {
        "reward": 1.0
      }
    }
  }
}
```

--------------------------------

### RetroEnv Initialization and Configuration

Source: https://stable-retro.farama.org/v0.9.1/_modules/retro/retro_env

Initializes the RetroEnv, setting up the game environment, state, scenario, and observation types. It configures the action and observation spaces based on game data and user-defined parameters.

```Python
import gc
import gzip
import json
import os

import gymnasium as gym
import numpy as np

import retro
import retro.data

__all__ = ["RetroEnv"]



class RetroEnv(gym.Env):
    """
    Gym Retro environment class

    Provides a Gym interface to classic video games
    """

    metadata = {"render_modes": ["human", "rgb_array"], "video.frames_per_second": 60.0}

    def __init__(
        self,
        game,
        state=retro.State.DEFAULT,
        scenario=None,
        info=None,
        use_restricted_actions=retro.Actions.FILTERED,
        record=False,
        players=1,
        inttype=retro.data.Integrations.STABLE,
        obs_type=retro.Observations.IMAGE,
        render_mode="human",
    ):
        if not hasattr(self, "spec"):
            self.spec = None
        self._obs_type = obs_type
        self.img = None
        self.ram = None
        self.viewer = None
        self.gamename = game
        self.statename = state
        self.initial_state = None
        self.players = players

        metadata = {}
        rom_path = retro.data.get_romfile_path(game, inttype)
        metadata_path = retro.data.get_file_path(game, "metadata.json", inttype)

        if state == retro.State.NONE:
            self.statename = None
        elif state == retro.State.DEFAULT:
            self.statename = None
            try:
                with open(metadata_path) as f:
                    metadata = json.load(f)
                if "default_player_state" in metadata and self.players <= len(
                    metadata["default_player_state"],
                ):
                    self.statename = metadata["default_player_state"][self.players - 1]
                elif "default_state" in metadata:
                    self.statename = metadata["default_state"]
                else:
                    self.statename = None
            except (OSError, json.JSONDecodeError):
                pass

        if self.statename:
            self.load_state(self.statename, inttype)

        self.data = retro.data.GameData()

        if info is None:
            info = "data"

        if info.endswith(".json"):
            # assume it's a path
            info_path = info
        else:
            info_path = retro.data.get_file_path(game, info + ".json", inttype)

        if scenario is None:
            scenario = "scenario"

        if scenario.endswith(".json"):
            # assume it's a path
            scenario_path = scenario
        else:
            scenario_path = retro.data.get_file_path(game, scenario + ".json", inttype)

        self.system = retro.get_romfile_system(rom_path)

        # We can't have more than one emulator per process. Before creating an
        # emulator, ensure that unused ones are garbage-collected
        gc.collect()
        self.em = retro.RetroEmulator(rom_path)
        self.em.configure_data(self.data)
        self.em.step()

        core = retro.get_system_info(self.system)
        self.buttons = core["buttons"]
        self.num_buttons = len(self.buttons)

        try:
            assert self.data.load(
                info_path,
                scenario_path,
            ), "Failed to load info ({}) or scenario ({})".format(
                info_path,
                scenario_path,
            )
        except Exception:
            del self.em
            raise

        self.button_combos = self.data.valid_actions()
        if use_restricted_actions == retro.Actions.DISCRETE:
            combos = 1
            for combo in self.button_combos:
                combos *= len(combo)
            self.action_space = gym.spaces.Discrete(combos**players)
        elif use_restricted_actions == retro.Actions.MULTI_DISCRETE:
            self.action_space = gym.spaces.MultiDiscrete(
                [len(combos) for combos in self.button_combos] * players,
            )
        else:
            self.action_space = gym.spaces.MultiBinary(self.num_buttons * players)

        if self._obs_type == retro.Observations.RAM:
            shape = self.get_ram().shape
        else:
            img = [self.get_screen(p) for p in range(players)]
            shape = img[0].shape
        self.observation_space = gym.spaces.Box(
            low=0,
            high=255,
            shape=shape,
            dtype=np.uint8,
        )

        self.use_restricted_actions = use_restricted_actions
        self.movie = None
        self.movie_id = 0
        self.movie_path = None
        if record is True:
            self.auto_record()
        elif record is not False:
            self.auto_record(record)

        self.render_mode = render_mode

```

--------------------------------

### ROM SHA1 Hash Example

Source: https://stable-retro.farama.org/integration

Provides the SHA1 hash for a ROM file, used for importing ROMs into Stable-Retro.

```plaintext
c67af162391fff4a63432be5a156eb9ca7b4da5a
```
Tokens:
Raw