Spielprogrammierung mit Java
HomeAufgabenDruckenJava-Online

Programmstrukturen


1. if-else-Struktur (Selektion)

Programmverzweigungen auf Grund von bestimmten Bedingungen gehören zu den Grundstrukturen jeder Programmiersprache.

    if (Bedingung)
  {
    Anweisungen  
  } 
  else
  {
    Anweisungen
  }   
  Die Anweisungen nach if werden nur dann ausgeführt, wenn die Bedingung stimmt, ansonsten werden die Anweisungen nach else ausgeführt. Häufig wird nur der if-Block verwendet, um Bedingungen zu überprüfen.

Beispiel 1: Links oder rechts?
Der Crab entscheidet sich nach jedem Schritt zufällig, ob er nach links oder rechts schwimmen soll. Mit Klick auf die Schaltfläche Reset kann das Programm noch einmal ausgeführt werden.

Mit der Methode move() bewegt sich ein Objekt in eine der 8 benachbarten Zellen.

setDirection() setzt die Richtung neu.

In unserem Beispiel wird zufällig zwischen der Richtung 45° und 135° gewählt.

 

 

// JGameEx5.java

import ch.aplu.jgamegrid.*;
import java.awt.Color;

public class JGameEx5 extends GameGrid
{
  private Actor crab = new Actor("sprites/crab.gif");
  
  public JGameEx5()
  {
    super(101060Color.red, "sprites/reef.gif");
    addActor(crab, new Location(40));
    show();
  }

  public void act()
  {
    double randomNumber = Math.random();
    if (randomNumber > 0.5)
      crab.setDirection(45);
    else
      crab.setDirection(135);
    crab.move();  
  }

  public static void main(String[] args)
  {
    new JGameEx5();
  }
}
Erklärungen zum Programmcode:
double randomNumber = Math.random() Die Methode Math.random() liefert eine zufällige Dezimalzahl
if (randomNumber > 0.5) Mit der Wahrscheinlichkeit 0.5 bewegt sich der crab nach rechts oder nach links

 

2. switch-Struktur (mehrfache Selektion)

Stehen bei der Selektion mehrere Möglichkeiten zur Auswahl, wird die switch-Struktur verwendet.

    switch (variable)
  {
    case wert1:
      Anweisungen;
      break;
    case wert2:
      Anweisungen;
      break;
    .....
    default:
      Anweisungen;  
  }

Beispiel 2: Links, rechts, nach oben oder nach unten
Der Crab wechselt nach jedem Schritt zufällig die Bewegungsrichtung. Wenn er eine der Randzellen erreicht hat, schwimmt er in der entgegengesetzten Richtung weiter.

 
// JGameEx5a.java

import ch.aplu.jgamegrid.*;
import java.awt.Color;

public class JGameEx5a extends GameGrid
{
  private Actor crab = new Actor("sprites/crab.gif");

  public JGameEx5a()
  {
    super(101060Color.red, "sprites/reef.gif");
    addActor(crab, new Location(43));
    show();
  }

  public void act()
  {
    int randomNumber = (int)(Math.random() * 4);
    switch (randomNumber)
        {
          case 0:
            crab.setDirection(0);
            break;
          case 1:
            crab.setDirection(90);
            break;
          case 2:
            crab.setDirection(180);
            break;
          case 3:
            crab.setDirection(270);
            break;         
        }
    if (!crab.isMoveValid())
      crab.turn(180);
    crab.move();
  }

  public static void main(String[] args)
  {
    new JGameEx5a();
  }
}
Erklärungen zum Programmcode:
(int)(Math.random() * 4) Erzeugt zufällig ganze Zahlen 0, 1, 2 oder 3
isMoveValid() Die Methode isMoveValid() gibt true zurück, falls die nächste Zellenposition innerhalb des sichtbaren Gitters liegt
break break in jedem case bewirkt, dass das Programm die switch-Struktur verlässt, sobald der passende Fall eingetroffen ist

 

3. for-Struktur (Iteration / Mehrfaches Ausführen von Anweisungen)


i = 0 : Startwert
i < n : Abbruchbedingung
i++ : Wertänderung

Beispiel 3: Mehrere Crab-Objekte erzeugen
Mit Hilfe einer for-Schleife werden 10 Crabs an zufälligen Positionen erzeugt. Da die Methode act() in der Klasse Crab implementiert ist, werden die Anweisungen in der Methode act() für alle Crab-Instanzen ausgeführt - alle Craben bewegen sich.

Gelangt ein Crab in eine Randzelle, dreht er sich um 90°. Da er sich danach immer noch in einer Randzelle befindet, muss er sich noch einmal um 90° drehen.  

 

// JGameEx6.java 

import ch.aplu.jgamegrid.*;
import java.awt.Color;

public class JGameEx6 extends GameGrid
{
  public JGameEx6()
  {
    super(101060Color.red, "sprites/reef.gif");
    for (int i = 0; i < 10; i++)
      addActor(new Crab()getRandomEmptyLocation());
    show();
  }

  public static void main(String[] args)
  {
    new JGameEx6();
  }
}

// ------------------- class Crab -----------------------
class Crab extends Actor
{
  public Crab()
  {
    super("sprites/crab.gif");
  }

  public void act()
  {
    if (isMoveValid())
      move();
    if (isNearBorder())
      turn(90);
  }
}

int  i  =  0

Deklaration und Initialisierung der Zählervariable i

i  <  10

Schleifen-Bedingung. So lange die Bedingung erfüllt ist, werden die Anweisungen im Schleifenblock wiederholt ausgeführt

i++

Ist gleichwertig mit i = i + 1
Der Wert der Variable i wird um 1 vergrössert

addActor(new Crab(), getRandomEmptyLocation())

Erzeugt eine neue Crab-Instanz in einer zufällig gewählten, freien Zelle

 

 

4. Verschachtelte for-Schleifen


Beispiel 4: Mehrere Crab-Objekte mit Hilfe von verschachtelten for-Schleifen erzeugen

Allgemeine Form:

    for (int x = 0; x < n; x++)
  {
    for (int y = 0; y < m; y++)
    {
      Anweisungen;
    }
  }  

Mit zwei for-Schleifen kann man alle Wertepaare (x, y) durchlaufen. Lässt man im folgenden Beispiel die if-Struktur, welche prüft, ob die Summe x + y eine gerade Zahl ist, weg, wird in jeder Zelle ein neuer Crab erstellt.

 

// JGameEx6a.java

import ch.aplu.jgamegrid.*;
import java.awt.Color;

public class JGameEx6a extends GameGrid
{
  public JGameEx6a()
  {
    super(101060Color.red, "sprites/reef.gif");
    for (int x = 0; x < 10; x++)
      for (int y = 0; y < 10; y++)
      {
        if ((+ y) % 2 == 0)
        addActor(new Crab()new Location(x, y));
      }
    show();
  }

  public static void main(String[] args)
  {
    new JGameEx6a();
  }
}

// --------------------- class Crab ----------------------
class Crab extends Actor
{
  public Crab()
  {
    super("sprites/crab.gif");
  }

  public void act()
  {
    if (isMoveValid())
      move();
    if (isNearBorder())
      turn(90);
  }
}

if ((x + y) % 2 == 0)

% ist eine Modulodivision, die den Rest nach der Division (x + y)/2 ergibt. Diese Funktion braucht man häufig, um zu testen, ob eine Zahl gerade oder ungerade ist. Wenn die Summe von x und y eine gerade Zahl ist, wird an der Location(x, y) ein Crab erzeugt

 

5. while-Struktur (Iteration)

Allgemeine Form:

    int i = 0;           
    while (< n)    
    {
      Anweisungen;    
      i++;           
    }
  Die while-Struktur wird in allen Programmiersprachen zur Wiederholung von Programmblöcken sehr oft verwendet. In JGameGrid werden nach Drücken der Schaltfläche Run oder dem Aufruf von doRun() die act-Methoden aller Actoren in einer while-Struktur periodisch aufgerufen. Dadurch wird in diesem Lehrgang die while-Struktur nur selten verwendet.

Beispiel 5: Im unteren Teil des GameGrid Fensters sollen 7 Crabs an zufälligen, aber verschiedenen Positionen erzeugt werden.

In diesem Fall eignet sich eine while-Struktur besser, da wir im Voraus nicht wissen, wieviele Positionen zufällig gewählt werden müssen, bis wir 7 von einander verschiedene erhalten. (Die Methode getRandomEmptyLocation() bezieht sich auf das ganze Fenster und eignet sich deshalb nicht).

 
// JGameEx7.java

import ch.aplu.jgamegrid.*;
import java.awt.Color;

public class JGameEx7 extends GameGrid
{
  public JGameEx7()
  {
    super(101060Color.red, "sprites/reef.gif");
    int nb = 0;
    while (nb < 7)
    {
      Location loc = new Location((int)(10 * Math.random()),
                     5 + (int)(5 * Math.random()));
      if (isEmpty(loc))
      {
        addActor(new Crab(), loc);
        nb++;
      }
    }
    show();
  }

  public static void main(String[] args)
  {
    new JGameEx7();
  }
}

//---------------- class Crab -----------------------------
class Crab extends Actor
{
  public Crab()
  {
    super("sprites/crab.gif");
  }

  public void act()
  {
    if (isMoveValid())
      move();
    if (isNearBorder())
      turn(90);
  }
}
Erklärungen zum Programmcode:
while (nb < 7) So lange die gefordete Anzahl noch nicht erreicht ist, müssen wir den Programmblock wiederholen

if (isEmpty(loc))

Ein neuer Crab wird nur erzeugt, falls die Position noch nicht besetzt ist