Game Of Live

[buffy2299s]

Hei Leute,

ich benötige für eine Aufgabe lediglich eine Methode, die ein Spielzeug von Game Of Live ausführt. So weit so gut, mein Problem liegt jetzt darin, dass ich die das gegebene Feld für jede Position die Nachbarn abklappern will und schauen will ob sie leben oder nicht. Hab ich jetzt beispielsweise ein Feld was am Rand liegt hat es ja an mindestens einer Seite kein Nachbarn. An dieser Stelle komme ich nicht weiter, was muss ich machen das mein Code überprüft ob die Position i/j >=0 ist.
und dann glaube ich das meine Schleifen aufhören sobald ein true feld gefunden wurde, ich möchte ja aber alle Felder abklappern und nicht beim ersten gefunden true feld schon aufhören, kann mir jemand bitte helfen?

public class GameLive {
   
    static boolean[][] method(boolean[][] feld){
       
        int [][] hilf_arr = new int[feld.length][feld[0].length];
        for(int i = 0; i < feld.length; i++){
            for(int j = 0; j < feld[i].length; j++){
                if((feld[i][j] == true) || (feld[i][j]==false)){
                   
                    for(int k = 0; k < feld.length; k++){
                        for(int l = 0; l < feld[k].length; l++){
                            if(feld[k][l]==true){
                                if((feld[k][l-1]==true) && ((feld[k][l-1]) >=0))
                                    hilf_arr[i][j]+=1;
                                else if((feld[k][l+1]==true) && (feld[k][l+1] >=0))
                                    hilf_arr[i][j]+=1;
                                else if((feld[k+1][l]==true) && (feld[k+1][l] >=0))
                                    hilf_arr[i][j]+=1;
                                else if((feld[k-1][l]==true) && (feld[k-1][l] >=0))
                                    hilf_arr[i][j]+=1;
                                else if((feld[k-1][l+1]==true) && (feld[k-1][l+1] >=0))
                                    hilf_arr[i][j]+=1;
                                else if((feld[k-1][l-1]==true) && (feld[k-1][l-1] >=0))
                                    hilf_arr[i][j]+=1;
                                else if((feld[k+1][l+1]==true) && (feld[k+1][l+1] >=0))
                                    hilf_arr[i][j]+=1;
                                else if((feld[k+1][l-1]==true) && (feld[k+1][l-1] >=0))
                                    hilf_arr[i][j]+=1;
                                   
                            }
                           
                        }
                    }
                       
                }
               
            }
        }
       
        boolean[][] feld_neu = new boolean[feld.length][feld[0].length];
            for(int x = 0; x < feld.length-1; x++){
                for(int y = 0; y < feld[x].length-1; y++){
               
                    if (feld[x][y]) {
                   
                     if ((hilf_arr[x][y] < 2) || (hilf_arr[x][y] >= 4))
                            feld_neu[x][y] = false;
                       
                     if ((hilf_arr[x][y] == 2) || (hilf_arr[x][y] == 3))
                            feld_neu[x][y] = true;
                    } else {
           
                        if (hilf_arr[x][y] == 3)
                            feld_neu[x][y] = true;
                    }
            }
        }
        return feld_neu;
       

    }
}

 

[Joose]

Was erhoffst du dir durch diese if-Abfrage? if((feld[i][j] == true) || (feld[i][j]==false)){
Da boolean nur den Wert true oder false annehmen kann ist sie so ziemlich nutzlos.

Zu einen Problem werden auch deine 4 verschachtelten for-Schleifen.
Mit den beiden äußeren gehst du dein Hilfsarray durch, mit den beiden inneren den Parameter.
Jetzt hast du aber das Problem das hilfs_arr[j] immer die Informationen vom kompletten Parameter durchgeht und "analysiert" (also auch von nicht benachbarten Feldern).

Allgemeine Anmerkung zum Code:
Die Abfrage auf ==true oder ==false zu prüfen ist unnötigt. Der Ausdruck mit dem du vergleichst ist schon ein boolean, welcher true oder false ist.
Statt if(feld[k][l]==true) kannst du also einfach nur if(feld[k][l] schreiben. Wenn du auf "false" prüfen willst denn negiere den boolschen Ausdruck mit "!" ---> if(!feld[k][l]).
Java erlaubt es zwar bei einzeiligen Blöcken auf Klammern zu verzichten, ich würde dir aber trotzdem raten immer {}-Klammern zu schreiben! Es ist einfach eine unnötige Fehlerquelle [/i][/i]

 

[Harry Kane]

So wie du ihn gepostet hast, ist der Code nicht kompilierbar, weil du bei Ausdrücken der Form

feld[k][l-1]) >=0

einen boolean und ein int vergleichst.

und dann glaube ich das meine Schleifen aufhören sobald ein true feld gefunden wurde

Kann nicht sein. Du hast nirgendwo vor dem Ende ein return, was zu einem Verfrühten verlassen der Schleifen führen könnte. Bei diesem Ausdruck

feld[k][l-1]

dürfte eher für l = 0 eine Exception geworfen werden.
Lösungsansatz:
1. Über dein feld iterieren. Das saind zwei verschachtelte for-Schleifen.
2. Für jedes Feld die Anzahl der lebenden Nachbarn prüfen. Du brauchst an dieser Stelle noch keine Unterscheidung zwischen lebenden und toten Zellen, sondern nur zwischen lebenden und toten Nachbarn!
Bei der Überprüfung der Nachbarn musst du leider überprüfen, welche Nachbarindices gültig sind. Etwa so:

int[][] livingNeighbours = new int[feld.length][feld[0].length];
for (int i = 0; i < feld.length; i++) {
    for (int j = 0; j < feld[i].length; j++) {
        if (feld[i][j]) {
            livingNeighbours[i][j] = livingNeighbours[i][j] + 1;
        }
        if (i > 0 && j > 0 && feld[i - 1][j - 1]) {
            livingNeighbours[i][j] = livingNeighbours[i][j] + 1;
        }
        if (i > 0 && feld[i - 1][j]) {
            livingNeighbours[i][j] = livingNeighbours[i][j] + 1;
        }
        if (i < feld.length - 1 && feld[i + 1][j]) {
            livingNeighbours[i][j] = livingNeighbours[i][j] + 1;
        }
        if (i < feld.length - 1 && j < feld[i].length - 1 && feld[i + 1][j + 1]) {
            livingNeighbours[i][j] = livingNeighbours[i][j] + 1;
        }
    }
}

 

[JStein52]

Bei der Überprüfung der Nachbarn musst du leider überprüfen, welche Nachbarindices gültig sind

Die Nachbarindices kriegst du auch mit der Modulo-Funktion: der "rechte" Nachbar von spielfeld[zeile] [spalte] ist bspw. spielfeld[zeile] [(spalte+1)%n] wobei n die Breite des Spielfeldes ist, die Nachbarn links, oben und unten kriegst du analog

 

[Harry Kane]

Oder noch kürzer mit zwei verschachtelten for-Schleifen.

for(int innerI = Math.max(0, i - 1); innerI < Math.min(feld.length-2, i); innerI++){
    for(int innerK= Math.max(0, k-1); innerK < Math.min(feld[i].length-2, k); innerK++){
        if(feld[innerI][innerK]){
            livingNeighbours[innerI][innerK] += 1;
        }
    }
}