Asteroids 5v5

Two fleets of five triangle ships fight it out in an Asteroids-style arena.

• Watch it in the browser: https://crunchy000.github.io/astroids/ (index.html, scripted AI on both sides). It has synthesised sound effects (lasers, hits, explosions, asteroid thuds, panned by position): press any key to start audio, and M to mute.
• Train agents in Python: astroids_gym, a Gymnasium (the maintained successor to OpenAI Gym) and PettingZoo port of the same game.
• Enter a team in the competition: competition/ runs the game as an AI competition in the Planet Wars RTS format: Docker entries that fly a team over a WebSocket, real-time matches with random settings, and a TrueSkill leaderboard.
• Separate project, Planet Wars: planetwars/ is our entry for the Planet Wars RTS game itself, trained with JAX on a GPU. It has its own code, tests and Dockerfile and doesn't touch the asteroids game. Play against it in the browser: https://crunchy000.github.io/astroids/planetwars/play/ (the entry ported to JavaScript and WebAssembly, see planetwars/play/).

Rules

Two rule sets, the same in the browser (press C to switch, or ?rules=classic) and in Python (Config() / Config.competitive()):

• Classic: endless battle; ships respawn after 3 s; score = kills.
• Competitive (the browser default): 60-second battles with
  • Control zone: the team with more living ships inside the centre circle gains 1 point per second, and every 3 zone points earn it an extra respawn (reinforcements). Score = kills + zone points.
  • Weapon heat: each shot adds 0.25 heat; at 1.0 the gun locks until it cools to 0.5 (cooling 0.35/s), so bursts are fine but spraying isn't.
  • Shorter guns: 384 px range (bullets live 0.8 s instead of 1.3 s), so the spawns are out of each other's range and teams have to move to fight.
  • Limited respawns: 20 per team (plus zone reinforcements), 4 s timer. A team wiped out with none left loses outright; otherwise the higher score wins at the buzzer.
  • Friendly fire: bullets hit teammates (never the shooter).
  • Fair spawns: each team spawns in the middle of its own half (at least 0.3 of the map width from the enemy spawn either way, instead of ~0.2 across the wrap seam), facing the zone; a respawning ship takes the safest of 8 candidate points, and spawn protection lasts 2 s. With bots, ships dying within 3 s of respawning fell from 40% to 28%, and zone points per battle rose from ~6 to ~22.

The bots contest the zone when no enemy is near. For agents, ObsConfig(extended=True) adds 32 observation inputs for the rules (heat, zone position and control, score lead, respawns and ships left, time remaining, nearby teammates' bullets), and RewardConfig has zone, friendly_hit, win and crash (dying to an asteroid or a ram, on top of death) terms.

Install

pip install -e .                  # core env: gymnasium + numpy
pip install -e ".[render]"        # + pygame for render_mode="human" / "rgb_array"
pip install -e ".[multiagent]"    # + pettingzoo for the multi-agent env
pip install -e ".[train]"         # + stable-baselines3 + torch for the example trainer
pip install -e ".[video]"         # + pygame + imageio/ffmpeg for MP4 recording

Single-agent env (Gymnasium)

You fly one blue ship. The other nine are flown by the built-in scripted bot, the same AI the web page uses, unless you swap in other policies.

import gymnasium as gym
import astroids_gym  # registers the env

env = gym.make("AsteroidsBattle-v0", render_mode="human")
obs, info = env.reset(seed=0)
for _ in range(1800):
    obs, reward, terminated, truncated, info = env.step(env.action_space.sample())
    if terminated or truncated:
        obs, info = env.reset()

Action	MultiDiscrete([5, 2, 2]) = (turn: full left / slow left / none / slow right / full right, thrust off/on, fire off/on). The slow turns give the fine aim control the bot gets from steering continuously.
Observation	Box(-1, 1, (160,)), relative to your ship: your own velocity, heading, HP, cooldown; the 5 nearest enemies (position, relative velocity, relative heading, HP, and the lead direction, i.e. where to point so a shot fired now hits); the 4 nearest allies (the same without lead); the 8 nearest enemy bullets; the 5 nearest asteroids. Empty slots are zero, and each slot has a "present" flag. Details are in astroids_gym/obs.py.
Reward	+1 kill, −1 death, +0.2 hit dealt, −0.2 hit taken, plus optional aim shaping (below). All set with RewardConfig.
Episode	Ships respawn, so an episode ends only at max_steps (default 1800 agent steps = 60 s of game time). terminate_on_death=True gives shorter episodes.
Timing	Physics runs at 60 Hz; the agent acts every frame_skip=2 ticks (30 Hz).

Useful kwargs: teammates= / opponents= take "scripted", "idle", "random" or a callable, so you can do self-play against frozen policies. A callable gets one batch of observations for all the ships it flies, shape (n, 160), and returns (n, 3) actions, so an SB3 model plugs straight in: opponents=lambda obs: model.predict(obs)[0]. You can also pass config=Config(asteroids=False, team_size=3, ...), reward_config=RewardConfig(...) and obs_config=ObsConfig(...). env.step(None) lets the built-in bot fly your ship, which gives a baseline in exactly the same seat.

This is the beginning of the README. Read the rest at the original. Read the full README ↗