Generated on the Website: Merak Map Maker

During stumbling or falling, there are no keyframed animations anywhere, they are not even blended in.

When a character gets hit or experiences any form of physical force, the body behaves like a fully simulated physical puppet. Balance controller then calculates where to put each feet and how stiff each joint should be based on the momentum of the body and which way it goes. All of it is computed in real time.

It’s my take on the kind of physics euphoria by natural motions brought to gta and rdr games, thus the chosen name, despair physics. It will be one of the core mechanics in my upcoming fps prototype called "Upper Management".

If you are interested in where this ends up, best place to follow is my official site and a mailing list.

I'm a solo dev making Seedborne Chronicle, a free-roaming guild RPG in the spirit of Lunatic Dawn IV: you wander, take jobs, make friends and pass your guild on.

You type a seed and a continent grows from it: the land and its coasts, 8 towns, 14 labyrinths and 28 adventurers with their own homes and stats.

The first version ran in the browser. When I moved it to Godot 4, I kept tests that compare the new generator with the browser build's output for four seeds, so the same seed still grows the same continent, down to the coastline.

The coastlines were the ugly part. Shores followed the tile grid, so water sat in steps wherever the height changed. Now the ground is one heightfield sampled three times per tile: the shoreline falls where land meets water, beaches slope into the sea, and grass, rock and snow blend at their edges. Images 2 and 3 are the same seed from the same camera, before and after.

How do you keep a seeded world stable while you keep adding features to the generator?

Image descriptions (in gallery order):

1. The Godot build's continent for the same seed: the same coastline, lakes and peaks, now with low-poly trees, towns and soft terrain.

2. Before: a lake next to the first town follows the square tile grid, with stepped square corners.

3. After, same camera: the lake has a curved shoreline with a sandy beach sloping into the water.

4. Eight continents from eight random seeds: islands, twin continents, a crescent bay and single landmasses.

Hey guys!
I made a world generator that runs entirely out of your command prompt/terminal for my indie game CultGame. It's like like Dwarf Fortress-lite means South Park.

The world generation works by seeing a 2D map of ocean tiles with volcanic activity and then additively generating tiles near the continent starting points (the @ signs) with a chance to randomly generate a land tile anywhere to add some chaos and variance. Tiles have a higher chance of becoming land tiles the more land tiles adjacent to them.

Once all the land tiles are decided, I used latitudes, nearness to water, and random chance to start generating terrains everywhere. Once a few terrains start generating, nearness to existing terrains also plays into the generation of new terrains on tiles that are undecided.

Hope you enjoy!

You can check out the game this is from, CultGame, here: https://store.steampowered.com/app/2345980/CultGame/

I’ve been working on this for a while and finally put it online: https://astrolume.ableproman.hu

It’s an endless map of single stars generated from a seed. Open a star and you get a rendered sphere on the left and a long list on the right with everything computed about it: mass, radius, temperature, luminosity, spectrum, rotation, age, how it will end, the habitable zone, and numbers for a planet at 1 AU such as the starlight it would get and how big the star would look.

How the generation works:

• The map is cut into chunks, and each chunk is generated on demand from the seed and its coordinates, so the same seed always gives the same stars. No star data is stored or downloaded, since each star is computed on your machine.
• Each star gets a population (thin disk, thick disk or halo), a mass from an initial mass function (Kroupa 2001), an age and a metallicity, and an analytic evolution track decides what it has become: a main-sequence dwarf, a giant, a white dwarf, a brown dwarf, a pulsating variable and so on.
• Everything else is derived from those. Temperature and luminosity come from the track, colour from a published calibration table, the spectrum from a blackbody with the main absorption lines, and the surface look (granulation, spots, gravity darkening) from rotation and activity.
• The sphere is rendered live in WebGL, and the whole app is one HTML file with no libraries.

Where a published relation exists I used it instead of putting false data, and rows that are rougher estimates are marked with an approximate sign. The only real star is the Sun, which sits at the origin with its measured values. Binaries, neutron stars and black holes aren’t in yet.

There’s also a compare mode that puts two stars side by side at true scale, so a red giant next to a white dwarf shows just how big the difference is.

I’d be glad to hear what looks wrong, especially from anyone who knows stellar physics better than I do.

My mobile game has no audio files: the whole soundtrack is a gayageum (Korean 12-string silk zither) generated at runtime. I wrote up how it works, with a demo you can play in the browser (same code as the game):

https://boreumdal.app/devlog/gayageum/

The procedural parts:

The string. Karplus-Strong with a fractional-delay allpass for tuning. The "silk" tone comes from shaping the excitation: the noise burst is smoothed twice, then comb-filtered at 1/7 of the loop to imitate the pluck position. Each string is baked once from a fixed seed, so the same string always sounds the same.

The composer. It writes 12-beat phrases in a five-note mode (pyeongjo):

• each note moves one or two steps from the previous one, inside two octaves
• long notes get vibrato; short notes landing on one particular degree sometimes get a bend up to the next
• every phrase comes to rest on the 1st or 4th degree so it sounds finished
• a low string drones every three beats
• if a new phrase has the same shape as any phrase from the last 60 seconds, it's thrown away and rewritten (up to 8 tries)

Density and tempo follow the game state (76 to 102 BPM as you survive longer), and endless mode shifts the register through day, dusk, night and dawn.

The visuals are generated too (ink brush strokes with tapering, bleed and dry-brush streaks drawn on Canvas 2D), so the game ships without image files either; the iOS app is 13 MB. Happy to go into any part of it.

more detail here: https://github.com/BaramiDev/MineAssembly/blob/main/docs/HOW_IT_WORKS.md

rough idea: - six noise fields (continentalness, erosion, temperature, humidity, peaks/valleys, hills) sampled every 4 blocks and lerped - height comes from the continuous values, not the biome id, so you don't get cliffs at biome borders - rivers follow the zero line of their own fbm. a wide band flattens the land toward water level and a narrow one digs the channel, in mountains you get gorges - biomes are a few rules (ocean/mountain/swamp/beach) + a temp x humidity table - caves: spaghetti where two 3d noises are both near zero, bigger caverns where a third one is high, lava below y=10 - trees that cross chunk borders: each chunk replays its neighbours' tree spots so all the worker threads agree

textures and sounds are generated too, there's no asset files at all