On "dynamism" and offline.
I posted this on the old thread; it's my personal answer to claims that offline wouldn't work due to being too complex, or that it couldn't as "rich" and "dynamic" as the online galaxy (whose "richness" and "dynamism" we have yet to experience, by the way, in my opinion).
I think it's worth reposting it here for ease of quoting; please excuse the inconvenience.
Long post warning.
Conclusions and TL;DR at the bottom.
(DISCLAIMER - I bear no malice towards Frontier or any Frontier employee, my intention is not to harass or insult anyone, and even less to cause harm; I'd just like the truth to come out; I apologise in advance for any offense I might unintentionally cause)
I've been thinking about this whole DYNAMIC™ nonsense.
First of all, it doesn't make sense.
We have, what, a couple hundred thousand players, at best... let's say a million players, for the sake of argument... in a 400,000,000,000 star galaxy. That's 400,000 stars per player, in the best of cases.
OK, OK, so they're not all inhabited (by humanity, at least); fine then, how many are? A couple hundred thousand, I hear? Let's say one hundred thousand, again, to get the best possible result for the sake of argument.
So we have, at best, 10 players per inhabited star (assuming no one takes off exploring the other 399,999 uninhabited ones that would correspond to them, of course).
Fine then... how many NPCs do we have per inhabited star? Let's assume one million, on average (which probably wouldn't be economically and politically sustainable, but again, we're picking best cases for the sake of argument).
So, if we take this numbers, we have one hundred thousand NPCs per player. We're not the one per cent, we are the one per one hundred thousand (or more realistically, one in a million).
Not only that, but the whole Elite concept (if there's anything left of that) and Frontier themselves tell us that players won't be the kind of people who influence things on the grand scale. We're not potentates, presidents, kings, or crime lords. We're regular joes. We're truckers, mercenaries, small crooks, petty criminals. We're anything but influential. Many of us will have less effect on the galaxy's society and economy than they have in real life. We can't even gang up or organize, we won't have EVE-style guilds or associations, Elite is everyone out for themselves.
Player influence on galactic economy and politics makes no sense. It's a mathematical impossibility. Marketspeak. Hogwash.
Elite: Dangerous, except for combat, is, like all previous Elite games, a single player game, by sheer mathematical imperative.
But that doesn't mean we can't have a changing, evolving, and interesting galaxy.
We know the galaxy is procedurally generated.
To clarify for anyone who doesn't know, this basically means that you take a basic seed, shared by all players so that we all get the same results, feed it into a pseudorandom number generator (which generates sequences that look as random as possible, yet are deterministic), and use the results to generate every entity on the galaxy whenever they are needed (the whole point of procedural generation is to exchange processing power for storage space, generating entities as needed and discarding them after use).
For instance (this is probably not the exact process the game uses, but it's intended as an example of the kind of process it uses), when you want to generate a star system, you feed your coordinates and the seed to a system generation algorithm (the famous "stellar forge") which generates the list of objects in the system. For each object that probably means type (G class star, rocky planet, ice moon, orbis space station, ice ring, whatever), parent (what it orbits), second focal point in the orbit (the first one is the parent), direction of orbit, starting angle of the orbit (I'm quite certain Kepler's third law means you don't need to specify orbital period), plus a seed/ID that can be fed to subsequent algorithms.
For our hypothetical system that'd give us a primary star, and maybe some secondary stars orbiting it and each other, some planets and rings orbiting them, moons and rings orbiting the planets, and stations orbiting the moons and planets.
For each of those entities, you can then get their seed/id and type (when you need to because you're close enough to see them), feed them to the appropriate algorithm for their type, and generate the physical model for the object.
This process can be repeated ad infinitum. For instance, for stations, you might generate a rough model for when you're far away, with a list of subcomponents (inertial rings and whatnot) and, once you get close enough, generate details for those objects (up to the point, once we can walk inside stations, of generating details for a specific barn in a specific section in a specific inertial ring... but not for all other barns that are too far away for you to see).
That doesn't only work for physical characteristics, either; the same way you can generate a planet's surface you can generate a station's list of market goods, or list of missions.
Of course, all this can be overridden. We have a list of stars taken from stellar catalogues, for instance. If your coordinates coincide with one on the list, you simply use that stored data to generate the system, instead of the stellar forge (you might still use it to generate the rest of the entities in the system, though, if we haven't yet found any exoplanets there or if we suspect there might be more).
For certain systems, like Sol, you'll even override the planets, moons, rings and stations.
All this can be done in a run-of-the-mill PC. Frontier: Elite 2 did it (with less detail, obviously) in an Amiga over twenty years ago. Space Engine does it (with arguably more detail for stars and planets, but without stations and whatnot) for the entire universe. Limit Theory, a game not very dissimilar to this one but developed by a single person, will do it. Heck, I'm quite certain that the Elite: Dangerous client is already doing it (it would make no sense to be shuffling all this data over the network).
it gives us, however, a pretty static galaxy, one might assume at first look... but that needn't be so.
Take exploration, for instance... how do you handle that in a procedurally generated galaxy that can't be influenced by player action?
Simple, really... we define a starting date, or clock tick, and we subtract it from the current date, or clock tick (which can be server based so that everyone uses the same number regardless of timezones), and use the resulting number as a time-dependent (yet still deterministic) seed.
[UPDATE] - Some people might prefer a galaxy that only changes while they are playing, and not while the game is off; just use a counter that gets incremented only while the game is running instead of the date, then; there could even be an option in the configuration menu to switch between the two modes.
That means that after a certain pseudorandom amount of time a by default unexplored system might start to be generated as explored (you might even define various gradual stages of exploration between completely unknown and fully colonized). Take also into account the system's distance to "human space", and you get a gradually expanding civilization, at apparently random rates, in apparently random directions (all handled by your algorithm, though, so you still have full control of the rate and direction of expansion).
That also works for other possible effects, like famines, wars, and whatnot. Same way you can generate a high-contrast spotted pattern with a Perlin noise, you can generate relatively short periods of special circumstances amongst significantly longer periods of "business as usual").
You feed that into the mission generator, and you've got yourself a pretty dynamic looking galaxy.
And at basically the same cost as the static one.
But OK, let's forget all that, let's forget maths, let's forget that players are irrelevant in a sea of uncaring NPCs, let's skew the numbers and against all reason give players the power to influence the economy and politics and whatnot.
Does that mean we'll now need a server, that we can no longer do it on our regular PCs?
Let's see... let's generate a GUID as each entity's seed/id (that might be overkill, but we're arguing for the sake of argument anyway). Remember that even though you generate and discard entities on demand, the results (except those that we've made dependant on the date), including this GUID, will be the same every time any player generates the same entity, so IDs will still work even though the entities are procedurally generated.
Let's also make a database table, with the following columns: "entity GUID", "player GUID", "date" (or "clock tick"), "status", and, um... "target", let's say. We'll keep that serverside, for now.
What do we store there, then?
Let's start with player-driven exploration, for instance. We can still have the regular automatic one, or not, doesn't matter.
Let's see; a player arrives in a system. The stellar forge has flagged each entity in it as either explored or unexplored (that's the automatic exploration working).
The player detects the main star. The server looks at the table we made earlier, filters it by the star's GUID on the "entity GUID" column, and counts the results. If it gets none, the star was undiscovered.
The server then adds an entry to the table: Star GUID, Player GUID, current date, "explored" (you would store it as a binary flag, not as text, but you get what I mean, I hope), Player GUID.
Repeat for any other entity the player discovers in that location.
If the star had already been discovered, instead, the server could have filtered the results again by "player GUID", to see if that particular player already had data on the star.
When the player later sells this information, we can add another line with Star GUID, Player GUID, current date, "revealed" (or whatever), GUID of the faction the player sold the data to.
That table will (for now) grow every time a player discovers any stellar object, or sells that information. The server can then filter the table by "entity GUID" when it's generating the system and use the number of results to calculate the exploration status; for instance, if it's over a certain threshold, generate an Ocellus station, if over an even larger threshold generate a more permanent station type (maybe at various progressive states of construction), whatever.
You can even automatically start a war, if the system information has been sold at similar rates to two opposing factions. All this statuses will generate different market demands, which will generate different mission sets, as advertised by Frontier.
That can be then optimized by periodically cleaning up the table. Once you've got an Ocellus station there, you probably don't need to keep track of all the discovery information, the system is already discovered, let's get some space back and start tracking how many players trade with the system, or pirate it, or whatever, and base system growth on that. It would probably make more sense to put that in a separate table that didn't track individual players, but only growing systems.
Anyway, we now have an automatically (or not) expanding dynamic civilization that is heavily influenced by player exploration.
The same concept can be expanded further to other player interactions. A player affiliated to a certain faction killed an NPC affiliated with a certain other faction? Keep track of that and, once you have enough incidents, you might have a war going on. A player has depleted a certain stock from a certain market? Keep track of that, and you might eventually have a famine going on. The concept is basically the same, in any case.
The cost of this is, basically, a quickly growing (even with optimization and regular cleanups) table or set of tables, with the growth rate and total size directly dependant on the number of players.
This probably means that you'll have pretty hefty storage and processing requirements, quite probably beyond those of regular PCs.
If you are managing hundreds of thousands of players, that is.
This design doesn't depend on the number of players. It's certainly more "dynamic" the more players there are (and it needs much more resources), but it will still work equally well with a single player.
And, really, how much space would a single player need? Could it be handled by a single PC? How many systems will the average player discover over their whole time on the game? One thousand? Ten thousand at most? How many wars can they start, if any? How many lines can a single player really add to the table(s)?
We're probably talking megabytes, here, not even gigabytes.
Your regular PC should easily be able to handle that (without synchronizing with the online servers, of course, but we don't really need that, offline was supposed to be separate anyway; we could still get the Frontier-originated events, like Thargoids and whatnot as updates, though).
And that's disregarding the fact that the end result would be, both for single player and massive multiplayer, virtually indistinguishable from the automatically dynamic procedural galaxy I discussed earlier, which makes one question the need for all this fooling around with tables and player influence and other nonsense.
And, for those worried about people who play offline finding out the "secret stuff" before those who play online... since online and offline modes are independent, just give different seeds to each one (and, if you want, don't give Frontier-specific overrides to the offline mode). The code doesn't need to change. Just a single number.
So, in conclusion:
Now, I'm far from the most intelligent person I know. I know a little about coding (I somehow managed to get an engineering degree on computer stuff), but I've never coded professionally or even steadily. I have no significant coding experience. My capabilities, therefore, are undoubtedly way below those of the people who are making Elite: Dangerous.
Yet, in my ignorance, after a bit of thinking I've managed to come up with what looks like a design that would allow a game like this to work without problems and still fulfill Frontier's marketspeach.
I can have no doubt that the far more experienced minds at Frontier will have come up with much better, much more efficient designs.
Yet, somehow, they claim they failed to do so. :S
Now, I'm the first to call for Hanlon's razor to be used, but it's very difficult, if not outright impossible, to apply it to people who are clearly neither incompetent nor stupid.
Which, tragically, leaves us with only one possible explanation.
TL;DR: Frontier's excuses don't hold water; they make no sense; by any rational analysis, we are for some unknown reason (which I'd like to know) being given false or incomplete information.
Which, frankly, sucks.
I posted this on the old thread; it's my personal answer to claims that offline wouldn't work due to being too complex, or that it couldn't as "rich" and "dynamic" as the online galaxy (whose "richness" and "dynamism" we have yet to experience, by the way, in my opinion).
I think it's worth reposting it here for ease of quoting; please excuse the inconvenience.
Long post warning.
Conclusions and TL;DR at the bottom.
(DISCLAIMER - I bear no malice towards Frontier or any Frontier employee, my intention is not to harass or insult anyone, and even less to cause harm; I'd just like the truth to come out; I apologise in advance for any offense I might unintentionally cause)
I've been thinking about this whole DYNAMIC™ nonsense.
First of all, it doesn't make sense.
We have, what, a couple hundred thousand players, at best... let's say a million players, for the sake of argument... in a 400,000,000,000 star galaxy. That's 400,000 stars per player, in the best of cases.
OK, OK, so they're not all inhabited (by humanity, at least); fine then, how many are? A couple hundred thousand, I hear? Let's say one hundred thousand, again, to get the best possible result for the sake of argument.
So we have, at best, 10 players per inhabited star (assuming no one takes off exploring the other 399,999 uninhabited ones that would correspond to them, of course).
Fine then... how many NPCs do we have per inhabited star? Let's assume one million, on average (which probably wouldn't be economically and politically sustainable, but again, we're picking best cases for the sake of argument).
So, if we take this numbers, we have one hundred thousand NPCs per player. We're not the one per cent, we are the one per one hundred thousand (or more realistically, one in a million).
Not only that, but the whole Elite concept (if there's anything left of that) and Frontier themselves tell us that players won't be the kind of people who influence things on the grand scale. We're not potentates, presidents, kings, or crime lords. We're regular joes. We're truckers, mercenaries, small crooks, petty criminals. We're anything but influential. Many of us will have less effect on the galaxy's society and economy than they have in real life. We can't even gang up or organize, we won't have EVE-style guilds or associations, Elite is everyone out for themselves.
Player influence on galactic economy and politics makes no sense. It's a mathematical impossibility. Marketspeak. Hogwash.
Elite: Dangerous, except for combat, is, like all previous Elite games, a single player game, by sheer mathematical imperative.
But that doesn't mean we can't have a changing, evolving, and interesting galaxy.
We know the galaxy is procedurally generated.
To clarify for anyone who doesn't know, this basically means that you take a basic seed, shared by all players so that we all get the same results, feed it into a pseudorandom number generator (which generates sequences that look as random as possible, yet are deterministic), and use the results to generate every entity on the galaxy whenever they are needed (the whole point of procedural generation is to exchange processing power for storage space, generating entities as needed and discarding them after use).
For instance (this is probably not the exact process the game uses, but it's intended as an example of the kind of process it uses), when you want to generate a star system, you feed your coordinates and the seed to a system generation algorithm (the famous "stellar forge") which generates the list of objects in the system. For each object that probably means type (G class star, rocky planet, ice moon, orbis space station, ice ring, whatever), parent (what it orbits), second focal point in the orbit (the first one is the parent), direction of orbit, starting angle of the orbit (I'm quite certain Kepler's third law means you don't need to specify orbital period), plus a seed/ID that can be fed to subsequent algorithms.
For our hypothetical system that'd give us a primary star, and maybe some secondary stars orbiting it and each other, some planets and rings orbiting them, moons and rings orbiting the planets, and stations orbiting the moons and planets.
For each of those entities, you can then get their seed/id and type (when you need to because you're close enough to see them), feed them to the appropriate algorithm for their type, and generate the physical model for the object.
This process can be repeated ad infinitum. For instance, for stations, you might generate a rough model for when you're far away, with a list of subcomponents (inertial rings and whatnot) and, once you get close enough, generate details for those objects (up to the point, once we can walk inside stations, of generating details for a specific barn in a specific section in a specific inertial ring... but not for all other barns that are too far away for you to see).
That doesn't only work for physical characteristics, either; the same way you can generate a planet's surface you can generate a station's list of market goods, or list of missions.
Of course, all this can be overridden. We have a list of stars taken from stellar catalogues, for instance. If your coordinates coincide with one on the list, you simply use that stored data to generate the system, instead of the stellar forge (you might still use it to generate the rest of the entities in the system, though, if we haven't yet found any exoplanets there or if we suspect there might be more).
For certain systems, like Sol, you'll even override the planets, moons, rings and stations.
All this can be done in a run-of-the-mill PC. Frontier: Elite 2 did it (with less detail, obviously) in an Amiga over twenty years ago. Space Engine does it (with arguably more detail for stars and planets, but without stations and whatnot) for the entire universe. Limit Theory, a game not very dissimilar to this one but developed by a single person, will do it. Heck, I'm quite certain that the Elite: Dangerous client is already doing it (it would make no sense to be shuffling all this data over the network).
it gives us, however, a pretty static galaxy, one might assume at first look... but that needn't be so.
Take exploration, for instance... how do you handle that in a procedurally generated galaxy that can't be influenced by player action?
Simple, really... we define a starting date, or clock tick, and we subtract it from the current date, or clock tick (which can be server based so that everyone uses the same number regardless of timezones), and use the resulting number as a time-dependent (yet still deterministic) seed.
[UPDATE] - Some people might prefer a galaxy that only changes while they are playing, and not while the game is off; just use a counter that gets incremented only while the game is running instead of the date, then; there could even be an option in the configuration menu to switch between the two modes.
That means that after a certain pseudorandom amount of time a by default unexplored system might start to be generated as explored (you might even define various gradual stages of exploration between completely unknown and fully colonized). Take also into account the system's distance to "human space", and you get a gradually expanding civilization, at apparently random rates, in apparently random directions (all handled by your algorithm, though, so you still have full control of the rate and direction of expansion).
That also works for other possible effects, like famines, wars, and whatnot. Same way you can generate a high-contrast spotted pattern with a Perlin noise, you can generate relatively short periods of special circumstances amongst significantly longer periods of "business as usual").
You feed that into the mission generator, and you've got yourself a pretty dynamic looking galaxy.
And at basically the same cost as the static one.
But OK, let's forget all that, let's forget maths, let's forget that players are irrelevant in a sea of uncaring NPCs, let's skew the numbers and against all reason give players the power to influence the economy and politics and whatnot.
Does that mean we'll now need a server, that we can no longer do it on our regular PCs?
Let's see... let's generate a GUID as each entity's seed/id (that might be overkill, but we're arguing for the sake of argument anyway). Remember that even though you generate and discard entities on demand, the results (except those that we've made dependant on the date), including this GUID, will be the same every time any player generates the same entity, so IDs will still work even though the entities are procedurally generated.
Let's also make a database table, with the following columns: "entity GUID", "player GUID", "date" (or "clock tick"), "status", and, um... "target", let's say. We'll keep that serverside, for now.
What do we store there, then?
Let's start with player-driven exploration, for instance. We can still have the regular automatic one, or not, doesn't matter.
Let's see; a player arrives in a system. The stellar forge has flagged each entity in it as either explored or unexplored (that's the automatic exploration working).
The player detects the main star. The server looks at the table we made earlier, filters it by the star's GUID on the "entity GUID" column, and counts the results. If it gets none, the star was undiscovered.
The server then adds an entry to the table: Star GUID, Player GUID, current date, "explored" (you would store it as a binary flag, not as text, but you get what I mean, I hope), Player GUID.
Repeat for any other entity the player discovers in that location.
If the star had already been discovered, instead, the server could have filtered the results again by "player GUID", to see if that particular player already had data on the star.
When the player later sells this information, we can add another line with Star GUID, Player GUID, current date, "revealed" (or whatever), GUID of the faction the player sold the data to.
That table will (for now) grow every time a player discovers any stellar object, or sells that information. The server can then filter the table by "entity GUID" when it's generating the system and use the number of results to calculate the exploration status; for instance, if it's over a certain threshold, generate an Ocellus station, if over an even larger threshold generate a more permanent station type (maybe at various progressive states of construction), whatever.
You can even automatically start a war, if the system information has been sold at similar rates to two opposing factions. All this statuses will generate different market demands, which will generate different mission sets, as advertised by Frontier.
That can be then optimized by periodically cleaning up the table. Once you've got an Ocellus station there, you probably don't need to keep track of all the discovery information, the system is already discovered, let's get some space back and start tracking how many players trade with the system, or pirate it, or whatever, and base system growth on that. It would probably make more sense to put that in a separate table that didn't track individual players, but only growing systems.
Anyway, we now have an automatically (or not) expanding dynamic civilization that is heavily influenced by player exploration.
The same concept can be expanded further to other player interactions. A player affiliated to a certain faction killed an NPC affiliated with a certain other faction? Keep track of that and, once you have enough incidents, you might have a war going on. A player has depleted a certain stock from a certain market? Keep track of that, and you might eventually have a famine going on. The concept is basically the same, in any case.
The cost of this is, basically, a quickly growing (even with optimization and regular cleanups) table or set of tables, with the growth rate and total size directly dependant on the number of players.
This probably means that you'll have pretty hefty storage and processing requirements, quite probably beyond those of regular PCs.
If you are managing hundreds of thousands of players, that is.
This design doesn't depend on the number of players. It's certainly more "dynamic" the more players there are (and it needs much more resources), but it will still work equally well with a single player.
And, really, how much space would a single player need? Could it be handled by a single PC? How many systems will the average player discover over their whole time on the game? One thousand? Ten thousand at most? How many wars can they start, if any? How many lines can a single player really add to the table(s)?
We're probably talking megabytes, here, not even gigabytes.
Your regular PC should easily be able to handle that (without synchronizing with the online servers, of course, but we don't really need that, offline was supposed to be separate anyway; we could still get the Frontier-originated events, like Thargoids and whatnot as updates, though).
And that's disregarding the fact that the end result would be, both for single player and massive multiplayer, virtually indistinguishable from the automatically dynamic procedural galaxy I discussed earlier, which makes one question the need for all this fooling around with tables and player influence and other nonsense.
And, for those worried about people who play offline finding out the "secret stuff" before those who play online... since online and offline modes are independent, just give different seeds to each one (and, if you want, don't give Frontier-specific overrides to the offline mode). The code doesn't need to change. Just a single number.
So, in conclusion:
- Player influence on the galaxy makes no sense given the numbers involved and simple math.
- A dynamic, evolving galaxy that isn't influenced by players can easily be produced through procedural generation on a regular PC.
- A dynamic, evolving galaxy that is influenced by a single player and by important Frontier updates can easily be produced through procedural generation on a regular PC.
- A dynamic, evolving galaxy that is influenced by hundreds of thousands of players and by important Frontier updates probably can not, and will need servers, but doesn't need the code to be substantially different from the single player version; it doesn't need to be a "different game" as Brookes and Braben claim.
- The galaxies on points 3 and 4 will be virtually indistinguishable from the galaxy on point 2 (except for Frontier's updates, and those could easily be implemented as overrides), so why the heck even bother!?.
- Given the previous points, Frontier's excuses for not providing an offline single player mode make no sense whatsoever, I'm afraid.
Now, I'm far from the most intelligent person I know. I know a little about coding (I somehow managed to get an engineering degree on computer stuff), but I've never coded professionally or even steadily. I have no significant coding experience. My capabilities, therefore, are undoubtedly way below those of the people who are making Elite: Dangerous.
Yet, in my ignorance, after a bit of thinking I've managed to come up with what looks like a design that would allow a game like this to work without problems and still fulfill Frontier's marketspeach.
I can have no doubt that the far more experienced minds at Frontier will have come up with much better, much more efficient designs.
Yet, somehow, they claim they failed to do so. :S
Now, I'm the first to call for Hanlon's razor to be used, but it's very difficult, if not outright impossible, to apply it to people who are clearly neither incompetent nor stupid.
Which, tragically, leaves us with only one possible explanation.
TL;DR: Frontier's excuses don't hold water; they make no sense; by any rational analysis, we are for some unknown reason (which I'd like to know) being given false or incomplete information.
Which, frankly, sucks.
Last edited:
