I was wondering how some procedurally generated games that generate the world on the fly save your progress. Specifically, how do they track where I've been as I explore the game world, what objects I've placed, what resources I harvested, and what structures have been generated. When I re-open the game later and load the world, how does it know that I placed this specific block in this specific place, and that I cut down this specific tree in this other place?

I imagine it's different based on the game, but I was curious about how it's done - does it just save everything about the generated parts of the world including what's there and what the player has done to it? Seems simple but also inefficient if the player travels through these generated sections without changing anything. Do some games just regenerate the area based on the seed but track what changes the player made to it? Are there other, more efficient ways to save this?

Here's three games that I've played that brought me to this question:

Minecraft: Minecraft generates chunks of 16x16 blocks as you explore the practically infinite world. Let's say I spawn in and build my base near the starting area, do some mining in the area, set up some farms. I then do some exploring and travel 500 blocks. I find a village there, loot some chests, and break some blocks. I travel another 500 blocks and chop down a single tree. I travel another 100 blocks and place down a crafting table, furnace, and a chest, then I place some items in said chest.

I have a feeling that Minecraft saves all the chunks I've already generated, since it takes way longer to render a chunk that has not been generated vs a chunk that was. But does it save the state of all blocks in that chunk, including the ones I placed and destroyed? Since each chunk is 16x16 blocks and if we say each chunk is about 100 blocks deep for simplicity, that's 25.6k blocks per chunk. Is all of that saved for every chunk that was generated in my journey, in addition to whatever I change? That seems like it will add up very quickly and make a massive save file.

Valheim: I'm pretty sure Valheim also generates as you explore, like Minecraft, but Valheim is not block based. Same kinda situation though, say I set up a base near the spawn, build a few buildings, sow a few carrots, and tame some boars. I then explore the world by sailing across the sea to the various boss locations. I stop in some places, cut down a tree or two to get some extra resources, loot a dungeon in the area, dig a hole, and then build a mini base and bed near the boss spawner.

The places I've been and the resources I've harvested don't regenerate or respawn as far as I am aware, so how does the game track that this specific tree has been harvested, or the resources in this specific dungeon have been looted? Or does it just save that Tree #1234 is at X, Y, Z for every single tree generated along the way?

No Man's Sky: Obviously different from the other two. I imagine it's not hard to at least store that "this star has x planets named a, b, c, and discovered by player z" in a big database. But what about when the player lands on a planet, explores some of the structures there and obtains the loot reward. Then they harvest some of the rare resources on the planet, and maybe build a small base on it. Maybe they also dig into the terrain to find a cave. How do these small things get saved such that if another player comes by and checks out the planet, will they see that someone has been there?

Not looking for a super technical explanation (though that would be cool too), just how these different games approach it at a high level. Also if there are other games that use procedural generation and have something interesting that they do, that's also welcome!

Ledgerbound is a 2026 video game made in Unity. At the very end of the game, after the credits, it's supposed to transition from a scene of a flag to the main menu. Instead, it stays on that flag scene.

The game has had 7 updates. The game getting stuck there is a known issue that they've acknowledged in the patch notes. The notes make it sound like they don't know what's causing this. This is the only place where the game fails to transition to another scene or menu.

To me, a person who has no idea how the game works, this feels like a thing that should take minutes to fix or work around. It's likely more complicated, or the devs are working on bugs that actually matter. I'm interested in hearing your thoughts too.

They usually get downvoted to 0, but I wanted to ask everyone before updating the Submission Guidelines.

Proposed rule:

• No posts about AI generated content or LLM coding systems. This subreddit is about curiosity and the craft of programming. There's plenty of other subreddits to discuss these topics, so take it there instead.
  

Edit: Ya'll have spoken! updating.

I've been looking into early 3D games like Duke Nukem 3D and Doom mainly out of curiosity.

I already know that build doesn't cast rays like doom does but instead transforms the wall end points into camera space and then interpolates between them to find the height at each column.

But i haven't found a way to figure out how to texture the walls. If you transform a screen coordinate back into camera space, it wouldn't account for the angle of the wall (or would it?).

Why did PS1 graphics looked so clunky and how where 3D graphics generally made prior to the graphical APIs. One thing I found out was that these older engines have something called fixed point math.

Hey everyone! I'm a design student doing an externship where I got to pitch a concept feature for BeReal, quick disclaimer, I'm not on the BeReal team; this is a student project, not an official feature (yet, who knows 👀).

The idea, called Abstract, is a fun new way to look back at your daily BeReal: instead of just a photo sitting in your memories, you'd have the option to turn it into a generated abstract art piece made from the photo's colors, not a filter on the picture itself, just its palette turned into something new. You could pin your favorite ones to your profile, comment on them, or even print one out as a keepsake from a day that mattered.

The goal was to give people a small reason to open the app again after posting, without turning BeReal into a game or adding any pressure, just one photo, once a day, the same as always.

I made a short video walking through how it'd work in the app and would genuinely love to know what actual BeReal users think, good or bad:

Google Questionnaire Link

https://forms.gle/T5HTAoYrTXsNV8YS6

Hello there, I'm still learning things as I go with openBOR, but I do have a question.

I know openBOR isn't specifically made to an isometric view/level designs, but is it possible do it?

Included Is a video of an isometric arcade game called "Dungeon magic" for an example of what I'm wondering is possible. And If so, are there any examples?

I was working on a project that required real-time mesh changes to simulate cutting etc. I couldn't find a solution at that time. Papers I dug into said it required a lot of compute. Some game devs I talked to said most of it were tricks that gave the appearance (eg animated meshes), and not actual changes.

The best I got was Teardown which simulates object destruction using voxels. It was hailed for technical achievement.

Today I just came across this game. Milling Machine Simulator.

It simulates material removal, cutting and hole creation etc. So it seems like compute is not the issue. Also, given it is basically free-form, it doesn't rely on tricks. And it doesn't seem to be doing what Teardown did.

Any idea how they did it?

EDIT: saw this one too VR Milling Machine VR Lathe Machine

Peak seems to generate 4 random levels each day, but they are always completable. Noita generated a new map for each run, and has the benefit of the player being able to modify terrain, but still needs to ensure the player isn't blocked from progressing downwards.

With Peak especially, being a 3d game with no terrain modification, how do they ensure a map is completable? (No necessary climb too high to progress past)

So I've been learning C and I'm actually a bit curious how they implemented it, Unity compiles stuff to CIL because it primarily runs C# scripts and AFAIK is programmed in C#, this makes sense because Microsoft provides tools to do this and it's in a virtual environment in it's runtime, a lot of engines use Lua, which turns into bytecode and is interpreted, this also makes sense because it's being put into essentially a runtime with completely virtual memory like C#. Now Unreal does Blueprint (if you use Blueprints) -> C++ -> Machine code. I have two questions:

- How does it actually look in the source code? Do they call the compiler and it magically gives them a function pointer to the machine code? (obviously isn't this simple but you get what I'm asking)

- How does that look under the hood? How does Unreal know that what it's about to execute won't cause an error in the rest of the program/whatever other user-defined code is running on that thread? Even the best compiler can't account for every possible error

Here is a link to the video: https://www.youtube.com/watch?v=FhMj5HGVGSA

Relevant timestamp is 5:53, here is a link to that time stamp - https://youtu.be/FhMj5HGVGSA?si=3oNLsW-Y6jyyJeww&t=353

It showcases units running and jumping off of walls. He doesn't actually talk about what he did in the video, except that he implied didn't use nav-links. He also has vertical nav meshes.

My guess is actually that he is using nav-links, but just generating a ton of them all over automatically, possibly using the movement code itself to determine values? And then maybe when the units are close to the player, they use some other AI entirely for jumping and such? (e.g., when on a wall within X distance of the player and you have line of sight, just jump at the player?).

I don't know though. I'd like to know! Please help.

I was trying to understand raster effects that stretch and compact images in old 2D games by searching the internet, watching youtube videos and ultimately even talking to Google Gemini, but it all just confused me. Whitepointer Gaming, Gamehut and Retro Game Mechanics youtube channels weren't enough.

Anyways, to the question:

tl;dr Are effects like Road Rash's hills and valleys, Axelay and Sonic 3D Blast's 3D effects done by skipping certain lines of the tilemap in certain sections, like instead of drawing lines 1,2,3,4,5,6,7 it draws lines 1,3,5,7? Or it uses vertical scroll faster in certain sections to overlay lines compacting them and scrolls slower to extend them?

And how can lines be added (like in Lawnmower Man), where do those lines come from? Gemini tells me they are repeated stripes.

I was designing a Roguelite (So mainly meta progression) Platformer of my own and wanted to know how games like Dead Cells created their level generating algorithms. I'm currently trying to find information on the topic so I know where it excels, what's the limit, how I should balance the flow of the level with scaling difficulty, essentially I want to break the algorithm down piece by piece to make a test algorithm so I can see how mechanics in my game would function in practice.

TLDR: How do I make an algorithm design the levels for my platformer? I'd love as much information as I can get.

I've been trying to do some research for a project I'm starting up and haven't been able to find a consensus online about it. Some people confidently state that it's an active rag doll, while others say that it's too smooth for that. Some say that it's just regular animations with a lot of IKs and dynamic bones.

There's something about it that feels uniquely "physics-y" if that makes any sense. You can slip off of inclines, bounce off of things, and there's a weight to movement that doesn't feel like it's just a stock unity character controller sliding forward.

Holding an item in your hands definitely gives off the impression of a spring joint with how it flops around with inertia and doesn't stay snapped to the center of your screen, but I don't know if this approach is used for the entire movement controller or just for holding items.

Clearly there's a toggle/state machine that ragdolls your character if you fall to far or are hit by something, but beyond that I don't know how it's done.

If anyone has any insights to share I'd be so happy

[Link to Itch]

I built a simple aquarium-style concept, during a slow period on-shift, based on my Elementary School Memory of an Ecological Balancing Concept, involving Wolves, Deer, and Berry Bushes, as Entities in a Forest, where each Student played a Role.

I don't remember much past wishing we spent more time exploring it in-class, and that my teacher didn't so quickly drive it to an unrecoverable state, to make the point he was trying to teach that day.

It started in Google AI Studio, as a Boxed-Step-By-Step process, more resembling the Conway's Game of Life, in some ways. But it wasn't what I was aiming for. So, that evening, I sat with Devin, and Claude, and a Game Engine in TS/Lua/YAML that I've been working on Demos within, and refined it into something more like a living Reef.

After some insights from a smaller audience, I refined it with a Main Menu, and some Basic Selections.
It has Sharks, Fish, and Algae Nodes, and the Sharks eat/bite the fish, causing Meat Chunks to appear.
The Meat Chunks can then decay, turning back into an Algae Core Node.
If an Algae Core Node is left without children for long enough, it can despawn.

Last I checked, it has a fair chance of staying in balance for up to 10 minutes, but it needs further refinement.
There are also depth layers now, and in theory, the Sharks prefer the Deeper Waters, and the Fish stay toward the Sun, so the Sharks tend to bury their head at the bottom to warm back up, but sometimes starve.

This was honestly the exploration of a concept, during a slow period on-shift, and turned into a deeper demo exploration. I had to literally spend hours playing with conceptual balance in order to achieve a 10 minute balance period, and I've not added a real simulation flowsheet system, where me and Claude can quickly check long-term results on a selection of Random Seeds. I only just added a Main Menu, but the concept still interests me, and somehow I ended up pivoting into a DinerSim, using similar logic in some small places.

Something about an Autonomous System that achieves balance, but still allows the User to nudge the system, like Pinball in some ways.

Musou games are games like Dynasty Warriors, Hyrule Warriors, Tears of Metal, etc. Where the player controls a general on a battlefield with sometimes hundreds of enemies on the screen at one time. They capture the feeling of being a nigh unstoppable god of war, cleaning through dozens of enemies in a few strikes.

I'm a solo indie dev trying to make a musou game, but im wondering the best ways to optimize enemies. Some ideas I've had include:

- create groups of enemies as one entity with one "brain" so instead of having a hundred enemies with a hundred scripts I've just got 20 scripts that control 5 enemies each.

- some alternative way of tracking collisions aside from just giving each individual enemy a collision shape. Maybe grid location based?

I haven't been able to find any info online about this so of anyone has some wisdom I'd love to hear it.

https://x.com/i/status/2080592057014555081

Obviously, if Coinbase has an internal system for scheduling calls with their support agents, they’re able to know whether a call is happening with a given customer at a given point. But how are they detecting that the customer is on the phone with someone potentially trying to spoof Coinbase?

I assume there are some Android or iPhone permissions for contacts, call data, or the current call. But what are they actually checking? Are they checking whether the caller ID matches Coinbase’s, or whether the phone number matches Coinbase’s? If phone numbers can be spoofed?

Hi all. I'm trying to find out how raycasting works — like in Wolfenstein 3D.

And as someone who knows absolutely nothing about programming, I (think I) understand it is thusly:

Raycasting is a programming trick that grants 2D maps a fake 3D appearance through the use of invisible rays that project outward from the player and detect collision.

Corrections to my nonsense would be appreciated!

I am currently writing an article, and I would like a layman's understanding before I commit to anything in there.

How did they make the graphic of Need for speed rivals so visually pleasing in 2013 w less than 8 gb of ram, meanwhile re9 while extremely good looking requires 16 gb of ram just to even run at the lowest settings. please do not give me the “ optimization ”. assume I’m relatively new to game dev, (only made a 2d game).

Did they just used a lot of raycasts or some kind of 3d shadowcasting algorithm?