Struct SnakeEnv 

pub struct SnakeEnv {
    pub width: i32,
    pub height: i32,
    pub snakes: Vec<Snake>,
    pub num_agents: usize,
    pub food: Position,
    pub episode: usize,
    pub steps: usize,
    pub max_steps: usize,
    pub done: bool,
    pub rng: StdRng,
}

Multi-agent Snake environment.

Snapshot semantics

clone_state / restore_state capture every visible env field (grid, snake bodies, food location, score, step count, done flag) and the env’s owned RNG. Because the RNG is part of the snapshot, restoring and re-stepping replays the identical random stream: a food respawn after restore_state lands in the same cell as the original trajectory, so round-trips are fully reproducible (including trajectories that eat food).

Fields

width: i32

Grid width

height: i32

Grid height

snakes: Vec<Snake>

All snakes

num_agents: usize

Number of agents

food: Position

Food position

episode: usize

Episode counter

steps: usize

Step counter

max_steps: usize

Maximum steps per episode

done: bool

Done flag

rng: StdRng

Owned RNG for food spawning. Captured by clone_state so that restore_state + step reproduces the exact same trajectory.

Implementations

impl SnakeEnv

pub fn new_multi(width: i32, height: i32, num_agents: usize) -> Self

Create new snake environment with specified number of agents

pub fn new_multi_with_seed( width: i32, height: i32, num_agents: usize, seed: u64, ) -> Self

Create new snake environment with a specific RNG seed.

The seed controls food placement. Two envs constructed with the same seed and stepped with the same actions produce identical trajectories.

pub fn new(width: i32, height: i32) -> Self

Create new single-agent snake environment (for backward compatibility)

pub fn reset(&mut self)

Reset environment to initial state

pub fn step_multi(&mut self, actions: &[i64]) -> StepResult

Execute multi-agent step with actions for all snakes Returns a single StepResult with summed rewards (for backward compatibility) Use step_multi_agents for per-agent rewards

pub fn step_multi_agents(&mut self, actions: &[i64]) -> (Vec<f32>, bool, bool)

Execute multi-agent step with per-agent rewards Returns individual rewards for each snake

pub fn step(&mut self, action: i64) -> StepResult

Execute single-agent step (for backward compatibility)

pub fn get_grid_observation(&self, snake_id: usize) -> Vec<f32>

Get grid-based observation for a specific snake

Returns a multi-channel grid representation:

• Channel 0: Own snake body (1.0 where body is)
• Channel 1: Own snake head (1.0 at head position)
• Channel 2: Other snakes (1.0 where other snakes are)
• Channel 3: Food (1.0 at food position)
• Channel 4: Walls (1.0 at boundaries)

Flattened as [C0_pixels…, C1_pixels…, C2_pixels…, …]

pub fn get_observation(&self) -> Vec<f32>

Get current observation (for first snake, backward compatibility)

pub fn render(&self) -> GameState

Render current game state

Trait Implementations

impl Clone for SnakeEnv

fn clone(&self) -> SnakeEnv

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SnakeEnv

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Environment for SnakeEnv

type Action = i64

Action type accepted by Environment::step.

type State = SnakeEnvState

Snapshot type for this env. For fully deterministic envs without internal RNG, this is the complete env state and restore_state reproduces every subsequent step exactly. For envs that consume an internal RNG (e.g. ball serve direction, food placement), the snapshot captures the simulation step but not the RNG; see the env-level documentation for which fields are preserved.

fn reset(&mut self)

Reset the environment and return initial observation

fn get_observation(&self) -> Vec<f32>

Get the current observation

fn step(&mut self, action: i64) -> StepResult

Step the environment with an action

fn observation_space(&self) -> SpaceInfo

Get the observation space dimensions

fn action_space(&self) -> SpaceInfo

Get the action space dimensions

fn render(&self) -> Vec<u8>

Render the current environment state

fn close(&mut self)

Close the environment

fn clone_state(&self) -> SnakeEnvState

Snapshot the current env state for later restoration.

fn restore_state(&mut self, state: &SnakeEnvState)

Restore the env to a previously-snapshotted state.