Und ich würde das gerne so machen, dass bei "Schiffe versenken..." die Buchstaben nacheinander kommen...ja? import java.io.*;
public class SchiffeVersenken {
static BufferedReader in;
static PrintWriter out;
public static int chValue; // das zuletzt von der Konsole eingelesene Zeichen
static boolean[][] spielfeld = new boolean[10][10]; // unser Spielfeld. true = Schiff
public static void main (String[] args) throws IOException {
in = new BufferedReader (new InputStreamReader(System.in, "Cp437"));
out = new PrintWriter (new OutputStreamWriter(System.out, "Cp437"), true);
System.out.println("--------------------");
System.out.println("Schiffe versenken...");
System.out.println("--------------------");
System.out.println( );
System.out.println( );
// das Spielfeld mit Schiffen füllen
spielfeld[8][7] = true;
spielfeld[2][1] = true;
spielfeld[2][5] = true;
spielfeld[3][5] = true;
spielfeld[6][2] = true;
spielfeld[6][3] = true;
spielfeld[6][4] = true;
spielfeld[2][8] = true;
spielfeld[3][8] = true;
spielfeld[4][8] = true;
spielfeld[5][8] = true;
zeichneSpielbrett(spielfeld);
// x- und y-Koordinaten einlesen und nachprüfen, ob
// getroffen wurde
try {
chValue = in.read();
skipBlanks();
int x, y;
while (chValue != -1) {
x = parseInt();
out.println("X-Koordinate: " + x);
skipBlanks();
y = parseInt();
out.println("Y-Koordinate: " + y);
// sind die eingegeben Koordinaten korrekt?
if ( (x < spielfeld.length) && (y < spielfeld[0].length) ) {
// wurde getroffen?
if (getroffen(x, y, spielfeld)) {
out.println("Getroffen!");
}
else {
out.println("Nicht getroffen... schade.");
}
}
else {
out.println("Eingabe nicht korrekt!");
}
skipBlanks();
}
}
catch (IOException e) {
System.out.println("Fehler: " + e);
}
}
static void skipBlanks () throws IOException {
while (chValue != -1 && chValue <= 32) // Steuerzeichen bis Blank skippen
chValue = in.read();
}
public static int parseInt() throws IOException {
// parseInt liest eine Zeichenfolge aus Ziffern von der Konsole (in)
// und "wandelt" sie in ein int.
// Rückgabewert: die gelesene Zahl als int
// Vorausgesetzt wird, daß das nächste Zeichen von der Konsole
// die erste Ziffer des Integer ist, und daß die Syntax der Eingabe
// korrekt ist.
int result = 0;
do {
result = result*10 + chValue - '0';
chValue = in.read();
}
while ( chValue != -1
&& '0' <= chValue && chValue <= '9' );
return result;
}
// gibt true zurück, wenn an x-y in einSpielfeld ein Schiff ist
static boolean getroffen(int x, int y, boolean[][] einSpielfeld) {
return einSpielfeld[x][y];
}
static void zeichneSpielbrett(boolean[][] einSpielfeld) {
System.out.print(" ");
// die Beschriftung der x-Achse
for (int x = 0; x <= 9; x++)
System.out.print(x + " ");
System.out.println();
// alle Zeilen
for (int y = 9; y >= 0; y--) {
// erst die Beschriftung...
System.out.print(y + " ");
// dann für jede Spalte entweder ein 'x' oder ein '-'
for (int x = 0; x <= 9; x++) {
if (einSpielfeld[x][y]) {
System.out.print("x ");
}
else {
System.out.print("- ");
}
}
System.out.println();
}
}
}
:lol:Destiny1985 hat gesagt.:
natürlich lässt sich das machen. Auch wenn es nur eine Konsolenausgabe ist, sollten Model und "View" getrennt sein.Destiny1985 hat gesagt.:
Das mag zwar richtig sein, aber viele Anfänger verschwenden viel zu viel Zeit bei dem Versuch eine hübscheIlluvatar hat gesagt.:
Wildcard hat gesagt.:
diese ********* firewall blockt mir alles...gibt es das tutorial als pfd oder kann man es in eine .doc file kopieren oder einfach die internet-seite speichern und mir per email schicken ? Das wäre super...Die Adresse, an die es soll, kriegt derjenige per PM, der sich bereiterklärt mir da eben zu helfen,...thx schonmalmic_checker hat gesagt.:
Aber ich glaub da setz ich mich mal ran wenn ich GUI beherrsche... static boolean[][] spielfeld = new boolean[HOEHE][BREITE]; // unser Spielfeld. true = Schiff
static boolean[][] feld_akt = new boolean[HOEHE][BREITE];
.....
spielfeld[2][8] = true;
spielfeld[3][8] = true;
spielfeld[4][8] = true;
spielfeld[5][8] = true;
zeichneSpielbrett(feld_akt);
.....
if (getroffen(x, y, spielfeld)) {
feld_akt[x][y] = true;
.....
zeichneSpielbrett(feld_akt);mic_checker hat gesagt.:
public class Main_SchiffeVersenken implements Mode {
final static int BREITE = 10;
final static int HOEHE = 10;
private static int versenkt,zu_versenken,count;
private static boolean weiter = true;
private static Spielfeld comp = new Spielfeld(HOEHE,BREITE);
private static PC_Player pc = new PC_Player(comp,10);
private static Human_Player human = new Human_Player(comp);
public static void main(String[] args) {
Spielfeld.menu();
zu_versenken = comp.getNum();
/*
* Es wird solange gespielt bis der Spieler alle Schiffe vom PC versenkt hat oder bis
* er das Spiel durch Eingabe von -1 beendet.
*/
do {
human.zeichne();
human.nextStep();
versenkt = human.getVersenkt();
count++;
/*
* Alle 5 Runden wird der User gefragt ob er weiter spielen möchte.
*/
if(count % 5 == 0)
if((Human_Player.readInt("\nRunde beenden ? [-1 == Ja / sonst == Nein] > ")) == -1)
weiter = false;
} while (versenkt < zu_versenken && weiter);
if(versenkt == zu_versenken)
congratulate(count);
else
System.out.println("Nicht gewonnen - Sie haetten noch "+(zu_versenken - versenkt)+" Schiffe versenken muessen");
}
public static void congratulate(int num) {
System.out.println("\n\tHerzlichen Glueckwunsch ! \n");
/*
* Der User hat öfter getippt als es eigentlich theoretisch möglich ist.
* -> Hat mehrmals die selbe Koordinate angegeben
*/
if(num > HOEHE * BREITE)
System.out.println("Sie haben zwar gewonnen, allerdings sollten Sie beim nächsten Spiel nicht versuchen eine Koordinate mehrmals zu versenken !");
}
}abstract class Player implements Mode {
protected Spielfeld sp;
private int hoehe,breite;
public Player() {
}
public Player(Player sp1) {
this(sp1.getSpielfeld());
}
public Player(Spielfeld sp) {
if(sp != null) {
this.sp = sp;
hoehe = sp.getHoehe();
breite = sp.getBreite();
}
}
abstract public void init(int mode);
public Spielfeld getSpielfeld() {
return sp;
}
public void setSpielfeld(Spielfeld sp) {
if(sp != null) {
this.sp = sp;
}
}
}import java.io.*;
class Human_Player extends Player {
private Spielfeld myself;
private int x,y;
private int versenkt = 0;
private int zu_versenken = 0;
static BufferedReader in;
static PrintWriter out;
public Human_Player(Human_Player sp1) {
this(sp1.getSpielfeld());
}
public Human_Player(Spielfeld sp) {
super(sp);
if(sp != null) {
myself = new Spielfeld(sp.getHoehe(),sp.getBreite());
zu_versenken = sp.getNum();
init(USER_SET);
}
}
public void init(int mode) {
if(mode == USER_SET) {
try {
in = new BufferedReader (new InputStreamReader(System.in, "Cp437"));
out = new PrintWriter (new OutputStreamWriter(System.out, "Cp437"), true);
} catch (IOException ioe) {
System.err.println("Fehler beim Umgang mit den Streams !");
System.exit(1);
}
}
}
public void nextStep() {
do {
x = readInt("X-Koordinate: ");
} while(x < 0 || x >= sp.getBreite());
do {
y = readInt("Y-Koordinate: ");
} while (y < 0 || y >= sp.getHoehe());
if(sp.pruefeIndizes(x,y) != -1) {
if (sp.getroffen(x,y)) {
if(myself.getWert(x,y) == false) {
myself.setWert(x,y,true);
versenkt++;
}
out.println(" -> Getroffen");
}
else
out.println(" -> Nicht getroffen");
System.out.println();
}
}
public void zeichne() {
myself.zeichne();
}
public static int readInt(String prompt) {
while (true) {
System.out.print(prompt);
try {
String zeile = in.readLine();
return Integer.parseInt(zeile);
} catch (NumberFormatException e) {
System.out.println ("Bitte eine ganze Zahl eingeben.");
} catch (IOException e) {
e.printStackTrace();
System.exit(1);
}
}
}
public int getX() {
return x;
}
public void setX(int x) {
if(x > 0)
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
if(y > 0)
this.y = y;
}
public int getVersenkt() {
return versenkt;
}
public void setVersenkt(int x) {
if(x > 0)
versenkt = x;
}
public int getZuVersenken() {
return zu_versenken;
}
public void setZuVersenken(int y) {
if(y > 0)
zu_versenken = y;
}
public Spielfeld getSpielfeld() {
return sp;
}
public void setSpielfeld(Spielfeld sp) {
if(sp != null) {
this.sp = sp;
}
}
}import java.util.*;
class PC_Player extends Player {
private int zuege;
private int lastx;
private int lasty;
public PC_Player(Spielfeld sp,int zuege) {
super(sp);
if(zuege > 0) {
this.zuege = zuege;
init(RANDOM);
}
}
public void init(int mode) {
if(mode == USER_SET) {
/*
* In diesem Modus legt der User die Koordinaten der Schiffe des PC's fest.
* Eigentlich lediglich zu Testzwecken der ganzen Klassen geeignet.
*/
sp.setWert(8,7,true);
sp.setWert(2,1,true);
sp.setWert(2,5,true);
sp.setWert(3,5,true);
sp.setWert(6,2,true);
sp.setWert(6,3,true);
sp.setWert(6,4,true);
sp.setWert(2,8,true);
sp.setWert(3,8,true);
sp.setWert(4,8,true);
sp.setWert(5,8,true);
} else if(mode == RANDOM) {
/*
* In diesem Modus generiert der PC die Koordinaten seiner "Schiffe" zufällig
*/
Random rgen = new Random();
for(int i = 0;i < zuege;) {
lastx = rgen.nextInt(sp.getBreite());
lasty = rgen.nextInt(sp.getHoehe());
if(!sp.getWert(lastx,lasty)) {
sp.setWert(lastx,lasty,true);
i++;
}
}
} else if(mode == SYSTEM_CONSTRUCT) {
/*
* In diesem Modus soll der PC das Spielfeld nach einem
* best. System füllen. D.h. benachbarte Feldelemente zu einem Schiff zusammenfügen etc.
*
* Random rgen = new Random();
* lastx = rgen.nextInt(sp.getBreite());
* lasty = rgen.nextInt(sp.getHoehe());
*/
}
}
}interface Mode {
/*
* Die folgenden Konstanten dienen der Steuerung der Methode init(int mode) von Player, bzw.
* der zugehörigen Subklassen.
*/
final static int USER_SET = 1;
final static int RANDOM = 2;
final static int SYSTEM_CONSTRUCT = 3;
}class Spielfeld {
private int hoehe;
private int breite;
private int num;
private boolean[][] feld;
/*
* Standardmäßig wird ein Spielbrett mit einer 10 x 10 Matrix angelegt
*/
public Spielfeld() {
this(10,10);
}
public Spielfeld(Spielfeld other) {
this(other.hoehe,other.breite);
}
/*
* Wir setzen voraus: Die Höhe und Breite ist >= 2. Grund: Eine gewisse Herausforderung muss
* für den Spieler schon existieren...
*/
public Spielfeld(int hoehe,int breite) {
if(hoehe > 1 && breite > 1) {
this.hoehe = hoehe;
this.breite = breite;
feld = new boolean[hoehe][breite];
}
}
// gibt true zurück, wenn an (x,y) ein Schiff ist
public boolean getroffen(int x, int y) {
if(pruefeIndizes(x,y) != -1)
return feld[x][y];
return false;
}
public int pruefeIndizes(int x,int y) {
if (x < 0 || x >= breite || y < 0 || y >= hoehe) {
//System.err.println("Ungueltige Indizes!");
//System.out.println("pruefe ("+x+","+y+")");
return -1;
}
return 0;
}
public void zeichne() {
System.out.print(" ");
for (int x = 0; x < breite; x++)
System.out.print(x + " ");
System.out.println();
for (int y = hoehe - 1; y >= 0; y--) {
System.out.print(y + " ");
for (int x = 0; x < breite; x++) {
if (feld[x][y])
System.out.print("x ");
else
System.out.print("- ");
}
System.out.println();
}
}
public static void menu() {
System.out.println("\t---------------------");
System.out.println("\t Schiffe versenken ");
System.out.println("\t---------------------");
System.out.println( );
System.out.println( );
}
public void setWert(int x,int y,boolean wert) {
if(pruefeIndizes(x,y) != -1) {
if(!feld[x][y]) {
feld[x][y] = wert;
num++;
}
}
}
public boolean getWert(int x,int y) {
if(pruefeIndizes(x,y) != -1)
return feld[x][y];
return false;
}
public int getNum() {
return num;
}
public void setNum(int num) {
if(num > 0)
this.num = num;
}
public int getHoehe() {
return hoehe;
}
public int getBreite() {
return breite;
}
public void setHoehe(int hoehe) {
if(hoehe > 0)
this.hoehe = hoehe;
}
public void setBreite(int breite) {
if(breite > 0)
this.breite = breite;
}
}import java.util.*;
class PC_Player2 extends Player {
private int zuege;
private int lastx;
private int lasty;
private boolean horizontal = false;
private boolean vertical = false;
public PC_Player2(Spielfeld sp,int zuege) {
super(sp);
if(zuege > 0) {
this.zuege = zuege;
init(SYSTEM_CONSTRUCT);
}
}
public void init(int mode) {
if(mode == USER_SET) {
/*
* In diesem Modus legt der User die Koordinaten der Schiffe des PC's fest.
* Eigentlich lediglich zu Testzwecken der ganzen Klassen geeignet.
*/
sp.setWert(8,7,true);
sp.setWert(2,1,true);
sp.setWert(2,5,true);
sp.setWert(3,5,true);
sp.setWert(6,2,true);
sp.setWert(6,3,true);
sp.setWert(6,4,true);
sp.setWert(2,8,true);
sp.setWert(3,8,true);
sp.setWert(4,8,true);
sp.setWert(5,8,true);
} else if(mode == RANDOM) {
/*
* In diesem Modus generiert der PC die Koordinaten seiner "Schiffe" zufällig
*/
Random rgen = new Random();
for(int i = 0;i < zuege;) {
lastx = rgen.nextInt(sp.getBreite());
lasty = rgen.nextInt(sp.getHoehe());
if(!sp.getWert(lastx,lasty)) {
sp.setWert(lastx,lasty,true);
i++;
}
}
} else if(mode == SYSTEM_CONSTRUCT) {
/*
* In diesem Modus soll der PC das Spielfeld nach einem
* best. System füllen. D.h. benachbarte Feldelemente zu einem Schiff zusammenfügen etc.
*/
Random rgen = new Random();
int cur = 0,num,neux,neuy,i = 0;
while(cur < zuege) {
i = 1;
/*
* Generiere als "Startwert" eine Koordinate. Von dieser ausgehend "bauen" wir unser
* Schiff in vertikale oder horizontale Richtung.
*/
lastx = rgen.nextInt(sp.getBreite());
lasty = rgen.nextInt(sp.getHoehe());
/* Horizontal */
if(rgen.nextInt(2) == 0) {
/*
* Ein Schiff besteht mindestens aus einer Koordinate, da wir horizontal bauen
* kann das Schiff maximal so breit sein wie das Spielfeld.
*/
num = 1 + rgen.nextInt(sp.getBreite() - 1);
System.out.println("Erzeuge "+num+" Schiffe horizontal");
neux = lastx;
neuy = lasty;
/*
* Überprüfe ob an dieser Stelle bereits eine Koordinate von einem andern
* Schiff liegt.
*/
if(!sp.getWert(neux,neuy)) {
sp.setWert(neux,neuy,true);
cur++;
}
/*
* Es soll ein Schiff mit 'num' Koordinaten entstehen
*/
while(i < num) {
if(cur < zuege) {
/*
* Wenn horizontal = true, dann sind wir rechts an die Grenzen des Spielfelds
* gestossen. Daraus folgt das wir die Koordinate dekrementieren müssen, so
* dass das Schiff "nach links wächst".
*/
if(horizontal)
neux--;
else
neux++;
/*
* Da die Koordinaten verändert wurden, müssen wir erneut überprüfen ob
* wir damit noch innerhalb des erlaubten Bereichs liegen.
*/
if(sp.pruefeIndizes(neux,neuy) != -1) {
/*
* Nur dann Anzahl der gesamten "Züge" erhöhen wenn an der
* entsprechenden Stelle noch keine Koordinate eines anderen
* Schiffs liegt.
*/
if(!sp.getWert(neux,neuy)) {
sp.setWert(neux,neuy,true);
cur++;
}
i++;
}
else {
neux = lastx;
horizontal = true;
}
} else {
break;
}
}
} else {
/* Vertikal */
num = 1 + rgen.nextInt(sp.getHoehe() - 1);
System.out.println("Erzeuge "+num+" Schiffe vertikal");
neux = lastx;
neuy = lasty;
/*
* Überprüfe ob an dieser Stelle bereits eine Koordinate von einem andern
* Schiff liegt.
*/
if(!sp.getWert(neux,neuy)) {
sp.setWert(neux,neuy,true);
cur++;
}
while(i < num) {
if(cur < zuege) {
/*
* Wenn vertical = true, dann sind wir oben an die Grenzen des Spielfelds
* gestossen. Daraus folgt das wir die Koordinate dekrementieren müssen, so
* dass das Schiff "nach unten wächst".
*/
if(vertical)
neuy--;
else
neuy++;
/*
* Da die Koordinaten verändert wurden, müssen wir erneut überprüfen ob
* wir damit noch innerhalb des erlaubten Bereichs liegen.
*/
if(sp.pruefeIndizes(neux,neuy) != -1) {
/*
* Nur dann Anzahl der gesamten "Züge" erhöhen wenn an der
* entsprechenden Stelle noch keine Koordinate eines anderen
* Schiffs liegt.
*/
if(!sp.getWert(neux,neuy)) {
sp.setWert(neux,neuy,true);
cur++;
}
i++;
} else {
neuy = lasty;
vertical = true;
}
} else {
break;
}
}
}
vertical = false;
horizontal = false;
}
}
}
} public int pruefeIndizes(int x,int y) {
if (x < 0 || x >= breite || y < 0 || y >= hoehe)
return -1;
return 0;
}
