wenn ich wüsste, was mein fehler ist.

[ManuP]

Kennt Ihr das Spiel Callaha? Hoffentlich, sonst muss ich so viel Regeltext schreiben... *g*
Naja, darum geht es nicht.

Erst mal ein bisschen code...

import java.io.IOException;

import SpielbrettTxt;

public class Callaha
  {

    public static void main(String[] args) throws IOException
      {
      SpielbrettTxt bretttxt = new SpielbrettTxt();
      bretttxt.zeige();
      }

  }

import KI;
import Regeln;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class SpielbrettTxt
  {
    private int[][] sp;
    private int spieler, tmp_int;
    private String tmp_str;
    private BufferedReader tastatur;
    private KI ki;

    private Regeln regeln;

    public SpielbrettTxt()
      {
        spieler = 0;
        regeln = new Regeln(spieler);

        sp = new int[2][7];
        ki = new KI();
        for (int i = 0; i < 6; i++)
          {
            sp[0][i] = 4;
            sp[1][i] = 4;
          }
      }

    public void zeige() throws IOException
      {
        System.out.println("Feld:   5   4   3   2   1   0");
        System.out.println("|====||===|===|===|===|===|===||====|");
        //es fehlen 3 leerzeichen bei sp[1/2][0..5]
        System.out.println("|    ||" + aus(sp[0][5]) + "|" + aus(sp[0][4])
            + "|" + aus(sp[0][3]) + "|" + aus(sp[0][2]) + "|" + aus(sp[0][1])
            + "|" + aus(sp[0][0]) + "||    |");
        //es fehlen 4 leerzeichen bei sp[1/2][6]
        System.out.println("|" + aus2(sp[0][6]) + "||===|===|===|===|===|===||"
            + aus2(sp[1][6]) + "|");
        System.out.println("|    ||" + aus(sp[1][0]) + "|" + aus(sp[1][1])
            + "|" + aus(sp[1][2]) + "|" + aus(sp[1][3]) + "|" + aus(sp[1][4])
            + "|" + aus(sp[1][5]) + "||    |");
        System.out.println("|====||===|===|===|===|===|===||====|");
        System.out.println("Feld:   0   1   2   3   4   5");

        ki.setBrett(sp);
        liesAktion();
      }

    private String aus(int i)
      {
        if(i < 10)
          tmp_str = " " + i + " ";
        else
          tmp_str = i + " ";
        return tmp_str;
      }

    private String aus2(int i)
      {
        if(i < 10)
          tmp_str = " " + i + "  ";
        else
          tmp_str = " " + i + " ";
        return tmp_str;
      }

    public void liesAktion()
      {
        if(!regeln.gewonnen(sp))
          {
            spieler = regeln.getSpieler();

            tastatur = new BufferedReader(new InputStreamReader(System.in));
            System.out.print("Spieler " + spieler + ": ");
            if(spieler == 0) // Für ein Spiel ohne ki:  if(true) oder  if(spieler == 0 || spieler==1)
              {
                try
                  {
                    tmp_str = tastatur.readLine();
                    tmp_int = Integer.parseInt(tmp_str);
                    if(tmp_int < 0 || tmp_int > 5)
                      {
                        System.out.println("Falsche Eingabe, bitte nochmal.");
                        liesAktion();
                      } else
                      {
                        System.out.println("\n\n\n");
                        sp = regeln.verteile(sp, tmp_int);
                        zeige();
                      }
                  } catch (Exception e)
                  {
                    System.out.println("Falsche Eingabe, bitte nochmal.");
                    liesAktion();
                  }
              } else
              {
                try
                  {
                    sp = regeln.verteile(sp, ki.zug());
                    zeige();
                  } catch (IOException e)
                  {
                    // Auto-generated catch block
                    e.printStackTrace();
                  }
              }
          }

      }
  }

public class KI
  {
    /**
     * Comment for <code>gewinn</code> Speicher die Feldernummern als index
     * und den Gewinn, den man macht, wenn mit dem index-feld gerückt wird.
     */
    private int[] gewinn;
    private int g, z;
    private int[][] sp;
    private int[][] sp_tmp;
    private Regeln regeln;

    public KI()
      {
        regeln = new Regeln(1);
        gewinn = new int[6];
        for (int i = 0; i < gewinn.length; i++)
          gewinn[i] = 0;
      }

    /**
     * @param sp
     *          sp ist der Array, der das Spielbrett enthält
     */
    public void setBrett(int[][] sp)
      {
        this.sp = sp;
      }

    public int zug()
      {
        z = 0; //Welcher Zug
        g = 0; //welcher Gewinn
        for (int i = 0; i < gewinn.length; i++)
          {
          //Wie kann es sein, dass sp verändert ist/wird?
          System.out.println("Feld:\n");
          System.out.println("f0: "+sp[1][0]);
          System.out.println("f1: "+sp[1][1]);
          System.out.println("f2: "+sp[1][2]);
          System.out.println("f3: "+sp[1][3]);
          System.out.println("f4: "+sp[1][4]);
          System.out.println("f5: "+sp[1][5]);
          System.out.println("f6: "+sp[1][6]);
          System.out.println();
          
          sp_tmp=sp;
          //hier wird sp_tmp nur die Werte von sp zugewiesen --> keine Veränderung
          
          sp_tmp = regeln.verteile(sp, i);
          //sp wird an eine Methode weitergereicht
          
          regeln.setSpieler(1); //1 == Spieler KI

            gewinn[i] = sp_tmp[1][6] - sp[1][6];
            //Ein wert aus sp wird abgerufen... aber nichts verändert!
            System.out
                .println("Gewinn bei Zug mit Feld " + i + ":" + gewinn[i]);
            if(gewinn[i] > g)
              {
                g = gewinn[i];
                z = i;
              }
          }
        System.out
            .println("###RUECKE MIT: " + z + " und gewinne: " + g + "###");
        return z;
      }
  }

public class Regeln
  {
    int spieler;

    public Regeln(int i)
      {
        spieler = i;
      }

    public Regeln()
      {

      }

    public int wechsel(int i)
      {
        if(i == 0)
          i = 1;
        else
          i = 0;
        return i;
      }

    public int zaehle_seite(int[] s)
      {
        int tmp_int = 0;
        for (int i = 0; i < 6; i++)
          {
            tmp_int += s[i];
          }
        return tmp_int;
      }

    public boolean seite_leer(int[] s)
      {
        int tmp_int = this.zaehle_seite(s);
        if(tmp_int == 0)
          return true;
        else
          return false;
      }

    public boolean gewonnen(int sp[][])
      {
        for (int s = 0; s < 2; s++)
          {
            if(this.seite_leer(sp[s]))
              {
                for (int i = 0; i < 6; i++)
                  {
                    sp[s][6] += sp[this.wechsel(s)][i];
                  }
              }
          }
        if((this.seite_leer(sp[0]) || this.seite_leer(sp[1]))
            && sp[0][6] > sp[1][6])
          {
            System.out.println("Spieler 0 hat gewonnen, " + sp[0][6] + ":"
                + sp[1][6] + ".");
            return true;
          } else if((this.seite_leer(sp[0]) || this.seite_leer(sp[1]))
            && sp[0][6] < sp[1][6])
          {
            System.out.println("Spieler 1 hat gewonnen, " + sp[1][6] + ":"
                + sp[0][6] + ".");
            return true;
          } else
          {
            return false;
          }
      }

    public void setSpieler(int s)
      {
        spieler = s;
      }

    public int getSpieler()
      {
        return spieler;
      }

    /**
     * @param sp
     *          Spielfeld
     * @param feld
     *          Feld, welchers gerueckt wird
     * @param spieler
     *          Spielerseite
     * @throws IOException
     */
    public int[][] verteile(int[][] sp, int feld)
      {
        int nextField = feld + 1;
        int seite = spieler;
        while (sp[spieler][feld] > 0)
          {
            if(nextField > 6)
              {
                seite = this.wechsel(seite);
                nextField = 0;
              }
            if(!(nextField == 6 && seite != spieler))
              {
                sp[seite][nextField]++;
                sp[spieler][feld]--;
              }
            nextField++;
          }
        if(nextField != 7 && sp[seite][nextField - 1] == 1
            && sp[this.wechsel(seite)][6 - nextField] != 0)
          {
            sp[spieler][6] += sp[seite][nextField - 1]
                + sp[this.wechsel(seite)][6 - nextField];
            sp[seite][nextField - 1] = 0;
            sp[this.wechsel(seite)][6 - nextField] = 0;
          }

        if(!(nextField == 7 && seite == spieler))
          {
            spieler = this.wechsel(spieler);
          }
        return sp;
      }
  }

Problem: es wird das sp-Array-Array von KI heraus verändert. Und ich bin schon seit gestern am grübeln, wie das gehen soll.
Eigentlich kann es, so wie ich es geschrieben habe, nicht sein!
Oder: ki.zug() gibt mehrere returns.. aber da steht nur einer drin. ich raffs nicht.

Es dreht sich also um:
in der Klasse SpielbrettTxt um die Methode liesAktion bei der else-Verzweigung: sp = regeln.verteile(sp,ki.zug());
und das, was dann hinter ki.zug() steckt.

Was mache ich nur falsch?[/code]

 

[Illuvatar]

Das Problem liegt in Zeilen 48 bis 51 der KI-Klasse. Wie bereits im Chat gesagt, erstellt das " = sp" und das "verteile (sp, i)" keine Kopie des Arrays, die neuen Variablen zeigen auf dasselbe Array.

Erstmal: Deine Zeile 48 hat demnach so eigentlich keinen Sinn (erst wird der Variable das Array zugewiesen, dann machst du aber nichts damit und es erfolgt gleich die nächste Zuweisung). Die kannst du eigentlich löschen.
Für die Methodenübergabe musst du das Array kopieren.
Wahrscheinlich suchst du also so etwas:

int[][] sp_param = new int[sp.length][];
for (int i = 0; i < sp_param.length; i++){
  sp_param[i] = new int[sp[i].length];
  for (int j = 0; j < sp_param[i].length; j++){
    sp_param[i][j] = sp[i][j];
  }
}

sp_tmp = regeln.verteile(sp_param, i);

 

[ManuP]

Danke, das war es wohl...
Ich habe nicht daran gedacht, das ich direkt auf den Speicher zugreiffe.. war wohl ein bisschen bei c (gedanklich >>&).

danke für die hilfe