API Referenz

Vollständige API Referenz

Auch in Kurzform innerhalb des Editors selbst verfügbar:

Asset-Konstruktoren

Konstruktoren erstellen die Haupt-Asset-Typen, die vom Editor verwendet werden. Wenn Sie einen einer Variablen zuweisen, erkennt der Editor ihn und ermöglicht es Ihnen, den entsprechenden Asset-Editor mit Strg+Klick zu öffnen.

Funktion	Beschreibung
`Sprite(width, height)`	Erstellt ein Sprite-Asset mit angegebenen Abmessungen
`Scene()` oder `Scene(name)`	Erstellt ein Szenen-Asset
`Audio()`	Erstellt ein kleines tracker-artiges Audio-Asset
`Object()` oder `Object(name)`	Erstellt ein Spielobjekt

Listenmethoden

Erstellen Sie Listen mit [] oder [value1, value2, ...]. Lesen und überschreiben Sie Einträge mit list[index], und iterieren Sie mit for (var i = 0; i < list.length(); i = i + 1).

Funktion	Beschreibung
`list.add(value)`	Fügt einen Wert ans Ende der Liste an
`list.length()`	Gibt die Anzahl der Elemente in der Liste zurück
`list.remove(index)`	Entfernt das Element am angegebenen Index
`list.clear()`	Entfernt alle Elemente aus der Liste

Operatoren

Operatoren sind kleine Symbole, die allgemeine Berechnungen durchführen. Der Modulo-Operator ist besonders nützlich für das Umwickeln von Timern, Indizes, Animationsschritten oder sich wiederholenden Mustern.

Operator	Beschreibung
`%`	Modulo. Gibt den Rest nach der Division zurück

Objekt-Eigenschaften

Objekte sind die Dinge, die Ihr Skript normalerweise während des Spiels bewegt und verändert. Diese Funktionen lesen oder aktualisieren die Position, das Sprite, das Kollisionsverhalten, die Schicht und den visuellen Farbton eines Objekts.

Funktion	Beschreibung
`getX(obj)`	Gibt die X-Position des Objekts zurück
`setX(obj, x)`	Setzt die X-Position des Objekts
`getY(obj)`	Gibt die Y-Position des Objekts zurück
`setY(obj, y)`	Setzt die Y-Position des Objekts
`getVelocityX(obj)`	Gibt die X-Geschwindigkeit des Objekts zurück
`setVelocityX(obj, vx)`	Setzt die X-Geschwindigkeit des Objekts
`getVelocityY(obj)`	Gibt die Y-Geschwindigkeit des Objekts zurück
`setVelocityY(obj, vy)`	Setzt die Y-Geschwindigkeit des Objekts
`getName(obj)`	Gibt den Namen des Objekts zurück
`setName(obj, name)`	Setzt den Namen des Objekts
`getSprite(obj)`	Gibt das Sprite des Objekts zurück
`setSprite(obj, sprite)`	Weist dem Objekt ein Sprite zu (setzt die Animation auf Frame 0 zurück)
`getLayer(obj)`	Gibt die Zeichenschicht des Objekts zurück
`setLayer(obj, layer)`	Setzt die Zeichenschicht des Objekts (höher = später gezeichnet)
`getTint(obj)`	Gibt den Farbton als [r, g, b, a] Liste zurück
`setTint(obj, r, g, b, a)`	Setzt den Farbton des Objekts (0-255 jeweils)
`getCollisionType(obj)`	Gibt die Kollisionstyp-Nummer zurück
`setCollisionType(obj, type)`	Setzt den Kollisionstyp

Sprite-Funktionen

Sprite-Funktionen ermöglichen es, die Sprite-Pixeldaten und die Animationsgeschwindigkeit zu inspizieren oder zu ändern. Die meisten Spiele zeichnen Sprites im Editor, aber diese Funktionen sind nützlich für prozedurale Effekte, Debugging oder einfache Laufzeitanpassungen.

Funktion	Beschreibung
`fillSprite(sprite, r, g, b, a)`	Füllt alle Pixel aller Frames mit einer soliden RGBA-Farbe (0-255)
`getPixel(sprite, frame, x, y)`	Gibt [r,g,b,a] des Pixels an (x,y) im gegebenen Frame zurück oder null, wenn es außerhalb der Grenzen liegt
`setPixel(sprite, frame, x, y, r, g, b, a)`	Setzt die Pixel-Farbe an (x,y) im gegebenen Frame. Tut nichts, wenn es außerhalb der Grenzen liegt
`getAnimationFPS(sprite)`	Gibt die Animationsgeschwindigkeit des Sprites in Frames pro Sekunde zurück
`setAnimationFPS(sprite, fps)`	Setzt die Animationsgeschwindigkeit des Sprites in Frames pro Sekunde

Animationsfunktionen

Animationsfunktionen arbeiten an Objekten, die Sprites mit mehreren Frames verwenden. Verwenden Sie sie, wenn Sie den aktuellen Animationsframe inspizieren oder erzwingen möchten.

Funktion	Beschreibung
`getFrame(obj)`	Gibt den aktuellen Animationsframe-Index des Objekts zurück
`setFrame(obj, frameIndex)`	Setzt den Animationsframe des Objekts (setzt den Timer zurück)
`getFrameCount(obj)`	Gibt die Anzahl der Frames im Sprite des Objekts zurück

Transformationsfunktionen (Flip/Rotation)

Transformationsfunktionen ändern, wie das Sprite eines Objekts gezeichnet wird, ohne das Sprite selbst zu bearbeiten. Sie sind gut dafür geeignet, ein Sprite in mehreren Richtungen wiederzuverwenden.

Funktion	Beschreibung
`getFlipX(obj)`	Gibt zurück, ob das Objekt horizontal gespiegelt ist
`setFlipX(obj, flip)`	Setzt die horizontale Spiegelung. `true` = gespiegelt, `false` = normal
`getFlipY(obj)`	Gibt zurück, ob das Objekt vertikal gespiegelt ist
`setFlipY(obj, flip)`	Setzt die vertikale Spiegelung. `true` = gespiegelt, `false` = normal
`getRotation(obj)`	Gibt den Drehwinkel des Objekts im Uhrzeigersinn in Grad zurück
`setRotation(obj, degrees)`	Setzt den Drehwinkel des Objekts im Uhrzeigersinn in Grad
`move(obj, x, y)`	Bewegt das Objekt in seinen lokal gedrehten Achsen. Positives X bewegt nach rechts, positives Y bewegt nach unten
`getCenterOffset(obj)`	Gibt den normalisierten Rotationspivots als `[x, y]` zurück
`setCenterOffset(obj, x, y)`	Setzt den normalisierten Rotationspivot. Werte werden von `0` bis `1` begrenzt
`getCenterOffsetX(obj)`	Gibt den normalisierten Pivot X zurück
`setCenterOffsetX(obj, x)`	Setzt den normalisierten Pivot X
`getCenterOffsetY(obj)`	Gibt den normalisierten Pivot Y zurück
`setCenterOffsetY(obj, y)`	Setzt den normalisierten Pivot Y
`getCenter(obj)`	Gibt die Weltposition des Rotationspivots als `[x, y]` zurück
`setCenter(obj, x, y)`	Bewegt das Objekt, sodass sein Rotationspivot an der Weltposition `(x, y)` liegt
`getCenterX(obj)`	Gibt die Welt-X-Position des Rotationspivots zurück
`setCenterX(obj, x)`	Bewegt das Objekt, sodass sein Pivot die Welt-X `x` hat
`getCenterY(obj)`	Gibt die Welt-Y-Position des Rotationspivots zurück
`setCenterY(obj, y)`	Bewegt das Objekt, sodass sein Pivot die Welt-Y `y` hat
`getDirectionRight(obj)`	Gibt die gedrehte rechte Richtung des Objekts als `[x, y]` zurück
`getDirectionDown(obj)`	Gibt die gedrehte nach unten gerichtete Richtung des Objekts als `[x, y]` zurück
`getDirectionLeft(obj)`	Gibt die gedrehte linke Richtung des Objekts als `[x, y]` zurück
`getDirectionUp(obj)`	Gibt die gedrehte nach oben gerichtete Richtung des Objekts als `[x, y]` zurück

Der Standard-Center-Offset ist [0.5, 0.5], was um die Mitte des Sprites rotiert. [0, 0] rotiert um die obere linke Ecke des Objekts, und [1, 1] rotiert um location + (width, height).

Warnung für ältere Projekte: Seit Tiniest2D 1.8 verwenden getRotation() und setRotation() Gradwinkel anstelle von Vierteldrehwerten. Rotierte Objekt-Kollidierer beeinflussen jetzt Physik und Szenenabfragen.

Kollisionsarten

Kollisionsarten entscheiden, wie ein Objekt an Kollisionsprüfungen teilnimmt. Wählen Sie den Typ basierend auf der Rolle des Objekts: Wände sind normalerweise statisch, Spieler normalerweise dynamisch und Aufnahmen sind oft Trigger.

Konstante	Wert	Beschreibung
`COLLISION_NONE()`	0	Keine Kollisionsüberprüfung
`COLLISION_STATIC()`	1	Kollidiert, bewegt sich aber nicht
`COLLISION_DYNAMIC()`	2	Kollidiert und wird herausgeschoben
`COLLISION_TRIGGER()`	3	Erfasst Kollision, blockiert aber nicht

Szenenfunktionen

Szenenfunktionen steuern, welche Szene aktiv ist, welche Objekte sich darin befinden, und szenenweit Einstellungen wie Hintergrundfarbe und Schwerkraft. Sie bieten auch Suchhelfer, um Objekte an Positionen oder nach Namen zu finden.

Funktion	Beschreibung
`addObject(scene, obj)`	Fügt ein Objekt zu einer Szene hinzu
`removeObject(scene, obj)`	Entfernt ein Objekt aus einer Szene
`setScene(scene)`	Setzt die aktive Szene
`getScene()`	Gibt die aktuelle aktive Szene zurück
`resetScene(scene)`	Setzt die Szene auf ihren ursprünglichen Zustand zurück (wie im Editor entworfen)
`setBackgroundColor(scene, r, g, b)`	Setzt die Hintergrundfarbe der Szene (RGB 0-255)
`getBackgroundColor(scene)`	Gibt die Hintergrundfarbe als [r, g, b] Liste zurück
`getGravityX(scene)`	Gibt die Schwerkraft X-Komponente der Szene zurück
`setGravityX(scene, gx)`	Setzt die Schwerkraft X-Komponente der Szene
`getGravityY(scene)`	Gibt die Schwerkraft Y-Komponente der Szene zurück
`setGravityY(scene, gy)`	Setzt die Schwerkraft Y-Komponente der Szene (positiv = unten)
`getObjectAt(scene, x, y)`	Gibt das erste Objekt an der Stelle (x,y) zurück oder null
`getObjectsAt(scene, x, y)`	Gibt eine Liste aller Objekte an der Stelle (x,y) zurück
`getObjectsInBox(scene, x, y, w, h)`	Gibt alle Objekte zurück, die den Kasten überlappen
`getObjectByName(scene, name)`	Findet ein Objekt nach Namen, oder null, wenn nicht gefunden
`getObjectCount(scene)`	Gibt die Anzahl der Objekte in der Szene zurück
`getAllObjects(scene)`	Gibt eine Liste aller Objekte in der Szene zurück
`isObjectInScene(scene, obj)`	Gibt true zurück, wenn das Objekt in der Szene ist
`getObjectsBySprite(scene, sprite)`	Gibt alle Objekte zurück, die das gegebene Sprite verwenden
`getObjectsByCollisionType(scene, type)`	Gibt alle Objekte mit dem gegebenen Kollisionstyp zurück

Audio-Wiedergabe

Audio-Wiedergabefunktionen starten und stoppen Audio-Assets aus dem Skript. playAudio() gibt einen Handle zurück, sodass Sie später diese spezifische Wiedergabeinstanz stoppen oder überprüfen können.

Funktion	Beschreibung
`playAudio(audio)`	Startet ein Audio-Asset und gibt einen Wiedergabe-Handle-ID zurück
`stopAudio(handle)`	Stoppt einen Wiedergabe-Handle, der von `playAudio()` zurückgegeben wurde
`isAudioPlaying(handle)`	Gibt true zurück, solange der Wiedergabe-Handle noch aktiv ist

Bildschirmfunktionen

Bildschirmfunktionen helfen, wenn Sie die Fenstergröße wissen müssen oder zwischen Bildschirm-Pixeln und Weltpositionen konvertieren müssen. Dies ist nützlich für Maus-Zielen, Klickerkennung und kamera-bewusste UI.

Funktion	Beschreibung
`getScreenWidth()`	Gibt die Breite des Bildschirms/Fensters in Pixeln zurück
`getScreenHeight()`	Gibt die Höhe des Bildschirms/Fensters in Pixeln zurück
`screenToWorld(screenX, screenY)`	Konvertiert Bildschirm-Pixelkoordinaten in Weltkoordinaten. Gibt [worldX, worldY] zurück
`worldToScreen(worldX, worldY)`	Konvertiert Weltkoordinaten in Bildschirm-Pixelkoordinaten. Gibt [screenX, screenY] zurück

Fenster Modus

Steuern Sie den Fenster-Modus für exportierte Spiele. Diese Funktionen haben keine Wirkung, wenn im Editor gespielt wird (der Editor hat höhere Autorität über den Fensterstatus).

Konstante	Wert	Beschreibung
`WINDOW_WINDOWED()`	0	Normale Fenstermodus
`WINDOW_MAXIMIZED()`	1	Maximiertes Fenster (Standard)
`WINDOW_FULLSCREEN()`	2	Randloser Vollbildmodus

Funktion	Beschreibung
`getWindowMode()`	Gibt die aktuelle Fenster-Modus-Konstante zurück
`setWindowMode(mode)`	Setzt den Fenster-Modus. Funktioniert nur in exportierten Spielen

Beispiel:

func start() {
    // Setze den Fenster-Modus (WINDOW_MAXIMIZED ist der Standard für exportierte Spiele)
    setWindowMode(WINDOW_MAXIMIZED())
}

Hinweis: Wenn setWindowMode() in einem exportierten Spiel niemals aufgerufen wird, ist der Standard WINDOW_MAXIMIZED.

UI Funktionen

Die Benutzeroberfläche verwendet eine virtuelle Bildschirmauflösung. Der Standard-UI-Raum ist 100 x 100. Die Schriftgröße kann für nachfolgende Text-Widgets mit uiPushFontSize(size) erhöht und mit uiPopFontSize() wiederhergestellt werden. Schriftfarben können mit uiPushFontColor(r, g, b[, a]) gestapelt werden, und UI-Elementfüllungen können mit uiPushElementColor(r, g, b[, a]) gestapelt werden. Wie der Rest der sofortigen UI gelten diese Überschreibungen beim Erstellen der Benutzeroberfläche des aktuellen Frames. Wenn die gestapelte Größe 0 oder kleiner ist, verwendet die Engine eine automatische Größenanpassung.

Funktion	Beschreibung
`getUIResolutionX()`	Gibt die aktuelle virtuelle UI-Breite zurück
`setUIResolutionX(width)`	Setzt die virtuelle UI-Breite für nachfolgende UI-Anrufe
`getUIResolutionY()`	Gibt die aktuelle virtuelle UI-Höhe zurück
`setUIResolutionY(height)`	Setzt die virtuelle UI-Höhe für nachfolgende UI-Anrufe
`uiPushFontSize(size)`	Erhöht eine Schriftgrößenskala für nachfolgende UI-Texte. Werte `<= 0` verwenden automatische Größenanpassung
`uiPopFontSize()`	Hebt die zuletzt verwendete UI-Schriftgrößenvorgabe auf
`uiPushFontColor(r, g, b)` oder `uiPushFontColor(r, g, b, a)`	Hebt eine Schriftfarbüberschreibung für nachfolgende UI-Texte auf
`uiPopFontColor()`	Hebt die zuletzt verwendete UI-Schriftfarbenüberschreibung auf
`uiPushElementColor(r, g, b)` oder `uiPushElementColor(r, g, b, a)`	Hebt eine Füllfarbüberschreibung für Kästchen, Schaltflächen, Umschalter, Schieberegler und Bildschaltflächen auf
`uiPopElementColor()`	Hebt die zuletzt verwendete UI-Elementfarbüberschreibung auf
`uiLabel(text, x, y)`	Zeichnet Bildschirmtext an virtuellen UI-Koordinaten
`uiBox(x, y, w, h)`	Zeichnet ein einfaches Paneel
`uiButton(text, x, y, w, h)`	Zeichnet einen Schaltfläche und gibt eine der `UI_*()`-Zustandskonstanten zurück
`uiToggle(text, value, x, y, w, h)`	Zeichnet einen Umschalter und gibt den aktualisierten booleschen Wert zurück
`uiSlider(text, value, min, max, x, y, w, h)`	Zeichnet einen Schieberegler und gibt den aktualisierten numerischen Wert zurück
`uiSprite(sprite, x, y)`	Zeichnet ein Sprite im UI-Raum mit der natürlichen Größe des Sprites in UI-Einheiten
`uiSprite(sprite, x, y, w, h)`	Zeichnet ein Sprite im UI-Raum mit einer expliziten Größe
`uiImageButton(sprite, x, y, w, h)`	Zeichnet einen Sprite-Button und gibt eine der `UI_*()`-Zustandskonstanten zurück

UI Zustand Konstanten

UI-Funktionen geben Zustand Konstanten zurück, sodass Ihr Skript feststellen kann, ob ein Widget inaktiv, überwacht, gehalten oder geklickt wurde. Gewöhnlich ist UI_CLICKED() der Wert, den Sie für Schaltflächenaktionen überprüfen.

Konstante	Wert	Beschreibung
`UI_IDLE()`	0	Widget ist weder überwacht noch gedrückt
`UI_HOVERED()`	1	Maus schwebt über dem Widget
`UI_HELD()`	2	Maustaste ist auf dem Widget gedrückt
`UI_CLICKED()`	3	Widget wurde in diesem Frame angeklickt

Kamera Funktionen

Die Kameraposition stellt das Zentrum der Ansicht dar. Der Zoom sorgt für eine konsistente vertikale Weltansicht unabhängig von der Bildschirmgröße.

Funktion	Beschreibung
`getCameraX(scene)`	Gibt die Kameraposition X (Zentrum der Ansicht) zurück
`setCameraX(scene, x)`	Setzt die Kameraposition X
`getCameraY(scene)`	Gibt die Kameraposition Y (Zentrum der Ansicht) zurück
`setCameraY(scene, y)`	Setzt die Kameraposition Y
`getCameraZoom(scene)`	Gibt den Kamerazoomlevel zurück
`setCameraZoom(scene, zoom)`	Setzt den Kamerazoom. Zoom 1.0 zeigt 720 Welt-Einheiten vertikal, 3.0 zeigt 240 Einheiten an.

Zoomverhalten: Der Zoom sorgt für eine konsistente vertikale Weltansicht unabhängig von der Fenstergröße oder dem Seitenverhältnis. Breitere Bildschirme zeigen mehr horizontal, aber die gleiche Menge vertikal.

Eingabe Funktionen

Eingabefunktionen ermöglichen es dem Spiel, auf den Zustand von Tastatur und Maus zu reagieren. Verwenden Sie Pressed für einmalige Aktionen, Held für kontinuierliche Bewegungen und Released für Aktionen, die stattfinden, wenn eine Taste losgelassen wird.

Funktion	Beschreibung
`isKeyPressed(key)`	Wahr nur im Frame, in dem die Taste gedrückt wurde
`isKeyHeld(key)`	Wahr, während die Taste gedrückt gehalten wird
`isKeyReleased(key)`	Wahr nur im Frame, in dem die Taste losgelassen wurde
`getMouseX()`	Gibt die Maus X in Bildschirmkoordinaten zurück
`getMouseY()`	Gibt die Maus Y in Bildschirmkoordinaten zurück
`getMouseDeltaX()`	Gibt die Maus X-Bewegung in diesem Frame zurück
`getMouseDeltaY()`	Gibt die Maus Y-Bewegung in diesem Frame zurück
`isMouseButtonPressed(button)`	Wahr nur im Frame, in dem die Maustaste gedrückt wurde
`isMouseButtonHeld(button)`	Wahr, während die Maustaste gedrückt gehalten wird
`isMouseButtonReleased(button)`	Wahr nur im Frame, in dem die Maustaste losgelassen wurde
`getFPS()`	Gibt die aktuellen Frames pro Sekunde zurück

Maus-Tasten Konstanten

Konstanten der Maustasten werden an die Maus-Eingabefunktionen übergeben. Sie machen den Code leserlicher als rohe Zahlen.

Konstante	Beschreibung
`MOUSE_LEFT()`	Linke Maustaste
`MOUSE_RIGHT()`	Rechte Maustaste
`MOUSE_MIDDLE()`	Mittlere Maustaste

Tastenkonstanten

Tastenkonstanten werden an die Tastatur-Eingabefunktionen übergeben. Die Engine bietet Buchstaben, Zahlen, Funktionstasten, Pfeile und eine kleine Menge gängiger Sondertasten.

Buchstaben: KEY_A() bis KEY_Z()

Zahlen: KEY_0() bis KEY_9()

Funktionstasten: KEY_F1() bis KEY_F12()

Sondertasten: | Konstante | Taste | |----------|-----| | KEY_SPACE() | Leertaste | | KEY_ENTER() | Eingabe/Return | | KEY_ESCAPE() | Escape | | KEY_TAB() | Tabulator | | KEY_BACKSPACE() | Rücktaste | | KEY_DELETE() | Löschen | | KEY_SHIFT() | Shift | | KEY_CTRL() | Steuerung | | KEY_ALT() | Alt | | KEY_LEFT() | Linke Pfeiltaste | | KEY_RIGHT() | Rechte Pfeiltaste | | KEY_UP() | Obere Pfeiltaste | | KEY_DOWN() | Untere Pfeiltaste | | KEY_HOME() | Pos1 | | KEY_END() | Ende |

Mathe Funktionen

Mathe-Helfer decken gängige Berechnungen ab, die in Bewegung, Animation, Zufälligkeit und Wertgrenzen verwendet werden. Sie halten Skripte kürzer und leichter lesbar.

Funktion	Beschreibung
`abs(n)`	Absoluter Wert
`min(a, b)`	Gibt die kleinere der beiden Zahlen zurück
`max(a, b)`	Gibt die größere der beiden Zahlen zurück
`clamp(value, min, max)`	Beschränkt einen Wert zwischen Minimum und Maximum
`lerp(a, b, t)`	Interpoliert linear von `a` nach `b` unter Verwendung von `t`
`floor(n)`	Rundet auf die nächstgelegene ganze Zahl ab
`ceil(n)`	Rundet auf die nächstgelegene ganze Zahl auf
`round(n)`	Rundet auf die nächstgelegene ganze Zahl
`sign(n)`	Gibt `-1`, `0` oder `1` abhängig vom Vorzeichen des Eingangs zurück
`sqrt(n)`	Quadratwurzel
`pow(base, exponent)`	Hebt eine Basis auf eine Potenz
`sin(radians)`	Sinus eines Winkels in Bogenmaß
`cos(radians)`	Kosinus eines Winkels in Bogenmaß
`tan(radians)`	Tangens eines Winkels in Bogenmaß
`random()`	Gibt einen zufälligen Float zwischen 0.0 und 1.0 zurück
`randomRange(min, max)`	Gibt einen zufälligen Float zwischen min und max zurück
`randomInt(min, max)`	Gibt einen zufälligen Ganzzahlwert zwischen min und max (einschließlich) zurück
`PI()`	Gibt pi (3.14159...) zurück
`TAU()`	Gibt tau (2 * pi = 6.28318...) zurück
`TWOPI()`	Gibt 2 * pi zurück (gleich wie TAU)
`E()`	Gibt Eulers Zahl e (2.71828...) zurück
`deg2rad(degrees)`	Konvertiert Grad in Bogenmaß
`rad2deg(radians)`	Konvertiert Bogenmaß in Grad

Utility Funktionen

Utility Funktionen sind allgemeine Helfer, die nicht zu einem bestimmten Asset-Typ gehören. print() ist besonders nützlich beim Lernen, da es zeigt, was Ihr Skript gerade tut.

Funktion	Beschreibung
`print(value)`	Gibt zum Debuggen aus (im Spiel angezeigt)
`quitGame()`	Beendet das Spiel. Im Editor wird der Spielmodus gestoppt. In exportierten Spielen schließt die Anwendung

String Funktionen

String Funktionen arbeiten mit Textwerten. Für den Moment ist dieser Abschnitt bewusst klein gehalten.

Funktion	Beschreibung
`strlen(string)`	Gibt die Länge eines Strings (Anzahl der Zeichen) zurück

Speicher Funktionen

Speichern und Laden von Spieldaten in Dateien. Unterstützt Zahlen, Strings, Booleans und Listen (einschließlich verschachtelter Listen). Unterstützt NICHT Sprite, Szene, Objekt oder Audio-Werte.

Funktion	Beschreibung
`save(path, data)`	Speichert Daten in einer Datei im Binärformat. Gibt `true` bei Erfolg zurück
`save(path, data, format)`	Speichert Daten im angegebenen Format: `"binary"` oder `"text"`
`save(path, data, format, key)`	Speichert Daten mit Verschlüsselung unter Verwendung des angegebenen Schlüsselstrings
`load(path)`	Lädt Daten aus einer Datei. Gibt die Daten oder `null` bei Fehler zurück
`load(path, key)`	Lädt verschlüsselte Daten unter Verwendung des angegebenen Schlüsselstrings
`fileExists(path)`	Gibt `true` zurück, wenn die Datei am angegebenen Pfad existiert
`deleteFile(path)`	Löscht die Datei am angegebenen Pfad. Gibt `true` bei Erfolg zurück
`getAppDataPath()`	Gibt den AppData/Tiniest2D-Ordnerpfad zurück (erstellt, falls benötigt)
`getDocumentsPath()`	Gibt den Dokumente-Ordnerpfad des Benutzers zurück
`getGamePath()`	Gibt das Verzeichnis zurück, in dem sich die ausführbare Spiel-Datei befindet

Beispiel: Speichern und Laden des Spielerfortschritts

// Spieler Daten speichern
var playerData = [100, "Player1", true, [1, 2, 3]]
var savePath = getAppDataPath() + "/MyGame/save.dat"
if (save(savePath, playerData)) {
    print("Spiel gespeichert!")
}

// Spieler Daten laden
if (fileExists(savePath)) {
    var loaded = load(savePath)
    if (loaded != null) {
        var health = loaded[0]
        var name = loaded[1]
        var hasKey = loaded[2]
        var inventory = loaded[3]
    }
}

// Verschlüsseltes Speichern (um Daten vor zufälliger Inspektion zu verbergen)
var secretData = [" geheim", 12345]
save(getAppDataPath() + "/MyGame/config.dat", secretData, "binary", "mySecretKey")
var decrypted = load(getAppDataPath() + "/MyGame/config.dat", "mySecretKey")

// Textformat (menschenlesbar, nützlich für Debugging)
save(getAppDataPath() + "/MyGame/debug.txt", playerData, "text")

Hinweise:

Binärformat (Standard) ist kompakt und schneller
Textformat ist menschenlesbar, nützlich für Debugging
Falscher Verschlüsselungsschlüssel gibt null zurück (Daten werden Müll sein)
Verzeichnisse werden automatisch beim Speichern erstellt

Erstelle 2D-Spiele mit Tiniest2D

Engine API Referenz

Keep your place in this quest