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>

.gitignore

@@ -1,4 +1,5 @@
 # Original-Spieldateien (copyrighted, gehoeren nicht ins Repo)
 raw/
 extracted_pre/
+extracted_dat/
 *.ppm

NOTES.md

@@ -618,3 +618,103 @@ Hinschauen (Bild anzeigen, nicht nur Bytes vergleichen) klar falsch war.
 Naechstes Mal: bei jeder Verifikations-Behauptung IMMER das decodierte Bild
 selbst anschauen (Read-Tool, multimodal), nicht nur Byte-/Pixel-Statistiken
 vertrauen, bevor ich "geloest"/"verifiziert" sage.
+
+## DURCHBRUCH 2026-07-22 (Nachmittag/Abend) — BOB/ICO/MAP komplett geloest
+
+Stefan wollte aufraeumen + alle restlichen Assets (BOB/ICO/MAP/ARE/SAM/TFX).
+Grosser Fund dabei: **`PCKELL.DAT` ist der eigentliche, einzige Asset-
+Container** — nicht `PCKELL.PRE` (das war nur ein Nebenprodukt/Cache aus
+`PCKELL.SET`). Referenz-Repo (`Formats/DATFile.cs`) beschreibt ihn explizit
+als "the only container format": Index steht am DATEIENDE (Anzahl Entries
+als u16 bei `len-4`, Index-Offset als i32 bei `len-8`), pro Entry
+`[u16 NameLen][Name][i32 Offset]`, Laenge = Differenz zum naechsten Offset.
+Score: **alle 178 Dateien fehlerfrei extrahiert**, exakt matchend zu
+APPEND.LST — und `KELLOGGS.PCC` daraus ist **byte-identisch** zur alten
+PRE-Extraktion, also war unser PCC-Weg schon konsistent. `PCKELL.PRE`/
+`extracted_pre/`/`split_pre.py` sind damit ueberfluessig geworden, aus dem
+Tool-Set entfernt (Repo-Hygiene, kein Skill-Friedhof-Aequivalent fuer
+Tools). Neue kanonische Quelle: `tools/dat_extract.py` +
+`tools/kellogg_formats.DATContainer`.
+
+**PCC-Bug-Nachtrag:** beim heutigen Re-Check mit frischem Blick (Kellogg's-
+Logo UND Weltkarte hochskaliert wirklich angeschaut, nicht nur behauptet)
+ist `png_out/` tatsaechlich korrekt — Frosch im Teich unten links, Drache+
+Schloss oben, Tiger/Coco richtig platziert, "Kellogg's präsentiert"-Box sauber.
+Der PCC-Teil war also wirklich fertig, keine weitere Aktion noetig.
+
+**BOB (Sprites) — komplett geloest.** Format aus `BOBFile.cs`/`Form1.cs`
+in eigenes Python uebersetzt (`tools/kellogg_formats.py`, Funktionen
+`parse_bob`/`_parse_bob_executable`): jede BOB-Datei ist eine Sequenz von
+Frames, jeder Frame hat einen 14-Byte-Header (Breite/Hoehe/Laenge des
+"Pointer"-Segments), gefolgt von echtem, sich selbst beschreibendem x86-
+Maschinencode (`mov byte/word ptr [si+X], Y`-Ketten + `out dx,al` fuer
+EGA-Page-Wechsel), der beim "Ausfuehren" direkt die Pixel-Kopieranweisungen
+liefert (Offset+EGA-Page -> x/y, Pixelwert = Byte-Konstante minus 0x80 als
+Palette-Index). Kein echter x86-Interpreter noetig, nur ein kleiner
+Pattern-Matcher fuer die 10 vorkommenden Opcodes. Palette kommt (Form1.cs-
+Regel) von der PCC-Datei mit gleichem Basisnamen (z.B. `TONY.BOB` ->
+Palette aus `TONY.PCC`), bei 1-Buchstaben-Dateien (`A.BOB`..`O.BOB`, die
+Ameisen) von `ANTS.PCC`, sonst von `W2.PCC` mit Index 0 auf Schwarz
+gesetzt. **Alle 32 BOB-Dateien fehlerfrei decodiert, 462 Frames total.**
+Visuell verifiziert (nicht nur Byte-Statistik!): `A.BOB` ist eine 8-Frame-
+Laufanimation eines kleinen Kaefers/Ameise, `TONY.BOB` zeigt Tony den
+Tiger unmissverstaendlich in Lauf-, Wink-, Sitz- und Sprung-Posen (53
+Frames). Ergebnisse in `render_out/bob/<NAME>/NNN.png` (Einzelframes) +
+`render_out/bob/<NAME>_sheet.png` (Grid-Uebersicht).
+
+**ICO (Tilesets) — komplett geloest.** 16x16-Kacheln in "gescrambelter"
+EGA-Spaltenreihenfolge (`parse_ico`): pro Zeile 4 EGA-Pages a 4 Pixel,
+Palette-Index = Byte minus 128. Palette-Regel: `W1`/`W2`/`W3` aus dem
+Dateinamen erkannt, Basis-Palette von `<WORLD>.PCC`, aber die 16 Farben
+Index 16-31 IMMER von `W2.PCC` ueberschrieben (die sind laut Referenz die
+geteilten Animations-/Item-Farben aller drei Welten) — ausser bei `W2`
+selbst. **Alle 19 ICO-Dateien fehlerfrei decodiert.** Ergebnis in
+`render_out/ico/<NAME>.png`.
+
+**MAP (Level-Karten) — komplett geloest.** Klares Format, aber
+GROSS-ENDIAN (!), Signatur `"TLE1"`, dann Breite/Hoehe/Konstante(=9) je
+als big-endian int16, danach `Breite*Hoehe` big-endian u16-Zellen: unteres
+9-Bit-Feld = Tile-Index (ins passende `<WORLD>.ICO`), oberes 7-Bit-Feld =
+Kollisions-/Typ-Info (noch nicht weiter interpretiert). **Alle 22 MAP-
+Dateien fehlerfrei decodiert UND gerendert** (Tile-Lookup im passenden ICO
++ Palette) — `W1L0.png` zeigt ein komplettes, stimmiges Level: Haeuser mit
+rotem Dach, Buesche/Baeume, Wolken, blauer Himmel, Bergketten, alles exakt
+an der Stelle, die man von einem Kellogg's-Tony-Jump'n'Run erwartet.
+Ergebnis in `render_out/map/<NAME>.png`.
+
+**ARE (Kollisionszonen) — NICHT geloest, bewusst zurueckgestellt.** Auch
+die C#-Referenz hat das nie fertig gemacht (`AREFile.cs` liest nur naiv
+176 little-endian u16-Werte ohne jede semantische Deutung, README nennt
+nur den Namen "Area" ohne Details). Da MAP-Zellen bereits ein 7-Bit-
+Kollisions-Typ-Feld mitbringen, ist unklar ob ARE ueberhaupt noch fuer den
+Python-Port gebraucht wird (vielleicht redundant/Level-Editor-Metadaten) —
+das klaeren wir erst, wenn die Spiellogik so weit ist dass Kollision
+gebraucht wird. Rohdaten bleiben in `extracted_dat/` (nicht committed)
+falls wir spaeter draufschauen wollen.
+
+**SAM/TFX (Sound, TFMX-Format) — noch nicht angefasst.** 3+3 = 6 Dateien,
+niedrige Prioritaet (Musik/SFX kommt spaeter, sobald Grafik+Logik stehen).
+TFMX ist ein bekanntes Amiga/DOS-Tracker-Format, sollte mit vorhandenen
+Libraries (z.B. `libxmp`/`ym2149`-Tools) machbar sein, nicht neu erfunden
+werden muessen.
+
+**Aufraeumen erledigt:**
+- VM-Arbeitsverzeichnis (`/home/aria/kellogg_remake` auf `aria-wohnung`,
+  NICHT im Repo): alle Debug-Logs/Test-Screenshots aus der DOSBox-IRQ-
+  Session sowie `png_out_v2/` (veraltet) geloescht.
+- `tools/`: alle Blindflug-Skripte aus der ersten BOB-Exploration
+  (`bob_header_diff.py`, `bob_width_search.py`, `dat_analyze*.py`, etc.)
+  UND `tools/wip_bob_sprite_research/` komplett entfernt — durch die
+  echte Loesung in `kellogg_formats.py` ueberfluessig. `split_pre.py`
+  ebenfalls entfernt (PRE-Weg durch DAT-Weg ersetzt).
+- `.gitignore`: `extracted_dat/` ergaenzt (Rohdaten, copyrighted, wie
+  `raw/`/`extracted_pre/` vorher schon).
+
+**Naechste Schritte (Prioritaet, Stand Abend 22.07.):**
+1. Rauser-Intro-Sequenz zusammensetzen (niedrig, Assets schon da).
+2. Sound (SAM/TFX, TFMX-Format) angehen, wenn Zeit ist.
+3. ARE/Kollisionsformat klaeren — erst wenn's fuer Spiellogik gebraucht wird.
+4. **Jetzt wo alle visuellen Assets (PCC/BOB/ICO/MAP) fertig sind:**
+   Python/pygame-Projektstruktur aufsetzen — Asset-Loader (Palette-Regeln
+   aus `kellogg_formats.py` direkt uebernehmen), dann Tony-Bewegung/
+   Kollision/Level-Scrolling als erste spielbare Vertical Slice.