# Textbasiertes Spiel programmieren



## mrbrightside (17. Dez 2015)

Hallo,

ich muss folgendes Spiel programmieren:

Spielbrett 8x8 Felder
62 Felder werden zufällig mit Zahlen zwischen 1-9 ausgefüllt
2 Felder nahe dem Zentrum, auf der Diagonale werden mit Spielfiguren gefüllt (w) und (s)
Die Spieler können dann abwechselnd in ein benachbartes Feld ziehen und bekommen den Wert des Feldes als Punk gutgeschrieben
Der erste Spieler, der >=100 Punkte erreicht gewinnt
Ich habe dafür überlegt erstmal 3 Klassen zu machen: Steuerung, Spielfeld und Spieler

Diese sehen nun so aus:


```
public class Steuerung {   
    public static void main(String[] args){       
        Spielfeld brett =  new Spielfeld();       
        brett.initialisiereSpielfeld();               
        Spieler s = brett.erzeugeSpielerS();
        Spieler w = brett.erzeugeSpielerW();       
        brett.spielfeldAusgeben();
    }
}
```


```
public class Spielfeld {   
    private String[][] feld;
   
    public Spielfeld(){
        feld = new String[8][8];
        for (int i = 0; i < feld.length; i++) {
            for (int j = 0; j < feld.length; j++) {
                feld[i][j]=" ";
            }
        }
    }
   
    public void spielfeldAusgeben(){
        for (int i = 0; i < feld.length; i++) {
            for (int j = 0; j < feld.length; j++) {
                IO.write(feld[i][j]+" ");
            }
            IO.write("\n");
        }
    }
   
    public void initialisiereSpielfeld(){
        for (int i = 0; i < feld.length; i++) {
            for (int j = 0; j < feld.length; j++) {
                feld[i][j]=""+(int)(Math.random()*100000%9+1);
            }
        }
    }
}
```


```
public class Spieler {   
    private int positionX;
    private int positionY;
   
    //Spieler mit Startposition erzeugen
    public Spieler(int posX, int posY){
        positionX = posX;
        positionY = posY;
    }   
   
    public int getPositionX() {
        return positionX;
    }   
   
    public int getPositionY() {
        return positionY;
    }
}
```

Da ich noch nicht besonders viel Erfahrung mit Klassendesign und der Interaktion von Klassen habe, möchte ich kurz um eure Meinung bitten. Ist der Ansatz ok? Was kann ich verbessern?


----------



## Joose (17. Dez 2015)

Ansatz ok, eine Verbesserungsvorschlag hätte ich aber:
Statt eines 2d String Arrays könntest du ein 2d int Array verwenden. Dadurch musst du die Strings nicht immer in Zahlen umrechnen um die Punkte zu addieren.
Bei der Darstellung des Spielfelds musst du einfach kontrollieren ob i und j der Position eines Spieleres entsprechen und statt der Zahl dann eben das Symbol des Spielers rausschreiben.
Und für Felder die schon besucht wurden den Wert 0 oder -1 verwenden.


----------



## Jardcore (17. Dez 2015)

Hey mrbrightside,

du könntest auch die Position auf dem Spielfeld in der Spieler-Klasse speichern (x,y)
Dann brauch dein Spielfeld nicht n Spielerpositionen speichern (falls du mal was erweitern willst).

Außerdem würde ich die Berechnung des Zufallswertes in eine Methode auslagern.

```
private int zufaelligerWert() {
        Random random = new Random();
        return random.nextInt((MAX_BELEGUNG + 1) - MIN_BELEGUNG) + MIN_BELEGUNG;
    }
```
Die Initialisierung könntest du anhand einer statischen Methode auf dem Spielfeld übernehmen und einen privaten Konstruktor verwenden. Das hilft den Code später besser zu lesen.
Dann hättest du in deiner Main nur den Aufruf *Spielfeld.erzeuge8x8Feld()* und könntest dann erweitern mit 16 32 ...

```
private Spielfeld(int feldGroesse) {
        feld = new int[feldGroesse][feldGroesse];
        init();
    }
 
    public static Spielfeld erzeuge8x8Feld() {
        return new Spielfeld(8);
    }
 
    private void init() {
        for(int x = 0; x < feld.length; x++) {
            for(int y = 0; y < feld.length; y++) {
                feld[x][y] = zufaelligerWert();
            }
        }
    }
```

Beste Grüße,
Jar

P.S.: für die Ausgabe kannst du auch die toString Methode überschreiben. (solange eh alles Textbasiert ist  )


----------



## Jardcore (17. Dez 2015)

Hab gerade gesehen, das deine Spieler schon die Koordinaten habe, hatte ich wohl übersehen.


----------



## VirtualIndex (17. Dez 2015)

Initialisierungsmethoden sind in der Regel nur aus anfänglicher Unwissenheit vorhanden, wenn man noch die Grundlagen lernt. Ich würde sie in Konstruktoren umwandeln.


----------

