like in videogames out of bounds of the map, the void space is infinite? a loop?
In: 0
It’s… nothing. That’s what void means.
In a game, the program has to track your position somehow and, if implemented incorrectly, will have checks to make sure you don’t go beyond the bounds of the map.
But games aren’t always coded perfectly, so if you managed to go beyond the bounds of the map then you’d theoretically go on “forever” however the numbers it uses to track your position have a maximum and minimum size. Once you go beyond those limits, it’ll loop back around. But charges are the game would crash or become unplayable before you reached those limits.
If you don’t add any boundaries, then it depends.
Usually we use floating point values, where the absolute limit is an absolutely huge number, but not infinity. If we use a typical number type, write a 1, followed by 308 zeroes. That’s the sort of number we’re talking about.
The problem is, the further from the centre you go, the more you start to lose precision. When you get to a light-year away from the centre, you can’t represent distances smaller than a metre with any accuracy.
In practice we’ll add a boundary at an arbitrary distance.
That depends on how it is implemented by a programmer.
If the coordinates are represented by *integers*, then the space goes on for about 2 billion “minimal distances” in every direction. How long is minimal distance? That is decided by a programmer. After you reach the end – you’ll get instantly teleported to the opposite end, because integers wrap around (after the maximal value they loop back to the minimal value).
If the coordinates are represented as *floating point values*, then the space goes for about 300000000000000000000000000000000000000 “unit distances”. However, the distance between nearby points is not constant – near the origin it is 1/16millionth of the unit distance, but it become more and more sparse as you go away from the origin. If you go far enough, your character starts to “jitter”, as it now teleports between nearby points. Eventually, the grid becomes sparser than your walking speed – after that you can no longer move. But if you somehow would go further, you would eventually reach the final value – Infinity. Once you reach infinity, you can’t leave – as it is infinitely far away from everything else.
The ‘void’ is a section of the world where there’s literally no data there, no objects close by, nothing to render there. The default state is a void. It’s not something that needs to be programmed in, it’s the opposite.
Also, it might seem infinite, but technically it isn’t endless, it’s limited by computer arithmetic, memory, and/or diskspace, you can only go so far in it and only fill it with so many things.
Cool thought by the way, it’s things like this that inspired Tron.
A 3D game is just a program that does a bunch of fancy math to figure out the coordinates of triangles in 3D space.
It then tells the GPU to do a bunch more fancy math to figure out the 2D coordinates of the triangles on the screen. There are some tricks to throw out triangles that aren’t in view of the in-game camera, and deal with cases where a triangle overlaps another triangle further away.
If the in-game camera is looking at a place where the game hasn’t calculated any triangles would be in its field of view, what you see is…whatever the game told the GPU to draw before drawing the triangles. That could be just a simple color like black or grey, or it could be some kind of sky effect.
Some games have a big box of very far away, very big triangles with distant scenes on them. In other words, the sky in a game is often just a cube of movie screens showing whatever the game’s sky effect is. In some games the cube is locked to the player, in others it could just be fixed in space. If you put the camera outside the cube, pointing further into space, again, you see…probably just black or grey.
I should also mention rounding issues. If you want to calculate 1/3, your calculator will tell you it’s 0.33333333, but a mathematician will tell you this is technically a wrong answer; the calculator’s rounded away the remaining 0.0000000033333333… because 8 decimal places is good enough for almost all purposes, and the calculator doesn’t have an infinite amount of memory.
The fancy 3D math in games rounds, just like your calculator. This means the math is always wrong but the wrongness is usually so small as to be unnoticeable. But for technical reasons, the wrongness becomes more noticeable with larger numbers. So when the player / camera is *very far away* from the origin, the math is wrong enough that you will notice: Game systems start to behave in janky, buggy, broken or downright weird ways. The developer never intended this stuff to occur, it’s just what happens because of rounding when you feed very large numbers into the specific calculations done by a particular game.
Rounding is the cause of the infamous [Far Lands](https://en.wikipedia.org/wiki/Far_Lands_or_Bust) in older versions of Minecraft.
Latest Answers