# Zweidimensionalen Array füllen



## Parder (8. September 2007)

Hallo ich hab ein Problem mit einem zweidimensionalen int Array

```
void commanderspielfeld(){

		System.out.println();
		System.out.println("-  a  b  c  d  e  f  g  h  i  j");
		System.out.println();

		for (int i = 0; i < 10; i++){

			System.out.print(""+(i));
				for (int j = 0; j < 10; j++){
//					System.out.print("  "+feld[i][j]);
				}
			System.out.println();
		}
	figureninitialisierung();
	}	
}
```

ich soll darin mehrere Balken (zwei und drei felder lang) entweder senkrech oder horizontal einfügen.

```
System.out.print(" x = ");
					xb = Tools.intEingabe();
						System.out.print(" y = ");
					yb = Tools.intEingabe();
```
Das einfügen klappt aber wie schaffe ich es, dass nur senkrecht oder horizontal möglich ist?


----------



## Laocoon (8. September 2007)

Hallo, 

vielleicht liegt es dran, dass ich übermüdet bin. Aber ich verstehe grad nicht so ganz was du möchtest. Was soll das Programm denn im groben tun (würde es für ne art Tetris halten ^^). Möchtest du die Eingabe beschränken?

Grüße
Daniel


----------



## Parder (9. September 2007)

Eine Art von Tetris soll es nicht werden eher eine Art von Schiffe versenken. Und ich soll die Schiffe richtig anordnen.
Zuerst hab ich ein Feld erstellt


```
int [] [] feld = new int [10] [10];
	int [] [] fuellung = new int [10] [10];

void feldini(){
		for (int i = 0;i<10;i++){
			
			for (int j = 0;j<10;j++){
				feld [j] [i] = 0;
			}
		}
	}
```
Danach eine Rückgabe erstellt

```
void commanderfeld(){

		System.out.println();
		System.out.println("-   a   b   c   d   e   f   g   h   i   j");
		System.out.println();
		for (int i = 0; i < 10; i++){
			System.out.print(""+(i));
				for (int j = 0; j < 10; j++){
					System.out.print("  "+feld[i][j]);
				}
			System.out.println();
		}
	}
```

und jetzt soll in dieser Methode die Schiffe entweder horizontal oder senkrecht eingetragen werden.

```
public void figureninitialisierung(){

		int xb;
		int yb;
		boolean xa = false;	
		boolean ya = false;

		for (int i = 0; i < 10; i++){

			for (int j = 0; j < 10; j++){
				fuellung[i][j] = 0;
			}
		}
	                                xa = false;
					ya = false;

						System.out.print(" x = ");
					xb = Tools.intEingabe();
						System.out.print(" y = ");
					yb = Tools.intEingabe();
			
			////////////////////////////////////////

				if (fuellung [xb] [yb] == 0){
					do{
						xac = false;
						yac = false;
						System.out.print(" x = ");
					xc = Tools.intEingabe();
						System.out.print(" y = ");
					yc = Tools.intEingabe();

				System.out.println("Bitte die x-y-Koordinaten f|r die Boote eingeben");
					System.out.println("1. Schnellboot" );

					System.out.println(feld [xb] [yb] = 1);
						commanderfeld();
				}
					if ((xb >= 1) && (xb <= 10)){
						xa = true;
					}
					if ((yb >= 1) && (yb <= 10)){
						ya = true;
					}
commanderspielfeld();
feuerfrei();
	}
```


----------



## Laocoon (9. September 2007)

Ach so.  Ich würde dir nebenbei empfehlen Variablen etwas aussagekräftigere Namen zu geben. Du vertust dich irgendwann relativ leicht, wenn du bei xz und yz angekommen bist   Also du überlässt es deinem Benutzer jedes Feld einzeln anzugeben? Wieso lässt du den Benutzer nicht einfach nur wählen was für eine art Schiff er haben möchte (per Nummernwahl 1. Schnellboot 2. Zerstörer etc.) und dann fragst du ab, ob das Boot horizontal oder Vertikal ausgerichtet werden soll. Den Rest kannst du dann vom ie machen lassen.  Grüße Daniel


----------



## Parder (9. September 2007)

Das mit der Schiffswahl versuch ich gerade auch, das einzige Problem ist, dass ich irgendwie nicht auf die richtige Schreibweise der Befehle komme, z.B. wo soll wenn welche Schleife bzw. if-Befehl beginnen und Enden.
Endweder mein Pc meckert nur oder er will es nicht compilieren :-(
Ich versuchs gerade die Schiffsklassenzuordnung mit einem int-Methode. Etwa in dieser Form:

```
int feldfuellung ( int b){

  int rasboot = 1;
  int laufboot = 2; 
  int schnellkreuzer =3;
  int kreuzer = 4;
      return b;
```

aber vielmehr an Befehl will er icht akzepieren. 
Theoretisch wird dann eine Zählschleife aktiviert die dann die passende Anzahl an koordinaten dann ausgibt aber das Funktioniert auch nicht.
MfG


----------



## vites (9. September 2007)

Ich habe hier ein bissle was geschrieben, weiß nicht genau was du brauchst, aber damit sollte es möglcih sein das Spiel "Schiffe versenken" zu realisieren. 


```
/**
 * Die Klasse ist die Hauptklasse und dient dazu, um das Spiel zu starten.
 * Desweiteren ist sie verantwortlich für die Interaktion mit dem User.
 * 
 * Die Klasse ist bissher ein Dummy.
 * 
 * @author Viktor Koop
 * 
 * 
 */
public class Schiffe_Versenken {

	public static final int KREUZER = 4;
	public static final int SCHNELLERKREUZER = 3;
	public static final int WACHBOOT = 2;
	public static final int SCHNELLBOOT = 1;

	public static void main(String[] args) {

	}
	// Das eigene -und gegnerische Spielfeld
	public Spielfeld spielfeld1;

	public Spielfeld spielfeld2;

	public Schiffe_Versenken() {
		spielfeld1 = new Spielfeld();
		spielfeld2 = new Spielfeld();
	}
}
```


```
import java.awt.Point;

/**
 * Die Klasse stellt ein Schiff-Objekt zur Verfügung und stellt grundlegende
 * Methoden zur Verfügung, um z.B. zu überprüfen, ob das Schiff getroffen oder
 * versenkt wurde.
 * 
 * @author Viktor Koop
 */
public class Schiff {

	int[] bordZustand;
	Point koordinaten;
	int lage;
	int länge;

	/**
	 * Schiff-Konstruktor
	 * 
	 * @param länge -
	 *            Länge des Schiffs
	 * @param lage -
	 *            0 - horizontal <br>
	 *            1 - vertikal
	 * @param x -
	 *            Die x-Koordinate
	 * @param y -
	 *            Die y-Koordinate
	 */
	Schiff(int länge, int lage, int x, int y) {

		this.bordZustand = new int[länge];
		this.länge = länge;
		this.lage = lage;
		this.koordinaten = new Point(x, y);

		for (int i = 0; i < bordZustand.length; i++) {
			bordZustand[i] = 0;
		}
	}

	@Override
	public String toString() {
		String s = "Koordinaten: (" + this.koordinaten.x + ","
				+ this.koordinaten.y + ")";
		s += " Lage: " + this.lage;
		s += " Länge: " + this.länge;
		s += " Zustand: ";
		s += "<";
		for (int i = 0; i < this.bordZustand.length; i++) {
			if (bordZustand[i] == 0)
				s += "=";
			else
				s += "x";
		}
		s += ">";
		return s;
	}

	/**
	 * @param p -
	 *            Punkt der Überprüft werden soll
	 * @param markieren -
	 *            gibt an, ob die getroffene Stelle markiert werden soll.
	 * @return Gibt zurück, ob das Schiff getroffen wurde. <br>
	 *         0 - nicht getroffen <br>
	 *         1 - getroffen <br>
	 *         -1 - war an der Stelle schon getroffen
	 */
	public int wurdeGetroffen(Point p, boolean markieren) {
		if (lage == 0) {
			if (p.y != koordinaten.y)
				return 0;
			if (p.x >= koordinaten.x + länge)
				return 0;
			if (bordZustand[p.x - koordinaten.x] == 1)
				return -1;
			bordZustand[p.x - koordinaten.x] = 1;
		}
		if (lage == 1) {
			if (p.x != koordinaten.x)
				return 0;
			if (p.y >= koordinaten.y + länge)
				return 0;
			if (bordZustand[p.y - koordinaten.y] == 1)
				return -1;
			bordZustand[p.y - koordinaten.y] = 1;
		}
		return 1;
	}

	/**
	 * @return Gibt zurück, ob das Schiff versenkt wurde.
	 */
	public boolean wurdeVersenkt() {
		for (int i = 0; i < this.bordZustand.length; i++) {
			if (bordZustand[i] != 1)
				return false;
		}
		return true;
	}

}
```


```
import java.awt.Point;
import java.util.Vector;

/**
 * 
 * Die Klasse stellt das Spielfeld beim "Schiffe versenken" dar.
 * 
 * @author Viktor Koop
 *
 */
public class Spielfeld {

	int[][] spielfeld;
	Vector<Schiff> schiffe;

	Spielfeld() {
		spielfeld = new int[10][10];
		for (int i = 0; i < 10; i++) {
			for (int j = 0; j < 10; j++) {
				spielfeld[i][j] = 0;
			}
		}
		schiffe = new Vector<Schiff>();
	}

	/**
	 * Auf einen Punkt feuern.
	 * 
	 * @param p -
	 *            Der Punkt auf den gefeuert werden soll.
	 * @return Gibt zurück, ob etwas getroffen wurde.
	 */
	public boolean feuer(Point p) {
		Schiff s;
		for (int i = 0; i < this.schiffe.size(); i++) {
			s = schiffe.elementAt(i);
			if (s.wurdeGetroffen(p, true) == 1) {
				if (s.wurdeVersenkt()) {
					System.out.println("Ein Schiff wurde versenkt");
					this.schiffe.remove(s);
				}
				return true;
			} else if (s.wurdeGetroffen(p, true) == (-1)) {
				System.out.println("Diese Stelle wurde schon getroffen.");
				return false;
			}

		}
		return false;
	}

	/**
	 * Methode zum prüfen, ob ein Schiff eingefügt werden darf.
	 * 
	 * @param s -
	 *            Das Schiff das geprüft werden soll.
	 * @param add -
	 *            Soll das Schiff auch eingefügt werden, falls möglich?
	 * @return Gibt zurück, ob es es Möglich ist das Schiff einzufügen.
	 */
	public boolean isValid(Schiff s, boolean add) {
		int i_max;
		int j_max;

		if (s.lage == 0) {
			i_max = s.koordinaten.x + s.länge - 1;
			j_max = s.koordinaten.y;
		} else {
			i_max = s.koordinaten.x;
			j_max = s.koordinaten.y + s.länge - 1;
		}

		for (int i = s.koordinaten.x; i <= i_max; i++) {
			for (int j = s.koordinaten.y; j <= j_max; j++) {
				if (spielfeld[j][i] != 0)
					return false;
			}
		}

		if (add == true) {
			for (int i = s.koordinaten.x; i <= i_max; i++) {
				for (int j = s.koordinaten.y; j <= j_max; j++) {
					spielfeld[j][i] = 1;
				}
			}
		}
		return true;
	}

	/**
	 * Fügt ein Schiff zum Spielfeld hinzu, falls möglich.
	 * 
	 * @param s -
	 *            Das Schiff das hinzugefügt werden soll
	 * @return Gibt zurück, ob das Schiff hinzugefügt wurde.
	 */
	public boolean schiffHinzufügen(Schiff s) {
		boolean valid = isValid(s, true);
		if (valid == true)
			schiffe.add(s);
		return valid;
	}

	@Override
	public String toString() {
		String s;
		s = (".___ ___ ___ ___ ___ ___ ___ ___ ___ ___.\n");
		for (int i = 0; i < 10; i++) {
			s = s.concat("|");
			for (int j = 0; j < 10; j++) {
				if (this.spielfeld[i][j] != 0) {
					s = s.concat(" " + "x" + " ");
				} else {
					s = s.concat("   ");
				}
				s = s.concat("|");
			}
			s = s.concat("\n");
			s = s.concat("|___|___|___|___|___|___|___|___|___|___|\n");
		}
		return s;
	}

}
```


----------



## Parder (11. September 2007)

Danke @ Vites. Ich habs versucht an meine Methoden anzupassen aber leider steht mir der Befehl vector nicht zur verfügung.  Und deshalb hab ich es auf int-Basis versucht:.
Nach dem Folgenden Schema soll diese Methode laufen:
Ich sage welches Schiff und an welcher Koordinate es beginnen soll.
Dann muss ich nur noch angeben in welche Richtung es ausgerichtet werden soll.
Die while-Schleifen sollten als begrenzung (theoretisch,praktisch funkioniert es auch nicht) dienen damit das Schiff nicht ausversehen ausherhalb des Spielfeldes liegt wenn jemand x=9 und y=9 eingibt. 

```
int lage (int bo){
		int xb;
		int yb;
		
		boolean horizontal;
		int rechts = 1;
		int runter = 1;
		System.out.println("Für eine horizontale Lage bitte |}1{| eingeben und für senkrechte Lage bitte |}0{| eingeben"); 
		
		horizontal=Tools.booleanEingabe();
		System.out.println("fff"+horizontal); // Testrückgabe
				rechts = Tools.intEingabe();
			if (horizontal == true){
//				do{
					System.out.println("Für Ausrichtung nach recht |}1{| nach links |}2{|");
					switch (rechts){
					case 1:	{// ?
						for (xb= 0;xb < b;xb++){
							System.out.println("alpha");
					feldfuellung(b);
					figureninitialisierung();
 						}
						break;
					}
//					if (rechts == false){
					case 2:	{//?
						for (xb= 0;xb < 5;xb--){
							System.out.println("beta");
					feldfuellung(b);
					figureninitialisierung();
						}
						break;
					}
					default:{
					}
				}
//				}while(bo < b);
			}
				runter = Tools.intEingabe();
			if (horizontal == false){
//				do{
					System.out.println("Für Ausrichtung nach unten |}1{| nach oben |}2{|");
				switch (runter){
					case 1:	{// ?
						for (yb= 0; yb < b;yb++){
							System.out.println("omega");
					feldfuellung(b);
					figureninitialisierung();
						}
						break;
					}
					case 2: {//?
						for (yb= 0;yb < b;yb--){
							System.out.println("delta");
					feldfuellung(b);
					figureninitialisierung();
						}
						break;
					}
					default:{
					}
				}
//				}while(bo < b);
//					return lage(bo);
			}
					feldfuellung(b);
					figureninitialisierung();
					return bo ;
	}
```
bloß ich bekomme dort wo die Fragezeichen stehen teilweise Rückgabewerte bzw. die Frage ausgegeben aber der Eingabebefehl wird übersprungen.
Woran kann das liegen?

Ps.: Die Methode feldfuellung(b) beinhaltet Arrays die ansagen sollen wie weit er Zählen soll.
	
	
	



```
int feldfuellung(int b){

		int [] s = new int [6];

		int flitzschnellboot =1;
		int ruderschnellboot =2;
		int schleichschnellboot =3;
		int vorkreuzer =4;
		int gardekreuzer =5;
		int traeger =6;

		int sflitzschnellboot [] = new int [b];

		int sruderschnellboot [] = new int [b];

		int sschleichschnellboot [] = new int [b];

		int svorkreuzer [] = new int [b];

		int sgardekreuzer [] = new int [b];

		int straeger [] = new int [b];
			return b;
	}
```


----------



## zerix (11. September 2007)

Hallo,

ich kann dir nicht sagen, warum die Eingabe übersprungen wird, da du ja nicht zeigst wie deine Eingabe aussieht. 



> Ich habs versucht an meine Methoden anzupassen aber leider steht mir der Befehl vector nicht zur verfügung.  Und deshalb hab ich es auf int-Basis versucht:.


Vector ist kein Befehl, sondern eine Klasse, die im Standard-JRE enthalten ist, auch bei dir. D. h. wenn du die Klassen einfach nur kopierst müsste es bei dir genauso funktionieren, vorausgesetzt die Klassen haben bei vites funktioniert.

MFG

zEriX


----------



## vites (11. September 2007)

Die Klasse Vector bekommst du einfach durch:

import java.util.Vector;

Die Methode zum überprüfen, ob ein Schiff eingefügt werden darf, ist bei mir schon vorhanden in der Klasse Spielfeld, jedoch wird da im Moment jedoch nur überprüft ob sich das Schiff mit keinem anderen überschneidet. Es sollte jedoch ganz einfach sein zu überprüfen, ob das Schiff noch im Spielfeld liegt. Liegt das Schiff nämlich nicht mehr im Spielfeld, so würde eine ArrayOutOfBoundsException geworfen werden. Somit kannst du mit entsprechendem Exception-Handling darauf eingehen und in dem Fall ausgeben, dass das Schiff nicht mehr auf dem Spielfeld ist.


----------

