AshvinP wrote: ↑Tue Feb 03, 2026 1:06 pm
One thing I kept thinking about when watching was: instead of recapitulating the medieval stage of the intellectual soul and its factionizing tendencies (which of course still carry into our time), what if there was a Minecraft experiment that prefigured the late stage consciousness soul in preparation for the sixth PA epoch of universal brotherly love?
I often think about such questions, because I believe that such potential interactive experiences could evoke valuable intuitions. For the moment, however, I have only the most vague ideas
One thing that I believe should be somehow employed is that the focus should be moved beyond the local Newtonian mechanics. Here's what I mean.
If we imagine a dungeon crawler game, it can be said that most of the gameplay takes shape through interactions that affect a small vicinity of the game state. For example, our movement is constrained by the most immediate geometry of the cave, we're threatened by the enemies close to us, and so on. Even though the game loop may be simulating processes across the whole game world, they still affect each other based on geometric distance. Of course, in video games, there's no obstacle to having interactions that influence arbitrary variables of the game state. These variables are simply bytes in RAM, and as the name says (Random-Accessed Memory), we can read and write in any order (in contrast, for example, to magnetic tape that may need a lot of time rewinding back and forth until we reach the requested location). For example, if a player performs some kind of global magic, there's no problem affecting the health variables of
all entities across the world in a single game tick, regardless of differences between x, y, and z variables.
We can use Minecraft as an example again. The game worlds are not individually sculpted by human beings but are generated (known as procedurally generated). To understand this, we first need to note that in computing we use pseudo-random generators. These are simply iterative functions that return a wildly different number compared to the one provided as input. For example:
x
n+1=(x
n*17+23) mod 256
The 'mod' is modulus division and it leaves only the reminder, effectively ensuring that the number stays within the 0-255 range (what we can encode with 8 binary bits). So this is an 8-bit random generator, which, to be sure, is very bad in terms of the quality of randomness, but it serves OK as an educational example. Practical random generators have more sophisticated algorithms that ensure a much more unpredictable distribution of the returned numbers.
The initial number is often called the 'seed'. Clearly, starting with the same seed always produces the same sequence of numbers. This is exploited in procedurally generated content, because we can share a single number (in Minecraft the seed is a 64-bit integer), and assuming that the generation algorithm is the same, the exact same world will be generated.
Here we can see the algorithm in action. The left graph is simply the result of starting with the seed and iteratively feeding back the result to the function. The right graph shows how we can generate deterministically even more complicated data. In this case, we use a combination of the original seed with two x, y coordinates to produce a new seed that we feed to the function and get a random value. We can see how changing the master seed produces a completely different landscape. If I need to describe the bubble landscape over the phone, dictating all values one by one can take a lot of time. Instead, it is enough to give them the function and the master seed, and they can calculate the values for themselves at any point they want.
We can chain such functions in any way we want to produce deterministic random functions. If we take the bubble graph on the right and imagine interpolating the space in between the grid, we arrive at precisely what is accomplished, for example, through Perlin noise.
Here, black corresponds to a low value, white to high. Perlin noise doesn't prescribe what algorithm to use for the generation of the grid points, but only the method of interpolation.
We can also extend these techniques to more parameters. Just as we can deterministically fill an x-y grid with random points and interpolate them, so we can for a x-y-z grid.
This is at the base of how Minecraft's world generation works. The result of the random function is mapped in the range [-1; 1] (in the 8-bit example, 0 may become -1, 127 becomes 0, and 255 becomes 1), and we basically say: "Anything greater than zero is considered dense and we place a stone block. Anything less than zero is air." If we apply this logic to the basic Perlin noise above, we get something like:
Then, it is a matter of combining such functions in different ways. It's really a mathematical art. The end result is still a single function (called density function) that when provided with three numbers x, y, and z, gives us a number between -1 and 1. When we visualize it, we get something like:
And the cool thing is that all of this is completely deterministic, building upon the master seed. We can evaluate the function at any possible x, y, and z, and as long as we use the same function and seed, we'll get the same value. When we probe the function for a whole range of x, y, and z values, we generate the world. When we understand how these things work, it is very interesting to move about the world, especially in VR, and try to feel how we're amid the distribution of a mathematical function.
Such functions can be made of more than three parameters. For example, in the octant space animation, I use precisely 4D Perlin noise.
Here, 4D shouldn't cause any mysterious conceptions. It is merely a function that is commanded with four different parameters, four independent potentiometers. It is simply guaranteed that moving any of them will yield a smoothly varying output number. This allows us to assign three of the pots to x, y, z coordinates, while rotating the fourth parameter makes it look like the 3D distribution morphs. Thus, if we equate the fourth parameter t to the clock value, we get an animation. For any point in the octant space, the x, y, and z are fixed according to the place in the cube, while t is varied slowly. When we change it, all points need to be reevaluated with the same x,y,z, but the new t. Then we plot a blob with size proportional to the returned value at these x, y, z, and t (it is basically a 3D bubble plot). There's nothing special about the four parameters. We can use y, z, and t as grid coordinates, while varying x - it will look in the same way.
So, getting back to the main topic, I vaguely imagine a game where, unlike Minecraft where the world is generated once and then we only break or place blocks by local interactions, the generation parameters can be varied at any time, which regenerates the blocks, resulting in a smoothly morphing world (note that smoothly varying the master seed does not yield smoothly metamorphosing worlds).
The next step would be to imagine that there could be different levels of interaction. On a lower level, we crawl the dungeon locally. Our inputs vary the x, y, z variables of our character. On a higher level, our inputs influence the generation parameters, which have non-local effects (many world points are reevaluated once a parameter changes). The caveat, however, is that these parameters are simultaneously influenced by other players too (we can imagine that gaining access to these parameters requires some in-game skills, raising the character to a magician level). Thus, in a sense, we 'meet' with other players at the level of the generation parameters, even if our characters are in faraway parts of the map, and we push and pull, fighting to control the same potentiometer. Or we can work together to morph the world such that our lower-level crawling riverbed is morphed favorably for more players. There could be, of course, even other hyperparameters that the players can only slightly budge, but nevertheless rotate as if by the overlords' intents.
All of this remains a very vague idea at the moment. And to be honest, I avoid spending much time on it, because it very easily lapses into an attempt to find the perfect model of reality
. But in any case, I think that the game should have this gradient between local and non-local interactions. Otherwise, the sense would remain "Yes, we live in a purely material world ruled by local interactions, so the most we can do is to agree on a protocol of moral rules that ensure peace and brotherly relations."
Maybe one day something more concrete will come of these ideas, but we'll see
