Spacegate

Thanks!

That is not something I initially thought was worth spading; I had the thought that the types of encounters were specific to a planet but they were randomly selected. I noticed that quest encounters were one type per planet, spants and murderbots had specific mixes of types, and that animals, plants, and aliens had one type - and always had the same image.

(I believe taltimir spaded and found that hostile aliens dropped specific trophies based on which of 6 images appeared. I should validate that - and incorporate it.)

Initially, I just had "rocks" - but when I decided that not all planets had all rocks - and one of the types was skippable - I added support for that and revisited every planet I'd been to prior to that fix.

So, lets see. I have fiveccharacters who generate a random planet name each day and explore.

Here is one result:

Code: 
> Today's encounters on the planet at coordinates BCROQNB (Delta Draper XI)
>     Cool Space Rocks: 2
>     Paradise Under a Strange Sun: 1
>     Space Cave: 6
>     Spant drone: 5
>     Wide Open Spaces: 3
>     small hostile animal: 3

Let's try that planet with a different character:
Code: 
> VeracitySpacegate visit coordinates BCROQNB
...
> Today's encounters on the planet at coordinates BCROQNB (Delta Draper XI)
>     Cool Space Rocks: 2
>     Paradise Under a Strange Sun: 1
>     Space Cave: 5
>     Spant drone: 4
>     Wide Open Spaces: 4
>     small hostile animal: 4

Regarding "deriving from planet name" - that was a main goal of this program's data collection.
There are seven letter in a planet name, so 26 ^ 7 = 8,031,810,176 different planets. That is about 33 bits of data.
Apparently, some data are shared - hostile alien image number and trophy item type.

The presence of hostile animals is there somewhere.
There are 20 different small hostile animal images (sganimala1.gif - sganimala20.gif)
There are 10 different large hostile animal images (sganimalb1.gif - sganimala10.gif)
There are 3 different exotic hostile animal images (sganimalc1.gif - sganimala3.gif)

In any case, it looks like encounter types are encoded in planet name - but distribution varies. Perhaps is is seeded by player, class, turn count, whatever. Or perhaps it is randomized, some how.

One could write a program to scrape the enounter summary from session logs and look into that, if one wanted to try spading it.
But the raw data is not in the distributed data files.

I should make a new data dump; I probably have a couple thousand new planets to publish.
 
Veracity said:
I should make a new data dump; I probably have a couple thousand new planets to publish.
Click to expand...
I'd love to get a new data drop. I hope you are still around and collecting more data.

I made some progress at reverse engineering the planets. I managed to find a number of hash collisions. It looks like we have about half the information I need for an empirical solver. I've started writing up the details and plan to post again this weekend.
 
I'm sorry for the long AI summery, but I think a lot of what was found was interesting. . .

Some new findings from analyzing Veracity's ~7,500 Spacegate planet records:

1. The first coordinate letter is the difficulty.
For essentially every record, A=0, B=1, ... Z=25. There appears to be one bad/incomplete record in the dataset.

2. Each gameplay property is associated with a specific coordinate letter.

  • B → plants
  • C → animals
  • D → intelligent aliens/trade
  • E → Spants
  • F → Murderbots
  • G → alien ruins
The other six letters still matter; this is not simply "letter B determines plants."

3. There are two very important sums of the seven coordinate letters.
If A=0, B=1, ..., Z=25, define:

S = sum of the 7 letters

P = 1*letter1 + 2*letter2 + ... + 7*letter7

Planets with the same (S,P)have the same cosmetic data: planet name, sky, sun, moon, etc. This is equivalent to the collision behavior of Adler-32 on a seven-letter uppercase coordinate, although that does not prove KoL literally uses Adler-32.

Gameplay properties appear to depend on (S,P) plus their particular letter. For example, plants behave like a deterministic function of (S,P,B), animals of (S,P,C), and so on.

4. Plant, animal, and alien image numbers share the same random-looking value.
This is one of the strongest findings.

If a planet has images chosen from sets of 20, 10, or 3 pictures, there is a single planet-specific fraction r such that:

image number = floor(number_of_images * r) + 1

The same r works simultaneously for the plant, animal, and alien images.

For example, a #17 image from a 20-image set requires 0.80 < r < 0.85; an image from a 10-image set on the same planet always lands in the compatible interval.

There were no contradictions in the dataset.

5. Hazard selection is also deterministic from the common (S,P) state.
Difficulty controls how many hazards appear, while (S,P) appears to determine their ordering.

Environmental hazards:

  • difficulty A–I: 1 hazard
  • J–S: 2 hazards
  • T–Z: 3 hazards
Elemental hazards:

  • A–E: 0
  • F–O: 1
  • P–Y: 2
  • Z: 3
For planets sharing (S,P) but having different difficulty letters, the hazard sets are always nested: the 1-hazard set is contained in the 2-hazard set, which is contained in the 3-hazard set.

6. The existing dataset already predicts cosmetics for far more coordinates than the exact coordinates it contains.
There are only 35,176 possible (S,P) states across all 26^7 Spacegate coordinates. Veracity's data contains about 5,593 of them.

Because common states have many coordinate equivalents, those observed states represent about 45% of all 8.03 billion possible seven-letter coordinates for cosmetic prediction.

Complete empirical cosmetic coverage would require observations of the remaining roughly 29,600 (S,P) states, not billions of planets.

Gameplay coverage is much harder because each property additionally depends on its own coordinate letter.

What we have not figured out: the actual KoL formula that turns (S,P) into the random-looking cosmetic/image values. We tested a lot of obvious possibilities—simple arithmetic, Adler/CRC/FNV-style hashes, PHP rand, PHP MT, simple integer mixers, etc.—without finding the generator. So (S,P) and the per-field letter dependencies are strongly supported empirically, but the server-side algorithm remains unknown.
 
Also of note, Veracity's data file columns almost matched the order of the letters they depend on. Just one adjacent pair was swapped. ChatGPT found this very "confusing" until I explained it was luck.
 
You must log in or register to reply here.
Back
Top