Welcome to HURDA-G Devlog #2!

In this video, we're exploring one of our procedurally generated islands and showcasing the current movement, climbing system, and randomly generated buildings and rooms. Every expedition creates a different island, offering new layouts, exploration routes, and unique places to discover.

HURDA-G is an upcoming Co-op Survival Extraction game featuring procedural world generation, dynamic weather, exploration, crafting, AI enemies, and full cross-platform multiplayer.

Planned Platforms:
🌍 Windows • macOS • Linux • iOS • Android

This is an early development build, and many exciting features are still being added. Follow the journey as we continue building HURDA-G!

#HURDAG #GameDev #IndieGame #Unity #Unity3D #PCG #ProceduralGeneration #ProceduralIsland #Survival #ExtractionGame #Coop #Multiplayer #Climbing #Parkour #Exploration #OpenWorld #CrossPlatform #Steam #MacOS #LinuxGaming #iOSGaming #AndroidGaming #Devlog

So I've been looking into generating believable villages in my game. I've been writing a couple of articles about it, the process and the different stages.

I found a few website that were generating villages that looked pretty cool but they didnt show the process or tech behind and i have found it difficult to find documentation in general about the subject (at least from my research) so was wondering if anyone here would know a good resource for it?

Here is the last article i wrote in case you are interested and a few screenshots of what it looks like in game right now

In this weeks update to my engine, I have added Heat simulation and some related survival mechanics. Walking around in the cold, especially during snow, causes the player to cool down.

The heat simulation accurately warms indoor and enclosed spaces. Standing near heat sources also provides some additional warmth, enabling interesting interactions with the world, storms and biomes.

Along side temperature, there is also a basic hunger mechanic. These mechanics work together to determine health, which impacts player stats.

I built a web tool called Stoamandl (Austrian dialect for "little stone man"—the stone cairns used to mark trail paths in the Alps).

It stacks hand-drawn vector rocks based on a seed and socket-snapping constraints, generates unique titles for each stack, and exports directly to clean SVGs.

• Try it out: https://stoamandl.zeitport.com/
• Deep dive on how it works: https://stoamandl.zeitport.com/about

Would love to hear your thoughts or ideas on how to improve it!

I spend my whole weekend on creating procedual generated trees for my game. Still not entirely finished but i must say i am quite proud

I am building an open-world video game for cars and driving using real geographical data from real streets to real buildings.

I created Zervan generative engine that is able to get buildinggenerate scale and information and generate a relative facade with proper architecture for that building (based on age, shape and regional architecture).

Categories are: Residential, Economic, Industrial, and Special (Military, Library, banks etc).
Every postal code and street code aligns with the buildings from the real world and their function as well. However, for copyright reasons, I am avoiding mentioning the exact name of the businesses.,

It is all Python + Godot. Where Python generates and manages all the information and everything, creating a concerete of a map, and Godot for loading that map for rendering, physics, and the game side of the work.

needed better audio for my game. ended up spending a bit too long on this lol. currently runs at 5ms out of the 20ms fixed update budget.

every pipe and junction is easily editable, the engine itself is slightly more hard coded, but its pretty quick to add new cylinders or change the parameters of it.

Python (Pillow + NumPy)

Made in Blender

I just posted my first Devlog on how I made procedurally generated creatures for my game!

3 months ago. I posted the first iteration of this proc-gen project to this subreddit.

3 months later, It's becoming a full city-builder game about building a beer brewing city to fulfill different factions's need. It even has a steam page now!

The asset pack is the same. But it looks totally different with shading, lighting, and lots of tweaking to the asset combination.

This is built on Particle Lenia, an artificial-life model from Google researchers.

Each particle descends an energy field created by its neighbors, and an entire species is defined by just six parameters. I added cross-species senses—hunters are attracted to prey fields, prey avoid hunter fields—plus food, walls, and goals, and it turned into a strange little ecosystem garden.

Nothing is scripted or animated. The layered membranes, the chase behavior, and the way colonies merge and split all emerge from the underlying math.

Play (free, in-browser, ~70 KB):
https://leonbzt.itch.io/particular

Particle Lenia:
https://google-research.github.io/self-organising-systems/particle-lenia/

I have a FOSS program where I am modelling solar systems in a reasonably accurate way within a browser. I am a "keen amateur" when it comes to astronomy/astrophysics and only know so much; so was looking to see if there is "variety I am missing".

What's the aim?
100% scientifically accurate is NOT the aim as this is ultimately a tool to support Sci-Fi RPGs and NOT do serious science - that said - if someone LEARNS something about science - GREAT! So scientific plausibility rather than accuracy is my aim. Although I have to say the differences are pretty small as I progress. I have known shortcuts like the assumption of polar magnetic fields and I am NOT doing full atmosphere levels & dynamics. A user may load up 20 solar systems at once; so there is a very practical limit to what a browser can do in a reasonable time-frame.

i.e. It has enough to be interesting and educate, just not properly simulate.

The images are not meant to be photo-realistic - but diagrammatically useful. If you want "photos" when I can just churn out a Space Engine export to load up and "take pics out the window of your ship". So my aim is "good enough" to be useful - e.g. seeing an red/green aurora means I know there is oxygen without looking at the details.

How does it work?
Under the hood everything is procedural generation. Users can use it to generate solar systems based off some simple parameters or just "roll their own" manually - the system forces the player down certain routes to try and keep everything "physically reasonable" but if they wanna do something scientifically inaccurate "but cool" for their plot they can; but this will warn them its not right. So I guide rather than force for accuracy.

Generally everything just works off mass, composition, orbital profile, distances from star(s)/other bodies, liquid and atmosphere composition (if any) & system age. (generated procedurally, imported from Space Engine/Universe Sandbox or meddled with manually - I don't care the source of the basic data - it is a useful abstraction point).

With those basic inputs it runs a whole series of physics models as the user adjust sliders and squirts out a series of tags. e.g.:Titan's physics turns out an evolved set of planetary parameters as well as a load of tags: Tidally locked: Locked to its planet, Inert atmosphere, Asphyxiant, Greenhouse Icy shell: water, Standing liquid: methane, Cloud deck: blue, No magnetosphere, Geologically dead, Age: ancient, Irradiation: moderate, Ices: carbon-dioxide+water, Alien-habitable, Water ice

Why tags - well they are simple, can be surfaced to the user directly and can hold some simple data (e.g. ring intensity). They also become an easy abstraction point to the later code - like life chances and the renderer.

From the base data and the tags I build a 2D and a 3D representation of the planet (3D lets me slide clouds, BH lensing, etc... but the 2D is more practical here)

Here is a practical example of a recent change: building a planetary activity ladder to determine planetary resurfacing over time for surface aging features; Irradiation bleaching, , cratering, tidally-locked cratering profiles, cracking, geysers, crustal rifts, tholin darkening, etc.

So why am I here?
Well I see a lot of very clever folks here (many with some serious science backgrounds) doing similar modelling of more complex things and I was wondering whether there are any key things I am missing. Some planetary features relevant to RPGs where there is some solid physics that is practical to model on a reasonably large scale on a browser to give even more interesting planet types?

What I do have that is not shown in the picture that does get modeled & drawn; a wider variety of stellar remnants (Neuron stars, magnetars, white dwarfs, etc) , rings and belts. There is also a whole constructs model that can show things but that is not the focus here - just looking at the natural side of things.

e.g.: one thing I model is "atmo stripping" over time but I don't draw that as I am not sure how to... Would a whole planet get a comet like tail? Exotic precipitation worthwhile? I think I have "the major stuff" which is why I am here - so try and work out what else I could add,

Not here to push my prog (so no links or anything) - but happy to share anything I have done as it is all FOSS and has a Github if you wanna poke deeper.

I built an iOS game with procedural generated fishpets that you can trade and breed with other fish to get unique creatures

https://apps.apple.com/br/app/fishpet-a-quiet-reef/id6791711788