Ein neues Projekt wurde gestartet. Ob ich es jemals vollenden werde liegt noch in den Sternen.

Ich habe mir gedacht ein primitives Spiel mit Java zu programmieren. Aussehen soll es wie ein Strategiespiel (2D-Grafik). Für den Anfang dachte ich mir ein Spielfeld zu realisieren, auf dem man Objekte - wie man sich es bei Strategiespielen gewohnt ist - irgendwo hinschicken kann. Dies wird mit einer 2D-Optik dargestellt.

Bis jetzt habe ich ein bisschen Codeschnippsel, welches zwei Objekte (”Hans” und “Peter”) erstellt und diese auf eine Koordinate auf dem Spielfeld laufen lässt. Der nächste Schritt wäre Funktionen für die grafische Darstellung zu programmieren und das Spiel danach immer mehr und mehr erweitern (Steuerung mit der Maus, Objekte die sich gegenseitig attackieren, künstliche Intelligenz, usw.).

Mein Grundgerüst kann auf eigene Gefahr übernommen werden. Falls es neuere Versionen geben wird, werde ich diese natürlich zur Verfügung stellen.

Die Klasse “Spiel”

/**
 * Die Klasse Spiel stellt das ganze Spiel dar.
 * Hier wird das Spiel gestartet, wobei ständig ein Zyklus abläuft.
 * Ein Takt ist ein Durchlauf des Zyklus, bei dem Aktionen von allen Objekten ausgeführt werden.
 * @author Klaudio Gospic (www.klajo.com)
 * @since 1.6
 * @version 1.00
 *
 */
public class Spiel {
	private Objekt[][] 			spielfeld;				//Das Spielbrett mit den Objekten drauf (sozusagen)
	private boolean 			finish;					//Kennzeichnet das Ende des Spiels
	private long 				geschwindigkeit;		//Geschwindigkeit eines Taktes in Milisekunden
	private Objekt[] 			gespielt;				//Liste mit allen Objekte, die eine Aktion hatten während eines Taktes
	private static final int 	MAXOBJEKTE 		= 100;	//Anzahl maximaler Objekte im Spiel
	private static final int 	XFELDER 		= 100;	//Anzahl X-Felder
	private static final int 	YFELDER 		= 100;	//Anzahl Y-Felder
	private static final long 	GESCHWINDIGKEIT = 1000;	//Geschwindigkeit eines Taktes in Milisekunden

	/**
	 * Konstruktor der Klasse Spiel.
	 * @param x					Anzahl X-Felder
	 * @param y					Anzahl Y-Felder
	 * @param geschwindigkeit	Geschwindigkeit eines Taktes in Milisekunden
	 */
	Spiel(int x, int y, long geschwindigkeit) {
		this.spielfeld 			= new Objekt[x][y];
		this.finish 			= false;
		this.geschwindigkeit 	= geschwindigkeit;
	}

	/**
	 * Start-Methode der Klasse Spiel. Mit dieser Methode
	 * wird ein Spiel gestartet.
	 * @param Args	-
	 */
	public static void main(String Args[]) {
		//Hier werden für den Anfang noch statisch Objekte erzeugt und je eine Aktion gesetzt.
		Spiel spiel = new Spiel(XFELDER,YFELDER, GESCHWINDIGKEIT);
		spiel.spielfeld[50][50] = new Objekt("Hans", 3, 50, 50);
		spiel.spielfeld[10][0] 	= new Objekt("Peter", 4, 10, 0);
		spiel.spielfeld[50][50].setZielX(20);
		spiel.spielfeld[50][50].setZielY(35);
		spiel.spielfeld[10][0].setZielX(1);
		spiel.spielfeld[10][0].setZielY(90);		

		while(!spiel.finish) { //Solange Spiel läuft, den Zyklus ablaufen lassen
			//Beginn des Taktes

			//Liste "gespielt" initialisieren
			spiel.gespielt = new Objekt[MAXOBJEKTE];

			spiel.finish = true;
			try {
				Thread.sleep(spiel.geschwindigkeit); //Spielgeschwindigkeit beeinflussen
			} catch(InterruptedException e) {
				//Exception abfangen
			}

			//Alle Spielfelder durchlaufen
			for(int i = 0; i < spiel.spielfeld.length; i++) {
				for(int j = 0; j < spiel.spielfeld[i].length; j++) {
					if(spiel.spielfeld[i][j] != null) {
						//Objekt nur bewegen, wenn es in diesem Takt noch keine Aktion hatte und sein Ziel noch nicht erreicht hat
						if(!spiel.arrayContainObject(spiel.gespielt, spiel.spielfeld[i][j])) {
							if(spiel.spielfeld[i][j].getXPos() != spiel.spielfeld[i][j].getZielX() || spiel.spielfeld[i][j].getYPos() != spiel.spielfeld[i][j].getZielY()) {
								spiel.spielfeld[i][j].bewegen(); //Objekt bewegen
								spiel.spielfeld[i][j].meldePosition(); //Position ausgeben
								spiel.spielfeld[spiel.spielfeld[i][j].getXPos()][spiel.spielfeld[i][j].getYPos()] = spiel.spielfeld[i][j]; //Objekt auf dem Spielfeld bewegen (zur neuen Position)
								spiel.finish = false; //Das Spiel kann noch einen Takt machen
								spiel.addGespielt(spiel, spiel.spielfeld[i][j].getXPos(), spiel.spielfeld[i][j].getYPos()); //Vermerken, dass das Objekt eine Aktion hatte
								spiel.spielfeld[i][j] = null; //Alte Position (vor der Bewegung) leeren

							}
						}
					}
				}
			}
		}
		//Ende des Taktes
		System.out.println("ENDE");
	}

	/**
	 * Prüft, ob ein Objekt in einer Liste enthalten ist.
	 * @param liste		Liste in der das Objekt vorhanden sein könnte.
	 * @param objekt	Objekt, nach welchem gesucht werden soll.
	 * @return			Boolean-Wert, ob das Objekt in der Liste vorhanden ist oder nicht.
	 */
	public boolean arrayContainObject(Objekt[] liste, Objekt objekt) {
		if(liste != null) {
			for(int i = 0; i < liste.length; i++) {
				if(liste[i] != null) {
					if(liste[i].equals(objekt)){
						return true;
					}
				}
			}
		}
		return false;
	}

	/**
	 * Ein Objekt der Liste "gespielt" hinzufügen.
	 * @param spiel	Das aktuelle Spiel
	 * @param x		X-Position des Objekts
	 * @param y		Y-Position des Objekts
	 */
	public void addGespielt(Spiel spiel, int x, int y) {
		for(int k = 0; k < spiel.gespielt.length; k++) {
			if(spiel.gespielt[k] == null) {
				spiel.gespielt[k] = spiel.spielfeld[x][y];
				break;
			}
		}
	}

	/**
	 * @return the spielfeld
	 */
	public Objekt[][] getSpielfeld() {
		return spielfeld;
	}

	/**
	 * @param spielfeld the spielfeld to set
	 */
	public void setSpielfeld(Objekt[][] spielfeld) {
		this.spielfeld = spielfeld;
	}

	/**
	 * @return the finish
	 */
	public boolean isFinish() {
		return finish;
	}

	/**
	 * @param finish the finish to set
	 */
	public void setFinish(boolean finish) {
		this.finish = finish;
	}

	/**
	 * @return the geschwindigkeit
	 */
	public long getGeschwindigkeit() {
		return geschwindigkeit;
	}

	/**
	 * @param geschwindigkeit the geschwindigkeit to set
	 */
	public void setGeschwindigkeit(long geschwindigkeit) {
		this.geschwindigkeit = geschwindigkeit;
	}

	/**
	 * @return the gespielt
	 */
	public Objekt[] getGespielt() {
		return gespielt;
	}

	/**
	 * @param gespielt the gespielt to set
	 */
	public void setGespielt(Objekt[] gespielt) {
		this.gespielt = gespielt;
	}

	/**
	 * @return the mAXOBJEKTE
	 */
	public static int getMAXOBJEKTE() {
		return MAXOBJEKTE;
	}

	/**
	 * @return the xFELDER
	 */
	public static int getXFELDER() {
		return XFELDER;
	}

	/**
	 * @return the yFELDER
	 */
	public static int getYFELDER() {
		return YFELDER;
	}

	/**
	 * @return the gESCHWINDIGKEIT
	 */
	public static long getGESCHWINDIGKEIT() {
		return GESCHWINDIGKEIT;
	}

}

und zu guter letzt die Klasse “Objekt”

/**
 * Die Klasse Objekt stellt ein Objekt auf dem Spielfeld dar.
 * Dieses Objekt kann z.B. ein Mensch,Tier, etc sein.
 * @author Klaudio Gospic (www.klajo.com)
 * @since 1.6
 * @version 1.00
 *
 */
public class Objekt {
	private String 	name;				//Name des Objekts
	private int 	xPos;				//Aktuelle Position auf der X-Achse
	private int 	yPos;				//Aktuelle Position auf der Y-Achse
	private boolean aktiv;				//Ist das Objekt gerade aktiv?
	private int 	geschwindigkeit;	//Felder pro Takt, die das Objekt vorwärts läuft
	private int 	zielX;				//Ziel-Position auf der X-Achse
	private int 	zielY;				//Ziel-Position auf der Y-Achse

	/**
	 * Konstruktor der Klasse Objekt.
	 * @param name				Name des Objekts
	 * @param geschwindigkeit	Felder pro Takt, die das Objekt vorwärts läuft
	 * @param xPos				Aktuelle Position auf der X-Achse
	 * @param yPos				Aktuelle Position auf der Y-Achse
	 */
	Objekt(String name, int geschwindigkeit, int xPos, int yPos) {
		this.name 				= name;
		this.geschwindigkeit 	= geschwindigkeit;
		this.xPos 				= xPos;
		this.yPos				= yPos;
	}

	/**
	 * Bewegt das Objekt für einen Takt
	 */
	public void bewegen() {
		//Nur bewegen wenn Ziel nicht erreicht wurde
		if(this.xPos != this.zielX || this.yPos != this.zielY) {
			this.aktiv = true;
			for(int i = 0; i < this.geschwindigkeit; i++) {
				//x-Position setzen
				if(this.xPos < this.zielX) {
					this.xPos++;
				} else if (this.xPos > this.zielX) {
					this.xPos–;
				}
				//y-Position setzen
				if(this.yPos < this.zielY) {
					this.yPos++;
				} else if (this.yPos > this.zielY) {
					this.yPos–;
				}
			}
		} else {
			this.aktiv = false;
		}
	}

	/**
	 * Gibt die aktuelle Position des Objekts aus.
	 */
	public void meldePosition() {
		System.out.println(”Objekt: ” + this.name + ” befindet sich auf der Position ” + this.xPos + “/” + this.yPos);
	}

	/**
	 * @return the name
	 */
	public String getName() {
		return name;
	}

	/**
	 * @param name the name to set
	 */
	public void setName(String name) {
		this.name = name;
	}

	/**
	 * @return the xPos
	 */
	public int getXPos() {
		return xPos;
	}

	/**
	 * @param pos the xPos to set
	 */
	public void setXPos(int pos) {
		xPos = pos;
	}

	/**
	 * @return the yPos
	 */
	public int getYPos() {
		return yPos;
	}

	/**
	 * @param pos the yPos to set
	 */
	public void setYPos(int pos) {
		yPos = pos;
	}

	/**
	 * @return the aktiv
	 */
	public boolean isAktiv() {
		return aktiv;
	}

	/**
	 * @param aktiv the aktiv to set
	 */
	public void setAktiv(boolean aktiv) {
		this.aktiv = aktiv;
	}

	/**
	 * @return the geschwindigkeit
	 */
	public int getGeschwindigkeit() {
		return geschwindigkeit;
	}

	/**
	 * @param geschwindigkeit the geschwindigkeit to set
	 */
	public void setGeschwindigkeit(int geschwindigkeit) {
		this.geschwindigkeit = geschwindigkeit;
	}

	/**
	 * @return the zielX
	 */
	public int getZielX() {
		return zielX;
	}

	/**
	 * @param zielX the zielX to set
	 */
	public void setZielX(int zielX) {
		this.zielX = zielX;
	}

	/**
	 * @return the zielY
	 */
	public int getZielY() {
		return zielY;
	}

	/**
	 * @param zielY the zielY to set
	 */
	public void setZielY(int zielY) {
		this.zielY = zielY;
	}

}