runevision,
@runevision@mastodon.gamedev.place avatar

I've quietly made my LayerProcGen framework public:
https://github.com/runevision/LayerProcGen

It's a framework (C#) that can be used to implement layer-based procedural generation that's infinite, deterministic and contextual.

Nobody else have tried/tested it yet - if you're up for taking it for a spin, let me know how it looks; what's clear or confusing, if you think there's low hanging fruit improvements I could make, etc.

Video of a mountainous terrain and visualizations of the kind of layer based generated data that's used to generate it.

runevision,
@runevision@mastodon.gamedev.place avatar

The value of layer-based generation is not just the implementation, but also a certain way to think about how to define spatial dependencies for large-scale generation.

I've put a lot of effort into the documentation and its illustrations (examples here), which explain the high level concepts of the framework as well as the details.
https://runevision.github.io/LayerProcGen/

A chunk in one layer requests data from another layer within its own world space bounds plus appropriate padding.
Pathfinding can be implemented to operate only within a maximum distance from the start-goal line segment in order to make the effect distance of the environment on the solution path be well-defined.
Each iteration of processing of input from another layer can increase the effect distance and thus the padding needed when requesting the data.

runevision,
@runevision@mastodon.gamedev.place avatar

Procedurally generated open-world games tend to use "the functional approach" which essentially requires embracing sandbox gameplay.

LayerProcGen points the way towards making open-world procedural games based on "the planning approach" instead, which is normally only seen in "finite space" games such as rogue-likes.
#ProcGen

jonikorpi,
@jonikorpi@mastodon.gamedev.place avatar

@runevision Finally ended up going through this proper, and realised I’ve taken basically the exact same approach! I just think of it as “cone-based” instead of “layer-based”, so I didn’t recognise it at first. :D Very happy to see someone write about this, and with such care!

runevision,
@runevision@mastodon.gamedev.place avatar

@jonikorpi Ah, cone-based as in the shape of the dependencies? Or maybe the shape of loaded data from consecutive layers? I’d love to hear more about your approach, possible differences, insights you’ve gained using it, what you’re using it for exactly etc. :) If you have time to tell about it sometime.

jonikorpi, (edited )
@jonikorpi@mastodon.gamedev.place avatar

@runevision It was for world generation. Each layer “zoomed out”, forming a kind of pyramid or cone if you rendered and spaced them out a little: just like many of your illustrations!

Managed to revive a bad old prototype. The “levels” on the right are the layers. Each hex depends on a group of closest hexes from the next layer. https://old-gamedev-experiments.pages.dev/worldgenerator/

scdollins,
@scdollins@genart.social avatar

@runevision For my PhD thesis, I created a multi-layered grid generating / caching system that you could think of as the dual of a quad-tree with the grid coordinates on the odd values rather than the evens. No two LODs share the same boundary which let me amortize updates across the different levels as you move. Also, objects of any scale would be fully contained in a single cell of some detail level. I didn't get around to implementing anything using the latter.

https://cs.brown.edu/people/sdollins/world/home.html

runevision,
@runevision@mastodon.gamedev.place avatar

@scdollins That's neat! I'm unsure though what this relates to? Did your system do anything based on a "planning approach"? Based on skimming your thesis it seems to be a classic "functional approach"?

scdollins,
@scdollins@genart.social avatar

@runevision I got a job offer and ran out of time, so I focused on implementing the functional terrain. Your implementation is much better fleshed out than mine would have been.

My idea was similar to yours in that coarse levels would place towns and the paths between them which would influence the terrain generation of the finer levels they overlap. Likewise, I intended to generate watersheds that would force the land to descend as needed.

Your implementation easily subsumes mine.

  • All
  • Subscribed
  • Moderated
  • Favorites
  • random
  • DreamBathrooms
  • mdbf
  • ethstaker
  • magazineikmin
  • cubers
  • rosin
  • thenastyranch
  • Youngstown
  • osvaldo12
  • slotface
  • khanakhh
  • kavyap
  • InstantRegret
  • Durango
  • JUstTest
  • everett
  • tacticalgear
  • modclub
  • anitta
  • cisconetworking
  • tester
  • ngwrru68w68
  • GTA5RPClips
  • normalnudes
  • megavids
  • Leos
  • provamag3
  • lostlight
  • All magazines