Struct WfcPropagator 

pub struct WfcPropagator<Pos, Pat>
where
    Pos: WavePosition,
{ /* private fields */ }

The propagator is responsible for the wave function collapse algorithm and it contains all the necessary data except for the WfcConstrain object that contains the rules for which patterns may be chosen.

The contraint object is not owned by the propagator because the wave function collapse algorithm may be spread out across many steps and it may be necessary for the constraint object to not live as long as the propagator, and be reconstructed at each step.

Every constraint object at each step should always fully agree with the constraint objects at all previous steps, or else the algorithm may produce undesired results.

Implementations

impl<Pos, Pat> WfcPropagator<Pos, Pat>

where Pos: WavePosition + Debug, Pat: Clone + Hash + Eq + Debug,

pub fn is_empty(&self) -> bool

This propagator contains no cells.

pub fn positions(&self) -> impl Iterator<Item = &Pos>

An iterator over the positions of every cell of the wave.

pub fn contains_cell(&self, position: &Pos) -> bool

True if the wave has a cell at the given position.

pub fn assigned_patterns(&self) -> impl Iterator<Item = (&Pos, &Pat)>

Iterator over the cells that have been given a pattern by the wave function collapse.

pub fn fill_from<Con>(&mut self, constraint: &Con)

where Con: WfcConstrain<Pattern = Pat, Offset = <Pos as OffsetPosition>::Offset>,

Use the data in a WfcConstrain object to initialize the propagator for a new wave function collapse using the given constraint. After calling this method, the next step is to call add_cell for each cell that needs to be filled by wave function collapse.

pub fn add_cell(&mut self, position: Pos)

Create a new cell at the given position, assuming that wave function collapse has not yet begun and all the surrounding cells have no restrictions. Calling this after restrict_edge, observe_random_cell, or observe_all may produce undesirable consequences. After all the cells have been added, the next step is to optionally call restrict_edge to constrain which patterns the may be put into the border cells.

pub fn find_min_entropy<R>(&self, rng: &mut R) -> Option<Pos>

where R: Rng + ?Sized, <Pos as WavePosition>::Counter: Debug,

Randomly choose a low-entropy cell. This is used by observe_random_cell to decide which cell will be observed.

pub fn choose_random_pattern<R, Con>( &self, position: &Pos, rng: &mut R, constraint: &Con, ) -> Option<Pat>

where R: Rng + ?Sized, Con: WfcConstrain<Pattern = Pat, Offset = <Pos as OffsetPosition>::Offset>,

Choose a random pattern from among the potential patterns for the given cell based on probabilities given in constraint. This is called by observe_random_cell to decide which pattern to assign.

pub fn restrict_edge<Con>( &mut self, position: &Pos, pattern: &Pat, constraint: &Con, ) -> Result<(), WfcFailure>

where Con: WfcConstrain<Pattern = Pat, Offset = <Pos as OffsetPosition>::Offset>, Pos: Debug,

Constrain the cells around the given position based on the assumption that the given position has the given pattern. Calling this method twice on the same position may put the surrounding cells into an invalid state, even if both calls have the same pattern. This should be called after all cells have been added using add_cell, and there should be no cell at the given position.

The next step is to call observe_random_cell or observe_all to begin collapsing the wave function.

pub fn observe_all<R, Con>( &mut self, rng: &mut R, constraint: &Con, ) -> Result<(), WfcFailure>

where R: Rng + ?Sized, Con: WfcConstrain<Pattern = Pat, Offset = <Pos as OffsetPosition>::Offset>, Pos: Debug, <Pos as WavePosition>::Counter: Debug,

Completely collapse the wave function. This method repeatedly observes a random cell and propagates each observation until all cells have been observed or the wave function collapse fails due to not being able to find a valid pattern for some cell.

If the number of cells is large, this method may be slow. Use observe_random_cell to progress the collapse one cell at a time and thereby have more control over the process and allow the possibility of aborting.

pub fn observe_random_cell<R, Con>( &mut self, rng: &mut R, constraint: &Con, ) -> Result<WfcControlFlow, WfcFailure>

where R: Rng + ?Sized, Con: WfcConstrain<Pattern = Pat, Offset = <Pos as OffsetPosition>::Offset>, Pos: Debug, <Pos as WavePosition>::Counter: Debug,

Observing a cell means choosing a random pattern for that cell from all the potential patterns for that particular cell. Each cell keeps its own independent list of possible patterns, and after a cell has been observed the possibilities for the surrounding cells may need to be restricted. The restriction of the surrounding cells is called propagation and it should be performed after each observation by calling propagate or propagate_until_finished.

If propagation is not complete when this method is called, then propagate_until_finished is automatically called before the cell is observed.

WfcControlFlow::Continue is returned if a cell was successfully observed, meaning that propagation and more observations may be required to complete the collapse. WfcControlFlow::Finish is returned if no cell could be observed because the pattern for all cells has already been determined and the wave function collapse is complete.

pub fn propagate_until_finished<Con>( &mut self, constraint: &Con, ) -> Result<(), WfcFailure>

where Con: WfcConstrain<Pattern = Pat, Offset = <Pos as OffsetPosition>::Offset>,

Repeatedly call propagate until it returns WfcControlFlow::Finish, thus ensuring that all the cells are prepared for the next observation. This is called automatically by observe_random_cell.

pub fn propagate<Con>( &mut self, constraint: &Con, ) -> Result<WfcControlFlow, WfcFailure>

where Con: WfcConstrain<Pattern = Pat, Offset = <Pos as OffsetPosition>::Offset>,

Propagate the restrictions from the most recent calls to observe_random_cell or restrict_edge by one step, so that appropriate restrictions are spread across the cells of the wave. This method should be repeatedly called until it returns WfcControlFlow::Finish before another cell is observed so that the observation is based upon an accurate list of possible patterns for the cell.

Trait Implementations

impl<Pos, Pat> Clone for WfcPropagator<Pos, Pat>

where Pos: Clone + WavePosition, Pat: Clone, <Pos as WavePosition>::Counter: Clone,

fn clone(&self) -> WfcPropagator<Pos, Pat>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Pos, Pat> Debug for WfcPropagator<Pos, Pat>

where Pos: Debug + WavePosition, Pat: Debug, <Pos as WavePosition>::Counter: Debug,

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

Formats the value using the given formatter.

impl<Pos, Pat> Default for WfcPropagator<Pos, Pat>

where Pos: Default + WavePosition, Pat: Default, <Pos as WavePosition>::Counter: Default,

fn default() -> WfcPropagator<Pos, Pat>

Returns the “default value” for a type.