https://github.com/MattWoelk/shuffle_vector

It would be really cool to run everything in parallel. I thought it would be an easy task until I read the source - it seems pretty much everything is trait level.

I found out about this library through the blog post
https://gridbugs.org/wave-function-collapse/
It describes the library as being composed of a basic WFC algorithm, which is part of the wfc
crate, and another library that uses the former in order to operate on images, wfc-image.
I have been successful in trying out wfc-image however I need a tile-based approach for my own
application.

I have a 2D tileset and want to create a map using adjacency rules (so basically tiled, not overlapping method)
This is described on the blog:

Note that there are some alternative applications of WFC besides generating similar images, such as arranging hand-crafted tiles with user-specified adjacency rules and frequency hints. These applications would still use the same core algorithm, but the image processor would be different.

In the post there's a function mentioned that would basically do what I want:

fn wfc_core(
    adjacency_rules: AdjacencyRules,
    frequency_rules: FrequencyHints,
    output_size: (u32, u32),
) -> Grid2D<TileIndex> { ... }

However this function doesn't exist inside wfc.
I've tried to understand how wfc-image uses wfc.
It seems like it calls new_wrap_forbid().
But it's not clear to me how I would accomplish my goal in particular, as there's no examples of using wfc by itself.

My question is, is this possible with your library? If so, then could you point me in the right direction as to which functions I should use?

I understand I'd probably have to call new_wrap_forbid().
I don't think I need to set the wrap to anything special, I assume it works with just WrapXY for my case? Same with forbid, I don't know what that is but I assume I can just set it to ForbidNothing.
Output_size and RNG are obvious.
But I don't understand what the GlobalStats part represents.
It must represent the adjacency rules since no other parameter contains those.
How do I construct the adjacency rules? I have explicit rules I already know beforehand.

Thanks in advance for any help you can give me.

Documentation of the public members of the crate is really sparse. Example in wfc_image makes the implementation a little easier to understand, but I personally don't find it straightforward.

I am currently in process of implementing WFC algorithm in my crate and will compare my implementation to the one derived from this crate. After successfully implementing it over grid type in my crate, I can try to open a PR with some additional documentation - would it be welcome?

Hello! I was about to implement my own wfc and found this, I have being playing with it and it's great!

I have a case of use where I need to create a map, but this map have fixed tiles in it, let's say that the tile in (0,0) must be type 1, (1,4) is type 2 and then the rest of tiles must be randomly generated using wfc

Does this crate cover that case? Can you point me in the right direction on how to do this?

Thanks

I would like to use your library in my pixel art editor. Can you add a license? Thanks!

The assertion in WaveCell::choose_pattern_id fails, seemingly no matter what global stats I use. I use patterns that all have the same weight (100).

        assert_eq!(
            self.sum_compatible_pattern_weight(global_stats),
            self.stats.sum_compatible_pattern_weight
        );

thread 'main' panicked at 'assertion failed: `(left == right)`
  left: `316900`,
 right: `321800`'

I'm confused how this is happening. I thought that collapse_retrying keeps going until each coordinate has been assigned a pattern, but it finishes execution and still returns an MultipleCompatiblePatterns error for a cell. Could you please explain what I'm doing wrong here?