Struct HashWfcConstraint 

pub struct HashWfcConstraint<Pat, V> { /* private fields */ }

An implementation for WfcConstrain that stores the information for each pattern in a hash table and also keeps track of a which values each pattern may represent, so that patterns may be translated into tiles after wave function collapse is complete.

Implementations

impl<Pat, V> HashWfcConstraint<Pat, V>

where Pat: Eq + Hash,

pub fn is_empty(&self) -> bool

True if this constraint contains no patterns.

pub fn clear(&mut self)

Remove all data, reseting this object to empty so it is ready to be reused with new pattern data.

pub fn add(&mut self, pattern: Pat, frequency: f32, value: V)

where Pat: Debug, V: Debug,

Add a new value to the data with the given pattern and frequency. The frequency does not need to be between 0.0 and 1.0. Frequencies of 0.0 or less will be silently ignored, and frequencies will be automatically normalized into probabilities when finalize is called.

pub fn finalize(&mut self)

Calculate the probability of each pattern based on the frequencies of all values that were added with add. The sum of the frequencies is calculated and then each frequency is divided by the sum to normalize the frequencies into probabilities between 0.0 and 1.0.

pub fn finalize_with_terrain_normalization<Ter, F>(&mut self, terrain: F)

where Ter: Hash + Eq, F: Fn(&Pat) -> Ter,

Calculate the probability of each pattern based on the frequencies of all values that were added with add. Divide the frequency of each pattern by the total number of patterns in that pattern’s terrain so that terrains with many patterns are not given an advantage over terrains with few patterns. The terrain function is used to determine the terrain of each pattern. The sum of the frequencies is calculated and then each frequency is divided by the sum to normalize the frequencies into probabilities between 0.0 and 1.0.

pub fn get_random<R>(&self, rng: &mut R, pattern: &Pat) -> Option<&V>

where R: Rng + ?Sized,

A random value that matches the given pattern, based upon previous calls to add. Often there may be more than one tile that matches a particular pattern, and so this method helps with the final step after wave function collapse: converting the chosen patterns into actual tiles.

Trait Implementations

impl<Pat, V> Default for HashWfcConstraint<Pat, V>

fn default() -> HashWfcConstraint<Pat, V>

Returns the “default value” for a type.

impl<Pat, V> WfcConstrain for HashWfcConstraint<Pat, V>

where Pat: Eq + Hash + Clone + TilePattern,

type Offset = <Pat as TilePattern>::Offset

The offset type that is used to specify the ways in which one pattern may be adjacent to another pattern.

type Pattern = Pat

The type of patterns that wave function collapse will choose.

fn all_patterns( &self, ) -> impl Iterator<Item = &<HashWfcConstraint<Pat, V> as WfcConstrain>::Pattern>

Iterator for all the patterns that wave function collapse is allowed to choose. Note that any pattern with a probability of 0.0 must not be included.

fn probability_of( &self, pattern: &<HashWfcConstraint<Pat, V> as WfcConstrain>::Pattern, ) -> f32

The probability of choosing a given pattern when there are no restrictions on patterns in any of the adjacent cells. This should be between 0.0 and 1.0.

fn is_legal( &self, from: &<HashWfcConstraint<Pat, V> as WfcConstrain>::Pattern, offset: &<HashWfcConstraint<Pat, V> as WfcConstrain>::Offset, to: &<HashWfcConstraint<Pat, V> as WfcConstrain>::Pattern, ) -> bool

True if the from pattern may be chosen when the to pattern has already been chosen for the cell at position offset relative to from.