Symmetrical planets are getting there...

Sorian, you've mentioned that you like options before, and have said that we will eventually be given many behavioral options, or options to disable tech, for the AI. I was also hoping for game options (game modes other than Assassination, or ways to turn off nukes, Annihilaser, etc.) as well. The links below are to posts from last September where you suggested that you would be building these options into the game. My question is, are either general game options, or AI options, currently being worked on, or planned to be included at some point?

https://forums.uberent.com/threads/for-backers-only-ai-building-stuff.49742/page-6#post-789070
https://forums.uberent.com/threads/for-backers-only-ai-building-stuff.49742/page-6#post-789619
https://forums.uberent.com/threads/for-backers-only-ai-building-stuff.49742/page-6#post-789664

I would love to know this also, I made a post awhile ago in the mods section about building a mod that disabled air and orbital units and it worked really well thanks to a lot of help from a few people in the community, one actually just simply made the mod for me (for while I appreciate). But quite obviously being able to play a certain way in game would be heck lot easier, land units only one a single large 1300 - 2000 radius map would just simply be awesome. Couldn't imagine the mass unit carnage that would be bring... or as you say, disable a few of the super weapons, no nukes for example but I would also love Shared Armies in singleplayer/skirmish would be really awesome too as a gamemode which I think a few people were asking for.

*claps*

I still don't see why we can't just make a planet and then have the engine reverse engineer it to get the seed needed to generate that planet.

I hope it is the 191 MB big patch I downloadad today.

I reckon there are planets for which there are no unique seeds - the seed space seems much more limited than the planet space. Additionally, planet generation from a single seed is pretty much a trapdoor function.
Both of which make reverse engineering the seed value not worth the effort, in my opinion. Which means planets have to be either generated in a deterministic fashion from a seed, or saved and transmitted in full. If the latter is the price we have to pay for fully custom planets, so be it. PA is eating up bandwidth like no one's business anyhow, it's not like that would make any major difference at this point.

That's not how seeds work, in any case, but you're correct about it being a choice between seeds (and a common set of terrain definitions) and transmitting the geometry data for the entire planet.

Seeds don't "encode" a planet; they are simply a number used as a parameter to the randomisation function, which is used to pick spots for terrain features etc. according to the planet type definitions. Even if the seed number was large enough to to count every single permutation (it isn't, by a long, long, long way), there's still no guarantee that every permutation is covered by a seed, since a seed merely maps to a certain selection of random numbers.

In short, it's better to think of seeds as a pre-determined set of random numbers to use when generating a planet, rather than a planet itself.

I do not see our posts contradicting one another, but hey, I will take that reiteration no matter what. Might be clearer than my post, at any rate.

But here is the thing. With computers, there is no such thing as a random number. What computers use is an equation to simulate the appearance of a random number, but the number isn't really random at all. (Google it)

So if we know what number the equation of randomness used to generate its result, then we just need to use some math to figure out what the result is and this means that we can also work the equation in reverse.

You are correct with regards to random numbers & computers (hence the existence of seeds), but they can't be worked out in reverse, because you don't know the order of features that are spawned (among other reasons). A seed will generate a series of pseudo-random numbers in a given sequence. If you have that sequence, and the formula used to generate it, then yes you can reverse engineer the seed, assuming one exists for that sequence. But we can't get that information from a generated planet. In fact, all we have from a generated planet is a 3D mesh & features, so we can't even tell what is a brush (which is randomly placed) and what is just the underlying terrain.

The only way to find if a given seed matches the planet you are looking at is to literally generate the planet for every single seed and compare it to the one you want. This is obviously not feasible.

Not so, you can generate a statistically random number from the right hardware, and /dev/random and like methods get pretty close.

Well, if I'm not completely wrong, there is a class (or several classes) of problems in mathematics where calculating a result is fairly easy, but given a result, determining the perquisites is really really hard. Most of them - which I know of - are in some way entangled with finite groups (this is mathematics where you only have a finite set of numbers). Modular groups is a good example of this, look at wikipedia under "groups mathematics"

For example, most of our current cryptography is based on this concept: You want some algorithm (which is deterministic, of course) that encrypts and decrypts a message relatively fast on the one side. But on the other side if you do not posses the secret information used for encrypting/decrypting the message it should be unbelievably hard to get from the encrypted message back to the original message. This is why the FBI is bitching about device encryption, now introduced by Apple and Android, because now (if the FBI don't have that passphrase (e.g. the key to the secret used to encrypt the device)) it needs a lot of time and really large computer farms to just break one encrypted device.

The same math is usually used in random number generators. This means even if you know the complete sequence a RNG will output, and even if a computer is deterministic, so you can re-produce the same sequence of numbers again and again, getting from that sequence back to the initial state or the seed of that RNG should be almost impossible. (Note that this is a guess, I don't know of any paper on completely reversing a RNG function efficiently, I guess outside of cryptography with it's statistical attacks on RNGs this is not of interest. But nonetheless, you can try it, depending on the RNG and the seed that was used, be prepared to invest a lot of time...)

I hope that clears this up a little bit. Cheers
criz.

The main issue about the "lets go from the planet we want to the seed we need" is that I doubt that there is a seed for every planet we can think of. Even if you try all seeds and check every planet generated I am sure you won't find an exact copy of a planet that is an empty Moon with LOL graved into it.

Challenge accepted.

It's not possible, and fairly trivial to prove. The seed is a single number. So at most, it can encode every position of a single object on a single axis

Sorry, but that's not true. Given that a number can be large enough you can encode arbitrary many numbers within one single number.
Even our decimal representation of numbers is something like this (it only allows the numbers 0-9 to be encoded, but I think this is sufficient for an example, there are however ways that can encode infinitely long numbers). The numbers 4, 5 , 6, and 7 can be represented by the single number 4567.

On the other hand the seed used by PA is too small to encode anything usefull.

Cheers,
criz.

Edit:
Oh, I get it. That smiley. Argh, I should let go my stance on sentences that are containing the word proof.

Two words:

Double

Laserbeams

Like that unit in the HR KS trailer that threw lasers all over the place?



Oh boy.

You don't have to know the order that the features where placed in, you can just make an assumption about how they where placed. IE: Assume that all elements of a planet are placed clockwise around the polar axis.

We now have an order, a result, and the method used to create that result.

If we have those, then what item is missing that is keeping us from calculating the seed?



Or at the very least we could change the method that planets use generat so that it takes in a non-random string and spits out a result. You would only have to store instructions to make changes to a standard sphere.

For 99.99% of all planets you might want there simply is no seed that generates them. You can't calculate the result of question that has no answer.