Struct Game

pub struct Game<T>
where
    T: Eq + Hash,
{ /* private fields */ }

A representation of a game.

The type parameter T is used as the type of the x- and y-coordinate values for each cell.

The following operations are supported:

• Constructing from Rule and Board
• Advancing a generation
• Returning the current state information

Examples

use life_backend::{Board, Game, Position, Rule};
let rule = Rule::conways_life();
let board: Board<_> = [(1, 0), (2, 1), (0, 2), (1, 2), (2, 2)] // Glider pattern
    .iter()
    .copied()
    .map(|(x, y)| Position(x, y))
    .collect();
let mut game = Game::new(rule, board);
game.advance();
let bbox = game.board().bounding_box();
assert_eq!(bbox.x(), &(0..=2));
assert_eq!(bbox.y(), &(1..=3));

Implementations

impl<T> Game<T>

where T: Eq + Hash,

pub fn new(rule: Rule, board: Board<T>) -> Self

Creates from the specified rule and the board.

Examples

use life_backend::{Board, Game, Position, Rule};
let rule = Rule::conways_life();
let board: Board<_> = [Position(1, 0), Position(0, 1)].iter().collect();
let game = Game::new(rule, board);

pub const fn rule(&self) -> &Rule

Returns the rule.

Examples

use life_backend::{Board, Game, Position, Rule};
let rule = Rule::conways_life();
let board: Board<_> = [Position(1, 0), Position(0, 1)].iter().collect();
let game = Game::new(rule.clone(), board);
assert_eq!(game.rule(), &rule);

pub const fn board(&self) -> &Board<T>

Returns the board.

Examples

use life_backend::{Board, Game, Position, Rule};
let rule = Rule::conways_life();
let board: Board<_> = [Position(1, 0), Position(0, 1)].iter().collect();
let game = Game::new(rule, board);
let board = game.board();
let bbox = board.bounding_box();
assert_eq!(bbox.x(), &(0..=1));
assert_eq!(bbox.y(), &(0..=1));
assert_eq!(board.contains(&Position(0, 0)), false);
assert_eq!(board.contains(&Position(1, 0)), true);
assert_eq!(board.contains(&Position(0, 1)), true);
assert_eq!(board.contains(&Position(1, 1)), false);

pub fn advance(&mut self)

where T: Copy + PartialOrd + Add<Output = T> + Sub<Output = T> + One + Bounded + ToPrimitive,

Advance the game by one generation.

Examples

use life_backend::{Board, Game, Position, Rule};
let rule = Rule::conways_life();
let board: Board<_> = [Position(0, 1), Position(1, 1), Position(2, 1)].iter().collect(); // Blinker pattern
let mut game = Game::new(rule, board);
game.advance();
let board = game.board();
let bbox = board.bounding_box();
assert_eq!(bbox.x(), &(1..=1));
assert_eq!(bbox.y(), &(0..=2));
assert_eq!(board.contains(&Position(1, 0)), true);
assert_eq!(board.contains(&Position(1, 1)), true);
assert_eq!(board.contains(&Position(1, 2)), true);

Trait Implementations

impl<T> Clone for Game<T>

where T: Eq + Hash + Clone,

fn clone(&self) -> Game<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Game<T>

where T: Eq + Hash + Debug,

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

Formats the value using the given formatter.

impl<T> Display for Game<T>

where T: Eq + Hash + Copy + PartialOrd + Zero + One + ToPrimitive,

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

Formats the value using the given formatter.

impl<T> PartialEq for Game<T>

where T: Eq + Hash + PartialEq,

fn eq(&self, other: &Game<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Eq for Game<T>

where T: Eq + Hash + Eq,

impl<T> StructuralPartialEq for Game<T>

where T: Eq + Hash,