I am relatively new to programming but am enthusiastic to learn. I am learning some rudimentary C++ and C# to use with simple creations in Unreal 5 and Unity.

I would like to learn about how I can create simple scenarios that generate themselves within certain parameters based on current and historical user input. Think something simple along the lines of The Oregon Trail, but with more branching paths that are generated randomly.

My goal is more or less to create a "tool" to generate (realistic) role-playing scenarios at random based on either custom input or randomly-selected variables (I'm in an office setting/I'm at a school/I'm in a mall/I'm working at a data center; it is September/October/December/whatever; we're in Maine/Texas/California/somewhere; there is an aggressive trespasser/shoplifter/active shooter/weirdo with a silly hat) for recipients to respond to.

What tools might I learn and use to accomplish this?

Hello everyone,

I'm developing a game and I'm currently stuck in a problem during my world generation process: I first generate a 512px x 512px height map of an island and then I want to let the player choose a start location. During gameplay, the actual chunks are generated and each pixel in the overworld should account for 32x32x32 blocks in the real world.

Here are some examples of the height maps generated and how they currently look in game: https://i.imgur.com/ST6YwyK.png https://i.imgur.com/fCgRY1K.png https://i.imgur.com/NdCd6WJ.png

Up until this point, I have been using the same noise functions but decreasing the frequency so that the noise appears scaled. This has some issues though. First of all, we loose a lot of detail. This can be somewhat worked around increasing the number of simplex noise octaves layered, but I'm not sure it's the best approach.

Worse than that, I started implementing biomes and other features that I want to be generated based on an analysis of the map. E.g., identifying coasts to generate beaches, using a unsigned distance field to be able to lookup the distance from the sea, finding local maxima to generate volcanoes, etc.

This analytic pass on the generated map seems incompatible with my current flow of generating chunks on the fly. It seems that I need to somehow upscale the initial generated maps.

I found this post describing an approach, but before diving too deep in this rabbit hole, I wanted to ask if anyone has other resources or ideas on how to solve this issue.

If anyone is interested, here's the repo for my game: https://github.com/stefandevai/ysamba

And here's the initial height map generation (the code is very dirty as I'm still experimenting with a lot of things): https://github.com/stefandevai/ysamba/blob/main/src/world/generators/island_generator.cpp

Thanks a lot in advance :)

I on a whim, thought about multiplying consecutive octaves of Perlin noise instead of adding them, and the results look quite interesting. It's as though it is an inversion, but more visually fractal like.
Both were generated on the same seed using unity built in Perlin noise functions.

https://preview.redd.it/027nc4vhdwuc1.png?width=1080&format=png&auto=webp&s=d9cc199a5ab411b4b143a2c049ae69cede0b8751

https://preview.redd.it/kke1t1vhdwuc1.png?width=1080&format=png&auto=webp&s=b1321713f065587402d43b11c4525f9c3d1a703e

Are there certain benefits to different types of noise, like Perlin and Open Simplex noise? I am working on procedural map generation for my 2d game but I want to code my own noise function (as a way to learn and understand the inner workings)?

After almost 30 hours, I have upgraded the github project from colordodge on github, to the modern version of threejs. I then integrated ldraw lego star wars shuttle into the code, and was even able to get other shuttle ships to fly at me. Labor of love. What do you guys think?

https://djbritt.github.io/star_wars_threejs_infinite_procedural_map_lego_shuttle/

https://preview.redd.it/7n9dyiwzuiuc1.png?width=1732&format=png&auto=webp&s=863d705a72eb579899c5310bfe2edc5be898c17a

Been working on procedural terrain using marching cubes, and decided to implement level of detail. This algorithm I found helps you to connect marching cubes chunks of different levels of detail. Pretty cool!

https://transvoxel.org/

Shaded view

Wireframe view

My procedural world is made of tiles determined by three noisemaps. Each biome has a min definition for each noisemap. Then I subtract the min definitions from the noisemap value at each tile and add those differences to get the “biome difference”. Then I iterate through my biomes to see which biome is closest to the tile or has smallest biome difference.

Now I’m trying to find out how biomey a tile is… how deep in the biome is the tile, if it’s right on the edge of the biome or nah.

Any ideas can’t find out how to adjust biome differences to see how deep the tile is..?

A Map Generation Tour

For anyone interested, a montage of procedurally generated maps, followed by a little walking around in them to show how they look up close. The game is still in a very early state (no combat in this video), but I wanted to share the recent progress on the surface map generator.

These maps use drunken walks, waypoints and paths, and a lot of cellular automata to produce these 100x100 tile terrain maps, most of which have interesting room layouts and sightlines for a roguelike that will (mostly) be about ranged combat!

This came about when I decided to go from a game that is about delving to the bottom of a dungeon to a more open-ended sandboxy kind of idea, in which the player roams the world. Each submap is based on the tile it is represented by in the overmap, which is also procedurally generated. I have created a variety of cave maps as well, but I thought this video is already pretty long so I'll post those down the road. Enjoy!

I'm struggling with making sure a level’s objectives, collectibles, and exits are fully walkable.

Here's a picture of a level my game can generate and my current solution.

The darkened tiles are debug data. They represent "blocked" tiles: an entity already spawned there and requested those tiles blocked. An entity blocks its own tiles and surrounding tiles. This clearly works -- it leaves walkable space around every entity -- but it generates very grid-like patterns. And looks boring.

(Ignore the two sections with barrels in consecutive tiles.)

The struggle is real. I've tried a few other simple ideas but they tend to quickly lead into corner cases. One such idea was create an "unbreakable path" for every room that allows walkable entities and leave all other space for "blocking" entities. How do you make sure a treasure chest, which would be blocking, is obtainable?

Do you just create whatever and throw out rooms whose contents and exits aren't pathable from everywhere? I remember reading something about Diablo 1's random level generator and how it was designed to toss out entire levels depending on pathing requirements.

Not sure if this is the best subreddit to post this in, but I figured I’d ask: what is the best known method for triangulating a Fibonacci sphere?

I know about the method for projecting points out onto a plane and then doing Delaunay Triangulation, but that doesn’t scale well as you increase the number of points.

There’s a paper I found that has a method with time complexity O(n*log(n)) but it’s from 1997, and I figure there’s gotta be some more recent work on this topic, right?

Anybody got any tips or pointers?

While I do have some experience with procedural generation. I'm uncertain how to handle incorporating linear story into procedurally generated progression. This means the game generates a random progression for the player to follow. But I'm not sure what I should do. Here are some of my inquiries, if anyone has more experience than me:

• Should world generation come after or before generating a progression dependency chart?
• How should I handle location-linked story events? A lot of story events can be forced to happen anywhere but what if I need them to happen in a specific place? The world won't always generate every possible 'biome' and town type so how can I handle those requirements?
• Should I define what locations connects to which through a graph? That seems incredibly useful to have for defining progression as to avoid forcing the player to travel locations very far away, making them only travel between immediate vicinities.
• Should story be held in a separate dependency tree from player progression? I had the idea of having the story tree be static and everything in-between the static story points be procedurally chosen.
• How to handle more open-world design, such as multiple possible pathways both in story and in player progression.

My current idea was to first generate the world, place each item and possible locations that may have requirements (such as a dungeon needing to be near a town.) and then generate a progression chart for items, making sure the player will always be in the vicinity of the next objective. The progression chart for the items then is used as the guide for the conditions to story events that will be integrated into part of the progression chart. But what do I know? Haha.