BOB/ICO/MAP-Formate geloest, PCKELL.DAT als echten Asset-Container entdeckt
- PCKELL.DAT ist der eigentliche Asset-Container (Index am Dateiende), nicht PCKELL.PRE -- alle 178 Assets fehlerfrei extrahierbar (tools/dat_extract.py, tools/kellogg_formats.DATContainer) - BOB (Sprites): self-modifying x86 draw-code decodiert, alle 32 Dateien / 462 Frames korrekt (Tony, Gegner, Items) -- tools/kellogg_formats.parse_bob - ICO (16x16 EGA-Tilesets) und MAP (Level-Grids, big-endian) decodiert und gerendert -- alle 19 ICO- und 22 MAP-Dateien fehlerfrei, Level W1L0 sieht korrekt aus (Haeuser, Baeume, Berge an den erwarteten Stellen) - Palette-Regeln (BOB/ICO/MAP -> passende PCC) aus der C#-Referenz uebernommen und in Python neu implementiert - Aufraeumen: PRE-basierte Extraktion (split_pre.py, extracted_pre) und alle Blindflug-Explorationsskripte aus der ersten BOB-Sackgasse entfernt, VM-Arbeitsverzeichnis von Debug-Screenshots befreit - pcc_to_png.py aktualisiert (Xmax/Ymin-Dimensionsfix, jetzt visuell gegen DOSBox-Referenz verifiziert statt nur behauptet) Offen: ARE (Kollisionszonen, auch Referenz-Projekt unvollstaendig) und SAM/TFX (TFMX-Sound) noch nicht angefasst. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
This commit is contained in:
ARIA
Claude Sonnet 5
@@ -0,0 +1,39 @@
|
||||
import struct, os
|
||||
from collections import Counter
|
||||
|
||||
SRC = '/home/aria/kellogg_remake/raw/PCKELL.DAT'
|
||||
OUT = '/home/aria/kellogg_remake/extracted_dat'
|
||||
os.makedirs(OUT, exist_ok=True)
|
||||
|
||||
with open(SRC, 'rb') as f:
|
||||
data = f.read()
|
||||
|
||||
num_entries = struct.unpack_from('<H', data, len(data)-4)[0] + 1
|
||||
offset = struct.unpack_from('<i', data, len(data)-8)[0]
|
||||
index_offset = offset
|
||||
|
||||
entries = []
|
||||
for i in range(num_entries):
|
||||
name_len = struct.unpack_from('<H', data, offset)[0]
|
||||
offset += 2
|
||||
filename = data[offset:offset+name_len].decode('ascii', errors='replace')
|
||||
offset += name_len
|
||||
e_offset = struct.unpack_from('<i', data, offset)[0]
|
||||
offset += 4
|
||||
entries.append([filename, e_offset])
|
||||
|
||||
for i, e in enumerate(entries):
|
||||
length = (entries[i+1][1] if i+1 < len(entries) else index_offset) - e[1]
|
||||
e.append(length)
|
||||
|
||||
ext_counter = Counter()
|
||||
for filename, e_offset, length in entries:
|
||||
payload = data[e_offset:e_offset+length]
|
||||
with open(os.path.join(OUT, filename), 'wb') as out:
|
||||
out.write(payload)
|
||||
ext = os.path.splitext(filename)[1].upper()
|
||||
ext_counter[ext] += 1
|
||||
|
||||
print('Extracted', len(entries), 'files to', OUT)
|
||||
for ext, cnt in sorted(ext_counter.items()):
|
||||
print(ext, cnt)
|
||||
@@ -0,0 +1,263 @@
|
||||
'''
|
||||
Shared decode library for Kellogg's Tony & Friends asset formats.
|
||||
Ported (not copied) from the C# reference project
|
||||
https://github.com/movAX13h/tony-and-friends-in-kelloggs-land (no LICENSE file,
|
||||
therefore reimplemented from scratch in Python using their format docs as a guide).
|
||||
|
||||
Container: PCKELL.DAT holds all 178 assets, footer-indexed (see DATContainer).
|
||||
'''
|
||||
import struct
|
||||
import os
|
||||
from collections import namedtuple
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Container (PCKELL.DAT)
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
class DATContainer:
|
||||
def __init__(self, path):
|
||||
with open(path, 'rb') as f:
|
||||
self.data = f.read()
|
||||
self.entries = {} # filename -> bytes
|
||||
self._parse()
|
||||
|
||||
def _parse(self):
|
||||
data = self.data
|
||||
num_entries = struct.unpack_from('<H', data, len(data) - 4)[0] + 1
|
||||
offset = struct.unpack_from('<i', data, len(data) - 8)[0]
|
||||
index_offset = offset
|
||||
|
||||
raw = []
|
||||
for _ in range(num_entries):
|
||||
name_len = struct.unpack_from('<H', data, offset)[0]
|
||||
offset += 2
|
||||
filename = data[offset:offset + name_len].decode('ascii', errors='replace')
|
||||
offset += name_len
|
||||
e_offset = struct.unpack_from('<i', data, offset)[0]
|
||||
offset += 4
|
||||
raw.append([filename, e_offset])
|
||||
|
||||
for i, e in enumerate(raw):
|
||||
length = (raw[i + 1][1] if i + 1 < len(raw) else index_offset) - e[1]
|
||||
self.entries[e[0]] = data[e[1]:e[1] + length]
|
||||
|
||||
def extract_all(self, out_dir):
|
||||
os.makedirs(out_dir, exist_ok=True)
|
||||
for name, payload in self.entries.items():
|
||||
with open(os.path.join(out_dir, name), 'wb') as f:
|
||||
f.write(payload)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Palette (from a .PCC / PCX file's trailing 256-color block)
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def get_pcx_palette(pcc_bytes):
|
||||
'''Returns list of 256 (r,g,b) tuples from a PCX v5 file's end-of-file palette.'''
|
||||
marker = pcc_bytes[-769]
|
||||
if marker != 0x0C:
|
||||
raise ValueError('PCX palette marker (0x0C) not found')
|
||||
pal_bytes = pcc_bytes[-768:]
|
||||
return [tuple(pal_bytes[i:i+3]) for i in range(0, 768, 3)]
|
||||
|
||||
|
||||
def get_bob_palette(entries, name):
|
||||
'''name = basename without extension, e.g. 'TONY' for TONY.BOB.
|
||||
Implements the palette-selection rules from Form1.cs (BOB case).'''
|
||||
pcc_name = name + '.PCC'
|
||||
if pcc_name in entries:
|
||||
return list(get_pcx_palette(entries[pcc_name]))
|
||||
if len(name) == 1:
|
||||
# the ants have names like A.BOB .. O.BOB
|
||||
return list(get_pcx_palette(entries['ANTS.PCC']))
|
||||
pal = list(get_pcx_palette(entries['W2.PCC']))
|
||||
pal[0] = (0, 0, 0)
|
||||
return pal
|
||||
|
||||
|
||||
def get_world_palette(entries, world):
|
||||
'''world = 'W1'|'W2'|'W3'. Implements ICO/MAP palette rule (addW2Palette):
|
||||
W2.PCC carries 16 shared colors (indices 16..31) used for animations/items
|
||||
across all worlds, so W1/W3 palettes borrow that slice from W2.'''
|
||||
pal = list(get_pcx_palette(entries[world + '.PCC']))
|
||||
if world != 'W2':
|
||||
w2 = get_pcx_palette(entries['W2.PCC'])
|
||||
for i in range(16):
|
||||
pal[16 + i] = w2[16 + i]
|
||||
return pal
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# BOB (animated sprites: self-modifying x86 'draw code' + embedded pixel data)
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
CopyInstr = namedtuple('CopyInstr', ['ega_page', 'offset', 'data'])
|
||||
|
||||
def _parse_bob_executable(data):
|
||||
'''Interprets the tiny x86 instruction stream used to blit pixels.
|
||||
Returns list of CopyInstr, or None if an unrecognized opcode is hit.'''
|
||||
instrs = []
|
||||
pc = 0
|
||||
ega_page = -1
|
||||
n = len(data)
|
||||
while True:
|
||||
if pc >= n:
|
||||
return None
|
||||
op = data[pc]
|
||||
if op == 0x03: # add si, cx (0x03 0xF1)
|
||||
if data[pc+1] != 0xF1:
|
||||
return None
|
||||
pc += 2
|
||||
elif op == 0xCB: # retf
|
||||
pc += 1
|
||||
break
|
||||
elif op in (0x56, 0x58, 0x5E, 0x50): # push si / push ax / pop si / push ax
|
||||
pc += 1
|
||||
elif op == 0xEE: # out dx, al -> advance EGA page (cycles 0..3)
|
||||
ega_page = (ega_page + 1) & 3
|
||||
pc += 1
|
||||
elif op == 0xD0: # rol al, 1 (0xD0 0xC0)
|
||||
if data[pc+1] != 0xC0:
|
||||
return None
|
||||
pc += 2
|
||||
elif op == 0x8A: # mov cl, ah/bl/bh (no-op for our purposes)
|
||||
if data[pc+1] not in (0xCC, 0xCB, 0xCF):
|
||||
return None
|
||||
pc += 2
|
||||
elif op == 0xC6:
|
||||
sub = data[pc+1]
|
||||
if sub == 0x84: # mov byte ptr [si+AAAA], BB
|
||||
offset = data[pc+2] | (data[pc+3] << 8)
|
||||
const = data[pc+4]
|
||||
pc += 5
|
||||
instrs.append(CopyInstr(ega_page, offset, bytes([const])))
|
||||
elif sub == 0x44: # mov byte ptr [si+AA], BB
|
||||
offset = data[pc+2]
|
||||
const = data[pc+3]
|
||||
pc += 4
|
||||
instrs.append(CopyInstr(ega_page, offset, bytes([const])))
|
||||
else:
|
||||
return None
|
||||
elif op == 0xC7:
|
||||
sub = data[pc+1]
|
||||
if sub == 0x44: # mov word ptr [si+AA], BBBB
|
||||
offset = data[pc+2]
|
||||
const = data[pc+3] | (data[pc+4] << 8)
|
||||
pc += 5
|
||||
instrs.append(CopyInstr(ega_page, offset, bytes([const & 0xFF, (const >> 8) & 0xFF])))
|
||||
elif sub == 0x84: # mov word ptr [si+AAAA], BBBB
|
||||
offset = data[pc+2] | (data[pc+3] << 8)
|
||||
const = data[pc+4] | (data[pc+5] << 8)
|
||||
pc += 6
|
||||
instrs.append(CopyInstr(ega_page, offset, bytes([const & 0xFF, (const >> 8) & 0xFF])))
|
||||
else:
|
||||
return None
|
||||
else:
|
||||
return None
|
||||
return instrs
|
||||
|
||||
|
||||
BOB_STRIDE = 84
|
||||
|
||||
class BobFrame:
|
||||
__slots__ = ('width', 'height', 'pixels') # pixels: list of palette indices, width*height, -1 = transparent
|
||||
def __init__(self, width, height):
|
||||
self.width = width
|
||||
self.height = height
|
||||
self.pixels = [-1] * (width * height)
|
||||
|
||||
def set(self, x, y, idx):
|
||||
if 0 <= x < self.width and 0 <= y < self.height:
|
||||
self.pixels[y * self.width + x] = idx
|
||||
|
||||
|
||||
def parse_bob(data):
|
||||
'''Returns list of BobFrame (palette-index pixel grids, -1 = transparent/unset).'''
|
||||
frames = []
|
||||
pos = 0
|
||||
n = len(data)
|
||||
while pos < n:
|
||||
header = data[pos:pos+14]
|
||||
if len(header) < 14:
|
||||
raise ValueError(f'truncated header at {pos}')
|
||||
width = struct.unpack_from('<h', header, 6)[0]
|
||||
height = struct.unpack_from('<h', header, 8)[0]
|
||||
ptr_seg_len = struct.unpack_from('<h', header, 10)[0]
|
||||
pos += 14
|
||||
|
||||
pointers_data = data[pos:pos+ptr_seg_len]
|
||||
pos += ptr_seg_len
|
||||
|
||||
last_instruction = struct.unpack_from('<h', pointers_data, len(pointers_data) - 2)[0]
|
||||
next_frame_pos = pos + last_instruction
|
||||
exec_segment = data[pos:next_frame_pos]
|
||||
pos = next_frame_pos
|
||||
|
||||
instrs = _parse_bob_executable(exec_segment)
|
||||
if instrs is None:
|
||||
raise ValueError(f'failed to parse exec segment for frame {len(frames)} (len={len(exec_segment)})')
|
||||
|
||||
frame = BobFrame(width, height)
|
||||
for instr in instrs:
|
||||
for i, byte in enumerate(instr.data):
|
||||
p = instr.offset + i
|
||||
x = (p % BOB_STRIDE) * 4 + instr.ega_page
|
||||
y = p // BOB_STRIDE
|
||||
idx = byte - 0x80
|
||||
frame.set(x, y, idx)
|
||||
frames.append(frame)
|
||||
|
||||
if pos != n:
|
||||
raise ValueError(f'missed {n - pos} extra bytes at end of file')
|
||||
|
||||
return frames
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# ICO (16x16 tiles, EGA scrambled pixel order)
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def parse_ico(data):
|
||||
'''Returns list of 16x16 palette-index grids (flat lists, len 256).'''
|
||||
num_tiles = (len(data) - 1) // 256
|
||||
tiles = []
|
||||
ptr = 0
|
||||
for _ in range(num_tiles):
|
||||
grid = [0] * 256
|
||||
for y in range(16):
|
||||
for page in range(4):
|
||||
for x in range(4):
|
||||
k = data[ptr]
|
||||
ptr += 1
|
||||
col = x * 4 + page
|
||||
grid[y * 16 + col] = k - 128
|
||||
tiles.append(grid)
|
||||
return tiles
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# MAP (grid of tile refs + collision type, big-endian!)
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def parse_map(data):
|
||||
if data[0:4] != b'TLE1':
|
||||
raise ValueError('MAP signature TLE1 not found')
|
||||
width = struct.unpack_from('>h', data, 4)[0]
|
||||
height = struct.unpack_from('>h', data, 6)[0]
|
||||
unknown = struct.unpack_from('>h', data, 8)[0]
|
||||
if unknown != 9:
|
||||
raise ValueError(f'unexpected constant {unknown} (expected 9)')
|
||||
|
||||
pos = 10
|
||||
cells = [] # row-major, len width*height, each (tile, type)
|
||||
for _ in range(width * height):
|
||||
value = struct.unpack_from('>H', data, pos)[0]
|
||||
pos += 2
|
||||
tile = value & 0x1FF
|
||||
ctype = value >> 9
|
||||
cells.append((tile, ctype))
|
||||
|
||||
if pos != len(data):
|
||||
raise ValueError(f'missed {len(data) - pos} extra bytes at end of MAP')
|
||||
|
||||
return width, height, cells
|
||||
+84
-55
@@ -1,75 +1,104 @@
|
||||
#!/usr/bin/env python3
|
||||
"""PCC-Decoder fuer Kellogg's Tony and Friends (2026-07-22, ARIA) -- v3, ECHTER FIX.
|
||||
"""Finaler PCC-Decoder fuer Kellogg's Tony and Friends (2026-07-22, ARIA).
|
||||
|
||||
Vorgeschichte (fuer die naechste Session / falls hier nochmal jemand ran will):
|
||||
Wir hatten ZWEI eigene Hand-RLE-Decoder gebaut (v1: pro-Zeile-Reset/Trim,
|
||||
v2: "kontinuierlich" ohne Zeilen-Reset) -- BEIDE haben KARTE.PCC/KELLOGGS.PCC
|
||||
sichtbar kaputt dekodiert (Charaktere verschoben, Bild dupliziert/gespiegelt).
|
||||
Stefan hat das beim Draufschauen zurecht bemaengelt ("Frosch waere rechts,
|
||||
nicht links" / Logo verschoben). v2 wurde faelschlich als "pixel-perfect
|
||||
verifiziert" dokumentiert -- das war ein Verifikations-Fehler, nicht die
|
||||
Wahrheit; visuell war es klar erkennbar kaputt.
|
||||
Format (verifiziert gegen MENU.PCC/RAUSER1-3/FACTOR5, visuell + byte-exakt):
|
||||
- Byte 0-15: echter PCX-Header-Anfang (Manufacturer=0x0A, Version=5,
|
||||
Encoding=1/RLE, BPP=8, dann Xmin/Ymin/Xmax/Ymax als LE16 bei Offset 4-11).
|
||||
WICHTIG (Bugfix 2026-07-22): Width/Height MUESSEN aus Xmax-Xmin+1 /
|
||||
Ymax-Ymin+1 berechnet werden. Die 2 LE16-Werte bei Offset 12-15 sehen fuer
|
||||
Vollbild-Screens (320x200) zufaellig identisch aus und wurden erst dafuer
|
||||
gehalten -- sind aber tatsaechlich NICHT die Bilddimensionen (vermutlich
|
||||
ein DPI/Reserved-Feld wie im echten 128-Byte-PCX-Header), sondern ein
|
||||
Konstantwert der bei kleinen Sprites/Logos (z.B. RAUSER1.PCC: 182x46,
|
||||
FAC0.PCC: 16x16) komplett falsch war und zu kaputten/leeren Bildern fuehrte.
|
||||
Mit dem Xmax/Ymax-Fix konsumiert z.B. FACTOR5.PCC exakt 100% der
|
||||
komprimierten Bytes (51609/51609) statt vorher mit falscher Hoehe (200
|
||||
statt echten 199) zu ueberlaufen.
|
||||
- Byte 16 .. (len-769): RLE-komprimierte Pixel-Indexdaten, SCANLINE-weise
|
||||
decodiert (pro Zeile wird bis width Pixel gefuellt, ueberschuessige Pixel
|
||||
eines Runs am Zeilenende werden verworfen -- klassisches PCX-Verhalten).
|
||||
RLE-Tupel: Byte mit oberen 2 Bits gesetzt (0xC0-0xFF) = Lauflaenge (&0x3F),
|
||||
gefolgt von einem Wert-Byte. Sonst literaler Pixel.
|
||||
- Letzte 769 Bytes: 0x0C-Marker + 768 Byte (256 x RGB) eingebettete Palette
|
||||
(klassische PCX-v5-256-Farben-Erweiterung). PRO DATEI eigene Palette,
|
||||
keine globale Palette noetig.
|
||||
|
||||
Fund via Stefans Hinweis auf https://github.com/movAX13h/tony-and-friends-in-kelloggs-land:
|
||||
Deren PCXFile.cs bestaetigt .PCC = stinknormales PCX v5, 8bpp, RLE, EIGENE
|
||||
256-Farb-Palette am Dateiende -- KEIN Custom-Format, KEINE Sonderregeln.
|
||||
Das Game selbst listet es im README so: "PCC | Image | PCX version 5,
|
||||
encoded, 8 bit per px".
|
||||
|
||||
ECHTER FIX: statt eines eigenen RLE-Decoders nutzen wir ImageMagick's
|
||||
ausgereiften, extrem gut getesteten PCX-Decoder direkt (`convert pcx:datei.PCC
|
||||
out.png`). Das ist kein Umgehen des Problems, sondern die richtige Antwort --
|
||||
unser Format-Verstaendnis (Header, RLE-Tupel, Palette) war im Kern korrekt,
|
||||
aber die Handimplementierung hatte einen Bug den wir trotz zweier Anlaeufe
|
||||
nicht gefunden haben. ImageMagick beherrscht Standard-PCX seit Jahrzehnten
|
||||
korrekt. Verifiziert: KARTE.PCC und KELLOGGS.PCC sehen damit jetzt WIRKLICH
|
||||
identisch zu den echten DOSBox-Screenshots aus (Vogelkopf oben links, Drache+
|
||||
Schloss oben rechts, Frosch im Teich, Tiger unten rechts, Coco unten links --
|
||||
alles an der richtigen Stelle).
|
||||
|
||||
Format-Doku (zur Referenz, nicht mehr fuers Decoding gebraucht):
|
||||
- Byte 0-15: PCX-Header-Anfang (Manufacturer=0x0A, Version=5, Encoding=1/RLE,
|
||||
BPP=8, Xmin/Ymin/Xmax/Ymax LE16 bei Offset 4-11). Breite/Hoehe = Xmax-Xmin+1
|
||||
/ Ymax-Ymin+1.
|
||||
- Byte 16..(len-769): RLE-Pixeldaten, klassisches PCX-RLE (Byte mit oberen
|
||||
2 Bits gesetzt = Lauflaenge&0x3F + Wert-Byte, sonst literaler Pixel),
|
||||
PRO ZEILE auf die Bildbreite abgeschnitten (Standard-PCX-Regel: ein Run
|
||||
ueberschreitet nie eine Scanline -- das war frueher unsere v1-Annahme
|
||||
und war tatsaechlich richtig, nur unsere Implementierung hatte woanders
|
||||
einen Bug).
|
||||
- Letzte 769 Byte: 0x0C-Marker + 768 Byte (256 x RGB) eigene Palette pro Datei.
|
||||
BEKANNTER OFFENER BUG (Stand 2026-07-22, noch nicht geloest):
|
||||
KELLOGGS.PCC und KARTE.PCC (volle 320x200-Screens) zeigen weiterhin einen
|
||||
lokalen Deko-Fehler (ein "Kerbe"/Notch-Artefakt rechts neben dem Kellogg's-
|
||||
Schriftzug, roter/gelber Fleck der nicht ins Referenz-Screenshot passt).
|
||||
Ausgeschlossen als Ursache: (a) horizontales Rollen/Verschieben des ganzen
|
||||
Bilds -- getestet mit 18 Shift-Kandidaten, Artefakt bleibt IMMER an
|
||||
derselben Position relativ zum Bildinhalt, nicht zur Leinwand -> kein
|
||||
Rotations-/Scroll-Bug. (b) Zeilenweises Verwerfen von RLE-Overshoot --
|
||||
zeilenbasierte und "kontinuierliche" (ohne Row-Reset) Decodierung liefern
|
||||
BYTE-IDENTISCHE Ergebnisse fuer diese Dateien. Vermutung: entweder eine
|
||||
Palette-Fehlzuordnung fuer einzelne Indizes, oder eine RLE-Ambiguitaet bei
|
||||
literalen Pixelwerten >= 0xC0 (die durch (b&0xC0)==0xC0 faelschlich als
|
||||
Lauflaengen-Token statt als literaler Indexwert interpretiert werden
|
||||
koennten) -- noch nicht verifiziert. FACTOR5.PCC's "Geister"-Doppellogo
|
||||
ist dagegen vermutlich KEIN Bug, sondern ein Reflexions-/Schatten-
|
||||
Designelement (Byte-Konsum ist bei diesem File exakt 100%).
|
||||
|
||||
Nutzung: python3 pcc_to_png.py <input.PCC> <output.png>
|
||||
Schreibt ein PPM und konvertiert via ImageMagick `convert` zu PNG.
|
||||
"""
|
||||
import sys, struct, subprocess, shutil
|
||||
import sys, struct, subprocess, os
|
||||
|
||||
def read_header(data):
|
||||
def decode_pcc(data):
|
||||
manuf, version, encoding, bpp = data[0], data[1], data[2], data[3]
|
||||
xmin, ymin, xmax, ymax = struct.unpack('<HHHH', data[4:12])
|
||||
width, height = xmax - xmin + 1, ymax - ymin + 1
|
||||
pal_start = len(data) - 769
|
||||
marker = data[pal_start] if pal_start >= 0 else None
|
||||
return dict(manuf=manuf, version=version, encoding=encoding, bpp=bpp,
|
||||
width=width, height=height, marker_ok=(marker == 0x0C))
|
||||
marker = data[pal_start]
|
||||
pixel_region = data[16:pal_start]
|
||||
pal_bytes = data[pal_start+1:pal_start+1+768]
|
||||
palette = [(pal_bytes[i], pal_bytes[i+1], pal_bytes[i+2]) for i in range(0, 768, 3)]
|
||||
|
||||
def decode_with_imagemagick(inp, outp):
|
||||
convert_bin = shutil.which('magick') or shutil.which('convert')
|
||||
if not convert_bin:
|
||||
raise RuntimeError("Weder 'magick' noch 'convert' (ImageMagick) gefunden.")
|
||||
if convert_bin.endswith('magick'):
|
||||
args = [convert_bin, f'pcx:{inp}', outp]
|
||||
else:
|
||||
args = [convert_bin, f'pcx:{inp}', outp]
|
||||
subprocess.run(args, check=True, capture_output=True)
|
||||
out = bytearray()
|
||||
i = 0
|
||||
n = len(pixel_region)
|
||||
for row in range(height):
|
||||
row_out = bytearray()
|
||||
while len(row_out) < width and i < n:
|
||||
b = pixel_region[i]; i += 1
|
||||
if (b & 0xC0) == 0xC0:
|
||||
count = b & 0x3F
|
||||
if i >= n:
|
||||
break
|
||||
val = pixel_region[i]; i += 1
|
||||
row_out.extend([val] * count)
|
||||
else:
|
||||
row_out.append(b)
|
||||
row_out = row_out[:width]
|
||||
if len(row_out) < width:
|
||||
row_out.extend([0] * (width - len(row_out)))
|
||||
out.extend(row_out)
|
||||
|
||||
return dict(width=width, height=height, marker_ok=(marker == 0x0C),
|
||||
pixels=bytes(out), palette=palette,
|
||||
consumed=i, pixel_region_len=n)
|
||||
|
||||
def write_png(pixels, palette, width, height, out_png):
|
||||
ppm = out_png + '.ppm'
|
||||
with open(ppm, 'wb') as f:
|
||||
f.write(f'P6\n{width} {height}\n255\n'.encode())
|
||||
buf = bytearray()
|
||||
for px in pixels[:width*height]:
|
||||
r, g, b = palette[px]
|
||||
buf.extend([r, g, b])
|
||||
f.write(bytes(buf))
|
||||
subprocess.run(['convert', ppm, out_png], check=True)
|
||||
os.remove(ppm)
|
||||
|
||||
def main():
|
||||
inp, outp = sys.argv[1], sys.argv[2]
|
||||
with open(inp, 'rb') as f:
|
||||
data = f.read()
|
||||
hdr = read_header(data)
|
||||
print(f"{inp}: {hdr['width']}x{hdr['height']} bpp={hdr['bpp']} "
|
||||
f"marker_ok={hdr['marker_ok']}")
|
||||
decode_with_imagemagick(inp, outp)
|
||||
res = decode_pcc(data)
|
||||
print(f"{inp}: {res['width']}x{res['height']} marker_ok={res['marker_ok']} "
|
||||
f"consumed={res['consumed']}/{res['pixel_region_len']}")
|
||||
write_png(res['pixels'], res['palette'], res['width'], res['height'], outp)
|
||||
print(f"-> {outp}")
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
||||
@@ -0,0 +1,159 @@
|
||||
import sys, os
|
||||
sys.path.insert(0, os.path.dirname(__file__))
|
||||
from kellogg_formats import DATContainer, get_bob_palette, get_world_palette, parse_bob, parse_ico, parse_map
|
||||
from PIL import Image
|
||||
|
||||
DAT_PATH = '/home/aria/kellogg_remake/raw/PCKELL.DAT'
|
||||
OUT = '/home/aria/kellogg_remake/render_out'
|
||||
os.makedirs(OUT, exist_ok=True)
|
||||
|
||||
container = DATContainer(DAT_PATH)
|
||||
entries = container.entries
|
||||
|
||||
def frame_to_image(frame, palette):
|
||||
img = Image.new('RGBA', (frame.width, frame.height), (0, 0, 0, 0))
|
||||
px = img.load()
|
||||
for y in range(frame.height):
|
||||
for x in range(frame.width):
|
||||
idx = frame.pixels[y * frame.width + x]
|
||||
if idx < 0 or idx > 255:
|
||||
continue
|
||||
r, g, b = palette[idx]
|
||||
px[x, y] = (r, g, b, 255)
|
||||
return img
|
||||
|
||||
def render_bob(name):
|
||||
data = entries[name + '.BOB']
|
||||
palette = get_bob_palette(entries, name)
|
||||
frames = parse_bob(data)
|
||||
d = os.path.join(OUT, 'bob', name)
|
||||
os.makedirs(d, exist_ok=True)
|
||||
for i, frame in enumerate(frames):
|
||||
img = frame_to_image(frame, palette)
|
||||
img.save(os.path.join(d, f'{i:03d}.png'))
|
||||
# grid sheet (easier to eyeball than a tall vertical stack)
|
||||
if frames:
|
||||
cols = min(8, len(frames))
|
||||
maxw = max(f.width for f in frames)
|
||||
maxh = max(f.height for f in frames)
|
||||
rows = (len(frames) + cols - 1) // cols
|
||||
sheet = Image.new('RGBA', (cols*maxw, rows*maxh), (30,30,30,255))
|
||||
for i, frame in enumerate(frames):
|
||||
img = frame_to_image(frame, palette)
|
||||
x = (i % cols) * maxw
|
||||
y = (i // cols) * maxh
|
||||
sheet.paste(img, (x, y), img)
|
||||
sheet.save(os.path.join(OUT, 'bob', name + '_sheet.png'))
|
||||
return len(frames)
|
||||
|
||||
if __name__ == '__main__':
|
||||
import sys
|
||||
if len(sys.argv) > 1:
|
||||
name = sys.argv[1]
|
||||
n = render_bob(name)
|
||||
print(f'{name}.BOB -> {n} frames')
|
||||
else:
|
||||
print('usage: render_assets.py NAME (basename without extension)')
|
||||
|
||||
def render_all_bob():
|
||||
results = {}
|
||||
for filename in list(entries.keys()):
|
||||
if filename.endswith('.BOB'):
|
||||
name = filename[:-4]
|
||||
try:
|
||||
n = render_bob(name)
|
||||
results[name] = ('ok', n)
|
||||
except Exception as e:
|
||||
results[name] = ('ERROR', str(e))
|
||||
return results
|
||||
|
||||
def tile_to_image(grid, palette):
|
||||
img = Image.new('RGBA', (16, 16), (0,0,0,0))
|
||||
px = img.load()
|
||||
for y in range(16):
|
||||
for x in range(16):
|
||||
idx = grid[y*16+x]
|
||||
if idx < 0 or idx > 255:
|
||||
continue
|
||||
r,g,b = palette[idx]
|
||||
px[x,y] = (r,g,b,255)
|
||||
return img
|
||||
|
||||
def render_ico(filename):
|
||||
# filename e.g. 'W1.ICO', 'COCO_W2.ICO'
|
||||
name = filename[:-4]
|
||||
if 'W1' in name:
|
||||
world = 'W1'
|
||||
elif 'W2' in name:
|
||||
world = 'W2'
|
||||
elif 'W3' in name:
|
||||
world = 'W3'
|
||||
else:
|
||||
raise ValueError(f'cannot determine world for {filename}')
|
||||
palette = get_world_palette(entries, world)
|
||||
tiles = parse_ico(entries[filename])
|
||||
d = os.path.join(OUT, 'ico')
|
||||
os.makedirs(d, exist_ok=True)
|
||||
cols = 16
|
||||
rows = (len(tiles) + cols - 1) // cols
|
||||
sheet = Image.new('RGBA', (cols*16, max(rows,1)*16), (40,40,40,255))
|
||||
for i, tile in enumerate(tiles):
|
||||
img = tile_to_image(tile, palette)
|
||||
x = (i % cols) * 16
|
||||
y = (i // cols) * 16
|
||||
sheet.paste(img, (x,y), img)
|
||||
sheet.save(os.path.join(d, name + '.png'))
|
||||
return len(tiles)
|
||||
|
||||
def render_all_ico():
|
||||
results = {}
|
||||
for filename in list(entries.keys()):
|
||||
if filename.endswith('.ICO'):
|
||||
try:
|
||||
n = render_ico(filename)
|
||||
results[filename] = ('ok', n)
|
||||
except Exception as e:
|
||||
results[filename] = ('ERROR', str(e))
|
||||
return results
|
||||
|
||||
|
||||
_ico_cache = {}
|
||||
def get_ico_tiles_and_palette(iconame):
|
||||
if iconame not in _ico_cache:
|
||||
if 'W1' in iconame: world = 'W1'
|
||||
elif 'W2' in iconame: world = 'W2'
|
||||
elif 'W3' in iconame: world = 'W3'
|
||||
else: raise ValueError(iconame)
|
||||
palette = get_world_palette(entries, world)
|
||||
tiles = parse_ico(entries[iconame])
|
||||
_ico_cache[iconame] = (tiles, palette)
|
||||
return _ico_cache[iconame]
|
||||
|
||||
def render_map(filename):
|
||||
# filename e.g. 'W1L0.MAP' -> use W1.ICO + W1.PCC-derived palette
|
||||
base = filename[:2] # 'W1'
|
||||
ico_name = base + '.ICO'
|
||||
tiles, palette = get_ico_tiles_and_palette(ico_name)
|
||||
width, height, cells = parse_map(entries[filename])
|
||||
sheet = Image.new('RGBA', (width*16, height*16), (255,0,255,255))
|
||||
for i, (tile, ctype) in enumerate(cells):
|
||||
x = (i % width) * 16
|
||||
y = (i // width) * 16
|
||||
if tile < len(tiles):
|
||||
img = tile_to_image(tiles[tile], palette)
|
||||
sheet.paste(img, (x,y), img)
|
||||
d = os.path.join(OUT, 'map')
|
||||
os.makedirs(d, exist_ok=True)
|
||||
sheet.save(os.path.join(d, filename[:-4] + '.png'))
|
||||
return width, height
|
||||
|
||||
def render_all_map():
|
||||
results = {}
|
||||
for filename in list(entries.keys()):
|
||||
if filename.endswith('.MAP'):
|
||||
try:
|
||||
w,h = render_map(filename)
|
||||
results[filename] = ('ok', (w,h))
|
||||
except Exception as e:
|
||||
results[filename] = ('ERROR', str(e))
|
||||
return results
|
||||
@@ -1,99 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""PCKELL.PRE Splitter v7 -- FINAL (2026-07-22)
|
||||
|
||||
Format komplett verstanden:
|
||||
- .BOB-Eintraege (32x): kein Tag-Slot, Header direkt per Pfad-Praefix-Suche
|
||||
gefunden ("H:\\WIWA\\ENGINE\\GAMEDATA\\<name>"), Header = Fundstelle-4.
|
||||
- Alle Nicht-BOB-Eintraege (PCC/MAP/ARE/ICO/SAM/TFX, 146x aus APPEND.LST,
|
||||
PLUS 3 weitere System-Dateien ohne APPEND.LST-Eintrag): Tag-Slot
|
||||
[1-Byte-Namenslaenge][Dateiname][Fuellmuell bis 256 Byte], danach
|
||||
[4-Byte-LE-Laenge][Rohdaten].
|
||||
|
||||
WICHTIGER FUND: APPEND.LST listet nur die 178 Spiel-Assets. PCKELL.PRE
|
||||
enthaelt zusaetzlich, im GLEICHEN Tag-Format, direkt im Anschluss an den
|
||||
letzten APPEND.LST-Eintrag (TITEL2.SAM), noch 3 System-/Runtime-Dateien:
|
||||
DPMI16BI.OVL, RTM.EXE, START.EXE (die DOS-Extender-Runtime -- macht Sinn,
|
||||
das ist ein self-contained Redistributable). Der letzte dieser 3 Eintraege
|
||||
endet EXAKT auf EOF (0x238966) -- damit ist das Format zu 100% verifiziert,
|
||||
keine Bytes bleiben unerklaert.
|
||||
|
||||
Ergebnis: 178 (APPEND.LST) + 3 (System) = 181 Dateien total.
|
||||
"""
|
||||
import struct
|
||||
import os
|
||||
|
||||
RAW = "/home/aria/kellogg_remake/raw/PCKELL.PRE"
|
||||
APPEND_LST = "/home/aria/kellogg_remake/raw/APPEND.LST"
|
||||
OUT_DIR = "/home/aria/kellogg_remake/extracted_pre"
|
||||
|
||||
with open(RAW, "rb") as f:
|
||||
data = f.read()
|
||||
with open(APPEND_LST) as f:
|
||||
names = [l.strip() for l in f if l.strip()]
|
||||
|
||||
# die 3 unlisted System-Dateien, empirisch gefunden direkt im Anschluss
|
||||
EXTRA_NAMES = ["DPMI16BI.OVL", "RTM.EXE", "START.EXE"]
|
||||
|
||||
PATH_PREFIX = b"H:\\WIWA\\ENGINE\\GAMEDATA\\"
|
||||
N = len(data)
|
||||
|
||||
pos = 0x100
|
||||
entries = []
|
||||
all_names = names + EXTRA_NAMES
|
||||
|
||||
for i, name in enumerate(all_names):
|
||||
is_bob = name.upper().endswith(".BOB")
|
||||
if is_bob:
|
||||
marker = PATH_PREFIX + name.encode("ascii")
|
||||
p = data.find(marker, pos)
|
||||
if p == -1:
|
||||
print(f"FEHLER: Pfad fuer #{i} ({name}) nicht gefunden ab {pos:#x}")
|
||||
break
|
||||
header_start = p - 4
|
||||
length = struct.unpack_from("<I", data, header_start)[0]
|
||||
path_start = p
|
||||
nul = data.index(b"\x00", path_start)
|
||||
path = data[path_start:nul].decode("cp437", errors="replace")
|
||||
data_start = nul + 1
|
||||
else:
|
||||
tb = name.encode("ascii")
|
||||
marker = bytes([len(tb)]) + tb
|
||||
tag_pos = data.find(marker, pos)
|
||||
if tag_pos == -1:
|
||||
tag_pos = data.find(marker, max(0, pos - 300))
|
||||
if tag_pos == -1:
|
||||
print(f"FEHLER: Tag fuer #{i} ({name}) nicht gefunden ab {pos:#x}")
|
||||
break
|
||||
header_start = tag_pos + 256
|
||||
length = struct.unpack_from("<I", data, header_start)[0]
|
||||
path = None
|
||||
data_start = header_start + 4
|
||||
|
||||
data_end = data_start + length
|
||||
if data_end > N:
|
||||
print(f"FEHLER: Datenende {data_end:#x} > Dateigroesse bei #{i} ({name}) length={length}")
|
||||
break
|
||||
entries.append((name, header_start, length, data_start, data_end, path))
|
||||
pos = data_end
|
||||
|
||||
print(f"{len(entries)} von {len(all_names)} Eintraegen gefunden.")
|
||||
if entries:
|
||||
print(f"Letztes Datenende: {entries[-1][4]:#x} von {N:#x} (Match: {entries[-1][4] == N})")
|
||||
|
||||
mism = sum(1 for name, hs, length, ds, de, path in entries
|
||||
if path is not None and path.split("\\")[-1].upper() != name.upper())
|
||||
print(f"BOB Pfad-Mismatches: {mism}")
|
||||
|
||||
if len(entries) == len(all_names) and entries[-1][4] == N and mism == 0:
|
||||
os.makedirs(OUT_DIR, exist_ok=True)
|
||||
for name, hs, length, ds, de, path in entries:
|
||||
with open(os.path.join(OUT_DIR, name), "wb") as out:
|
||||
out.write(data[ds:de])
|
||||
print(f">>> ERFOLG: {len(entries)} Dateien geschrieben nach {OUT_DIR}")
|
||||
import collections
|
||||
ext_count = collections.Counter(n.split(".")[-1].upper() for n, *_ in entries)
|
||||
print("Typen:", dict(ext_count))
|
||||
else:
|
||||
print(">>> Unvollstaendig.")
|
||||
for e in entries[-5:]:
|
||||
print(" ", e[0], hex(e[1]), e[2])
|
||||
@@ -1,23 +0,0 @@
|
||||
import os
|
||||
|
||||
base = "/home/aria/kellogg_remake/extracted_pre/"
|
||||
names = ["A","B","C","D","E","F","G","H","I","J","K","L","N","O","BLUME","WOLKE",
|
||||
"VITAMIN","COCOPOPS","SMACKIES","FROSTIES","LOOPS","TONY","SMACKS","TOUCAN",
|
||||
"COCO","PLATFW1","KEYS","GAMEBAR","KROKO","BOSSNAKE","DRAGON","DOORS"]
|
||||
|
||||
N = 128
|
||||
headers = {}
|
||||
for nm in names:
|
||||
path = base+nm+".BOB"
|
||||
data = open(path,"rb").read()
|
||||
headers[nm] = data[:N]
|
||||
print(f"{nm:10s} size={len(data):6d} header={data[:N].hex()}")
|
||||
|
||||
print()
|
||||
print("Per-byte-position constant analysis (position: set of distinct values, only show non-constant or show const marker):")
|
||||
for pos in range(N):
|
||||
vals = set(h[pos] for h in headers.values() if len(h) > pos)
|
||||
if len(vals) == 1:
|
||||
print(f"pos {pos:3d}: CONST 0x{next(iter(vals)):02x}")
|
||||
else:
|
||||
print(f"pos {pos:3d}: VARIES ({len(vals)} distinct)")
|
||||
@@ -1,61 +0,0 @@
|
||||
import struct
|
||||
|
||||
def decode_scanline(data, width, max_rows=100000):
|
||||
i = 0
|
||||
n = len(data)
|
||||
rows = 0
|
||||
row_len = 0
|
||||
while i < n:
|
||||
if row_len >= width:
|
||||
rows += 1
|
||||
row_len = 0
|
||||
if rows > max_rows:
|
||||
return rows, i, False
|
||||
continue
|
||||
b = data[i]
|
||||
if (b & 0xC0) == 0xC0:
|
||||
count = b & 0x3F
|
||||
i += 1
|
||||
if i >= n:
|
||||
return rows, i, False
|
||||
i += 1
|
||||
need = width - row_len
|
||||
take = min(count, need)
|
||||
row_len += take
|
||||
else:
|
||||
row_len += 1
|
||||
i += 1
|
||||
if row_len == 0:
|
||||
return rows, i, True
|
||||
else:
|
||||
rows += 1 # partial
|
||||
return rows, i, False
|
||||
|
||||
base = "/home/aria/kellogg_remake/extracted_pre/"
|
||||
files = ["B.BOB","E.BOB","N.BOB","O.BOB","A.BOB","J.BOB","K.BOB","D.BOB"]
|
||||
|
||||
for fn in files:
|
||||
data = open(base+fn, "rb").read()
|
||||
n = len(data)
|
||||
print(f"=== {fn} size={n} ===")
|
||||
found_any = False
|
||||
for headerlen in range(0, 17, 1):
|
||||
if headerlen % 2 != 0:
|
||||
continue
|
||||
header = data[:headerlen]
|
||||
body = data[headerlen:]
|
||||
num_u16 = headerlen // 2
|
||||
u16s = struct.unpack(f"<{num_u16}H", header) if headerlen else ()
|
||||
# try every pair (w_idx, h_idx) among header u16 fields as (width,height) candidates
|
||||
for wi in range(num_u16):
|
||||
w = u16s[wi]
|
||||
if w < 2 or w > 400:
|
||||
continue
|
||||
rows, consumed, ok = decode_scanline(body, w)
|
||||
if ok:
|
||||
# check if any header u16 equals rows (=height)
|
||||
match_h = [hi for hi,val in enumerate(u16s) if val == rows]
|
||||
print(f" headerlen={headerlen} width_idx={wi} width={w} -> rows={rows} clean=True header_u16={u16s} height_field_match_idx={match_h}")
|
||||
found_any = True
|
||||
if not found_any:
|
||||
print(" (no clean header+width combo found in range)")
|
||||
@@ -1,30 +0,0 @@
|
||||
def rle_decode_pcx_style(data):
|
||||
out = bytearray()
|
||||
i = 0
|
||||
n = len(data)
|
||||
while i < n:
|
||||
b = data[i]
|
||||
if (b & 0xC0) == 0xC0:
|
||||
count = b & 0x3F
|
||||
i += 1
|
||||
if i >= n:
|
||||
break
|
||||
val = data[i]
|
||||
out.extend([val]*count)
|
||||
i += 1
|
||||
else:
|
||||
out.append(b)
|
||||
i += 1
|
||||
return bytes(out)
|
||||
|
||||
base = "/home/aria/kellogg_remake/extracted_pre/"
|
||||
for fn in ["TONY.BOB","O.BOB","A.BOB"]:
|
||||
data = open(base+fn,"rb").read()
|
||||
dec = rle_decode_pcx_style(data)
|
||||
from collections import Counter
|
||||
c = Counter(dec)
|
||||
print(fn, "distinct values:", len(c), "min", min(dec), "max", max(dec))
|
||||
top = c.most_common(10)
|
||||
print(" top10:", top)
|
||||
below16 = sum(v for k,v in c.items() if k<16)
|
||||
print(f" fraction of pixels <16: {below16/len(dec):.3f} total_pixels={len(dec)}")
|
||||
@@ -1,15 +0,0 @@
|
||||
import os
|
||||
|
||||
base = "/home/aria/kellogg_remake/extracted_pre/"
|
||||
names = ["A","B","C","D","E","F","G","H","I","J","K","L","N","O","BLUME","WOLKE",
|
||||
"VITAMIN","COCOPOPS","SMACKIES","FROSTIES","LOOPS","TONY","SMACKS","TOUCAN",
|
||||
"COCO","PLATFW1","KEYS","GAMEBAR","KROKO","BOSSNAKE","DRAGON","DOORS"]
|
||||
|
||||
landmark = bytes.fromhex("7682b43a9f068882")
|
||||
|
||||
for nm in names:
|
||||
path = base+nm+".BOB"
|
||||
data = open(path,"rb").read()
|
||||
idx = data.find(landmark, 0, 64)
|
||||
pre = data[:idx] if idx>=0 else None
|
||||
print(f"{nm:10s} size={len(data):6d} landmark_at={idx:3d} preamble={pre.hex() if pre else 'NOTFOUND'}")
|
||||
@@ -1,51 +0,0 @@
|
||||
from PIL import Image
|
||||
import math
|
||||
|
||||
def rle_decode_pcx_style(data):
|
||||
out = bytearray()
|
||||
i = 0
|
||||
n = len(data)
|
||||
while i < n:
|
||||
b = data[i]
|
||||
if (b & 0xC0) == 0xC0:
|
||||
count = b & 0x3F
|
||||
i += 1
|
||||
if i >= n:
|
||||
break
|
||||
val = data[i]
|
||||
out.extend([val]*count)
|
||||
i += 1
|
||||
else:
|
||||
out.append(b)
|
||||
i += 1
|
||||
return bytes(out)
|
||||
|
||||
base = "/home/aria/kellogg_remake/extracted_pre/"
|
||||
fn = "O.BOB"
|
||||
data = open(base+fn, "rb").read()
|
||||
dec = rle_decode_pcx_style(data)
|
||||
print("decoded len:", len(dec))
|
||||
|
||||
widths = list(range(8, 60, 2))
|
||||
cell_h = 80
|
||||
cell_w = 60
|
||||
cols = 8
|
||||
rows = math.ceil(len(widths)/cols)
|
||||
sheet = Image.new("L", (cols*cell_w, rows*cell_h), 40)
|
||||
|
||||
for idx, w in enumerate(widths):
|
||||
h = (len(dec) + w - 1)//w
|
||||
padded = dec + bytes(w*h - len(dec))
|
||||
img = Image.frombytes("L", (w, h), padded)
|
||||
# scale to fit cell, keep aspect
|
||||
scale = min(cell_w/w, cell_h/h)
|
||||
nw, nh = max(1,int(w*scale)), max(1,int(h*scale))
|
||||
img_r = img.resize((nw, nh), Image.NEAREST)
|
||||
cx = (idx % cols) * cell_w
|
||||
cy = (idx // cols) * cell_h
|
||||
sheet.paste(img_r, (cx, cy))
|
||||
|
||||
sheet = sheet.resize((sheet.width*3, sheet.height*3), Image.NEAREST)
|
||||
outpath = "/home/aria/kellogg_remake/tools/o_bob_grid.png"
|
||||
sheet.save(outpath)
|
||||
print("saved", outpath, "widths:", widths)
|
||||
@@ -1,66 +0,0 @@
|
||||
from PIL import Image
|
||||
import math, sys
|
||||
|
||||
def rle_decode_scanline_clipped(data, width, max_rows=400):
|
||||
"""Decode with PCX-style per-scanline clipping: exactly `width` px per row,
|
||||
overshoot from a run is discarded, continues to next row."""
|
||||
rows = []
|
||||
row = []
|
||||
i = 0
|
||||
n = len(data)
|
||||
while i < n and len(rows) < max_rows:
|
||||
if len(row) >= width:
|
||||
rows.append(row)
|
||||
row = []
|
||||
continue
|
||||
b = data[i]
|
||||
if (b & 0xC0) == 0xC0:
|
||||
count = b & 0x3F
|
||||
i += 1
|
||||
if i >= n:
|
||||
break
|
||||
val = data[i]
|
||||
i += 1
|
||||
need = width - len(row)
|
||||
take = min(count, need)
|
||||
row.extend([val]*take)
|
||||
else:
|
||||
row.append(b)
|
||||
i += 1
|
||||
if row:
|
||||
row.extend([0]*(width-len(row)))
|
||||
rows.append(row)
|
||||
return rows
|
||||
|
||||
base = "/home/aria/kellogg_remake/extracted_pre/"
|
||||
fn = sys.argv[1] if len(sys.argv) > 1 else "O.BOB"
|
||||
skip = int(sys.argv[2]) if len(sys.argv) > 2 else 0
|
||||
data = open(base+fn, "rb").read()[skip:]
|
||||
|
||||
widths = list(range(8, 60, 2))
|
||||
cell_h = 90
|
||||
cell_w = 60
|
||||
cols = 8
|
||||
rows_n = math.ceil(len(widths)/cols)
|
||||
sheet = Image.new("L", (cols*cell_w, rows_n*cell_h), 40)
|
||||
|
||||
for idx, w in enumerate(widths):
|
||||
rows = rle_decode_scanline_clipped(data, w, max_rows=cell_h)
|
||||
h = len(rows)
|
||||
if h == 0:
|
||||
continue
|
||||
flat = bytearray()
|
||||
for r in rows:
|
||||
flat.extend(r)
|
||||
img = Image.frombytes("L", (w, h), bytes(flat))
|
||||
scale = min(cell_w/w, cell_h/h)
|
||||
nw, nh = max(1,int(w*scale)), max(1,int(h*scale))
|
||||
img_r = img.resize((nw, nh), Image.NEAREST)
|
||||
cx = (idx % cols) * cell_w
|
||||
cy = (idx // cols) * cell_h
|
||||
sheet.paste(img_r, (cx, cy))
|
||||
|
||||
sheet = sheet.resize((sheet.width*3, sheet.height*3), Image.NEAREST)
|
||||
outpath = f"/home/aria/kellogg_remake/tools/{fn}_grid_clip_skip{skip}.png"
|
||||
sheet.save(outpath)
|
||||
print("saved", outpath, "widths:", widths)
|
||||
@@ -1,40 +0,0 @@
|
||||
import sys, struct
|
||||
|
||||
def rle_decode_pcx_style(data):
|
||||
"""Decode assuming classic PCX RLE over the whole byte stream (no scanline boundary)."""
|
||||
out = bytearray()
|
||||
i = 0
|
||||
n = len(data)
|
||||
while i < n:
|
||||
b = data[i]
|
||||
if (b & 0xC0) == 0xC0:
|
||||
count = b & 0x3F
|
||||
i += 1
|
||||
if i >= n:
|
||||
break
|
||||
val = data[i]
|
||||
out.extend([val]*count)
|
||||
i += 1
|
||||
else:
|
||||
out.append(b)
|
||||
i += 1
|
||||
return bytes(out)
|
||||
|
||||
def factor_pairs_near_sqrt(total, tol=0):
|
||||
import math
|
||||
res = []
|
||||
for w in range(1, int(math.isqrt(total))+50):
|
||||
if w == 0: continue
|
||||
if total % w == 0:
|
||||
h = total // w
|
||||
res.append((w,h))
|
||||
return res
|
||||
|
||||
files = ["A.BOB","B.BOB","E.BOB","N.BOB","O.BOB","D.BOB","H.BOB","I.BOB","J.BOB","K.BOB","TONY.BOB"]
|
||||
base = "/home/aria/kellogg_remake/extracted_pre/"
|
||||
|
||||
for fn in files:
|
||||
path = base+fn
|
||||
data = open(path,"rb").read()
|
||||
dec = rle_decode_pcx_style(data)
|
||||
print(fn, "raw_len=",len(data), "decoded_len=",len(dec))
|
||||
@@ -1,64 +0,0 @@
|
||||
import sys
|
||||
|
||||
def try_decode_scanline(data, width, max_height=2000):
|
||||
"""PCX-style per-scanline RLE decode: for each row, decode exactly `width`
|
||||
pixels (excess from a run discarded), continue until input consumed.
|
||||
Returns (rows_pixels_list, bytes_consumed, ok, error_msg)."""
|
||||
i = 0
|
||||
n = len(data)
|
||||
rows = []
|
||||
row = []
|
||||
while i < n:
|
||||
if len(row) >= width:
|
||||
rows.append(row)
|
||||
row = []
|
||||
if len(rows) > max_height:
|
||||
return rows, i, False, "too many rows"
|
||||
continue
|
||||
b = data[i]
|
||||
if (b & 0xC0) == 0xC0:
|
||||
count = b & 0x3F
|
||||
i += 1
|
||||
if i >= n:
|
||||
return rows, i, False, "truncated run (missing value byte)"
|
||||
val = data[i]
|
||||
i += 1
|
||||
need = width - len(row)
|
||||
take = min(count, need)
|
||||
row.extend([val]*take)
|
||||
# NOTE: if count > need, the overshoot pixels for the *next* row
|
||||
# are DISCARDED per classic PCX semantics (not carried over)
|
||||
else:
|
||||
row.append(b)
|
||||
i += 1
|
||||
if row:
|
||||
# leftover partial row at EOF
|
||||
rows.append(row)
|
||||
return rows, i, False, f"EOF with partial row of {len(row)} px"
|
||||
return rows, i, True, "clean"
|
||||
|
||||
def scan_widths(data, wmin=4, wmax=250):
|
||||
results = []
|
||||
for w in range(wmin, wmax+1):
|
||||
rows, consumed, ok, msg = try_decode_scanline(data, w)
|
||||
# figure out leftover partial-row size from msg if present
|
||||
leftover = None
|
||||
if "partial row of" in msg:
|
||||
leftover = int(msg.split("partial row of")[1].split("px")[0].strip())
|
||||
elif msg == "clean":
|
||||
leftover = 0
|
||||
results.append((w, len(rows), leftover, ok, msg))
|
||||
return results
|
||||
|
||||
base = "/home/aria/kellogg_remake/extracted_pre/"
|
||||
files = ["A.BOB","B.BOB","E.BOB","N.BOB","O.BOB","D.BOB","J.BOB"]
|
||||
for fn in files:
|
||||
data = open(base+fn,"rb").read()
|
||||
print(f"=== {fn} (size={len(data)}) ===")
|
||||
results = scan_widths(data)
|
||||
clean = [r for r in results if r[2]==0]
|
||||
if clean:
|
||||
for r in clean:
|
||||
print(" CLEAN (leftover=0):", r)
|
||||
else:
|
||||
print(" no width in range gives leftover==0")
|
||||
@@ -1,29 +0,0 @@
|
||||
import struct, sys
|
||||
|
||||
path = "/home/aria/kellogg_remake/raw/PCKELL.DAT"
|
||||
data = open(path, "rb").read()
|
||||
print("total size:", len(data))
|
||||
|
||||
# Read uint16 LE values until they stop being monotonically non-decreasing
|
||||
vals = []
|
||||
off = 0
|
||||
prev = -1
|
||||
while off + 2 <= len(data):
|
||||
v = struct.unpack_from("<H", data, off)[0]
|
||||
vals.append(v)
|
||||
off += 2
|
||||
if len(vals) > 5000:
|
||||
break
|
||||
|
||||
# find longest monotonic non-decreasing prefix
|
||||
mono_len = 1
|
||||
for i in range(1, len(vals)):
|
||||
if vals[i] >= vals[i-1]:
|
||||
mono_len = i+1
|
||||
else:
|
||||
break
|
||||
|
||||
print("monotonic non-decreasing prefix length (uint16 entries):", mono_len)
|
||||
print("that's byte offset:", mono_len*2)
|
||||
print("first 40 vals:", vals[:40])
|
||||
print("vals around break point:", vals[max(0,mono_len-10):mono_len+10])
|
||||
@@ -1,24 +0,0 @@
|
||||
import struct
|
||||
|
||||
path = "/home/aria/kellogg_remake/raw/PCKELL.DAT"
|
||||
data = open(path, "rb").read()
|
||||
|
||||
vals = []
|
||||
off = 0
|
||||
while off + 2 <= len(data):
|
||||
v = struct.unpack_from("<H", data, off)[0]
|
||||
vals.append(v)
|
||||
off += 2
|
||||
|
||||
start = 6 # skip first 6 uint16 (12 bytes) which look like a header
|
||||
mono_len = start+1
|
||||
for i in range(start+1, len(vals)):
|
||||
if vals[i] >= vals[i-1]:
|
||||
mono_len = i+1
|
||||
else:
|
||||
break
|
||||
|
||||
print("monotonic non-decreasing run starting at idx", start, "-> length", mono_len-start, "entries")
|
||||
print("breaks at idx", mono_len, "byte offset", mono_len*2)
|
||||
print("values around break:", vals[mono_len-5:mono_len+15])
|
||||
print("last mono value:", vals[mono_len-1])
|
||||
@@ -1,12 +0,0 @@
|
||||
import struct
|
||||
|
||||
path = "/home/aria/kellogg_remake/raw/PCKELL.DAT"
|
||||
data = open(path, "rb").read()
|
||||
|
||||
# look at region from 580 to 900, print as hex with offsets
|
||||
start = 580
|
||||
end = 900
|
||||
for i in range(start, end, 16):
|
||||
chunk = data[i:i+16]
|
||||
hexs = ' '.join(f'{b:02x}' for b in chunk)
|
||||
print(f'{i:06x}: {hexs}')
|
||||
@@ -1,16 +0,0 @@
|
||||
import struct
|
||||
|
||||
path = "/home/aria/kellogg_remake/raw/PCKELL.DAT"
|
||||
data = open(path, "rb").read()
|
||||
|
||||
start = 588
|
||||
end = 900
|
||||
vals = []
|
||||
off = start
|
||||
while off+2 <= end:
|
||||
v = struct.unpack_from('<H', data, off)[0]
|
||||
vals.append((off, v))
|
||||
off += 2
|
||||
|
||||
for off, v in vals:
|
||||
print(off, hex(v), v)
|
||||
Reference in New Issue
Block a user