# Grundgerüst für Schiffe versenken



## mele (28. Feb 2005)

Hallo zusammen...ich bräuchte wohl ein Grundgerüst für Schiffe versenken. Am besten ein ganz einfaches...welches ich mit dem java editor bearbeiten kann. Ich weiß nicht wie ich das hinbekomme, dass man die Schiffe nicht sieht. Und wie ich die 
Schiffe größer bekomme, kriege ich auch nicht wirklich hin... kann mir einer helfen=?

 ???:L


----------



## Destiny1985 (28. Feb 2005)

Zeig doch mal deine Ansätze und stell konkretere Fragen...


----------



## mele (28. Feb 2005)

also...bei mir sieht man die Schiffe.Das soll ja vermieden werden 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();
        }
    }
}
```

Edit plak: code tags


----------



## Destiny1985 (28. Feb 2005)

Also erstmal solltest du Code Tags einfügen

[.code] dein quelltext [./code] (ohne die punkte ^^)

Und des weiteren denke ich das sich das mit ner GUI wesentlich besser machen würde (lol das kommt gerade von mir)

Glaube nicht das sich das mit nicht sichtbar auf Konsole verwirklichen lässt!


----------



## Wildcard (28. Feb 2005)

Destiny1985 hat gesagt.:
			
		

> Und des weiteren denke ich das sich das mit ner GUI wesentlich besser machen würde(lol das kommt gerade von mir)


 :lol: 


			
				Destiny1985 hat gesagt.:
			
		

> Glaube nicht das sich das mit nicht sichtbar auf Konsole verwirklichen lässt


natürlich lässt sich das machen. Auch wenn es nur eine Konsolenausgabe ist, sollten Model und "View" getrennt sein.
Allerdings ist es die Mühe nicht wert, da ein Konsolen Schiffeversenken ziemlich bescheiden aussieht.


----------



## Illuvatar (28. Feb 2005)

Vielleicht ist er noch ein Anfänger?
Natürlich sieht es net so toll aus, aber irgendwann muss amn halt manl ohne GUI anfangen. Oder sollte es zumindest.


----------



## Wildcard (28. Feb 2005)

Illuvatar hat gesagt.:
			
		

> Natürlich sieht es net so toll aus, aber irgendwann muss amn halt manl ohne GUI anfangen. Oder sollte es zumindest.


Das mag zwar richtig sein, aber viele Anfänger verschwenden viel zu viel Zeit bei dem Versuch eine hübsche 
Konsolenausgabe zu machen, die sie sinnvollerweise in GUI-Basics investieren sollten.
Bei Konsolen ein- und ausgaben (besonders Menüsteuerung usw.) steht der lernfaktor in keinem verhältnis zur 
aufgebrachten zeit. Deshalb sollte man IMO nur ganz am anfang kleine Sachen (in keinem Fall ein Spiel) über Konsole
machen, und so früh wie möglich auf GUI umsteigen.


----------



## Destiny1985 (28. Feb 2005)

Wildcard hat gesagt.:
			
		

> Illuvatar hat gesagt.:
> 
> 
> 
> ...



OK, das betrifft mich voll und ganz. Mach atm alles mit Konsole. Einen Einstieg in GUI zu finden wäre schon fein, bevor ich weiter meine Konsolenausgaben mit Sterchen verschönern muss. Ist jetzt zwar völlig Off-Topic, aber ein paar deutsche Tutorials o.ä. für den Einstieg in GUI wären super...und zwar ganz vom anfang an, denn gui ist absolutes neuland

*das hilft dann auch dem topic-ersteller und es ist doch nicht sooo sehr ot :>*


----------



## Wildcard (28. Feb 2005)

@Destiny1985
Kennst du den noch?
www.gailer-net.de  :wink:


----------



## Destiny1985 (28. Feb 2005)

komme ich nicht drauf  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 schonmal


----------



## Wildcard (28. Feb 2005)

Kannst du >5 MB anlagen empfangen?
Dann schick mir deine Adresse.


----------



## mic_checker (28. Feb 2005)

Btw. eine Kleinigkeit, aber ich finde es nicht so "schön" wenn man erst eingibt u. danach erscheint das ganze nochmal, also:



> 8
> X-Koordinate: 8
> 7
> Y-Koordinate: 7



Wenn schon dann würde ich das so machen:



> X-Koordinate: 8
> Y-Koordinate: 7



Wegen deinem Problem:
Momentan ist es ja so das du anfangs sagst: Der PC hat seine Schiffe an den Koordinaten (x,y) etc., also z.B. (8,7).

Vor dem ersten Tippen soll dann ein "leeres" Spielfeld erscheinen, also überall nur "-".
Sobald du richtig getippt hast soll dann für die entsprechende Koordinate "x" erscheinen ?
Ein "fehlerhafter" Tipp soll nicht berücksichtigt werden ?

Will nur sichergehen das ich dein Problem richtig verstanden hab.


----------



## Destiny1985 (1. Mrz 2005)

mic_checker hat gesagt.:
			
		

> Vor dem ersten Tippen soll dann ein "leeres" Spielfeld erscheinen, also überall nur "-".
> Sobald du richtig getippt hast soll dann für die entsprechende Koordinate "x" erscheinen ?
> Ein "fehlerhafter" Tipp soll nicht berücksichtigt werden ?



Ich hab gesagt das geht nicht ? So ein Unsinn  :noe: 

Hab das Programm schon im Hinterkopf  Aber ich glaub da setz ich mich mal ran wenn ich GUI beherrsche...

btw Wildcard ist deine Mail raus ?

mfg


----------



## Wildcard (1. Mrz 2005)

Destiny1985 hat gesagt.:
			
		

> btw Wildcard ist deine Mail raus ?


Sollte eigentlich. Hab's in 2 aufteilen müssen, weil Web nicht mehr als 5 MB verschicken wollte.
Wenn's nicht geklappt hat meld dich nochmal.


----------



## Destiny1985 (1. Mrz 2005)

hm komisch hier kam nichts an...kann sein das es noch dauert, oder die firewall hat es ganz abgefangen...wenn nichts kommt ist es erstmal ok


----------



## mele (1. Mrz 2005)

ja ich bin anfänger und würde mich freuen, wenn einer eine einfache lösung posten würde.


----------



## mic_checker (1. Mrz 2005)

edit: Destiny : Ich denke du hast nichts dagegen wenn ich meinen Müll von hier oben rauseditiere ? 

So hab ich mir das gedacht (Konsole):



> ---------------------
> Schiffe versenken
> ---------------------
> 
> ...



Wird jetzt durch quote nicht so ganz korrekt dargestellt, auf der Konsole siehts aber richtig aus.

mele: Das Problem bei dir ist du hast nur ein Spielfeld. Ich würde dir empfehlen ein zweites zu erzeugen.

IN das erste trägst du die Felder vom PC ein, das zweite ist erstmal leer, wenn du ein Schiff getroffen hast , bzw eine Koordinate, so trägst du in dieses anfangs leere Spielfeld an entspr. Position ein "x" ein.


```
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);
```

So kriegst du immer nur das Spielfeld angezeigt mit dem aktuellen Stand, also ob du schon was versenkt hast.


----------



## Destiny1985 (1. Mrz 2005)

<edit>

auch mal rauseditier, hat hier ja nichts zu suchen

</edit>


----------



## mic_checker (1. Mrz 2005)

Sorry, hab da was in den falschen Hals bekommen, das passiert wenn man schlecht schläft u. gereizt aufsteht  - sorry.

mele: würde dir allerdings empfehlen das prog noch zu erweitern:
- bisher ist es alles andere als OOP 
- Der PC sollte seine Koordinaten nicht vorher festlegen, da du ja dann weisst wo die sind.
- etc. pp.

Habe das ganze in Richtung OO etwas umgebaut, aber lass dir erst noch etwas zeit um selber drauf zu kommen.


----------



## Destiny1985 (1. Mrz 2005)

mic_checker hat gesagt.:
			
		

> Sorry, hab da was in den falschen Hals bekommen, das passiert wenn man schlecht schläft u. gereizt aufsteht  - sorry.



<ot>

akzeptiert und haken dran

</ot>


----------



## mele (1. Mrz 2005)

OK Danke! und wie mache ich das jetzt, dass der PC sich die Koordinaten für die Schiffe selber sucht?


----------



## mic_checker (1. Mrz 2005)

Du könntest mit Random() arbeiten, also so das zwei Zufallszahlen generiert werden. Dabei musst du drauf achten, dass das Paar - also die Koordinate (x,y) nicht schon existiert.

Vielleicht kann ich nachher den andern Code noch posten.


----------



## mic_checker (1. Mrz 2005)

mele: Hast du dir wenigstens schon mal Gedanken darüber gemacht wie du das ganze mehr in Richtung "Objekt-Orientierung" gestalten könntest ?
Kann ja immernoch meinen Ansatz nachher posten...


----------



## Knoxx (2. Mrz 2005)

Schau mal hier: http://sourceforge.net/projects/battleshipgame.
Wir haben vor einiger Zeit ein "Schiffe versenken" als Programmier-Projekt an der Uni entwickelt. Angefangen auch mit Konsolenausgabe, später einfach ne GUI draufgesetzt. Ist sogar netzwerk-fähig und besitzt (sehr beschränkte) intelligente Computerspieler.

Gruß,
Knoxx


----------



## mic_checker (3. Mrz 2005)

Poste hier mal ein bisschen Code, keine Gewähr auf Richtigkeit etc. Habs nur mal schnell hingeschrieben, ohne großartig zu testen:


```
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;
	}
}
```

Wie gesagt, bei Fehlern bitte posten. Sind sicher einige drin, das Grundkonzept dahinter ist aber wichtiger 

Btw. das Interface musst du nicht unbedingt implementieren, hab mir nur gedacht je nachdem wie du es erweitern willst kann es nicht schaden.
Ist sowieso noch genügend Raum für Ausweiterungen des Ganzen.


----------



## Guest (4. Mrz 2005)

Danke Danke!!! :toll:


----------



## mic_checker (7. Mrz 2005)

Hab die Klasse PC_Player mal etwas umgeschrieben, jetzt funzt "SYSTEM_CONSTRUCT":


```
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;	
			}
		}
	}
}
```

Beachte: Zu Testzwecken habe ich das ganze Player2(!) genannt. Musst also entsprechend anpassen.

Auch positioniert in Spielfeld wurde minimal angepasst:


```
public int pruefeIndizes(int x,int y) {
	   if (x < 0 || x >= breite || y < 0 || y >= hoehe) 		   
	   	return -1;	   
		
		return 0;
	}
```

Btw. an einigen Stellen muss aufgrund dessen noch eine if-Abfrage rein, aber ich poste mal nicht alles damit du noch was zum suchen hast


----------

