Skip to content

Free games for graphing calculators: NumWorks, TI-Nspire CX, Casio fx-CG50 and soon TI-84 Plus CE. Balatro, Celeste, Hollow Knight, Minecraft and more.

mrow purr

Lily Pitiot822cf60a7c62
diff --git a/games/celeste/src/data.bin b/games/celeste/src/data.bin
index f1a20749..2076ea3a 100644
Binary files a/games/celeste/src/data.bin and b/games/celeste/src/data.bin differ
diff --git a/games/celeste/src/level.c b/games/celeste/src/level.c
index cfd5eb3f..9bc86a04 100644
--- a/games/celeste/src/level.c
+++ b/games/celeste/src/level.c
@@ -110,6 +110,24 @@ static void tiles_unpack(uint8_t *dst, const uint8_t *src, int tw, int th) {
}
}
+/* CELESTE_DECAL_ZIGZAG_XY_V1: restore x/y arrays in the existing room buffer.
+ * No heap or extra persistent RAM, and no per-frame decoding. */
+static void cel_decals_unzigzag(uint8_t *part) {
+ unsigned n = rd16(part), nt = part[2];
+ uint8_t *xs = part + 4 + 2 * nt;
+ for (unsigned axis = 0; axis < 2; axis++) {
+ uint8_t *p = xs + (axis ? 2 * n : 0);
+ uint32_t prev = 0;
+ for (unsigned i = 0; i < n; i++) {
+ unsigned z = rd16(p + 2 * i);
+ int32_t d = (int32_t)(z >> 1) ^ -(int32_t)(z & 1u);
+ prev = (prev + d) & 65535u;
+ p[2 * i] = (uint8_t)prev;
+ p[2 * i + 1] = (uint8_t)(prev >> 8);
+ }
+ }
+}
+
static void session_enter(int index, int intro);
static bool room_load(int slot, int index, int intro) {
Room *rm = &g_level.rooms[slot];
@@ -148,6 +166,9 @@ static bool room_load(int slot, int index, int intro) {
tiles_unpack(mem + hdr[RB_FG], blob + rd16(blob + 2 * RB_FG), rm->tw, rm->th);
tiles_unpack(mem + hdr[RB_BG], blob + rd16(blob + 2 * RB_BG), rm->tw, rm->th);
memcpy(mem + hdr[RB_EXTRAS], blob + from, keep - hdr[RB_EXTRAS]);
+ /* CELESTE_DECAL_ZIGZAG_XY_V1: restore decoded coordinates before exposing decal pointers. */
+ cel_decals_unzigzag(mem + hdr[RB_DFG]);
+ cel_decals_unzigzag(mem + hdr[RB_DBG]);
setup_layer(&rm->layer[0], mem + rd16(mem + 2 * RB_FG), rm->th);
setup_layer(&rm->layer[1], mem + rd16(mem + 2 * RB_BG), rm->th);
/* extras: objtiles, then scenery over fg and bg */
diff --git a/games/celeste/tools/pack.py b/games/celeste/tools/pack.py
index b7c7e080..eb954127 100644
--- a/games/celeste/tools/pack.py
+++ b/games/celeste/tools/pack.py
@@ -1038,6 +1038,28 @@ BLOB_BYTES = {}
ROOM_POOL_FULL = 19092
+
+# CELESTE_DECAL_ZIGZAG_XY_V1: same-length, reversible decal x/y preconditioner.
+# Every room uses this transform; level.c undoes it once after room loading.
+def _cel_decals_zigzag_room(blob):
+ out = bytearray(blob)
+ for part in (3, 4): # RB_DFG, RB_DBG
+ start = struct.unpack_from('<H', blob, 2 * part)[0]
+ n = struct.unpack_from('<H', blob, start)[0]
+ nt = blob[start + 2]
+ xat = start + 4 + 2 * nt
+ for at in (xat, xat + 2 * n):
+ previous = 0
+ for i in range(n):
+ value = struct.unpack_from('<H', blob, at + i * 2)[0]
+ delta = (value - previous) & 65535
+ signed = delta if delta < 32768 else delta - 65536
+ z = ((signed << 1) ^ (signed >> 15)) & 65535
+ struct.pack_into('<H', out, at + i * 2, z)
+ previous = value
+ return bytes(out)
+
+
def room_blob(ch, r):
"""Everything a room needs; the first part (up to RB_ENTS) stays in RAM while the room is loaded
(level.c room_load), the entities and triggers are read once."""
@@ -1152,7 +1174,8 @@ def room_blob(ch, r):
name = ("fg", "bg", "extras", "dfg", "dbg", "spin", "need", "ents", "trigs")[k]
BLOB_PARTS[name] += b - a
BLOB_BYTES.setdefault(name, bytearray()).extend(w.b[a:b])
- return bytes(w.b)
+ # CELESTE_DECAL_ZIGZAG_XY_V1: same raw room size and same offsets.
+ return _cel_decals_zigzag_room(bytes(w.b))
def room_pool_size(chapters):