Tile-Based Map Generation using Wave Function Collapse in 'Caves of Qud'

Summary

ブライアン・バクリィは、プロシージャル生成ゲーム「ケイブズ・オブ・カット」の開発者であり、同社の共同創業者であるフリーホールド・ゲームズのメンバーです。彼は、ゲームのマップ生成に使用されている「波動関数崩壊」という手法について語りました。この手法は、パーリンノイズなどの一般的な手法に加えて、新しい手法も使用していると述べました。波動関数崩壊は、俄国の数学者マキシム・グーマンによって開発され、MITライセンスで公開されています。この手法はタイルベースのマップデザインにも適用できますが、彼らはテクスチャモードを使用し、小さなトレーニング画像から任意の大きさの出力を生み出すことができます。この手法は、タイルの隣接性を強力に制約づけることができるため、より強力な結果を得ることができます。また、この手法を応用して、マップのセグメント化や詳細なドアや家具の配置など、より複雑なマップを生成する方法についても説明しました。最後に、この手法を他のプロジェクトに取り入れることの容易さと、ドキュメントの充実度について触れ、話は終了しました。

Takeaways

• 🎮 Brian Buckleyは、Freehold Gamesの共同創設者で、ゲーム「Caves of Qud」の開発に携わっています。
• 🧩 「Caves of Qud」は、プロシージャル・ジェネレーションを用いて、タイルベースのゲームマップを作成しています。
• 📈 ゲームのマップは80×25タイルで、壁、生物、植物などの要素が抽象的に表現されています。
• 🌐 Wave Function Collapse（WFC）というテクスチャ合成手法を使用し、マップの多様性を実現しています。
• 🤖 WFCは、ロシアの数学者Maxim Guminによって開発され、MITライセンスで公開されています。
• 🔍 WFCはタイルとテクスチャの2つのモードで動作し、小さなトレーニング画像から大きな出力を生み出すことができます。
• 🛠️ WFCは、入力されたトレーニング画像に基づいて、すべてのタイルの可能性を超位置状態にし、徐々に選択を狭めます。
• 🏗️ ゲームマップの生成では、WFCを用いて大域的な構造を作り、その後詳細を手動で追加することで、均質性の問題を解決しています。
• 🔄 WFCを使用する際には、同種のタイルが繰り返し生成されることを避けるため、制約を追加することが重要です。
• 📉 過剰適合を防ぐために、WFCの出力を用いて基本的な壁構造を生成し、その後にドアや家具などの詳細を追加します。
• 🔢 WFCのトレーニングセットは、できるだけ小さな画像を使用し、必要とする性格を詰め込んでいます。
• 🔄 対称性を使用することで、WFCは同じタイルが異なる角度で繰り返されることを防ぎ、タイル配置の多様性を確保できます。

Q & A

ブライアン・バクリーが開発したゲームは何ですか？

ブライアン・バクリーが開発したゲームは「Caves of Qud」です。

Caves of Qudのマップ生成にはどのような手法が使用されていますか？

Caves of Qudのマップ生成には、パーリンノイズなどの一般的な手法に加えて、波動関数崩壊という新しいテクスチャー合成手法が使用されています。

波動関数崩壊とは何ですか？

波動関数崩壊は、マキシム・グーマンというロシアの数学者が開発した、タイルベースのプロシージャル生成手法です。タイルやテクスチャに対して作用し、入力されたトレーニング画像の性質を持ちながら、より大きな出力を生み出します。

波動関数崩壊の訓練画像はどのくらいの大きさが良いですか？

波動関数崩壊の訓練画像は、8x8ピクセルや16x16ピクセルなどの小さいサイズが効果的です。訓練画像が小さいほど、より強力な結果を得ることができます。

Caves of Qudのマップはどのようにして生成されますか？

Caves of Qudのマップは、波動関数崩壊手法を使用して生成されます。タイルベースのゲームであるため、各マップは80x25タイルで構成され、壁、生物、植物などが抽象的な形で表現されています。

波動関数崩壊手法を実装する際のコードは複雑ですか？

波動関数崩壊手法を実装する際のコードは、3行のシンプルなコードで済むため、複雑ではありません。モデルを初期化し、実行させ、出力を取得するだけで済みます。

Caves of Qudのマップ生成で直面した問題は何ですか？

Caves of Qudのマップ生成で直面した問題は、同質性とオーバーフィッティングの2つです。同質性は、大きな出力が均質的になる傾向があることを意味し、オーバーフィッティングは、訓練画像に色を追加することで出力が多様でなくなる傾向があることを意味します。

同質性の問題はどのように解決されましたか？

同質性の問題は、出力空間をセグメント化し、波動関数崩壊を使用して詳細を埋めることで解決されました。これにより、均質的な出力ではなく、より興味深いグラフ構造が得られます。

オーバーフィッティングの問題はどのように対処されましたか？

オーバーフィッティングの問題は、波動関数崩壊の出力を用いて高いレベルの壁構造を生成し、その後のプロセッシングでドアや家具などの詳細を生成することで対処されました。

Caves of Qudの開発チームはどのようにして波動関数崩壊手法を実装しましたか？

Caves of Qudの開発チームは、ゲームのアエスセティックに沿って、生成システムを自由自在に動かし、出力を組み合わせることで実装しました。また、タイルベースの手法を用いて、デザイナーが制御できるプリファブを組み合わせることで、より細かい制御が可能です。

波動関数崩壊手法のリポジトリはどの言語で利用できますか？

波動関数崩壊手法のリポジトリは、20以上の異なる言語で利用可能です。MITライセンスで公開されており、幅広く利用されています。

Outlines

00:00

🎮 プロシージャルジェネレーションの紹介とWFCの活用

Brian Buckleyが開発したゲーム「Caves of Qud」のプロシージャルジェネレーションについて紹介。特に、Wave Function Collapse (WFC)という手法について解説し、ゲーム内のマップ生成にどのように応用されているかを説明。WFCは、タイルベースのマップデザインに適しており、小さなトレーニング画像から大きな出力が生成できるという驚くべき機能を持ち、ゲームのマップ生成において非常に強力なツールとなっている。

05:01

🧠 WFCアルゴリズムの基礎と動作原理

WFCアルゴリズムの基本的な動作原理について解説。アルゴリズムは、入力されたタイルを3x3タイルのスーパーポジションとして開始し、逐次的にタイルを選択して確定化していく。このプロセスでは、タイル間の隣接性制約を利用して、最終的なマップを生成。Brianは、WFCの決定プロセスを視覚的に説明し、どのようにして隣接するタイルを選択し、マップを確定させるかを解説。

10:03

🏡 テクスチャモードでのWFC実験とマップ生成

BrianがテクスチャモードでWFCを実験し、タイルマップを構築する手法を探求した経験について語る。最初の試みでは、単純な3色パターンから始め、空間的整合性を持つ結果を得ることができた。さらに、より複雑なトレーニング画像を用いて自然な庭園のような構造を生成することができると示す。WFCのパラメータ設定についても触れ、同質性の問題やオーバーフィッティングの問題に対する解決策として、出力空間のセグメント化とポストプロセスを使用した方法を紹介。

15:04

🛠️ WFCを用いたマップ生成のプロセス

Brianが実際にCaves of Qudのマップを生成するプロセスを説明。大まかなセグメント化から始め、WFCを使用して詳細を埋め、単純なA*アルゴリズムでドアの設置などを行う。この手法により、複雑なマップが生成されるが、プロセスは非常に単純である。また、WFCを使用する際の設計に関する議論や、他のチームがどのようにWFCを応用しているかについて触れる。

20:05

📚 WFCアルゴリズムの応用と改善

WFCアルゴリズムに追加の制約を加えることで、特定の領域内にタイルが繰り返し表示されないようにするなどの改善が提案された。Brianは、実際には追加の制約を試行錯誤したが、問題に遭遇したため、基本的なWFCの活用に留めた。また、より詳細なトレーニングセットを使用することで、隣接する素材のバリエーションを増やす方法についても議論。最後に、聴衆からの質問に対して応答し、WFCの応用に関する洞察を提供。

Keywords

💡プロシージャルジェネレーション

プロシージャルジェネレーションは、コンピュータグラフィックスやゲーム開発でよく使われる手法で、アルゴリズムを用いてランダムに生成された環境やオブジェクトを作成します。このビデオでは、ゲーム「Caves of Qud」のマップ生成に使われています。

💡パーリンノイズ

パーリンノイズは、グラフィックスソフトウェアで使用されるノイズ関数で、自然現象をシミュレーションするために使われます。ビデオでは、マップのプロシージャル生成で使用される一般的な技術の一つとして言及されています。

💡ウェーブファンクションコラプス

ウェーブファンクションコラプスは、タイルベースのマップ生成に用いられるテクスチャ合成手法で、小さなトレーニング画像から大きな出力を生み出すことができます。ビデオでは、この手法がゲームのマップ生成にどのように適用され、多様な結果を生むかに重点的に説明されています。

💡トレーニング画像

トレーニング画像とは、ウェーブファンクションコラプスで用いられる小さな入力画像のことです。これらの画像は、アルゴリズムに生成する結果の性質を教える役割を果たします。ビデオでは、8x8や16x16の小さなサイズのトレーニング画像が強力な結果を生むと示されています。

💡タイル

タイルは、タイルベースのゲームマップで使用される正方形のブロックで、マップの地形や構造を形成します。ビデオでは、タイルがウェーブファンクションコラプスアルゴリズムによってどのように生成されるかが説明されています。

💡エントロピー

エントロピーは、情報理論で使用される概念で、システムの無序さを測定します。ビデオでは、ウェーブファンクションコラプスアルゴリズムが最初にエントロピーが低いタイルを選択することで、ランダム性から始めながらも決定的な結果に至るプロセスを説明しています。

💡同質性

同質性は、生成されたマップが同じような構造で構成される傾向を指します。ビデオでは、ウェーブファンクションコラプスが生成するマップが同質的になる問題と、それがどのように解決されるかが議論されています。

💡オーバーフィッティング

オーバーフィッティングは、学習アルゴリズムがトレーニングデータに過剰に適応し、汎化能力が低下することを指します。ビデオでは、ウェーブファンクションコラプスで高レベルの壁構造を生成し、詳細を後処理で追加することでオーバーフィッティングを防ぐ方法が説明されています。

💡A*アルゴリズム

A*アルゴリズムは、経路探索問題を解決するための有効な手法で、ゲーム開発でよく使われます。ビデオでは、A*アルゴリズムを使ってマップ内のドアの位置を決定し、マップの詳細を生成するプロセスが説明されています。

💡MITライセンス

MITライセンスは、ソフトウェアがオープンソースで配布される際によく使われるライセンスです。ビデオでは、ウェーブファンクションコラプスがMITライセンスでリリースされ、誰もがプロジェクトに組み込むことができると説明されています。

Highlights

Brian Buckley, co-founder of Freehold Games, discusses the game 'Caves of Qud' which utilizes procedural generation.

The game features a procedural generation technique called 'wave function collapse' developed by Russian mathematician Maxim Gootman.

Wave function collapse operates in two primary modes: tiles and textures, offering powerful results for tile-based map design.

The technique uses small training inputs to produce arbitrarily large outputs with the character of the input image.

An algorithm can be applied to generate different map types, from rectilinear rooms to naturalistic gardens, using simple training inputs.

The algorithm begins by chopping the input into n by n tiles and sets up the output as a superposition of all possible tiles.

The process involves selecting tiles at random and collapsing them down to a single tile based on entropy and adjacency.

The algorithm propagates by removing adjacencies from the list as it continues to select tiles.

The technique can create complex and varied outputs from simple training inputs, offering a single algorithm for multiple map generation styles.

The speaker shares initial experiments with the algorithm, highlighting the creation of structured outputs like square buildings for a village.

To address homogeneity, the output space is segmented, and WFC is used to fill in details with different character.

Overfitting is solved by using WFC to generate high-level wall structures and post-processing to add detailed elements like doors and furniture.

The algorithm is simple to implement, requiring only a few lines of code for initialization, running, and obtaining the output image.

Design challenges are addressed by segmenting the map and using WFC for broad strokes, followed by detailed prefabs.

The speaker discusses the aesthetic of 'Caves of Qud', which embraces the generative systems and allows for unique game environments.

The repository for WFC is well-documented and available in multiple languages, making it accessible for integration into various projects.

The talk concludes with a Q&A session addressing practical implementation, communication with traditional level designers, and potential constraints within the algorithm.

Transcripts

[Music]

why are we here

uh caves of cud is a game that i develop

i'm brian buckley i'm a co-founder at

freehold games

caves of cut has

a ton of procedural generation

we use a bunch of normal techniques that

you've heard of perlin noise etc

and we use a few novel techniques and

today we're going to talk about a

specific one wave function collapse

which sounds scary but i hope by the end

you'll realize it's not particularly

terrifying

so we're going to first start by looking

at some final results that we get by

utilizing this technique

and then we'll go through some slides to

talk about how we get there

so here's a map in caves of cut if

you're not familiar with it it's a

tile-based game so each of the maps is

80 by 25 and it's very discreet so you

can see walls and creatures and plants

here and they're represented in a sort

of abstract way so here we have a sort

of rectilinear palace it has sort of an

outer wall

and inner buildings and they're

populated by various things blood

splatters and centipedes and gardens

and here we have an underground map

where we have some very narrow corridors

goalies full of water

little rooms full of water this is very

sort of maisy narrow map

and here we have a

circular tower embedded in some rock

salt it's filled with bears i guess an

asphalt

and a little statuary on the right it's

got

sort of curvy labyrinthine halls

and here we have a little town we've got

maybe a big ruined civic structure up

north and in the south we have

a bunch of rectilinear village buildings

adjacent laid out along a nice forested

path

so these are a wide

variety of results but the result of a

single algorithm so these each had a

very different character you had little

maisy corridors you had a fairly

dispersed village with well-ordered

buildings you had a

water filled goalies

and instead of using an individual

technique to generate each of these we

use a powerful new texture synthesis

technique called wave function collapse

alongside a few other tools that we use

to supplement its weaknesses when

applied to maps

so wave function collapse it was

developed by a russian mathematician

named maxim gooman released open source

mit licensed and the repositories out

here it's in 20 different languages you

can go out there and download it now and

use it hopefully after this talk you'll

be able to go out there and build into

your projects

caves of code was its first commercial

commercial use a bunch of others quickly

followed because it's such a powerful

technique

wave function collapse has two primary

modes it operates on tiles

and operates on textures

if you do procedural generation you've

probably encountered wong tile maps

which are based on edge colored

adjacencies

the tile map generation is sort of

similar to that but

the adjacency constraints are much more

powerful than edge coloring you can get

a much more powerful result so if you're

interested in tile-based

map design

this is great we're not going to talk

about it

instead we use texture mode

texture mode

uses small training inputs they can be

big but it's most powerful when they're

small

maybe 8 by 8 or 16x16 training images

and they can produce arbitrarily large

outputs with the character of that input

training image

this is pretty amazing so on the left

you have three separate inputs and the

top you see a sort of rectilinear room

hall and you can see seven sample

outputs here just bigger you can see

that each of them has a pretty different

layout but

shares structurally uh the same

character as the input

on the second row you see some caves

these are caves that you would typically

generate via cellular automata system or

something

or box filters something very different

from that that first rectilinear room

hall arrangement

and then third you see an input texture

that's five by five simple couple dots

in a line and you get some very complex

uh

quilted patterns and this would be some

custom line drawing technique so instead

of having to have three very different

algorithms you're able to have

one single algorithm that's fed

different very simple training inputs

this is something you can pop open ms

paint right any training input and throw

it through the algorithm

very cool so i'm going to run quickly

through this text slide don't feel like

you have to load this into your brain

we're going to walk through it more

carefully i just want to prime your

system for

what we're going to talk about i'm

actually not going to go way down to the

nuts of bolts of this algorithm they're

good papers to do that i want to give

you a intuitive understanding of how

this algorithm is making decisions when

it's painting its output

so first what it does is it chops it up

into n by end tiles

n is something you pick um

three is a very typical size so it's

going to operate on individual three by

three tiles chop up your input image

into those it's going to operate on

those as its basic atom you can choose

bigger or smaller atoms depending on

the character you want out of your

output then we output

the or we set up the output as a

superposition of all those possible

tiles so you can imagine each element of

the output being superimposed of each of

the tiles that are pulled out of the

input and this is the character it

shares with quantum wave function

collapse it's it's sort of a snide

relationship it's not anything

complicated

what it does then is it picks one at

random to start with and says well of

all these possible tiles we're going to

select the lowest in by an entropy area

and pick one at random and collapse it

down to a single tile

and then it's got some new information i

know that this tile exists these

adjacencies are removed from the list

and then it continues until every output

has only a single selection and that's

pretty much it so didn't catch that

we'll walk through that in a little more

detail here so the first thing it does

is it identifies all the in-by-end

patterns

so the example here i'm going to use is

a very simple three color training input

it's got red on the outside and a green

box and a blue inside and so it's going

to chop it up into all these three by

three patterns so i'm showing you five

here but they're obviously a bunch in a

nine by nine box without wrapping it's

gonna be like 49 and uh if you allow

wrapping it's like what a 81.

if you allow symmetries and rotations

it's much more

then it goes through and for each tile

it figures out where do the other tiles

overlap and it's going to use this

information in order to do the

propagation

and so here i'm just showing an example

you've got two tiles and you can see

that

the first tile on the left it overlaps

with the two tiles below it sharing

those six red pixels

so this is an example output of an wfc

run so let's unpack what we're looking

at here a little bit on the very left

you see the training input what you're

seeing is the first four steps of the

wfc collapse

in the very first frame the white

outline box is the three by three tile

it's decided to collapse it then steps

through one three by three section at a

time and selects an output tile that

correctly overlaps the existing tiles

that it knows about and it steps through

the image until all of them are

collapsed from the existing input data

so to give you a real idea what's going

on

if you look at the area in the box it's

very clearly green blue

that's a single

non-superimposed result the rest of the

blending pixels is a visualization of

the output tiles that are remain for

that available for that area

superimposed on one another so pixels

that have sort of a green blue box they

can still be either green or blue

depending on what tiles remain to be

chosen

so let's look very specifically at this

first step and try to build an intuition

for how it makes these decisions let's

look at this strip of three pixels here

unlike the pixels to the left you can

see these blue pixels are a little green

which means they still have some

possibility to become green pixels so

why is this

well we look to the left of this pattern

and we see to the left of this pattern

in the input is a strip of blue blue

green

and where can we find this in the input

pattern we can essentially find it in

these three places we can find it here

each of these magenta boxes

is what the output column we're thinking

about might be

in this case in the most leftmost case

you can see left of that is blue blue

green

and the second case left of that is blue

blue green and third case left of that

is blue blue green so these are all

these could all slot in there

two of these outputs that column is blue

blue green and the third possible output

the column is green green green and so

we can see

here we go if

if we look at

two blue blue green inputs and one green

green green input you can see that the

probability is

two blues and one green for each of

those top two pixels and oh it's always

going to be green in the output so you

can see that we though we've selected

that

initial three by three box we know quite

a bit about what possible adjacencies

exist based on the input image

and so again looking at this you should

have a better idea sort of intuitively

what it's doing each of these white

boxes is selecting for sure what these

pixels are in each case it knows a

little bit more about the possibilities

that remain and it simply sort of flood

fills around the area to make it work

so let's watch this work it's fun

so we have

five training inputs on the left we have

a little white box

a little red box

sort of more complex temple

you can watch in real time as it decides

usually from the edges

what the possibilities are

and then

folds in those

overlapping potentials

until we've got a final image and you

can obviously run this many times and

get a different output each time

pretty fun so you can get big complex

outputs from little inputs

so that gives you an idea of how the

technique works again you don't have to

understand it when i started

experimenting with it i had no clue what

was going on so i i'm sort of a hands-on

learner so i just tried to give it input

and

see what it see what happened and so

this was my first experiment in texture

mode in respect to building tile maps i

wanted to build structured output so in

this case i was like well can i make it

build little square buildings for a

village that would be neat

i gave it a black box on a white

background and i did not get a bunch of

little square buildings and it turns out

that's because

what is the image telling it it tells

it's telling it basically on the order

of three by three pixels that a line can

turn left or a line can turn right or a

line can go straight you'll notice that

there's no overlaps but there's also

no training in that image that tells

that there's an inside and out to side

of the square there's no spatial spatial

relationship between those turns and so

you get the output there

i said well what if i had

a third color so now i've got white and

i've got black and i've got red inside

this suddenly produces the kind of

spatial coherence that i want across the

map you've got little red filled boxes

that's awesome because not only do you

get the spatial coherence but you also

get some structural hinting the red

pixels tell me hey that's the inside of

a place and when you're building a map

that's a pretty interesting distinction

to be able to pull out of a real simple

texture okay well something i can put

furniture inside and plants outside and

that looks

like a already a coherent village with

almost nothing going on we've got a

three color texture going into it

here's another example as i get more

comfortable playing with it hey what if

i feed a bigger training image do i get

noise or do i get something interesting

i get something interesting that's cool

another example i said well can i

produce sort of naturalistic gardens

sure i mean these are like eight second

experiments in ms paint this is i'm not

i'm not spending 20 hours learning to do

high level math

so maybe i'm in the wrong lecture also

here's an introductory shape and keep

this in mind because we're going to

return to the star shape i added an

additional color here and you can see

you get star-like shapes

not identical stars but some variation

and that's pretty interesting

how to use this in your code probably

the most interesting slide for people

it's not complicated it's three lines of

code you initialize the model you tell

it to run and you get the output image

and that's it and let's take a look at

the inputs because sometimes

the complexity is hidden in the in the

parameterization for wfc it's not

there's not even any complexity there

you give it the training image you say

what is the n i want i want it to be two

or three or four

how big do i want the output to be do i

want the input to wrap across edges do i

want the output direct cross edges and

do i want it to sample with symmetry

symmetry is a little bit interesting not

very complicated if you're for instance

putting in something where orientation

matters and you've got ground at the

bottom at sky at the top you probably

don't want symmetry unless you want to

end up with sky at the bottom if you've

got buildings where you don't care about

the orientation you want to probably

crank that symmetry up to eight where

you've got full reflection and

rotational symmetry

so

applied to map design these are not

problems with the algorithm per se but

only domain specific problems what

problems did we run into when we tried

to use this problem one was homogeny the

outputs are

as you get bigger and bigger just

completely homogeneous in all directions

they're interesting at the small scale

but you don't really want to walk across

an infinite homogeneous plane of these

buildings

problem two is overfitting and so we'll

return to the star shape

one of the things you want to do in maps

is have more interesting details than

walls you want to have doors and where

the monsters are and where the furniture

is etc etc and you might think that well

let me add more colors to the wfc input

and that of course was the first thing i

tried the reality is as soon as you

start adding more and more colors less

of these tiles tend to overlap and so

you tend to get

very

uh

very non-varied outputs because the

tiles can fit together only in one

particular way and so instead you just

reflect and rotate the shape across

space

so how do we solve these

the solution to

homogeny was very simple we segmented

the output space and then used wfc to

fill in details

so in this case this very simple example

we've segmented this map into three high

level chunks and each of them is filled

with a wfc input with different

character so this produces a

high level

graph that's more interesting than a

homogeneous output and then the

interiors that interior detailing which

can be quite difficult to get with uh

standard procedural techniques can be

highly varied because you can pick from

a big library of 500 templates you made

in ms paint and get some really

interesting complex output

how do we deal with overfitting the

solution to overfitting was pretty

simple which was to use the output of

wsc in order to generate high level wall

structure and then use a post-processing

pass to generate the more detailed uh

more detailed things like doors and

furniture you can imagine a bunch of

ways to do this i'm going to show you

one of the full run throughs that we did

we did to get a level in caves of cod

so here's a real simple example first we

pick some segmentation in this case

we're going to pick a big circle in the

middle middle of the map

where they're going to run a wfc

template to fill the whole map up

in this case we're just going to run a

set of buildings

we're going to cookie cutter that circle

out and our we are left with some walls

you can see that

this has created some disjoint rooms and

so what we do is we simply

segment this map we figure out which are

the disconnected spaces and then we a

star from segment to segment anywhere we

pop through a wall we're going to place

a door so you can see in this case we're

a-starring here you've got a little red

cross where the door is punched and we

do it

again

and again

and again

and again

and once that's done

we are able to build a whole map which

looks pretty complicated but you can see

now that there's there's very little

going on right we've we've done a top

level segmentation we've filled in the

details with wfc and we've punched some

doors with a pretty simple a-star and

that's

the output is pretty complex so let's

revisit

the initial maps

which looked complex before but let's

think about how we did these these are

each accomplished through the exact same

technique in this case we've got a

couple square areas that were filled

with rectilinear wfc output that's it

you get this cool looking palace

here we have a full map that's been

allowed to run we had a tiny little

corridor wfc it's maybe eight by eight

we let it just run out across the whole

map then we flood fill in some of the

edges with with dirt so this looks like

a buried

buried set of goalies

here we've just got a circle and a

square output that been filled with real

simple labyrinthine wfc

and here we have a big square at the top

that's been filled with wfc output and a

big square at the bottom which has been

filled with wfc output and that's it and

you get this cool little village right

pretty simple so

there are some really good papers in the

wild

isaac karth has written a good one

called wfc is constraint solving the

wild if you want to go

really deep down into how the algorithm

works you can go uh grab that the

repository is a really excellent

resource unlike a lot of reports

repositories it's really excellently

documented it's got source code in

30 different languages because as you

can see it's like a super easy technique

and a super powerful one and so it's

very easy to plug into your project and

go

and that is it i'm brian buckler that

was wfc

do i have

yeah if you have questions come to

mike's happy to answer

so

how did you deal with

communicating the algorithm to

like uh people who are more used to

traditional level design tools uh or

more traditional uh procedural

generation

uh

approaches which tend to work on like

kind of room chunks or things like that

where there's discrete combat spaces or

discrete uh spaces for different

gameplay styles yeah the question is how

would i how would i communicate that to

them or how would you yeah how how did

working with how did working with design

people from that background work out for

you yeah well our team is so the

question is how did it work out working

with people who are

more interested in discrete level design

and the answer is we have no none of

those people on the team

how did it go with you

well i mean this this was a big uh

challenge for counter spy because we

ended up doing room by room chunking

because that was easy to build out

spaces and have combat ai work in it but

yeah if i can take that question to an

adjacent space i think there's a

tendency to want to have a little bit

more control ability from a designer's

perspective these

in caves of code we let our generative

systems run really wild and it's part of

the aesthetic of the game and we can

lean into it um and you can see we do

things like we just smash outputs on top

of each other but because our game is

about runes that have been smashed out

on top of each other that's great um

i think that i think that

the when you get into the design space

where you want more control the

tendencies to move more towards prefabs

which designers have control over so you

want to lean into like the tile based

techniques in order to put fit those

prefabs together and then allow the

designators to design spaces that

can work within a particular bound right

so within this prefab this area can be

filled in this knuckle so so if i'm

following you you're suggesting maybe uh

when you're doing the spatial

partitioning uh step you can do some of

that wfc step to do the kind of broad

strokes and then chunk down uh prefabs

into the appropriate size spaces yeah i

would actually say probably the tile

based uh

portion of wfc which i didn't talk about

is probably more interesting than those

teams that gets a little bit more

controllability to that out thank you

sure

did you try building any constraints

into the wave function collapse

algorithm itself like no repeating tiles

in this

region or anything like that because

i've experimented with that with some

other

implementations of this and ran into

quite a few problems yeah the the

question was did we build any additional

constraints on top of wfc um the answer

is no because i tried it and i ran into

a bunch of problems

max is is a cool guy and very

knowledgeable obviously since he created

and if you have a specific question

about constraint building i would

actually hit him up on twitter and and

ask because he's helpful but

i i didn't have time to push past those

problems in this case and we were able

to get really good output without any

kind of complex

constraint additions i would say there's

a great c sharp library on github by guy

boris the brave or whatever i think it's

linked within that repository works

great inside unity yeah awesome

great talk um i had a question did you

ever try having like a more detailed uh

training set to be able to have more

permutations of different sort of

adjacent materials yeah it's really

tricky because the reality is that those

bigger training sets like the temple

really you can reduce those um

quite a bit and still get similar output

um those bigger

bigger sets

unless they're very complicated tend to

just start repeating the same patterns

and so a good train because as your

training set gets bigger the memory

impact and the cpu impact of the of the

collapse gets bigger

it tends to be best just to try to

figure out exactly what the character is

and pack it into as small as spaces as

possible for actual production right um

so i meant sort of when um when you have

like so when you had multiple colors

colors you got the repeating patterns

right yeah so uh by having maybe a

bigger training set maybe you could have

more permutations of colors adjacent to

each other to sort of still be able to

get the detail but oh yeah could you

work around overfitting by by having a

bunch of them with different colors yeah

i think you probably could i haven't

really experimented with it but i mean

that would that would certainly be an

effective use of it i think something to

experiment with

any other questions

no okay well thank you