Struct Grid 

pub struct Grid<T: PossibleValues, const D: usize> { /* private fields */ }

A microwfc grid.

Implementations

impl<T: PossibleValues, const D: usize> Grid<T, D>

pub fn new(size: [usize; D]) -> Result<Self, SizeErr>

Constructs a new Grid using the n-dimensional size.

Examples found in repository

examples/main.rs (line 35)

fn main() {
    let mut rng = thread_rng();
    // Make a new 30-by-30 grid.
    let mut grid: Grid<Tile, 2> = Grid::new([30, 30]).unwrap();
    loop {
        let r = grid.wfc(
            |g, loc, me, probability| {
                // We use !any(|x| ...) to get none(|x| ...) functionality
                match *me {
                    // Disallow water next to grass
                    Tile::Water => (
                        !g.unidirectional_neighbors(loc).iter().any(|x| {
                            x.1.determined_value
                                .as_ref()
                                .map(|x| *x == Tile::Grass)
                                .unwrap_or(false) // Allow unsolved pixels
                        }),
                        probability,
                    ),
                    // Dirt is always allowed
                    Tile::Dirt => (true, probability),
                    // Disallow grass next to water
                    Tile::Grass => (
                        !g.unidirectional_neighbors(loc).iter().any(|x| {
                            x.1.determined_value
                                .as_ref()
                                .map(|x| *x == Tile::Water)
                                .unwrap_or(false)
                        }),
                        probability,
                    ),
                }
            },
            1,
            &mut rng,
            0.05,
            |grid| {
                // Clear the screen
                println!("\x1b[H\x1b[2J\x1b[3J");

                let mut s = String::new();
                for y in 0..grid.size()[0] {
                    s += "\n";
                    for x in 0..grid.size()[1] {
                        if let Some(x) = grid.get_item([x, y]).determined_value {
                            s += &String::from(x);
                        } else {
                            s += "  ";
                        }
                    }
                }

                println!("{}", s);
                thread::sleep(Duration::from_millis(10));
            },
        );
        if r.is_ok() {
            break;
        } else {
            println!("fuck");
        }
    }
}

pub fn size(&self) -> [usize; D]

Returns the n-dimensional size of the Grid. In all default implementations, this returns a n-tuple where n is the dimensionality of the Grid.

Examples found in repository

examples/main.rs (line 73)

fn main() {
    let mut rng = thread_rng();
    // Make a new 30-by-30 grid.
    let mut grid: Grid<Tile, 2> = Grid::new([30, 30]).unwrap();
    loop {
        let r = grid.wfc(
            |g, loc, me, probability| {
                // We use !any(|x| ...) to get none(|x| ...) functionality
                match *me {
                    // Disallow water next to grass
                    Tile::Water => (
                        !g.unidirectional_neighbors(loc).iter().any(|x| {
                            x.1.determined_value
                                .as_ref()
                                .map(|x| *x == Tile::Grass)
                                .unwrap_or(false) // Allow unsolved pixels
                        }),
                        probability,
                    ),
                    // Dirt is always allowed
                    Tile::Dirt => (true, probability),
                    // Disallow grass next to water
                    Tile::Grass => (
                        !g.unidirectional_neighbors(loc).iter().any(|x| {
                            x.1.determined_value
                                .as_ref()
                                .map(|x| *x == Tile::Water)
                                .unwrap_or(false)
                        }),
                        probability,
                    ),
                }
            },
            1,
            &mut rng,
            0.05,
            |grid| {
                // Clear the screen
                println!("\x1b[H\x1b[2J\x1b[3J");

                let mut s = String::new();
                for y in 0..grid.size()[0] {
                    s += "\n";
                    for x in 0..grid.size()[1] {
                        if let Some(x) = grid.get_item([x, y]).determined_value {
                            s += &String::from(x);
                        } else {
                            s += "  ";
                        }
                    }
                }

                println!("{}", s);
                thread::sleep(Duration::from_millis(10));
            },
        );
        if r.is_ok() {
            break;
        } else {
            println!("fuck");
        }
    }
}

pub fn as_inner(&self) -> &Array<Pixel<T>, D>

Returns an immutable reference to the inner microNDArray

pub fn as_mut_inner(&mut self) -> &mut Array<Pixel<T>, D>

Returns an mutable reference to the inner microNDArray

pub fn get_item(&self, location: [usize; D]) -> Pixel<T>

Clones and returns a Pixel from the Grid.

Examples found in repository

examples/main.rs (line 76)

fn main() {
    let mut rng = thread_rng();
    // Make a new 30-by-30 grid.
    let mut grid: Grid<Tile, 2> = Grid::new([30, 30]).unwrap();
    loop {
        let r = grid.wfc(
            |g, loc, me, probability| {
                // We use !any(|x| ...) to get none(|x| ...) functionality
                match *me {
                    // Disallow water next to grass
                    Tile::Water => (
                        !g.unidirectional_neighbors(loc).iter().any(|x| {
                            x.1.determined_value
                                .as_ref()
                                .map(|x| *x == Tile::Grass)
                                .unwrap_or(false) // Allow unsolved pixels
                        }),
                        probability,
                    ),
                    // Dirt is always allowed
                    Tile::Dirt => (true, probability),
                    // Disallow grass next to water
                    Tile::Grass => (
                        !g.unidirectional_neighbors(loc).iter().any(|x| {
                            x.1.determined_value
                                .as_ref()
                                .map(|x| *x == Tile::Water)
                                .unwrap_or(false)
                        }),
                        probability,
                    ),
                }
            },
            1,
            &mut rng,
            0.05,
            |grid| {
                // Clear the screen
                println!("\x1b[H\x1b[2J\x1b[3J");

                let mut s = String::new();
                for y in 0..grid.size()[0] {
                    s += "\n";
                    for x in 0..grid.size()[1] {
                        if let Some(x) = grid.get_item([x, y]).determined_value {
                            s += &String::from(x);
                        } else {
                            s += "  ";
                        }
                    }
                }

                println!("{}", s);
                thread::sleep(Duration::from_millis(10));
            },
        );
        if r.is_ok() {
            break;
        } else {
            println!("fuck");
        }
    }
}

pub fn set_item(&mut self, location: [usize; D], item: Pixel<T>)

Sets a Pixel in the Grid.

pub fn unidirectional_neighbors( &self, location: [usize; D], ) -> Vec<([usize; D], Pixel<T>)>

Returns unidirectional neighbors, meaning only neighbord with one common face. This means the corners will not be returned.

Examples found in repository

examples/main.rs (line 43)

fn main() {
    let mut rng = thread_rng();
    // Make a new 30-by-30 grid.
    let mut grid: Grid<Tile, 2> = Grid::new([30, 30]).unwrap();
    loop {
        let r = grid.wfc(
            |g, loc, me, probability| {
                // We use !any(|x| ...) to get none(|x| ...) functionality
                match *me {
                    // Disallow water next to grass
                    Tile::Water => (
                        !g.unidirectional_neighbors(loc).iter().any(|x| {
                            x.1.determined_value
                                .as_ref()
                                .map(|x| *x == Tile::Grass)
                                .unwrap_or(false) // Allow unsolved pixels
                        }),
                        probability,
                    ),
                    // Dirt is always allowed
                    Tile::Dirt => (true, probability),
                    // Disallow grass next to water
                    Tile::Grass => (
                        !g.unidirectional_neighbors(loc).iter().any(|x| {
                            x.1.determined_value
                                .as_ref()
                                .map(|x| *x == Tile::Water)
                                .unwrap_or(false)
                        }),
                        probability,
                    ),
                }
            },
            1,
            &mut rng,
            0.05,
            |grid| {
                // Clear the screen
                println!("\x1b[H\x1b[2J\x1b[3J");

                let mut s = String::new();
                for y in 0..grid.size()[0] {
                    s += "\n";
                    for x in 0..grid.size()[1] {
                        if let Some(x) = grid.get_item([x, y]).determined_value {
                            s += &String::from(x);
                        } else {
                            s += "  ";
                        }
                    }
                }

                println!("{}", s);
                thread::sleep(Duration::from_millis(10));
            },
        );
        if r.is_ok() {
            break;
        } else {
            println!("fuck");
        }
    }
}

pub fn neighbors( &self, location: [usize; D], distance: usize, ) -> Vec<([usize; D], Pixel<T>)>

Returns all neighbors, including ones touching only at a single point. This does return corners.

pub fn check_loc(&self, location: [i128; D]) -> Option<[usize; D]>

Checks if a location is inside the Grid, then returns its Grid coordinates.

pub fn check_validity<F>(&mut self, test: F) -> Result<(), [usize; D]>

where F: Fn(&Grid<T, D>, [usize; D], &T, f32) -> (bool, f32),

Checks if the Grid is valid

pub fn collapse<F, R>( &mut self, test: F, effect_distance: usize, rng: &mut R, item: ([usize; D], Pixel<T>), ) -> Result<(), [usize; D]>

where F: Fn(&Grid<T, D>, [usize; D], &T, f32) -> (bool, f32), R: Rng,

Collapses a single Pixel and updates neighbors. This will return false if the Grid is invalid. Please note that this function is not very useful, and you should use wfc instead

pub fn wfc<F, R>( &mut self, test: F, effect_distance: usize, rng: &mut R, chance: f32, on_update: impl Fn(&Self), ) -> Result<(), [usize; D]>

where F: Fn(&Grid<T, D>, [usize; D], &T, f32) -> (bool, f32), R: Rng,

Performs the wave-function-collapse algorithm on the Grid. This returns if the algorithm was successful, and the state of the Grid is not guaranteed to be valid if it returns false, but there is never unsafety in reading from the Grid.

The chance parameter determines the likelyhood of a random collapse happening anywhere on the grid. In some strict environments, this can cause unsolvable grids.

Examples found in repository

examples/main.rs (lines 37-87)

fn main() {
    let mut rng = thread_rng();
    // Make a new 30-by-30 grid.
    let mut grid: Grid<Tile, 2> = Grid::new([30, 30]).unwrap();
    loop {
        let r = grid.wfc(
            |g, loc, me, probability| {
                // We use !any(|x| ...) to get none(|x| ...) functionality
                match *me {
                    // Disallow water next to grass
                    Tile::Water => (
                        !g.unidirectional_neighbors(loc).iter().any(|x| {
                            x.1.determined_value
                                .as_ref()
                                .map(|x| *x == Tile::Grass)
                                .unwrap_or(false) // Allow unsolved pixels
                        }),
                        probability,
                    ),
                    // Dirt is always allowed
                    Tile::Dirt => (true, probability),
                    // Disallow grass next to water
                    Tile::Grass => (
                        !g.unidirectional_neighbors(loc).iter().any(|x| {
                            x.1.determined_value
                                .as_ref()
                                .map(|x| *x == Tile::Water)
                                .unwrap_or(false)
                        }),
                        probability,
                    ),
                }
            },
            1,
            &mut rng,
            0.05,
            |grid| {
                // Clear the screen
                println!("\x1b[H\x1b[2J\x1b[3J");

                let mut s = String::new();
                for y in 0..grid.size()[0] {
                    s += "\n";
                    for x in 0..grid.size()[1] {
                        if let Some(x) = grid.get_item([x, y]).determined_value {
                            s += &String::from(x);
                        } else {
                            s += "  ";
                        }
                    }
                }

                println!("{}", s);
                thread::sleep(Duration::from_millis(10));
            },
        );
        if r.is_ok() {
            break;
        } else {
            println!("fuck");
        }
    }
}