Struct Grid

pub struct Grid<T> {
    pub cells: Vec<T>,
    pub bounds: Rect,
}

The core type of this library. A 2D grid of cell type T.

Fields

cells: Vec<T>

Row-major, linear storage of cell data.

bounds: Rect

Implementations

impl<T> Grid<T>

pub fn new(bounds: Rect) -> Self

where T: Default + Clone,

Examples found in repository

examples/dungeon.rs (line 14)

fn main() {
    let rect = Rect::new((64, 64));
    // The minimum distance a partition can get to the edge of a Rect.
    let min_size = 8;

    let mut grid = Grid::<LifeState>::new(rect);
    let room_tree = grid
        .bounds
        .bsp(Orientation::Horizontal, &|rect, orientation| {
            let dimension = match orientation {
                Orientation::Horizontal => rect.width(),
                Orientation::Vertical => rect.height(),
            };
            let max_size = dimension - min_size;
            // No valid partitions; any cut would make the leaves too small.
            if max_size - min_size <= 0 {
                return None;
            }
            let partition = rand::thread_rng().gen_range(min_size..=max_size);
            Some((partition, orientation.orthogonal()))
        });
    let room_bounds = room_tree.leaves();
    let rooms = room_bounds.iter().flat_map(|room| {
        shrink_randomly(
            Rect {
                bottom: room.bottom + 1,
                left: room.left + 1,
                top: room.top,
                right: room.right,
            },
            4,
        )
        .iter()
    });

    // room_tree

    let layers = cluster_layers(rooms.collect());
    for result in grid.selection_iter_mut(layers.interior.into_iter()) {
        if let Ok((_coord, cell)) = result {
            *cell = LifeState::Floor;
        }
    }
    for result in grid.selection_iter_mut(layers.internal_border.into_iter()) {
        if let Ok((_coord, cell)) = result {
            *cell = LifeState::Wall;
        }
    }
    println!("{}", grid);
}

pub fn with_generator<C>(bounds: Rect, generator: impl Fn(C) -> T) -> Self

where C: From<Coord>,

Examples found in repository

examples/life.rs (lines 24-26)

    fn random<C: Into<Coord>>(dimensions: C) -> Self {
        Self {
            grid: Grid::with_generator(Rect::new(dimensions), |(_x, _y)| {
                rand::random::<LifeState>()
            }),
        }
    }

pub fn get<C: Into<Coord>>(&self, coord: C) -> Option<&T>

pub fn get_mut<C: Into<Coord>>(&mut self, coord: C) -> Option<&mut T>

pub fn set<C: Into<Coord>>(&mut self, coord: C, value: T) -> bool

pub fn replace<C: Into<Coord>>(&mut self, coord: C, value: T) -> Option<T>

pub fn take<C: Into<Coord>>(&mut self, coord: C) -> Option<T>

where T: Default,

pub fn copy<C1, C2>(&mut self, src: C1, dest: C2) -> bool

where T: Copy, C1: Into<Coord>, C2: Into<Coord>,

pub fn swap<C1, C2>(&mut self, coord1: C1, coord2: C2) -> bool

where C1: Into<Coord>, C2: Into<Coord>,

Swaps the contents of two cells.

pub fn mov(&mut self, src: Coord, dest: Coord) -> Option<T>

where T: Default,

Moves the contents of src into dest, returning the previous contents of dest.

pub fn iter<'a>(&'a self) -> impl Iterator<Item = (Coord, &'a T)>

Returns an iterator over all cells in the grid.

Examples found in repository

examples/life.rs (line 33)

    fn step(&mut self) {
        let neighbor_counts = self
            .grid
            .iter()
            .map(|cell| self.live_neighbor_count(cell.0))
            // `collect` to release the borrow on `self`.
            .collect::<Vec<_>>();

        for (cell, neighbor_count) in self.grid.cell_iter_mut().zip(neighbor_counts) {
            *cell = LifeBoard::compute_state(*cell, neighbor_count)
        }
    }

pub fn cell_iter_mut(&mut self) -> impl Iterator<Item = &mut T>

Examples found in repository

examples/life.rs (line 38)

    fn step(&mut self) {
        let neighbor_counts = self
            .grid
            .iter()
            .map(|cell| self.live_neighbor_count(cell.0))
            // `collect` to release the borrow on `self`.
            .collect::<Vec<_>>();

        for (cell, neighbor_count) in self.grid.cell_iter_mut().zip(neighbor_counts) {
            *cell = LifeBoard::compute_state(*cell, neighbor_count)
        }
    }

pub fn selection_iter<I>(&self, coords: I) -> SelectionIter<'_, T, I>

where I: Iterator<Item = Coord>,

Returns an iterator over the cells specified by the coords iterator.

Examples found in repository

examples/life.rs (line 45)

    fn live_neighbor_count(&self, coord: Coord) -> usize {
        self.grid
            .selection_iter(patterns::neighborhood(coord))
            .filter(|r_cell| {
                if let Ok(cell) = r_cell {
                    *cell.1 == LifeState::Alive
                } else {
                    false
                }
            })
            .count()
    }

pub fn selection_iter_mut<I>(&mut self, coords: I) -> SelectionIterMut<'_, T, I>

where I: Iterator<Item = Coord>,

Returns a mutable iterator over the cells specified by the coords iterator.

If there is an attempt to visit a given cell more than once (which would create multiple simultaneous mutable references to the cell), a GridError::AlreadyVisited will be returned in place of the cell contents.

Examples found in repository

examples/dungeon.rs (line 47)

fn main() {
    let rect = Rect::new((64, 64));
    // The minimum distance a partition can get to the edge of a Rect.
    let min_size = 8;

    let mut grid = Grid::<LifeState>::new(rect);
    let room_tree = grid
        .bounds
        .bsp(Orientation::Horizontal, &|rect, orientation| {
            let dimension = match orientation {
                Orientation::Horizontal => rect.width(),
                Orientation::Vertical => rect.height(),
            };
            let max_size = dimension - min_size;
            // No valid partitions; any cut would make the leaves too small.
            if max_size - min_size <= 0 {
                return None;
            }
            let partition = rand::thread_rng().gen_range(min_size..=max_size);
            Some((partition, orientation.orthogonal()))
        });
    let room_bounds = room_tree.leaves();
    let rooms = room_bounds.iter().flat_map(|room| {
        shrink_randomly(
            Rect {
                bottom: room.bottom + 1,
                left: room.left + 1,
                top: room.top,
                right: room.right,
            },
            4,
        )
        .iter()
    });

    // room_tree

    let layers = cluster_layers(rooms.collect());
    for result in grid.selection_iter_mut(layers.interior.into_iter()) {
        if let Ok((_coord, cell)) = result {
            *cell = LifeState::Floor;
        }
    }
    for result in grid.selection_iter_mut(layers.internal_border.into_iter()) {
        if let Ok((_coord, cell)) = result {
            *cell = LifeState::Wall;
        }
    }
    println!("{}", grid);
}

pub fn flood_iter<C: Into<Coord>>( &self, starting_coord: C, predicate: impl Fn(&T) -> bool + 'static, ) -> FloodIter<'_, T>

Returns an iterator beginning from starting_coord and continuing through all recursively adjacent coords that satisfy the predicate. In other words, this iterates through the cells according to a flood fill algorithm.

Since there is no mut version of this iterator (which would require simultaneous mutable and shared references to most of the cells), the resulting iterator can be collected and then passed into Grid::selection_iter_mut to gain access to mutable cell contents.

Trait Implementations

impl<T> Display for Grid<T>

where char: From<T>, T: Copy,

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

Formats the value using the given formatter.