Bermuda: ein Beispiel-Applet in Java

Willemers Informatik-Ecke

Die Aufgabenstellung

Bermuda ist ein kleines Spiel, das mit einer einfachen Textoberfläche in einem Applet realisiert werden kann und damit ideal zur Demonstration verwendbar ist.

In einem Feld von 9x7 Punkten sind Schiffe verschwunden, die durch Anticken der Positionen gesucht werden können. Nach Anklicken zeigt die Position ein X, wenn ein Schiff gefunden wurde oder eine Zahl, die Auskunft gibt, in wieviele Richtungen (!) Schiffe gesehen werden. Ein Schiff kann also durch ein davor liegendes verdeckt werden.

Das Auffinden aller Schiffe soll erkannt und dem Anwender angezeigt werden. Er soll die Möglichkeit haben, das Spiel neu zu starten.

Das Spiel als Applet

Spielen Sie: es sollte funktionieren, wenn Ihr Browser Java unterstützt.

Die Sourcen

import java.awt.*;
import java.applet.*;
import java.awt.event.*;
import java.lang.String.*;
/**
 * Bermuda: ein kleines Spiel als Java-Applet-Demo
 * @author Arnold Willemer
 * @version 1.0 5/1999
 */

/**
 * Klasse cShips simuliert die verborgenen Schiffe
 */
class cShips
{
final char SHIP='X';
int maxShips = 4;	// Anzahl der Schiffe
int x[] = new int[maxShips];	// x-Position
int y[] = new int[maxShips];	// y-Position
boolean found[] = new boolean[maxShips];	// bereits entdeckt?
int maxX;	// die maximale Spielfelddimension
int maxY;

	/**
	 * Verstecke die Schiffe und markiere als nicht gefunden
	 */
	public void Hide(int pX, int pY)
	{
	int i=0; int j=0;
	
		maxX = pX; maxY = pY;

		while (i<maxShips) {
			x[i] = (int) (Math.random()*(maxX-1));
			y[i] = (int) (Math.random()*(maxY-1));
			for (j=0; j<i; j++) {
				if (x[j]==x[i] && y[j]==y[i]) {
					// Die Schiffe sind gleich, wir brauchen ein Neues!
					i--;
					break;
				}
			}
			i++;
		}
		for(i=0;i<maxShips;i++) found[i] = false;
	}
	/**
	 * Suche die Schiffe (Search) und melde die Anzahl der RICHTUNGEN(!!!)
	 */
	private int Touch(int px, int py)
	{ // lokal zu Search: ist hier etwas?
	int i;
	int count = 0;
	
		for (i=0; i<maxShips; i++) {
			if (x[i]==px && y[i]==py) {
				return i+1;
			}
		}
		return 0;
	}
	private int WalkLine(int px, int py, int dx, int dy)
	{ // lokal zu Search: laufe eine Linie entlang
		if (dx==0 && dy==0) return 0;
		while (px>=0 && px<maxX && py>=0 && py<maxY) {
			px += dx;
			py += dy;
			if (Touch(px, py)>0) return 1;
		}
		return 0;		
	}
	public char Search(int px, int py)
	{
		int i, j;
		int count=0;
		// haben wir bereits ein Schiff getroffen?
		count = Touch(px, py);
		if (count>0) {
			found[count-1] = true;
			return SHIP;
		}
		// suche in alle Richtungen
		for (i=-1; i<=1; i++) {
			for (j=-1; j<=1; j++) {
				count += WalkLine(px, py, i, j);
			}
		}
		return (char)('0'+count);
	}
	/**
	 * sind bereits alle Schiffe entdeckt worden?
	 */
	public boolean AllFound()
	{
		int i;
		for (i=0; i<maxShips; i++) {
			if (found[i]==false) return false;
		}
		return true;
	}
}


/**
 * die Klasse simuliert das Spielfeld von 9 x 7 Feldern
 * auf denen sich Schiffe verbergen koennen.
 */
class GameArea extends cShips
{
int maxX = 9;	// die Felddimensionen
int maxY = 7;
private char pos[][] = new char[maxX][maxY];	// das Spielfeld
//private cShips Ship = new cShips();				// die Schiffe

	public GameArea()
	{
		Setup();
	}
	/**
	 * neues Spiel
	 */
	public void Setup()
	{
		int i,j;
		super.Hide(maxX, maxY);
		for (i=0; i<maxX; i++) {
			for (j=0; j<maxY; j++) {
				pos[i][j] = '+';
			}
		}
	}
	/**
	 * was ist auf diesem Feld eingetragen?
	 */
	public char get(int xPos, int yPos)
	{
		return pos[xPos][yPos];
	}
	/**
	 * was verbirgt sich hinter diesem Feld?
	 */
	public char Search(int x, int y) 
	{
		pos[x][y] = super.Search(x, y);
		return pos[x][y];
	}
}


/**
 * Bermuda ist die Klasse, die das Spiel realisiert.
 * Dabei ist dies in erster Linie die Oberflaeche und
 * Benutzerfuehrung.
 */
public class Bermuda extends Applet implements MouseListener 
{
GameArea sf = new GameArea();
boolean Finish = false;	// ist das Spiel beendet worden?
String StatusStr = "                            ";
	public void init()
	{
		this.addMouseListener(this); // fange die Mausereignisse
		this.resize(300,200);
	}
	/**
	 * Anzeige des Spielfelds findet durch repaint statt
	 */
	public void paint(Graphics g)
	{
		int i, j;
		String str;

		for (i=0; i<sf.maxX; i++) {
			for (j=0; j<sf.maxY; j++) {
				str = String.valueOf(sf.get(i,j));
				g.drawString(str, (i+1)*20, (j+1)*20);
			}
		}
		g.drawString(StatusStr, 10, (sf.maxY+1) * 20);
	}

	/**
	 * der Benutzer tut was relevantes, er klickt mit der Maus
	 */
	public void mouseClicked(MouseEvent me)
	{
	int x, y;
	char c;
	
		x = me.getX();
		y = me.getY();
		if (!Finish) {
			c = sf.Search((x-10)/20, (y-10)/20);
			if (c==sf.SHIP) {
				if (sf.AllFound()) {
					// alle gefunden: GEWONNEN!
					Finish = true;
					StatusStr = "Gewonnen! Mausklick: neues Spiel";
				}
			}
		} else {
			// sonderfall: Mausklick, um Sieg zu bestaetigen
			Finish = false;
			StatusStr = "                              ";
			sf.Setup();
		}
		repaint();
	}
	// zur Realisierung des Interface, auch wenn wir es nicht
	// brauchen...
	public void mouseReleased(MouseEvent me) { }
	public void mousePressed(MouseEvent me)	{ }
	public void mouseEntered(MouseEvent me)	{ }
	public void mouseExited(MouseEvent me)	{ }
}

Homepage - Java (C) Copyright 1999, 2000 Arnold Willemer