Hallo ich bins wieder mit meinem Monstercode. Ich arbeite am Reversi in Java und das Spiel kann man spielen bis zu einem gewissen Zeitpunkt bis das Programm sich aufhängt. Da kein StackOverflowError gemeldet wird vermute ich einfach ich habe eine Endlosschleife in meinem Programm. Nur leider kann ich die nach 3 Stunden immernoch nicht finden. Wenn jemandem etwas auffällt würde ich mich sehr über einen Hinweis freuen. Ich vermute dass der Fehler in der Spiellogik steckt. Sicherheithalber poste ich alle 4 Klassen
Code:
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class Spiellogik{
static int Höhe=RevSpielfeldx.Höhe;
static int Breite=RevSpielfeldx.Breite;
//Der Einfachheit halber ist der Computergengner immer Spieler 2
boolean gegenComputer=RevSpielfeldx.gegenComputer;
static int xKoordinate;
static int yKoordinate;
public static void überprüfenachunten(int eigenerStein,int gegnerischerStein){
for(int i=0;i<Höhe;i++){
for(int j=0;j<Breite;j++){
if(RevSpielfeldx.SFeld[i][j].getState()==2){
if(i+1<Höhe&&RevSpielfeldx.SFeld[i+1][j].getState()==gegnerischerStein){
//Beginn der Überprüfung ob nach unten ob Steine gesetzt werden können
//Und in der Reihe ein Stein mit dem Status 0 kommt
for(int gehenachunten=i+2;gehenachunten<Höhe;gehenachunten++){
if(gehenachunten<Höhe&&RevSpielfeldx.SFeld[gehenachunten][j].getState()==eigenerStein){
RevSpielfeldx.SFeld[i][j].setBackground(Color.YELLOW);
RevSpielfeldx.SFeld[i][j].setState(3);
xKoordinate=i;
yKoordinate=j;
break;
}
//Wenn ein leeres Feld nach dem gegnerischen Stein kommt muss abgebrochen werden
if(gehenachunten<Höhe&&RevSpielfeldx.SFeld[gehenachunten][j].getState()==2){
break;
}
}//Ende der for-Schleife
//Ende der Überprüfung ob nach unten ob Steine gesetzt werden können
//Wenn über dem leeren Feld ein Feld mit dem Status 1 ist
}
}
}
}
}
public static void überprüfenachoben(int eigenerStein,int gegnerischerStein){
for(int i=0;i<Höhe;i++){
for(int j=0;j<Breite;j++){
if(RevSpielfeldx.SFeld[i][j].getState()==2){
//Beginn der Überprüfung ob nach oben ob Steine gesetzt werden können
//Und in der Reihe ein Stein mit dem Status 0 kommt
//Wenn über dem leeren Feld ein Feld mit Status 1 ist
if(i-1>=0&&RevSpielfeldx.SFeld[i-1][j].getState()==gegnerischerStein){
//System.out.println("oben");
for(int gehenachoben=i-2;gehenachoben>=0;gehenachoben--){
if(gehenachoben>=0&&RevSpielfeldx.SFeld[gehenachoben][j].getState()==eigenerStein){
RevSpielfeldx.SFeld[i][j].setBackground(Color.YELLOW);
RevSpielfeldx.SFeld[i][j].setState(3);
xKoordinate=i;
yKoordinate=j;
break;
}
//Wenn ein leeres Feld nach dem gegnerischen Stein kommt muss abgebrochen werden
if(gehenachoben<Höhe&&RevSpielfeldx.SFeld[gehenachoben][j].getState()==2){
break;
}
}//Ende der for-Schleife
}
//Ende der Überprüfung ob nach oben ob Steine gesetzt werden können
}
}
}
}
public static void überprüfenachlinks(int eigenerStein,int gegnerischerStein){
for(int i=0;i<Höhe;i++){
for(int j=0;j<Breite;j++){
if(RevSpielfeldx.SFeld[i][j].getState()==2){
if(j-1>=0&&RevSpielfeldx.SFeld[i][j-1].getState()==gegnerischerStein){
//Beginn der Überprüfung ob nach unten ob Steine gesetzt werden können
//Und in der Reihe ein Stein mit dem Status 0 kommt
for(int gehenachlinks=j-2;gehenachlinks>=0;gehenachlinks--){
if(gehenachlinks>=0&&RevSpielfeldx.SFeld[i][gehenachlinks].getState()==eigenerStein){
RevSpielfeldx.SFeld[i][j].setBackground(Color.YELLOW);
RevSpielfeldx.SFeld[i][j].setState(3);
xKoordinate=i;
yKoordinate=j;
break;
}
//Wenn ein leeres Feld nach dem gegnerischen Stein kommt muss abgebrochen werden
if(gehenachlinks>=0&&RevSpielfeldx.SFeld[i][gehenachlinks].getState()==2){
break;
}
}//Ende der for-Schleife
//Ende der Überprüfung ob nach unten ob Steine gesetzt werden können
//Wenn über dem leeren Feld ein Feld mit dem Status 1 ist
}
}
}
}
}
public static void überprüfenachrechts(int eigenerStein,int gegnerischerStein){
for(int i=0;i<Höhe;i++){
for(int j=0;j<Breite;j++){
if(RevSpielfeldx.SFeld[i][j].getState()==2){
if(j+1<Breite&&RevSpielfeldx.SFeld[i][j+1].getState()==gegnerischerStein){
//Beginn der Überprüfung ob nach unten ob Steine gesetzt werden können
//Und in der Reihe ein Stein mit dem Status 0 kommt
for(int gehenachrechts=j+2;gehenachrechts<Breite;gehenachrechts++){
if(gehenachrechts>=0&&RevSpielfeldx.SFeld[i][gehenachrechts].getState()==eigenerStein){
RevSpielfeldx.SFeld[i][j].setBackground(Color.YELLOW);
RevSpielfeldx.SFeld[i][j].setState(3);
xKoordinate=i;
yKoordinate=j;
break;
}
//Wenn ein leeres Feld nach dem gegnerischen Stein kommt muss abgebrochen werden
if(gehenachrechts<Breite&&RevSpielfeldx.SFeld[i][gehenachrechts].getState()==2){
break;
}
}//Ende der for-Schleife
//Ende der Überprüfung ob nach unten ob Steine gesetzt werden können
//Wenn über dem leeren Feld ein Feld mit dem Status 1 ist
}
}
}
}
}
public static void überprüfediagonalrechtsoben(int eigenerStein,int gegnerischerStein){
for(int i=0;i<Höhe;i++){
for(int j=0;j<Breite;j++){
if(RevSpielfeldx.SFeld[i][j].getState()==2){
//Wenn ein gegnerischer Stein am Rand liegt kann man rechts diagonal keinen Stein mehr platzieren also Höhe- 2, Breite + 2 prüfen
if((i-2>=0)&&(j+2<Breite)&&(RevSpielfeldx.SFeld[i-1][j+1].getState()==gegnerischerStein)){
//Beginn der Überprüfung ob nach rechtsoben Steine gesetzt werden können
//Und wenn in der digonalen Reihe ein Stein mit dem Status 0 kommt
int gehenachrechtsoben_rechts=j+2;
for(int gehenachrechtsoben=i-2;gehenachrechtsoben>=0;gehenachrechtsoben--){
if((gehenachrechtsoben>=0)&&(gehenachrechtsoben_rechts+2<Breite)){
if(RevSpielfeldx.SFeld[gehenachrechtsoben][gehenachrechtsoben_rechts].getState()==eigenerStein){
RevSpielfeldx.SFeld[i][j].setBackground(Color.YELLOW);
RevSpielfeldx.SFeld[i][j].setState(3);
//xKoordinate=i;
//yKoordinate=j;
break;
}
else {
gehenachrechtsoben_rechts++;
}
}
//Wenn ein leeres Feld nach dem gegnerischen Stein kommt muss abgebrochen werden
if((gehenachrechtsoben>0)&&(gehenachrechtsoben_rechts+2<Breite)){
if(RevSpielfeldx.SFeld[gehenachrechtsoben][gehenachrechtsoben_rechts].getState()==2){
break;
}
}
gehenachrechtsoben_rechts++;
}//Ende der for-Schleife
//Ende der Überprüfung ob nach unten ob Steine gesetzt werden können
//Wenn über dem leeren Feld ein Feld mit dem Status 1 ist
}
}
}
}
}
public static void überprüfediagonalrechtsunten(int eigenerStein,int gegnerischerStein){
for(int i=0;i<Höhe;i++){
for(int j=0;j<Breite;j++){
if(RevSpielfeldx.SFeld[i][j].getState()==2){
if((i+1<Höhe)&&(j+1<Breite)&&(RevSpielfeldx.SFeld[i+1][j+1].getState()==gegnerischerStein)){
//Beginn der Überprüfung ob nach unten ob Steine gesetzt werden können
//Und in der Reihe ein Stein mit dem Status 0 kommt
int gehenachrechtsunten_rechts=j+2;
for(int gehenachrechtsunten=i+2;gehenachrechtsunten<Breite;gehenachrechtsunten++){
if((gehenachrechtsunten<Höhe)&&(gehenachrechtsunten_rechts+2<Breite)){
if(RevSpielfeldx.SFeld[gehenachrechtsunten][gehenachrechtsunten_rechts].getState()==eigenerStein){
RevSpielfeldx.SFeld[i][j].setBackground(Color.YELLOW);
RevSpielfeldx.SFeld[i][j].setState(3);
//xKoordinate=i;
//yKoordinate=j;
break;
}
}
//Wenn ein leeres Feld nach dem gegnerischen Stein kommt muss abgebrochen werden
if((gehenachrechtsunten>=0)&&(gehenachrechtsunten_rechts<Breite)){
if(RevSpielfeldx.SFeld[gehenachrechtsunten][gehenachrechtsunten_rechts].getState()==2){
break;
}
}
gehenachrechtsunten_rechts++;
}//Ende der for-Schleife
//Ende der Überprüfung ob nach unten ob Steine gesetzt werden können
//Wenn über dem leeren Feld ein Feld mit dem Status 1 ist
}
}
}
}
}
public static void überprüfediagonallinksoben(int eigenerStein,int gegnerischerStein){
for(int i=0;i<Höhe;i++){
for(int j=0;j<Breite;j++){
if(RevSpielfeldx.SFeld[i][j].getState()==2){
if((i-1>=0)&&(j-1>=0)&&(RevSpielfeldx.SFeld[i-1][j-1].getState()==gegnerischerStein)){
//Beginn der Überprüfung ob nach unten ob Steine gesetzt werden können
//Und in der Reihe ein Stein mit dem Status 0 kommt
int gehenachlinksoben_links=j-2;
for(int gehenachlinksoben=i-2;gehenachlinksoben>0;gehenachlinksoben--){
if((gehenachlinksoben>=0)&&(gehenachlinksoben_links>=0)){
if(RevSpielfeldx.SFeld[gehenachlinksoben][gehenachlinksoben_links].getState()==eigenerStein){
RevSpielfeldx.SFeld[i][j].setBackground(Color.YELLOW);
RevSpielfeldx.SFeld[i][j].setState(3);
//xKoordinate=i;
//yKoordinate=j;
break;
}
}
//Wenn ein leeres Feld nach dem gegnerischen Stein kommt muss abgebrochen werden
if((gehenachlinksoben>=0)&&(gehenachlinksoben_links>0)){
if(RevSpielfeldx.SFeld[gehenachlinksoben][gehenachlinksoben_links].getState()==2){
break;
}
}
gehenachlinksoben_links--;
}//Ende der for-Schleife
//Ende der Überprüfung ob nach unten ob Steine gesetzt werden können
//Wenn über dem leeren Feld ein Feld mit dem Status 1 ist
}
}
}
}
}
public static void überprüfediagonallinksunten(int eigenerStein,int gegnerischerStein){
for(int i=0;i<Höhe;i++){
for(int j=0;j<Breite;j++){
if(RevSpielfeldx.SFeld[i][j].getState()==2){
if(i+1<Höhe&&j-1>0&&RevSpielfeldx.SFeld[i+1][j-1].getState()==gegnerischerStein){
//Beginn der Überprüfung ob nach unten ob Steine gesetzt werden können
//Und in der Reihe ein Stein mit dem Status 0 kommt
int gehenachlinksunten_links=j-2;
for(int gehenachlinksunten=i+2;gehenachlinksunten<Breite;gehenachlinksunten++){
if((gehenachlinksunten<Höhe)&&(gehenachlinksunten_links>0)){
if(RevSpielfeldx.SFeld[gehenachlinksunten][gehenachlinksunten_links].getState()==eigenerStein){
RevSpielfeldx.SFeld[i][j].setBackground(Color.YELLOW);
RevSpielfeldx.SFeld[i][j].setState(3);
//xKoordinate=i;
//yKoordinate=j;
break;
}
}
//Wenn ein leeres Feld nach dem gegnerischen Stein kommt muss abgebrochen werden
if((gehenachlinksunten>=0)&&(gehenachlinksunten_links>0)){
if(RevSpielfeldx.SFeld[gehenachlinksunten][gehenachlinksunten_links].getState()==2){
break;
}
}
gehenachlinksunten_links--;
}//Ende der for-Schleife
//Ende der Überprüfung ob nach unten ob Steine gesetzt werden können
//Wenn über dem leeren Feld ein Feld mit dem Status 1 ist
}
}
}
}
}
public static void dreheSteineUm(int x,int y){
if(RevSpielfeldx.zähler%2==0){
dreheSteineUmNachUnten(x,y,1,0);
dreheSteineUmNachOben(x,y,1,0);
dreheSteineUmNachRechts(x,y,1,0);
dreheSteineUmNachLinks(x,y,1,0);
dreheSteineUmNachLinksOben(x,y,1,0);
dreheSteineUmNachLinksUnten(x,y,1,0);
dreheSteineUmNachRechtsOben(x,y,1,0);
dreheSteineUmNachRechtsUnten(x,y,1,0);
}
else{
dreheSteineUmNachUnten(x,y,0,1);
dreheSteineUmNachOben(x,y,0,1);
dreheSteineUmNachRechts(x,y,0,1);
dreheSteineUmNachLinks(x,y,0,1);
dreheSteineUmNachLinksOben(x,y,0,1);
dreheSteineUmNachLinksUnten(x,y,0,1);
dreheSteineUmNachRechtsOben(x,y,0,1);
dreheSteineUmNachRechtsUnten(x,y,0,1);
}
}
public static void dreheSteineUmNachUnten(int x,int y,int gegnerischerStein,int eigenerStein){
int nachunten=x+1;
int bisX;
if((nachunten+2<Höhe)&&RevSpielfeldx.SFeld[nachunten][y].getState()==gegnerischerStein){
//Bis zum gegnerischen Stein(inklusive soll umgedreht werden
bisX=nachunten;
//System.out.println("Gegnerischer Stein: "+bisX);
for(int nachunten_unten=bisX+1;nachunten_unten+1<Höhe;nachunten_unten++){
if((nachunten_unten<Höhe)&&(RevSpielfeldx.SFeld[nachunten_unten][y].getState()==eigenerStein)){
System.out.println("Bis nach unten "+bisX);
System.out.println("Schleife nachunten betreten");
for(int nachunten_dreheUm=nachunten_unten-1;nachunten_dreheUm>=bisX;nachunten_dreheUm--){
//System.out.println("Nahunten Schleife betreten");
RevSpielfeldx.SFeld[nachunten_dreheUm][y].setState(eigenerStein);
}
//System.out.println("Schleife beendet");
break;
}
}
}
}
public static void dreheSteineUmNachOben(int x,int y,int gegnerischerStein,int eigenerStein){
int nachoben=x-1;
if((nachoben-2>=0)&&RevSpielfeldx.SFeld[nachoben][y].getState()==gegnerischerStein){
//System.out.println("nachoben");
int bisX=nachoben;
for(int nachoben_oben=nachoben-1;nachoben_oben>=0;nachoben_oben--){
if(RevSpielfeldx.SFeld[nachoben_oben][y].getState()==eigenerStein){
for(int nachoben_dreheUm=nachoben_oben+1;nachoben_dreheUm<=bisX;nachoben_dreheUm++){
RevSpielfeldx.SFeld[nachoben_dreheUm][y].setState(eigenerStein);
}
//System.out.println("Schleife beendet");
break;
}
}
}
}
public static void dreheSteineUmNachRechts(int x,int y,int gegnerischerStein,int eigenerStein){
int nachrechts=y+1;
if((nachrechts+2<Breite)&&RevSpielfeldx.SFeld[x][nachrechts].getState()==gegnerischerStein){
int bisY=nachrechts;
for(int nachrechts_rechts=nachrechts+1;nachrechts_rechts+1<Breite;nachrechts_rechts++){
System.out.println("Nach rechts betreten");
if(RevSpielfeldx.SFeld[x][nachrechts_rechts].getState()==eigenerStein){
for(int nachrechts_dreheUm=nachrechts_rechts-1;nachrechts_dreheUm>=bisY;nachrechts_dreheUm--){
RevSpielfeldx.SFeld[x][nachrechts_dreheUm].setState(eigenerStein);
System.out.println("Nach rechts umgedreht");
}
break;
}
}
}
}
public static void dreheSteineUmNachLinks(int x,int y,int gegnerischerStein,int eigenerStein){
int nachlinks=y-1;
if((nachlinks-2>=0)&&RevSpielfeldx.SFeld[x][nachlinks].getState()==gegnerischerStein){
int bisY=nachlinks;
for(int nachlinks_links=nachlinks-1;nachlinks_links-1>=0;nachlinks_links--){
if(RevSpielfeldx.SFeld[x][nachlinks_links].getState()==eigenerStein){
for(int nachlinks_dreheUm=nachlinks_links+1;nachlinks_dreheUm<=bisY;nachlinks_dreheUm++){
RevSpielfeldx.SFeld[x][nachlinks_dreheUm].setState(eigenerStein);
}
break;
}
}
}
}
public static void dreheSteineUmNachLinksOben(int x,int y,int gegnerischerStein,int eigenerStein){
int nachrechtsoben_oben=x-1;
int nachrechtsoben_rechts=y+1;
if((nachrechtsoben_oben>=0)&&(nachrechtsoben_rechts<Breite)&&RevSpielfeldx.SFeld[nachrechtsoben_oben][nachrechtsoben_rechts].getState()==gegnerischerStein){
//System.out.println("gegnerischer Stein gefunden-rechtsoben");
System.out.println(x+" : "+y);
int bisX=nachrechtsoben_oben;
int bisY=nachrechtsoben_rechts;
System.out.println(bisX+" : "+bisY+"////");
//Schleife starten
//Vom gegnerischen Stein nach rechtsoben Suchen bis ein eigener Stein kommt, wenn leeres Feld: abbrechen
int j=nachrechtsoben_rechts+1;
for(int i=nachrechtsoben_oben-1;i>0;i--){
//Abbruchbedingung
if((j+1<Breite)&&(RevSpielfeldx.SFeld[i][j].getState()==2)){break;}
//Wenn das nächste Feld auch vom Typ gegnerische Stein ist weiter nachobensuchen also j inkrementieren, i wird schon ducrch die schleife verändert
if((j+1<Breite)&&(RevSpielfeldx.SFeld[i][j].getState()==2)){j++;}
//Wenn ein eigener Stein auftritt, beginnen mit dem Steinedrehen in die entgegengesetzte Richtung, sprich nach linksunten
if((j+1<Breite)&&(RevSpielfeldx.SFeld[i][j].getState()==eigenerStein)){
System.out.println("gegnerischer Stein gefunden-rechtsoben");
System.out.println(bisX+" : "+bisY);
System.out.println("Eigener Stein gefunden");
int vonX=i;
int vonY=j;
System.out.println(vonX+" : "+vonY);
for(int dreheSteineUm_nachlinksuntenX=vonX+1;dreheSteineUm_nachlinksuntenX<=bisX;dreheSteineUm_nachlinksuntenX++){
if((dreheSteineUm_nachlinksuntenX<Höhe)&&(vonY-1>0)){
RevSpielfeldx.SFeld[dreheSteineUm_nachlinksuntenX][vonY-1].setState(eigenerStein);
//System.out.println(vonY);
vonY--;
}
}
break;
}
if(nachrechtsoben_rechts<Breite-1){
nachrechtsoben_rechts++;
}
else{
break;
}
}
}
}
public static void dreheSteineUmNachLinksUnten(int x,int y,int gegnerischerStein,int eigenerStein){
int nachrechtsoben_oben=x-1;
int nachrechtsoben_rechts=y+1;
if((nachrechtsoben_oben>=0)&&(nachrechtsoben_rechts<Breite)&&RevSpielfeldx.SFeld[nachrechtsoben_oben][nachrechtsoben_rechts].getState()==gegnerischerStein){
//System.out.println("gegnerischer Stein gefunden-rechtsoben");
System.out.println(x+" : "+y);
int bisX=nachrechtsoben_oben;
int bisY=nachrechtsoben_rechts;
System.out.println(bisX+" : "+bisY+"////");
//Schleife starten
//Vom gegnerischen Stein nach rechtsoben Suchen bis ein eigener Stein kommt, wenn leeres Feld: abbrechen
int j=nachrechtsoben_rechts+1;
for(int i=nachrechtsoben_oben-1;i>0;i--){
//Abbruchbedingung
if((j+1<Breite)&&(RevSpielfeldx.SFeld[i][j].getState()==2)){break;}
//Wenn das nächste Feld auch vom Typ gegnerische Stein ist weiter nachobensuchen also j inkrementieren, i wird schon ducrch die schleife verändert
if((j+1<Breite)&&(RevSpielfeldx.SFeld[i][j].getState()==2)){j++;}
//Wenn ein eigener Stein auftritt, beginnen mit dem Steinedrehen in die entgegengesetzte Richtung, sprich nach linksunten
if((j+1<Breite)&&(RevSpielfeldx.SFeld[i][j].getState()==eigenerStein)){
System.out.println("gegnerischer Stein gefunden-rechtsoben");
System.out.println(bisX+" : "+bisY);
System.out.println("Eigener Stein gefunden");
int vonX=i;
int vonY=j;
System.out.println(vonX+" : "+vonY);
for(int dreheSteineUm_nachlinksuntenX=vonX+1;dreheSteineUm_nachlinksuntenX<=bisX;dreheSteineUm_nachlinksuntenX++){
if((dreheSteineUm_nachlinksuntenX<Höhe)&&(vonY-1>0)){
RevSpielfeldx.SFeld[dreheSteineUm_nachlinksuntenX][vonY-1].setState(eigenerStein);
//System.out.println(vonY);
vonY--;
}
}
break;
}
if(nachrechtsoben_rechts<Breite-1){
nachrechtsoben_rechts++;
}
else{
break;
}
}
}
}
public static void dreheSteineUmNachRechtsOben(int x,int y,int gegnerischerStein,int eigenerStein){
int nachrechtsoben_oben=x-1;
int nachrechtsoben_rechts=y+1;
boolean überprüfung=false;
if((nachrechtsoben_oben>=0)&&(nachrechtsoben_rechts<Breite)&&RevSpielfeldx.SFeld[nachrechtsoben_oben][nachrechtsoben_rechts].getState()==gegnerischerStein){
//System.out.println("gegnerischer Stein gefunden-rechtsoben");
überprüfung=true;
//System.out.println(x+" : "+y);
int bisX=nachrechtsoben_oben;
int bisY=nachrechtsoben_rechts;
//System.out.println(bisX+" : "+bisY+"////");
//Schleife starten
//Vom gegnerischen Stein nach rechtsoben Suchen bis ein eigener Stein kommt, wenn leeres Feld: abbrechen
int j=nachrechtsoben_rechts+1;
for(int i=nachrechtsoben_oben-1;i>0;i--){
//Abbruchbedingung
//System.out.println("Schleife wurde betreten");
/*if((j+1<Breite)&&(RevSpielfeldx.SFeld[i][j+1].getState()==2)){
System.out.println("Break wurde betreten");
break;}*/
//Wenn das nächste Feld auch vom Typ gegnerische Stein ist weiter nachobensuchen also j inkrementieren, i wird schon ducrch die schleife verändert
if((überprüfung)&&(j+1<Breite)&&(RevSpielfeldx.SFeld[i][j].getState()==gegnerischerStein)){j++;}
//Wenn ein eigener Stein auftritt, beginnen mit dem Steinedrehen in die entgegengesetzte Richtung, sprich nach linksunten
if((überprüfung)&&(j+1<Breite)&&(RevSpielfeldx.SFeld[i][j].getState()==eigenerStein)){
//System.out.println("gegnerischer Stein gefunden-rechtsoben");
//System.out.println(bisX+" : "+bisY);
//System.out.println("Eigener Stein gefunden");
int vonX=i;
int vonY=j;
//System.out.println(vonX+" : "+vonY);
for(int dreheSteineUm_nachlinksuntenX=vonX+1;dreheSteineUm_nachlinksuntenX<=bisX;dreheSteineUm_nachlinksuntenX++){
if((dreheSteineUm_nachlinksuntenX<Höhe)&&(vonY-1>0)){
RevSpielfeldx.SFeld[dreheSteineUm_nachlinksuntenX][vonY-1].setState(eigenerStein);
//System.out.println(vonY);
vonY--;
}
}
break;
}
if(nachrechtsoben_rechts<Breite-1){
nachrechtsoben_rechts++;
}
else{
break;
}
}
}
}
public static void dreheSteineUmNachRechtsUnten(int x,int y,int gegnerischerStein,int eigenerStein){
int nachrechtsunten_unten=x+1;
int nachrechtsunten_rechts=y+1;
if((nachrechtsunten_unten<Höhe)&&(nachrechtsunten_rechts<Breite)&&RevSpielfeldx.SFeld[nachrechtsunten_unten][nachrechtsunten_rechts].getState()==gegnerischerStein){
//System.out.println("gegnerischer Stein gefunden-rechtsoben");
System.out.println(x+" : "+y);
int bisX=nachrechtsunten_unten;
int bisY=nachrechtsunten_rechts;
System.out.println(bisX+" : "+bisY+"////");
//Schleife starten
//Vom gegnerischen Stein nach rechtsoben Suchen bis ein eigener Stein kommt, wenn leeres Feld: abbrechen
int j=nachrechtsunten_rechts+1;
for(int i=nachrechtsunten_unten+1;i<Höhe;i++){
//Abbruchbedingung
if((j+1<Breite)&&(RevSpielfeldx.SFeld[i][j].getState()==2)){break;}
//Wenn das nächste Feld auch vom Typ gegnerische Stein ist weiter nachobensuchen also j inkrementieren, i wird schon ducrch die schleife verändert
if((j+1<Breite)&&(RevSpielfeldx.SFeld[i][j].getState()==gegnerischerStein)){j++;}
//Wenn ein eigener Stein auftritt, beginnen mit dem Steinedrehen in die entgegengesetzte Richtung, sprich nach linksunten
if((j+1<Breite)&&(RevSpielfeldx.SFeld[i][j].getState()==eigenerStein)){
System.out.println("gegnerischer Stein gefunden-rechtsoben");
System.out.println(bisX+" : "+bisY);
System.out.println("Eigener Stein gefunden");
int vonX=i;
int vonY=j;
System.out.println(vonX+" : "+vonY);
for(int dreheSteineUm_nachlinksobenX=vonX-1;dreheSteineUm_nachlinksobenX<=bisX;dreheSteineUm_nachlinksobenX--){
if((dreheSteineUm_nachlinksobenX>=bisX)&&(vonY-1>0)){
RevSpielfeldx.SFeld[dreheSteineUm_nachlinksobenX][vonY-1].setState(eigenerStein);
//System.out.println(vonY);
vonY--;
}
}
break;
}
if(nachrechtsunten_rechts<Breite-1){
nachrechtsunten_rechts++;
}
else{
break;
}
}
}
}
public static int zähleWeisseSpielsteine(){
int anzahlWeisserSteine=0;
for(int i=0;i<Höhe;i++){
for(int j=0;j<Breite;j++){
if(RevSpielfeldx.SFeld[i][j].getState()==0){
anzahlWeisserSteine++;
}
}
}
return anzahlWeisserSteine;
}
public static int zähleSchwarzeSpielsteine(){
int anzahlSchwarzerSteine=0;
for(int i=0;i<Höhe;i++){
for(int j=0;j<Breite;j++){
if(RevSpielfeldx.SFeld[i][j].getState()==1){
anzahlSchwarzerSteine++;
}
}
}
return anzahlSchwarzerSteine;
}
}
Code:
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class RevSpielfeldx extends JApplet implements MouseListener{// JInternalFrame
//Instanzvariablen
static int zähler = 0;
static int Höhe = 10;//RevStartx.tse;
static int Breite =Höhe;
static Felder[][] SFeld = new Felder[Höhe][Breite];
//JButton[][] SFeld = new JButton[Höhe][Breite];
JTextField zug;
JTextField test;
JTextField test2;
//Gasis Änderung 1
JTextField spielerdran;
//ReversiMaster des;
JTextField steine1;
JTextField steine2;
int aktspieler=0;
int FeldKoordinate;
static boolean gegenComputer=false;
//---Init-Methode---------------------------------------------------------------
public RevSpielfeldx(){//ReversiMaster df) {
//des = df;
setSize(600,400);
// setIconifiable(true);
/* setDefaultCloseOperation(
JInternalFrame.DISPOSE_ON_CLOSE
);*/
JSplitPane main =new JSplitPane(JSplitPane.HORIZONTAL_SPLIT); //Das Fenster wird durch eine
//JSplitPane geteilt
JPanel spielfeld = new JPanel(); //Die linke Seite zeigt das
spielfeld.setMinimumSize(new Dimension(400,400)); //Spielfeld
spielfeld.setPreferredSize(new Dimension(400,400));
spielfeld.setLayout(new BorderLayout(1,1));
JPanel center = new JPanel();
center.setLayout(new GridLayout(Höhe,Breite));
center.setSize(400,400);
//SFeld[Höhe-1][Breite-1]=new Felder();
for (int i=0; i<Höhe; i++){ //Baut Spielfeld
for(int j =0; j<Breite; j++){ //mit Hilfe der Klasse
//"Felder" auf
SFeld[i][j] = new Felder(i,j);
SFeld[i][j].addMouseListener(this);
center.add(SFeld[i][j]);
}
}
SFeld[Höhe/2][Breite/2].setState(1); //Baut Startaufstellung
SFeld[Höhe/2][Breite/2-1].setState(0); //auf
SFeld[Höhe/2-1][Breite/2].setState(0);
SFeld[Höhe/2-1][Breite/2-1].setState(1);
//sucheZüge();
spielfeld.add(center);
JPanel status =new JPanel(); //Die rechte Seite ist für
status.setMinimumSize(new Dimension(200,400)); //Statusanzeigen vorgesehen
status.setPreferredSize(new Dimension(200,400));
zug =new JTextField("Spielzug: "+(zähler+1),13);
zug.setEditable(false);
test =new JTextField("Feld: ",13);
test.setEditable(false);
test2 =new JTextField("State: ",13);
test2.setEditable(false);
spielerdran=new JTextField(zähler%2==0?"Weiss ist am Zug":"Schwarz ist am Zug",13);
spielerdran.setEditable(false);
steine1=new JTextField("Weisse Steine: "+Spiellogik.zähleWeisseSpielsteine(),13);
steine1.setEditable(false);
steine2=new JTextField("Schwarze Steine: "+Spiellogik.zähleSchwarzeSpielsteine(),13);
steine2.setEditable(false);
status.add(zug);
status.add(test);
status.add(test2);
status.add(spielerdran);
status.add(steine1);
status.add(steine2);
main.setLeftComponent(spielfeld);
main.setRightComponent(status);
Container ois=getContentPane();
ois.add(main);
JMenuBar mb = new JMenuBar(); //Hier wird das Menu gebaut
JMenu datei = new JMenu("Datei");
datei.setMnemonic('D');
JMenuItem neu = new JMenuItem("Neues Spiel");
neu.setMnemonic('N');
neu.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e){
//des.addChild(new RevStartx(), 20,20);
}});
JMenuItem save= new JMenuItem("Speichern");
save.setMnemonic('S');
JMenuItem load= new JMenuItem("Laden");
load.setMnemonic('L');
JMenuItem quit= new JMenuItem("Beenden");
quit.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e){
setVisible(false);
}});
datei.add(neu);
datei.addSeparator();
datei.add(save);
datei.add(load);
datei.addSeparator();
datei.add(quit);
JMenu option = new JMenu("Optionen");
option.setMnemonic('p');
JMenuItem undo = new JMenuItem("Undo");
undo.setMnemonic('U');
JMenu stauf= new JMenu("Startaufstellung");
stauf.setMnemonic('t');
JMenuItem kla =new JMenuItem("klassisch");
JMenuItem mod =new JMenuItem("modern");
stauf.add(kla);
stauf.add(mod);
option.add(undo);
option.addSeparator();
option.add(stauf);
JMenu frage = new JMenu ("?");
JMenuItem about = new JMenuItem("About");
JMenuItem zusp = new JMenuItem("Über das Spiel");
frage.add(zusp);
frage.addSeparator();
frage.add(about);
mb.add(datei);
mb.add(option);
mb.add(frage);
setJMenuBar(mb);
setVisible(true);
sucheNachSetzbarenFeldern();
}
//---Main-Methode---------------------------------------------------------------
public static void main(String[] args) {
Konsole.run(new RevSpielfeldx(),600,400);
}
//---Methoden-------------------------------------------------------------------
public void mouseExited(MouseEvent e){
}
public void mouseEntered(MouseEvent e){
}
public void mouseReleased(MouseEvent e){
}
public void mousePressed(MouseEvent e){
}
public void mouseClicked(MouseEvent e){
try{
Felder eld = (Felder)e.getSource();
int x = eld.getIDx();
int y = eld.getIDy();
/*zug.setText("Spielzug: "+(zähler+1));
test.setText("Feld: "+x+", "+y);//FeldKoordinate);
test2.setText("State: "+SFeld[x][y].getState());
*/
if(SFeld[x][y].getState()==3){
//System.out.println("Der Stein wird gesetzt");
//setzeStein(x,y,zähler);
//sucheNachSetzbarenFeldern();
spielroutine(x,y);
}
}
catch(StackOverflowError eflow){
System.out.println("Sie haben ein falsches Feld gewählt");
}
}
//Gasis krasse Funktionen
public void sucheNachSetzbarenFeldern(){
for(int i=0;i<Höhe;i++){
for(int j=0;j<Breite;j++){
//Prüfe ob das Feld leer ist
if(SFeld[i][j].getState()==2){
//Wenn zähler%2==0 dann ist Spieler1 dran ansonsten Spieler2
if(zähler%2==0){
//System.out.println("hallo");
//Wenn unter dem leeren Feld ein Feld mit dem Status 1 ist
Spiellogik.überprüfenachunten(0,1);
Spiellogik.überprüfenachoben(0,1);
Spiellogik.überprüfenachlinks(0,1);
Spiellogik.überprüfenachrechts(0,1);
Spiellogik.überprüfediagonallinksoben(0,1);
Spiellogik.überprüfediagonallinksunten(0,1);
Spiellogik.überprüfediagonalrechtsoben(0,1);
Spiellogik.überprüfediagonalrechtsunten(0,1);
}
//Spieler 2 ist dran
else{
Spiellogik.überprüfenachunten(1,0);
Spiellogik.überprüfenachoben(1,0);
Spiellogik.überprüfenachlinks(1,0);
Spiellogik.überprüfenachrechts(1,0);
Spiellogik.überprüfediagonallinksoben(1,0);
Spiellogik.überprüfediagonallinksunten(1,0);
Spiellogik.überprüfediagonalrechtsoben(1,0);
Spiellogik.überprüfediagonalrechtsunten(1,0);
}
}
}
}
}
public void setzeStein(int x,int y,int zähler){
if(zähler%2==0){
SFeld[x][y].setState(0);
Spiellogik.dreheSteineUm(x,y);
}
else{
SFeld[x][y].setState(1);
Spiellogik.dreheSteineUm(x,y);
}
}
public void hintergrundAufGrünSetzen(){
for(int i=0;i<Höhe;i++){
for(int j=0;j<Breite;j++){
SFeld[i][j].setBackground(Color.GREEN);
}
}
}
public void alleLeerenFelderAuf2Setzen(){
for(int i=0;i<Höhe;i++){
for(int j=0;j<Breite;j++){
if(SFeld[i][j].getState()==3){
SFeld[i][j].setState(2);
}
}
}
}
public void spielroutine(int x,int y){
System.out.println("Spielroutine aufgerufen");
zug.setText("Spielzug: "+(zähler+1));
test.setText("Feld: "+x+", "+y);//FeldKoordinate);
test2.setText("State: "+SFeld[x][y].getState());
//Beim Wert 3 kann ein Stein gesetzt werden
if(SFeld[x][y].getState()==3){
setzeStein(x,y,zähler);
zähler++;
Spiellogik.dreheSteineUm(x,y);
}
else{
System.out.println("Das Spielroutine wird mit"+x+y);
spielroutine(x,y);
}
zug.setText("Spielzug: "+(zähler+1));
spielerdran.setText(zähler%2==0?"Weiss ist am Zug":"Schwarz ist am Zug");
steine1.setText("Weisse Steine: "+Spiellogik.zähleWeisseSpielsteine());
steine2.setText("Schwarze Steine: "+Spiellogik.zähleSchwarzeSpielsteine());
hintergrundAufGrünSetzen();
alleLeerenFelderAuf2Setzen();
sucheNachSetzbarenFeldern();
}
/*public void dreheSteineUm(int x,int y){
if(zähler%2==0){
Spiellogik.dreheSteineUmNachUnten(x,y,1,0);
Spiellogik.dreheSteineUmNachOben(x,y,1,0);
Spiellogik.dreheSteineUmNachRechts(x,y,1,0);
Spiellogik.dreheSteineUmNachLinks(x,y,1,0);
Spiellogik.dreheSteineUmNachLinksOben(x,y,1,0);
Spiellogik.dreheSteineUmNachLinksUnten(x,y,1,0);
Spiellogik.dreheSteineUmNachRechtsOben(x,y,1,0);
Spiellogik.dreheSteineUmNachRechtsUnten(x,y,1,0);
}
else{
Spiellogik.dreheSteineUmNachUnten(x,y,0,1);
Spiellogik.dreheSteineUmNachOben(x,y,0,1);
Spiellogik.dreheSteineUmNachRechts(x,y,0,1);
Spiellogik.dreheSteineUmNachLinks(x,y,0,1);
Spiellogik.dreheSteineUmNachLinksOben(x,y,0,1);
Spiellogik.dreheSteineUmNachLinksUnten(x,y,0,1);
Spiellogik.dreheSteineUmNachRechtsOben(x,y,0,1);
Spiellogik.dreheSteineUmNachRechtsUnten(x,y,0,1);
}
}*/
}
Code:
/*Felder erweitert JPanel
*um ein Feld, dass auf Mausklicks
*reagiert indem es einen Markierung
*zeichnet.
*
*/
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
class Felder extends JPanel{
//Instanzvariablen
int counter = RevSpielfeldx.zähler;
int leer =2;
int state=leer; // Standart-Feld-Belegung
int sp1 = 1; // Spieler 1
int sp2 = 0; // Spieler 2
int turn= 1;
int feldstatus=0; //Wenn Feldstatus = 0 dann klickbar,
//wenn Feldstatus = 1 dann nicht klickbar
Color spielerfarbe1 = Color.BLACK;
Color spielerfarbe2 = Color.WHITE;
Color hellgrün = new Color(150,255,150);
int idx; //Identifikationsnummern.
int idy;
//---Konstruktor----------------------------------------------------------------
public Felder(int x, int y ){
System.out.println(""+x);
System.out.println(""+y) ;
idx=x;
idy=y;
setBackground(Color.GREEN);
addMouseListener (new MoLi());// ML wird registriert
}
//---Main-Methode---------------------------------------------------------------
public static void main(String [] args){
}
//---Methoden-------------------------------------------------------------------
public void paintComponent(Graphics g){ //Zeichnet das Feld
super.paintComponent(g);
int arcx= 5;
int arcy= 5;
int x1 = 0; // x,y-Koordinaten der
int y1 = 0; // Punkte oben links und
int x2 = getSize().width-1; // unten rechts
int y2 = getSize().height-1;
int x11 = 0; // x,y-Koordinaten der
int y11 = 0; // Punkte oben links und
int x22 = getSize().width-1; // unten rechts
int y22 = getSize().height-1;
//g.setColor(Color.GREEN);
g.drawRoundRect(x1, y1, x2, y2, arcx, arcy); // Rechteck zeichnen
x1 = x2/4; // x,y-Koordinate
y1 = y2/4;
int wide= x2/2; // innere Weite,
int high = y2/2; // Hoehe
g.drawRect(x11, y11, x22, y22); // Rechteck zeichnen
x11 = x22/4; // x,y-Koordinate
y11 = y22/4;
int wide2 = x22/2; // innere Weite,
int high2 = y22/2; // Hoehe
if(feldstatus ==1){
setBackground(hellgrün);
repaint();
}
if(feldstatus ==2){
setBackground(Color.GREEN);
repaint();
}
if (state== sp1) {
g.setColor(spielerfarbe1);
g.fillOval (x1-5, y1-5, x1 + wide/2+10, y1 + high/2+10); // Spielermarke zeichnen
}
if (state== sp2) { //
g.setColor(spielerfarbe2);
g.fillOval (x1-5, y1-5, x1 + wide/2+10, y1 + high/2+10); // Spielermarke zeichnen
}
if (state== 2) { //Leerzustand einzeichnen
if (feldstatus==0){
g.setColor(Color.GREEN);
g.fillOval (x1-5, y1-5, x1 + wide/2+10, y1 + high/2+10);
}
else if(feldstatus==1){
g.setColor(hellgrün);
g.fillOval (x1-5, y1-5, x1 + wide/2+10, y1 + high/2+10);
}
}
} // end paintComponent
//..............................................................................
public void setState (int zustand){
state=zustand;//(zustand == 0 ? sp1 :sp2);
repaint();
}
//..............................................................................
public int getState (){
return state;
}
//..............................................................................
public void setFeldStatus(int a){
feldstatus=a;
repaint();
}
//..............................................................................
public int getFeldStatus(){
return feldstatus;
}
//..............................................................................
public int getIDx (){
return idx;
}
public int getIDy (){
return idy;
}
//..............................................................................
public void setIDx (int x){
idx=x;
}
public void setIDy (int y){
idy=y;
}
//---Innere-Klassen-------------------------------------------------------------
class MoLi extends MouseAdapter{ // MouseListener, innere Kl.
public void mousePressed (MouseEvent e) { // reagiere auf gedrueckte Maus
if(feldstatus==1)
if(state== leer) { // wenn Feld leer:
state= (RevSpielfeldx.zähler%2==0?sp1:sp2);
RevSpielfeldx.zähler++;
}
feldstatus=0;
setBackground(Color.GREEN);
repaint(); // Neuzeichnen
}
}// end ML
}
Code:
import java.awt.event.*;
import javax.swing.*;
class Konsole {
public static String title(Object o) {
String t = o.getClass().toString();
if(t.indexOf("class") != -1) t = t.substring(6);
System.out.println ("Konsole: running "+t);
return t;
}
public static void setupClosing(JFrame frame) {
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
public static void run(JFrame frame, int width, int height) {
setupClosing(frame);
frame.setSize(width, height);
frame.setVisible(true);
}
public static void run(JApplet applet, int width, int height) {
JFrame frame = new JFrame(title(applet));
setupClosing(frame);
frame.getContentPane().add(applet);
frame.setSize(width, height);
applet.init();
applet.start();
frame.setVisible(true);
}
public static void run(JPanel panel, int width, int height) {
JFrame frame = new JFrame(title(panel));
setupClosing(frame);
frame.getContentPane().add(panel);
frame.setSize(width, height);
frame.setVisible(true);
}
}
