Struct TileSetWfcPropagator 

pub struct TileSetWfcPropagator { /* private fields */ }

Wave function collapse propagator for the tiles of a TileSet that uses the nine-slice values of one of the tile set’s properties as the wave function’s pattern.

Implementations

impl TileSetWfcPropagator

pub fn constrain_edges<Con>( &mut self, tile_set: &TileSet, pattern_property: TileSetPropertyNine, tile_map: &TileMap, update: &MacroTilesUpdate, constraint: &Con, ) -> Result<(), WfcFailure>

where Con: WfcConstrain<Pattern = PatternBits, Offset = Vector2Offset>,

After all the wave cells have been added using WfcPropagator::add_cell, this method may be used to automatically restrict the edges of the cells by using the given tile map to find the patterns of surrounding tiles and calling WfcPropagator::restrict_edge as appropriate.

This forces the wave function collapse to fit smoothly with the existing tiles of the tile map, though such restrictions may make failure more likely. WfcFailure is returned if wave function collapse is made impossible by the restrictions.

pub fn apply_autotile_to_update<R: Rng + ?Sized>( &self, rng: &mut R, value_map: &TileSetWfcConstraint, update: &mut MacroTilesUpdate, )

Modify the given tile map update based on the result of the autotiler.

pub fn apply_autotile_to_data<R: Rng + ?Sized>( &self, rng: &mut R, value_map: &TileSetWfcConstraint, data: &mut TileMapData, )

Modify the given tile map data based on the result of the autotiler.

Methods from Deref<Target = WfcPropagator<Vector2<i32>, PatternBits>>

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 Clone for TileSetWfcPropagator

fn clone(&self) -> TileSetWfcPropagator

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TileSetWfcPropagator

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

Formats the value using the given formatter.

impl Default for TileSetWfcPropagator

fn default() -> TileSetWfcPropagator

Returns the “default value” for a type.

impl Deref for TileSetWfcPropagator

type Target = WfcPropagator<Matrix<i32, Const<2>, Const<1>, ArrayStorage<i32, 2, 1>>, PatternBits>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for TileSetWfcPropagator

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.