Support multiple seed pools

seed_compressor/compressor.py

@@ -3,14 +3,42 @@ import struct
 import zlib
 
 def main():
+    # No need to store any seeds for level 2 or 3: all 5000 of the first 5000 seeds are fine
+    # We could use negencode_delta_4b, which is pretty uneventful
+    # level_1 = load_seeds("input/level_1.txt")[:5000]
+    # analyze(level_1)
+    # level_2 = load_seeds("input/level_2.txt")[:5000]
+    # analyze(level_2)
+    # level_3 = load_seeds("input/level_3.txt")[:5000]
+    # analyze(level_3)
+    level_4 = load_seeds("input/level_4.txt")[:5000]
+    # analyze(level_4)
+    level_5 = load_seeds("input/level_5.txt")[:5000]
+    # analyze(level_5)
     ff = load_seeds("input/fortunes_foundation.txt")
+    # analyze(ff)
 
-    ffdata = delta_4b(ff)
+    # level_7 = load_seeds("input/level_7.txt")[:5000]
+    # analyze(level_7)
 
-    augment_map("../main.p8", "../seed_constants.lua", ffdata, {
-        "ffdata_start": 0,
-        "ffdata_end": len(ffdata),
-    })
+    level_4_data = negencode_16b(level_4)
+    level_5_data = negencode_delta_4b(level_5)
+    ff_data = delta_4b(ff)
+
+    all_data = b""
+
+    offsets = {}
+    for block, data in [
+        ("l4", level_4_data),
+        ("l5", level_5_data),
+        ("ff", ff_data)
+    ]:
+        offsets[f"{block}_start"] = len(all_data)
+        all_data += data
+        offsets[f"{block}_end"] = len(all_data)
+
+
+    augment_map("../main.p8", "../seed_constants.lua", all_data, offsets)
 
 
 def augment_map(target, constants_file, binary, offsets):
@@ -58,13 +86,21 @@ def analyze(seeds):
 
     print("{} seeds".format(len(seeds)))
     for encoding in [
-        naive, delta_8b, delta_3b, delta_4b, delta_5b, zlib_delta_4b, zlib_delta_8b
+        naive, bitfield, delta_8b, delta_2b, delta_3b, delta_4b, delta_5b, zlib_delta_4b, zlib_delta_8b,
+        negencode_delta_4b, negencode_16b,
     ]:
         print("{} encoding: {} bytes".format(encoding.__name__, len(encoding(seeds))))
 
 def naive(seeds):
     return b"".join(struct.pack("<I", s) for s in seeds)
 
+def bitfield(seeds):
+    mx = max(seeds)
+    out = bytearray((mx+7)//8)
+    for s in seeds:
+        out[s // 8] |= 1 << (s % 8)
+    return bytes(out)
+
 def delta_8b(seeds):
     out = b""
     acc = 0
@@ -110,6 +146,9 @@ def delta_4b(seeds):
 def zlib_delta_4b(seeds):
     return zlib.compress(delta_4b(seeds))
 
+def delta_2b(seeds):
+    return delta_nb(seeds, 2)
+
 def delta_3b(seeds):
     return delta_nb(seeds, 3)
 
@@ -151,6 +190,26 @@ def delta_nb(seeds, n):
         out += bytes(chunk_bytes)
     return out
 
+def negencode_delta_4b(seeds):
+    mx, new = negencode(seeds)
+    return struct.pack("<H", mx) + delta_4b(new)
+
+def negencode_16b(seeds):
+    mx, new = negencode(seeds)
+    out = b""
+    out += struct.pack("<H", mx)
+    for i in new:
+        out += struct.pack("<H", i) 
+    return out
+
+def negencode(seeds):
+    mn = 0
+    mx = max(seeds) + 1
+    everyone = set(range(mn, mx))
+    for i in seeds:
+        everyone.remove(i)
+    return mx, sorted(everyone)
+
 
 if __name__ == "__main__":
     main()