Erstelle 2D-Spiele mit Tiniest2D

Kollisionssystem

Wie es funktioniert

• Jedes Objekt hat eine AABB (Achsen-aligne Begrenzungsbox), basierend auf seiner Sprite-Größe
• Sprites können benutzerdefinierte Collider-Grenzen haben (im Sprite-Editor festgelegt)
• Kollisionen werden in jedem Frame für dynamische Objekte überprüft

Kollisionstypen erklärt

1. Keine - Objekt wird vollständig vom Kollisionssystem ignoriert
2. Statisch - Fungiert als unbewegliche Wand (für Terrain, Plattformen verwenden)
3. Dynamisch - Bewegt sich und wird aus anderen Kollisionen gedrängt (für Spieler, Feinde verwenden)
4. Trigger - Erfasst Überlappungen, blockiert jedoch keine Bewegung (für Sammlerstücke, Zonen verwenden)

Kollisionauflösung

• Dynamische Objekte werden automatisch aus statischen und anderen dynamischen Objekten gedrängt
• Trigger blockieren niemals die Bewegung - sie erfassen nur Überlappungen

Der onCollision-Callback

Die Funktion onCollision(objA, objB) wird aufgerufen, wenn Objekte überlappen. Die Callback-Muster sind:

Wichtige Regeln:

• objA ist immer entweder dynamisch oder Trigger
• Wenn zwei dynamische Objekte kollidieren, erhält jedes einen Rückruf (jeweils als objA)
• Wenn zwei Trigger überlappen, wird ein Rückruf generiert (erster Trigger als objA)
• Statische Objekte erscheinen niemals als objA

Beispiel: Erkennen verschiedener Kollisionstypen

func onCollision(objA, objB) {
    var typeA = getCollisionType(objA)
    var typeB = getCollisionType(objB)

    // Spieler (dynamisch), der eine Münze (Trigger) berührt
    if (getName(objA) == "player" && typeB == COLLISION_TRIGGER()) {
        print("Eingesammelt!")
        removeObject(gameScene, objB)
    }

    // Zwei Trigger überlappen (z.B. Erkennungszonen)
    if (typeA == COLLISION_TRIGGER() && typeB == COLLISION_TRIGGER()) {
        print(getName(objA) + " betrat " + getName(objB) + "'s Zone")
    }

    // Spieler wird von Feind getroffen (beide dynamisch)
    if (getName(objA) == "player" && getName(objB) == "enemy") {
        print("Spieler getroffen!")
    }
}

Physiksystem

Die Tiniest Engine hat ein integriertes Physiksystem, das Gravitation und Geschwindigkeit automatisch für dynamische Objekte behandelt.

Wie die Physik funktioniert

In jedem Frame wendet die Engine automatisch:

1. Die Schwerkraft der Szene auf die Geschwindigkeit jedes dynamischen Objekts an
2. Die Geschwindigkeit auf die Position jedes dynamischen Objekts an

// Physik-Pipeline (automatisch von der Engine verarbeitet):
velocity += gravity * dt
position += velocity * dt

Schwerkraft einrichten

Setzen Sie die Schwerkraft in einer Szene, damit dynamische Objekte fallen:

func start() {
    // Nach unten gerichtete Schwerkraft (300 Pixel pro Sekunde²)
    setGravityY(gameScene, 300)

    // Optional: horizontale Schwerkraft (Wind-Effekt)
    setGravityX(gameScene, 0)

    setScene(gameScene)
}

Geschwindigkeit verwenden

Steuern Sie Objekte mithilfe von Geschwindigkeit, anstatt die Position direkt festzulegen:

var player = Object("player")
var jumpForce = -200  // Negativ = nach oben

func start() {
    setCollisionType(player, COLLISION_DYNAMIC())
    addObject(gameScene, player)
    setGravityY(gameScene, 300)
    setScene(gameScene)
}

func onUpdate(dt) {
    // Horizontale Bewegung über Geschwindigkeit
    if (isKeyHeld(KEY_LEFT())) {
        setVelocityX(player, -100)
    } else if (isKeyHeld(KEY_RIGHT())) {
        setVelocityX(player, 100)
    } else {
        setVelocityX(player, 0)
    }

    // Sprung durch Setzen der nach oben gerichteten Geschwindigkeit
    if (isKeyPressed(KEY_SPACE())) {
        setVelocityY(player, jumpForce)
    }
}

Physikfunktionen

Wichtig: Nur COLLISION_DYNAMIC() Objekte sind von der Schwerkraft betroffen und haben ihre Geschwindigkeit automatisch angewendet.