CollisionListener (Kollisionen-Erkennung)¹

Spielkonzept und grundlegender Aufbau

Ein Frosch soll fröhlich durch das Spiel springen und sich vom Boden abstoßen, wenn immer er die Chance dazu hat.

Dieser Frosch soll durch das Spiel springen

In der Scene FroggyJump kann der Spieler ein Objekt der Klasse Frog steuern. Zusätzlich geben Objekte der Klasse Platform halt.

Damit ergibt sich das Codegerüst für das Spiel:

Der Frosch kann sich bewegen, knallt aber unangenehmerweise noch gegen die Decke

Ein paar Erklärungen zum Codegerüst für FroggyJump:

Physikalische Eigenschaften

Wie im Physics-Tutorial beschrieben, werden die physikalischen Eigenschaften der Spielobjekte und ihrer Umgebung bestimmt:

• Platformen sind statische Objekte: Sie ignorieren Schwerkraft und können nicht durch andere Objekte verschoben werden (egal mit wie viel Kraft der Frosch auf sie fällt).
• Der Frosch ist ein dynamisches Objekt: Er lässt sich von der Schwerkraft beeinflussen und wird von den statischen Platformen aufgehalten.
• In der Scene FroggyJump existiert eine Schwerkraft von 10 m/s^2. Sie wird mit setGravity(Vector) gesetzt.

Bewegung des Frosches

Die Bewegung des Frosches wird in jedem Frame kontrolliert. Wie im Game Loop Tutorial beschrieben, wird hierzu das Interface FrameUpdateListener genutzt.

In jedem Frame wird die Bewegung des Frosches in dreierlei hinsicht kontrolliert:

• Teil A: Blickrichtung des Frosches: Das Bild des Frosches wird gespiegelt, falls er sich nach links bewegt.
• Teil B: Horizontale Bewegung des Frosches: Jeden Frame, in dem der Spieler den Frosch (per Tastendruck) nach links oder rechts steuern möchte, wird eine Bewegungskraft auf den Frosch angewendet. Wird der Frosch in die Gegenrichtung seiner aktuellen Bewegung gesteuert, wird seine horizontale Geschwindigkeit zuvor auf 0 gesetzt, um ein langsames Abbremsen zu verhindern. Das ermöglicht schnelle Reaktion auf Nutzereingabe und ein besseres Spielgefühl. Zusätzlich wird seine Geschwindigkeit auf die Konstante MAX_SPEED begrenzt.
• Teil C: Springe, wenn möglich: Mit der Funktion isGrounded() bietet die Engine einen einfachen Test, um sicherzustellen, dass der Frosch Boden unter den Füßen hat. Wenn dies gegeben ist, wird ein Sprungimpuls auf den Frosch angewandt. Zuvor wird die vertikale Komponente seiner Geschwindigkeit auf 0 festgesetzt - das garantiert, dass der Frosch jedes mal die selbe Sprunghöhe erreicht.

Die Kamera folgt dem Frosch

Der Frosch soll stets sichtbar bleiben. Hierzu werden zwei Funktionen der Engine-Kamera genutzt:

1. Der Frosch wird mit Camera.setFocus(Actor) in den Mittelpunkt der Kamera gesetzt. Sie folgt dem Frosch.
2. Gleichzeitig soll der Frosch nicht exakt im Mittelpunkt des Bildschirms sein: Weil das Spielziel ist, sich nach oben zu bewegen, braucht der Spieler mehr Blick nach oben als nach unten. Mit Camera.setOffset(Vector) wird die Kamera nach oben verschoben.

Durch Platformen Springen: Kollisionen kontrollieren

Das Interface CollisionListener wurde bereits in seiner grundlegenden Form im Nutzereingabe-Tutorial benutzt.

CollisionListener kann mehr als nur melden, wenn zwei Actor-Objekte sich überschneiden. Um das FroggyJump-Spiel zu implementieren, nutzen wir weitere Features.

Unser Frosch soll fähig sein, von unten „durch die Platform hindurch“ zu springen. Von oben fallend soll er natürlich auf der Platform stehen bleiben.

Um diesen Effekt zu erzeugen, müssen Kollisionen zwischen Frosch und Platform unterschiedlich behandelt werden:

1. Kollidiert der Frosch von unten, so soll die Kollision ignoriert werden. Er prallt so nicht von der Decke ab und kann weiter nach oben Springen.
2. Kollidiert der Frosch von oben, so soll die Kollision normal aufgelöst werden, sodass er nicht durch den Boden fällt.

Hierzu stellt das CollisionEvent-Objekt in der onCollision-Methode Funktionen bereit.

class Platform extends Rectangle implements CollisionListener<Frog>
{
    public Platform(double width, double height)
    {
        super(width, height);
        makeStatic();
        addCollisionListener(Frog.class, this);
        color("brown");
    }

    @Override
    public void onCollision(CollisionEvent<Frog> collisionEvent)
    {
        double frogY = collisionEvent.colliding().anchor().y();
        if (frogY < y())
        {
            collisionEvent.ignoreCollision();
            collisionEvent.colliding().jumpEnabled(false);
        }
    }

    @Override
    public void onCollisionEnd(CollisionEvent<Frog> collisionEvent)
    {
        collisionEvent.colliding().jumpEnabled(true);
    }
}

Zum Java-Code: demos/subprojects/demos/src/main/java/demos/docs/events/collision/froggy_jump/Platform.java

Kompletter Code

import pi.Camera;
import pi.Controller;
import pi.Random;
import pi.Scene;
import pi.graphics.geom.Vector;

public class FroggyJump extends Scene
{
    private Frog frog;

    private final double PLATFORM_HEIGHT = 0.5;

    public FroggyJump()
    {
        info().title("Spiel „Froggy Jump“")
            .help(
                "Tastenkürzel: a bewegt den Frosch nach links, d bewegt den Frosch nach rechts.");
        frog = new Frog();
        add(frog);
        gravity(Vector.DOWN.multiply(10));
        Camera camera = camera();
        camera.focus(frog);
        camera.offset(new Vector(0, 4));
        makeLevel(40);
        makePlatforms(10);
    }

    private void makePlatforms(int heightLevel)
    {
        for (int i = 0; i < heightLevel; i++)
        {
            Platform platform = new Platform(5, PLATFORM_HEIGHT);
            platform.anchor(0, i * 4);
            add(platform);
        }
    }

    private void makeLevel(int heightLevel)
    {
        for (int i = 0; i < heightLevel; i++)
        {
            int numPlatforms = Random.range(2) + 1;
            for (int j = 0; j < numPlatforms; j++)
            {
                Platform platform = new Platform(6 / numPlatforms,
                        PLATFORM_HEIGHT);
                platform.anchor(numPlatforms * (j + 1) * i * Random.range(),
                    i * 4);
                add(platform);
            }
            if (i > 3)
            {
                for (int j = 0; j < Random.range(3); j++)
                {
                    SpikeBall.setupSpikeBall(Random.range() * (4 + j) * i,
                        Random.range() * 4 + 0.5 + 5 * i,
                        layer());
                }
            }
        }
    }

    public static void main(String[] args)
    {
        Controller.instantMode(false);
        Controller.start(new FroggyJump(), 400, 600);
    }
}

Zum Java-Code: demos/subprojects/demos/src/main/java/demos/docs/events/collision/froggy_jump/FroggyJump.java

import java.awt.event.KeyEvent;

import pi.Controller;
import pi.Scene;
import pi.Text;
import pi.event.KeyStrokeListener;

class DeathScreen extends Scene implements KeyStrokeListener
{
    public DeathScreen()
    {
        Text message = new Text("You Died. Press any button to try again");
        message.height(.6);
        message.center(camera().focus());
        add(message);
    }

    @Override
    public void onKeyDown(KeyEvent e)
    {
        Controller.transitionToScene(new FroggyJump());
    }
}

Zum Java-Code: demos/subprojects/demos/src/main/java/demos/docs/events/collision/froggy_jump/DeathScreen.java

import java.awt.event.KeyEvent;

import pi.Controller;
import pi.Image;
import pi.event.FrameUpdateListener;
import pi.graphics.geom.Vector;

class Frog extends Image implements FrameUpdateListener
{
    private boolean canJump = true;

    private static double MAX_SPEED = 4;

    public Frog()
    {
        super("froggy/Frog.png");
        pixelPerMeter(25);
        makeDynamic();
        rotationLocked(true);
    }

    public void jumpEnabled(boolean jumpEnabled)
    {
        canJump = jumpEnabled;
    }

    public void kill()
    {
        Controller.transitionToScene(new DeathScreen());
    }

    @Override
    public void onFrameUpdate(double pastTime)
    {
        Vector velocity = this.velocity();
        // A: Die Blickrichtung des Frosches steuern
        if (velocity.x() < 0)
        {
            flippedHorizontally(true);
        }
        else
        {
            flippedHorizontally(false);
        }
        // B: Horizontale Bewegung steuern
        if (Controller.isKeyPressed(KeyEvent.VK_A))
        {
            if (velocity.x() > 0)
            {
                velocity(new Vector(0, velocity.y()));
            }
            applyForce(Vector.LEFT.multiply(600));
        }
        else if (Controller.isKeyPressed(KeyEvent.VK_D))
        {
            if (velocity.x() < 0)
            {
                velocity(new Vector(0, velocity.y()));
            }
            applyForce(Vector.RIGHT.multiply(600));
        }
        if (Math.abs(velocity.x()) > MAX_SPEED)
        {
            velocity(new Vector(MAX_SPEED * Math.signum(velocity.x()),
                    velocity.y()));
        }
        // C: Wenn möglich den Frosch springen lassen
        if (isGrounded() && velocity.y() <= 0 && canJump)
        {
            velocity(new Vector(velocity.x(), 0));
            applyImpulse(Vector.UP.multiply(180));
        }
    }
}

Zum Java-Code: demos/subprojects/demos/src/main/java/demos/docs/events/collision/froggy_jump/Frog.java

import pi.Rectangle;
import pi.event.CollisionEvent;
import pi.event.CollisionListener;

class Platform extends Rectangle implements CollisionListener<Frog>
{
    public Platform(double width, double height)
    {
        super(width, height);
        makeStatic();
        addCollisionListener(Frog.class, this);
        color("brown");
    }

    @Override
    public void onCollision(CollisionEvent<Frog> collisionEvent)
    {
        double frogY = collisionEvent.colliding().anchor().y();
        if (frogY < y())
        {
            collisionEvent.ignoreCollision();
            collisionEvent.colliding().jumpEnabled(false);
        }
    }

    @Override
    public void onCollisionEnd(CollisionEvent<Frog> collisionEvent)
    {
        collisionEvent.colliding().jumpEnabled(true);
    }
}

Zum Java-Code: demos/subprojects/demos/src/main/java/demos/docs/events/collision/froggy_jump/Platform.java

import pi.Image;
import pi.Layer;
import pi.event.CollisionEvent;
import pi.event.CollisionListener;

class SpikeBall extends Image implements CollisionListener<Frog>
{
    public SpikeBall()
    {
        super("froggy/Spiked-Ball.png");
        pixelPerMeter(40);
        gravityScale(0);
        addCollisionListener(Frog.class, this);
    }

    public static SpikeBall setupSpikeBall(double x, double y, Layer layer)
    {
        SpikeBall ball = new SpikeBall();
        ball.center(x, y);
        SpikeSensor sensor = new SpikeSensor(ball);
        sensor.anchor(x - 1, y - 8);
        layer.add(ball, sensor);
        return ball;
    }

    @Override
    public void onCollision(CollisionEvent<Frog> collisionEvent)
    {
        collisionEvent.colliding().kill();
    }
}

Zum Java-Code: demos/subprojects/demos/src/main/java/demos/docs/events/collision/froggy_jump/SpikeBall.java

import pi.Rectangle;
import pi.event.CollisionEvent;
import pi.event.CollisionListener;

class SpikeSensor extends Rectangle implements CollisionListener<Frog>
{
    private SpikeBall ball;

    public SpikeSensor(SpikeBall ball)
    {
        super(2, 8);
        this.ball = ball;
        visible(false);
        makeSensor();
        addCollisionListener(Frog.class, this);
        gravityScale(0);
    }

    @Override
    public void onCollision(CollisionEvent<Frog> collisionEvent)
    {
        ball.gravityScale(1);
    }
}

Zum Java-Code: demos/subprojects/demos/src/main/java/demos/docs/events/collision/froggy_jump/SpikeSensor.java

---

1. Der Abschnitt stammt aus dem Engine-Alpha-Wiki: https://engine-alpha.org/wiki/v4.x/Collision ↩