Objektorientierung, hilfe

[Knuspakeks]

Bisher bin ich soweit gekommen den Konstruktor zu erstellen der einen String entgegennimmt und daraus ein zweidimensionales Array macht
Die getCell Methode überprüft ob das Koordinatenpaar innerhalb des feldes liegt oder eben nicht
getNeighborhood gibt die Sigantur zurück die oben im Quelltext erwähnt wird

Allerdings soll ich den Konstruktor jetzt erweitern, er soll in zweierschritten durch die Spielfeldbeschreibung laufen und jeweils die nachbarschaftssignatur ausrechnet und diese als index in das array NEIGHBORHOOD_TO_FILENAME verwendet um damit GameObject-Objekte konstruiert. Die Koordinaten müssen dabei halbiert werden.

Kann mir jemand helfen einen Ansatz zu finden oder das mit mir zsm durchrechnet, meinetwegen auch mit anderen Daten?

Quelltext:
/**
* Diese Klasse repräsentiert ein Spielfeld. Ihr Konstruktur bekommt dieses als
* String-Array übergeben.
*/
class Field
{
/**
* Die Dateinamen der Bodengitterelemente, die direkt mit einer
* Rotation 0 verwendet werden können. Der Index ergibt sich
* aus der Summe der folgenden Zahlen:
* 1: In Richtung 0 (+1, 0) gibt es eine Verbindung.
* 2: In Richtung 1 (0, +1) gibt es eine Verbindung.
* 4: In Richtung 2 (-1, 0) gibt es eine Verbindung.
* 8: In Richtung 3 (0, -1) gibt es eine Verbindung.
*/
private static final String[] NEIGHBORHOOD_TO_FILENAME = {
"floor",
"floor-e-0",
"floor-e-1",
"floor-l-0",
"floor-e-2",
"floor-i-0",
"floor-l-1",
"floor-t-1",
"floor-e-3",
"floor-l-3",
"floor-i-1",
"floor-t-0",
"floor-l-2",
"floor-t-3",
"floor-t-2",
"floor-x"
};
char dieter[][];
/** Ein Testfall, der alle Nachbarschaften enthält. */
static void test()
{
// Auskommentieren, sobald Konstruktor vorhanden
new Field(new String[] {
"O-O-O-O ",
"| | ",
"O O-O-O O",
"| | | | |",
"O-O-O-O-O",
"| | | | |",
"O O-O-O O",
" | |",
" O-O-O-O"
});
}
public Field(String[]field){
dieter=new char[field.length][];
for(int x=0;x<field.length;x++){
dieter[x]=new char[field[x].length()];
for(int y=0; y<field[x].length();y++){
dieter[x][y]=field[x].charAt(y);
}
}
}
private int getNeighborhood(int x, int y){
int counter=0;
if(getCell(x+1,y)!= ' '){
return counter=1;
}
else if(getCell(x,y+1)!= ' '){
return counter=2;
}
else if(getCell(x-1,y)!= ' '){
return counter=4;
}
else if(getCell(x,y-1)!= ' '){
return counter=8;
}
else{
return counter=0;
}

}
private char getCell(int x, int y){
if(x>=0 && y>=0 && dieter[y].length-1>x && dieter.length-1>y){
return dieter[x][y];
}
else{
return ' ';
}
}
}

 

[Senftube]

Hallo Scherzkeks .-),
Ob dir da jemand helfen kann ?. Du entwickelst ein Spiel das keiner kennt und willst dann, an der Strategie was ändern. Vermutlich hast du kein konkretes Java-Probelrm sondern weisst nur nicht wie du die neue Anforderung implementieren sollst.
Wenn es jetzt Monoploy wäere und du sollest einen fünften Bahnhof vor der Schlossalee einbauen, dann ja.
Erkläre erstmal die Spielidee.

 

[MoxxiManagarm]

Dein Problem ist sehr schwer aufzufassen. Wenn ich dein Problem richtig verstanden habe:
Du weißt nicht wie du sinnvoll zum richtigen Imagenamen (Index) kommst. Denn...

Der Index ergibt sich aus der Summe der
folgenden Zahlen: 1: In Richtung 0 (+1, 0) gibt es eine Verbindung. 2: In
Richtung 1 (0, +1) gibt es eine Verbindung. 4: In Richtung 2 (-1, 0) gibt
es eine Verbindung. 8: In Richtung 3 (0, -1) gibt es eine Verbindung

und das ist hier ja kaum eine sinnvolle Summenbildung:

private int getNeighborhood(int x, int y) {
        int counter = 0;
        if (getCell(x + 1, y) != ' ') {
            return counter = 1;
        } else if (getCell(x, y + 1) != ' ') {
            return counter = 2;
        } else if (getCell(x - 1, y) != ' ') {
            return counter = 4;
        } else if (getCell(x, y - 1) != ' ') {
            return counter = 8;
        } else {
            return counter = 0;
        }
    }

Letztlich ist es am Besten dir die 4 Richtungen als wahr und falsch zu speichern. Oder in anderen Worten 1 und 0. Die 4 einsen und nullen kannst du als Binärzahl interpretieren. Wenn alle 4 Richtungen gegeben sind, dann hast du die Binärzahl 1111 = 15, also den Index 15, was in deinem Array dann "floor-x" entspricht. Hast du aber nur die Richtung (0, +1), dann ist deine Binärzahl 0001, was auch der Zahl 1 entspricht und daher dann zu "floor-e-0" gemappt wird.

 

[Knuspakeks]

Es gibt dazu keine Spielidee, aber ja ich weiß nicht wie ich das implementieren soll, die Aufgabe war nur das der Konstruktor den String übergeben bekommt und aus diesem String ein Spielfeld erzeugt:
Die Liste mit den Floors ist halt l für eine Abzweigung, eine kurve, i für eine gerade strecke, t für eine Kreuzung t Kreuzung, und x für eine normale Kreuzung und e für eine halbe strecke. Die zahlen dahinter stecken für die rotation.
Die Testmethode beinhaltet ja schon einen String un der Konstruktor soll daraus am ende ein Spielfeld erzeugen allerdings beinhaltet der String ja auch "-" zwischen den Kreisen und den langen strichen, deswegen in zweierschritten da das "-" kein Spielelement darstellt sondern die rotation.

 

[Knuspakeks]

@MoxxiManagarm ne die implementierung ist schon richtig so, allerdings muss der counter zurückgegeben werden und nur der counter ohne ihn auf null zu setzen
Die Nachbarschaftssignatur ist dazu da das man im Spielfeld auch weiß wo man sich befindet und damit der Konstruktor dann weiß was er erzeugen soll

 

[Knuspakeks]

Vllt damit es verständlicher wird

 

[VfL_Freak]

desweiteren: nutze die Code-Tags, so bekommt man ja Augenkrebs
Und schreib' bitte den einleitenden Text so, dass ihn auch ein Aussenstehender verstehen kann .....
VG Klaus

 

[MoxxiManagarm]

Dann addiere halt auch.

private int getNeighborhood(int x, int y) {
        int counter = 0;

        if (getCell(x + 1, y) != ' ') counter += 1;
        if (getCell(x, y + 1) != ' ') counter += 2;
        if (getCell(x - 1, y) != ' ') counter += 4;
        if (getCell(x, y - 1) != ' ') counter += 8;
      
        return counter;
}

Aber die Binärvariante solltest du trotzdem kennen.

public class IndexerDemo {
    public static int toIndex(boolean b1, boolean b2, boolean b3, boolean b4) {
        int index = (b1 ? 1 : 0);
        index = (index << 1) + (b2 ? 1 : 0);
        index = (index << 1) + (b3 ? 1 : 0);
        index = (index << 1) + (b4 ? 1 : 0);
      
        return index;
    }
  
    public static void main(String... args) {
        // die boleans entsprechen bei dir:
        // [hat(0, -1), hat(-1, 0), hat(0, +1), hat(+1, 0)]
        System.out.println(toIndex(false, true, false, true)); // prints: 5
        System.out.println(toIndex(true, true, true, true)); // prints: 15
    }
}

 

[Knuspakeks]

Also was die IndexerDemo da bei dir macht versteh ich nicht und ich soll das ja auch in den Konstruktor schreiben und keine neue Methode.

 

[MoxxiManagarm]

Also ist dein Problem die Aufgabe 3 gesamt. Aber du sollst doch keinen neuen Konstruktor erstellen, sondern deinen bestehenden erweitern. Was du nun brauchst ist statt (oder zusätzlich zu) char[][] dieter nun ein int[][] signature mit

int[][] signature = new int[dieter.length / 2 + 1][maxSubLength(dieter) / 2 + 1];

Das befüllst du dann mithilfe von deinen vorhergehenden Methoden. Wo genau liegt hier dein Problem?
Das Array kannst du dann verwenden um deine GameObjects anhand des "gemappten" Strings zu laden.

Deine getNeighbourhood Methode war dennoch vorher falsch, sie hatte nicht addiert.

Zur Erläuterung was die toIndex Methode macht bei false true false true:

0       int index = (b1 ? 1 : 0);
00      index = (index << 1)
01       + (b2 ? 1 : 0);
010     index = (index << 1)
010      + (b3 ? 1 : 0);
0100    index = (index << 1)
0101     + (b4 ? 1 : 0);

5         return index;