KistePix

So gebaut

KistePix ist ein reines Kiste-Programm — eine einzige Datei mit rund 5700 Zeilen, ohne Spiel- oder Grafik-Engine. Es nutzt die eingebauten Module gui (Fenster, Leinwand, Bedienelemente), bild (Pixel-Puffer, PNG/GIF), datei, json und pfad (Speichern/Laden), bytes (Hex-Farben) und mathe.

Was drinsteckt

• Ebenen mit Deckkraft und Reihenfolge, live übereinandergelegt
• Animation mit Frames, Zeitleiste, Zwiebelschale und Dauer pro Frame
• Eigene Paletten (bis 256 Farben) zum Laden und Speichern
• Werkzeuge: Stift, Radierer, Füller, Linie, Rechteck, Kreis, Auswahl, Lasso, Pipette, Spiegeln & Symmetrie
• Undo/Redo, Zoom & Verschieben, Transparenz-Schachbrett
• Export als PNG, animiertes GIF und Sprite-Sheet (mit Aseprite-JSON, das Godot, Unity oder Phaser direkt lesen)
• Zweisprachige Oberfläche (Deutsch/Englisch) und eigenes Hilfe-Fenster

Ebenen in einem Rutsch zeichnen

Statt Pixel für Pixel zu setzen, mischt KistePix alle sichtbaren Ebenen in einen flachen Speicherpuffer und schreibt diesen in einem Aufruf auf die Leinwand. Dadurch bleibt das Zeichnen auch bei großen Bildern flüssig.

// Alle Ebenen werden in EINEN flachen RGBA-Puffer gemischt und
// dann in einem einzigen Aufruf auf die Leinwand geschrieben —
// die Kosten hängen nicht mehr an der Leinwandgröße.
bild.setze_puffer(komposit_bild, komposit_puf)

Rückgängig, ohne Speicher zu fressen

Ein voller Bild-Schnappschuss pro Pinselstrich wäre viel zu teuer. KistePix merkt sich stattdessen nur die geänderten Pixel — Index und alten Wert — in einem Ringpuffer. Eine „Generations-Marke" verhindert, dass derselbe Pixel im selben Schritt doppelt landet.

funktion undo_erfasse(idx, alt) {
    wenn d_offen == falsch { gib }
    nimm mk = d_mark
    wenn mk[idx] == d_gen { gib }     // in diesem Schritt schon erfasst
    mk[idx] = d_gen
    // nur den Pixel-Index und seinen ALTEN Wert merken:
    ai[w] = idx
    av[w] = alt
    d_len = d_len + 1
}

Animation exportieren

Jeder Frame hat seine eigene Dauer. Beim Export wird daraus ein animiertes GIF mit passenden Verzögerungen — oder ein Sprite-Sheet samt JSON für Spiel-Engines.

funktion exportiere_gif(pfad, faktor) {
    nimm bilder = liste.gefüllt(länge(frames), 0)
    nimm dauern = liste.gefüllt(länge(frames), 0)   // je Frame eine Dauer
    für f = 0 bis länge(frames) - 1 {
        bilder[f] = frame_als_bild(f, faktor, 0)
        dauern[f] = frames[f].dauer div 10          // ms -> 1/100 s (GIF-Einheit)
    }
    bild.schreibe_gif_animiert_dauern(pfad, bilder, dauern)
}

Sprite-Sheets für Spiele-Engines

Für Spiele exportiert KistePix alle Frames als ein Sprite-Sheet — ein breites Bild mit allen Einzelbildern nebeneinander — und schreibt dazu automatisch eine Begleit-.json im Aseprite-Schema. Godot, Unity oder Phaser lesen sie direkt ein, samt der Dauer jedes Frames. So wird aus einer Animation in KistePix ohne Umwege ein fertiges Spiel-Asset.

funktion exportiere_blatt(pfad, faktor, transparent) {
    nimm n = länge(frames)
    nimm img = bild.neu(n * LEIN_B * faktor, LEIN_H * faktor)
    für f = 0 bis n - 1 {
        // jeden Frame nebeneinander ins Blatt malen …
    }
    bild.schreibe_png(img, pfad)
    // Begleit-JSON im Aseprite-Schema — Godot/Unity/Phaser lesen es direkt:
    datei.schreibe(mit_json(pfad), blatt_json_text(pfad, faktor))
}

KistePix zeigt, wie weit ein einzelnes Kiste-Programm trägt: ein komplettes Kreativwerkzeug, das es mit den üblichen Pixel-Editoren aufnimmt — offen zum Anschauen, Verändern und Selber-Bauen.