OO-Problem bei Entwicklung von Reversi

[Gaston]

Zum x-ten Mal belästige euch schom wegen dem Spiel Reversi. Also ich bin soweit dass alles super in einem Spielfeld läuft. Aber wenn ich ein neues Spielfenster aufmache, und somit zwei Spielfenster offen habe, werden bei jedem Klick ins alte Feld die Steine im neuen gedreht. Mein Problem leigt jetzt darin dass eine neues Spielfeld mit new RevSpielfeldx() gestartet wird, jedoch scheinen die neuen Instanzen von RevSpielfeldx auf dieselbe Instanz von Spiellogik zuzugreifen. Wie schaffe ich jetzt dass bei jedem neuen Aufruf der Instanz von RevSpielfeldx eine neue Instanz von Spiellogik() aufgerufen wird und diese miteinander kommunizieren? etwa mit einem Konstruktor in der Spiellogik oder doch einem Parameter? ich bin ziemlcih ratlos. Bin für jeden Vorschlag dankbar.

import java.awt.*;
import java.awt.event.*; 
import javax.swing.*;
import java.io.*;
import java.util.*;


public class RevSpielfeldx extends JApplet implements MouseListener,
																						Serializable{// JInternalFrame
	
//Instanzvariablen
	
	static int zähler = 0;
	static int Höhe = 14;//RevStartx.tse;
	static int Breite =Höhe;
	static Felder[][] SFeld = new Felder[Höhe][Breite];
	//JButton[][] SFeld = new JButton[Höhe][Breite];

	static JTextField zug;
	static JTextField test;
	static JTextField test2;
	//Gasis Änderung 1
	static JTextField spielerdran;
	//ReversiMaster des;
	static JTextField steine1;
	static JTextField steine2;
	int aktspieler=0;
	
	int FeldKoordinate;
	static boolean gegenComputer=true;
	//static Felder[][] UndoFeld=new Felder[Höhe][Breite];
	static int[][] UndoFeld=new int[Höhe][Breite];
	//static int undoX;
	//static int undoY;
	static int xx;
	static int yy;
	static int[][] SpeichernFeld=new int[Höhe][Breite];
//---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(1);							//auf
					SFeld[Höhe/2-1][Breite/2].setState(0);
					SFeld[Höhe/2-1][Breite/2-1].setState(0);
					
					//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?"Spieler1 ist am Zug":"Spieler2 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){
						Konsole.run(new RevSpielfeldx(),200,200);
						}});

				JMenuItem save= new JMenuItem("Speichern");
					save.setMnemonic('S');
					save.addActionListener(new ActionListener() {
						public void actionPerformed(ActionEvent e){
						//System.out.println("speichern");
						//SpeichernUndLaden.speichern();
						Konsole.run (new FileChooserReversi(),400,200);
						
						}});

					
				JMenuItem load= new JMenuItem("Laden");
					load.setMnemonic('L');
					load.addActionListener(new ActionListener() {
						public void actionPerformed(ActionEvent e){
						Konsole.run (new FileChooserReversi(),400,200);
						//laden();
						}});
				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.addActionListener(new ActionListener(){
					public void actionPerformed(ActionEvent e){
						//System.out.println("Undo");
						undo_aufrufen();
						}});
					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){
		
			Felder eld = (Felder)e.getSource();

		   int x = eld.getIDx();
		   int y = eld.getIDy();
		   
		   try{
		   		
		   			if((gegenComputer)&&(zähler%2==0)){
		   				spielroutine(x,y);
		   				
		   				spielroutine(Spiellogik.xKoordinate,Spiellogik.yKoordinate);
		   				;
		   			}
		   			else{
		   				spielroutine(x,y);
					}
			}catch(StackOverflowError overflow){
			System.out.println("Sie haben ein falsches Feld gewählt");
			}
			
		
		}
	
	
	
	
		
		
		//Gasis krasse Funktionen
		
	public static 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 if(zähler%2==1){
						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 static void setzeStein(int x,int y,int zähler){
			
			if(zähler%2==0){
				SFeld[x][y].setState(0);
			}
			else{
				SFeld[x][y].setState(1);
			}
		}
		
		public static  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 static  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 static void keineSetzbarenFelder(){
		
			for(int i=0;i<Höhe;i++){
				for(int j=0;j<Breite;j++){
					if(RevSpielfeldx.SFeld[i][j].getState()==3){
						return;
					}
				}
			}
			System.out.println("Das Spiel ist zu Ende da kein Stein mehr gesetzt werden kann");
			if(Spiellogik.zähleWeisseSpielsteine()>Spiellogik.zähleSchwarzeSpielsteine()){
				System.out.println("Weiss hat das Spiel gewonnen");
			}
			else if(Spiellogik.zähleWeisseSpielsteine()<Spiellogik.zähleSchwarzeSpielsteine()){
				System.out.println("Schwarz hat das Spiel gewonnen");
			}
			else{
				System.out.println("Remis-Die Spieler waren ebenbürtige Gegner");
			}
		}
		

		public static void spielroutine(int x,int y){
			
			undo();
			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);
					dreheSteineUm(x,y);
					zähler++;
					sucheNachSetzbarenFeldern();
					
			

				}
				
				else{
					spielroutine(x,y);
				}
			
			
			zug.setText("Spielzug: "+(zähler+1));
			spielerdran.setText(zähler%2==0?"Spieler1 ist am Zug":"Spieler2 ist am Zug");
			steine1.setText("Weisse Steine: "+Spiellogik.zähleWeisseSpielsteine());
			steine2.setText("Schwarze Steine: "+Spiellogik.zähleSchwarzeSpielsteine());
			hintergrundAufGrünSetzen();
			alleLeerenFelderAuf2Setzen();
			sucheNachSetzbarenFeldern();
			
			keineSetzbarenFelder();
			
			
		}
		
		//Parameterlose Spielroutine für KI
		
		public void spielroutine(){
				
			 			int xx=0;
			 			int yy=0;
			 			for(int i=0;i<Höhe;i++){
							for(int j=0;j<Breite;j++){
									if(RevSpielfeldx.SFeld[i][j].getState()==3){
										xx=i;
										yy=j;
										break;
									}
							}		
						}				
										setzeStein(xx,yy,zähler);
										dreheSteineUm(xx,yy);
										try{
										if((gegenComputer)&&(zähler%2==0)){
										
										Thread.sleep(1000);
										}
										}
										catch(Exception e){
										}
										zähler++;
		
		}
		
		
		
		public static 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);
			}
		
		}
		
		public static void undo(){
		
			for(int i=0;i<Höhe;i++){
				for(int j=0;j<Breite;j++){
				UndoFeld[i][j]=SFeld[i][j].getState();
				}
			}
			for(int i=0;i<Höhe;i++){
				for(int j=0;j<Breite;j++){
					if(SFeld[i][j].getState()==3){
						UndoFeld[i][j]=2;
						}
				}
			}
			
		}
		
		public void undo_aufrufen(){
			for(int i=0;i<Höhe;i++){
				for(int j=0;j<Breite;j++){
					int kkk=UndoFeld[i][j];
					
					
						SFeld[i][j].setState(kkk);
						SFeld[i][j].setBackground(Color.GREEN);
					}
				}
			
			zähler--;
			zug.setText("Spielzug: "+(zähler+1));
			spielerdran.setText(zähler%2==0?"Spieler1 ist am Zug":"Spieler2 ist am Zug");
			steine1.setText("Weisse Steine: "+Spiellogik.zähleWeisseSpielsteine());
			steine2.setText("Schwarze Steine: "+Spiellogik.zähleSchwarzeSpielsteine());
			alleLeerenFelderAuf2Setzen();
			
			sucheNachSetzbarenFeldern();
			
		}
		
		public static void speichern(){
			for(int i=0;i<Höhe;i++){
				for(int j=0;j<Breite;j++){
				SpeichernFeld[i][j]=SFeld[i][j].getState();
				}
			}
			for(int i=0;i<Höhe;i++){
				for(int j=0;j<Breite;j++){
					if(SFeld[i][j].getState()==3){
						SpeichernFeld[i][j]=2;
						}
				}
			}
		}
		
		public static void laden(String File){
			try{
			FileInputStream fs=new FileInputStream(File);
			ObjectInputStream is=new ObjectInputStream(fs);
			for(int i=0;i<Höhe;i++){
				for(int j=0;j<Breite;j++){
				int num=is.readInt();
				System.out.println(num);
				SFeld[i][j].setState(num);
				SFeld[i][j].setBackground(Color.GREEN);
				}
			}
			zähler=is.readInt();
			is.close();
			zug.setText("Spielzug: "+(zähler+1));
				spielerdran.setText(zähler%2==0?"Spieler1 ist am Zug":"Spieler2 ist am Zug");
				steine1.setText("Weisse Steine: "+Spiellogik.zähleWeisseSpielsteine());
				steine2.setText("Schwarze Steine: "+Spiellogik.zähleSchwarzeSpielsteine());
				alleLeerenFelderAuf2Setzen();
				sucheNachSetzbarenFeldern();
			
			}catch(IOException e){
			
			
			}
			
			
			
		
		
		}
		
		
				
		
		
	
		
}

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
static 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);
										if((gegenComputer)&&(RevSpielfeldx.zähler%2==1)){
											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);
										if((gegenComputer)&&(RevSpielfeldx.zähler%2==1)){
											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);
										if((gegenComputer)&&(RevSpielfeldx.zähler%2==1)){
											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);
										if((gegenComputer)&&(RevSpielfeldx.zähler%2==1)){
											
											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){
							if((i-1>=0)&&(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 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);
											if((gegenComputer)&&(RevSpielfeldx.zähler%2==1)){
											xKoordinate=i;
											yKoordinate=j;
										}
											break;
										}
									}
							
									//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);
											if((gegenComputer)&&(RevSpielfeldx.zähler%2==1)){
											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);
											if((gegenComputer)&&(RevSpielfeldx.zähler%2==1)){
											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);
										if((gegenComputer)&&(RevSpielfeldx.zähler%2==1)){
											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 dreheSteineUmNachUnten(int x,int y,int gegnerischerStein,int eigenerStein){
			//Nach unten bedeutet x+1 und y bleibt gleich
			
			if((x+2<Höhe)&&(RevSpielfeldx.SFeld[x+1][y].getState()==gegnerischerStein)){
				int bisX=x+1;
				//System.out.println(bisX);
				for(int i=bisX+1;i<Höhe;i++){
					if(RevSpielfeldx.SFeld[i][y].getState()==eigenerStein){
						for(int j=i-1;j>=bisX;j--){
							RevSpielfeldx.SFeld[j][y].setState(eigenerStein);
						}
					return;
					}	
					else if(RevSpielfeldx.SFeld[i][y].getState()==2){
					return;
					}
							
				
				}
			}
		}
		
		public static void dreheSteineUmNachOben(int x,int y,int gegnerischerStein,int eigenerStein){
			//Nach unten bedeutet x-1 und y bleibt gleich
			
			if((x-2>=0)&&(RevSpielfeldx.SFeld[x-1][y].getState()==gegnerischerStein)){
				int bisX=x-1;
				//System.out.println(bisX);
				for(int i=bisX-1;i>=0;i--){
					if(RevSpielfeldx.SFeld[i][y].getState()==eigenerStein){
						for(int j=i+1;j<=bisX;j++){
							RevSpielfeldx.SFeld[j][y].setState(eigenerStein);
						}
					return;
					}	
					else if(RevSpielfeldx.SFeld[i][y].getState()==2){
					return;
					}
							
				
				}
			}
		
		}
		public static void dreheSteineUmNachRechts(int x,int y,int gegnerischerStein,int eigenerStein){
		
		//Nach rechts bedeutet x bleibt gleich und y+1
			
			if((y+2<Breite)&&(RevSpielfeldx.SFeld[x][y+1].getState()==gegnerischerStein)){
				int bisY=y+1;
				//System.out.println(bisY);
				for(int i=bisY+1;i<Breite;i++){
					if(RevSpielfeldx.SFeld[x][i].getState()==eigenerStein){
						for(int j=i-1;j>=bisY;j--){
							RevSpielfeldx.SFeld[x][j].setState(eigenerStein);
						}
					i=Breite;
					}	
					else if(RevSpielfeldx.SFeld[x][i].getState()==2){
					i=Breite;
					}
							
				
				}
			}
			
		}
		public static void dreheSteineUmNachLinks(int x,int y,int gegnerischerStein,int eigenerStein){
			//Nach links bedeutet x bleibt gleich und y-1
			
			if((y-2>=0)&&(RevSpielfeldx.SFeld[x][y-1].getState()==gegnerischerStein)){
				int bisY=y-1;
				//System.out.println(bisY);
				for(int i=bisY-1;i>=0;i--){
					if(RevSpielfeldx.SFeld[x][i].getState()==eigenerStein){
						for(int j=i+1;j<=bisY;j++){
							RevSpielfeldx.SFeld[x][j].setState(eigenerStein);
						}
					i=-1;
					}	
					else if(RevSpielfeldx.SFeld[x][i].getState()==2){
					i=-1;
					}
							
				
				}
			}
		}
		
		public static void dreheSteineUmNachLinksOben(int x,int y,int gegnerischerStein,int eigenerStein){
			
			//Nach linksoben bedeutet x-1 und y-1
			
			if((x-2>=0)&&(y-2>=0)&&(RevSpielfeldx.SFeld[x-1][y-1].getState()==gegnerischerStein)){
				int bisX=x-1;
				int bisY=y-1;
				//System.out.println(bisX);
				//System.out.println(bisY);
				int laufvariableX=bisX-1;
				for(int laufvariableX2=laufvariableX,i=bisY-1;laufvariableX2>=0&&i>=0;laufvariableX2--,i--){
					if((laufvariableX2>=0)&&(RevSpielfeldx.SFeld[laufvariableX2][i].getState()==eigenerStein)){
						//System.out.println("Eigener Stein gefunden");
						//System.out.println(laufvariableX2);
						//System.out.println(i);
						
						for(int i2=laufvariableX2+1,j=i+1;i2<=bisX&&j<=bisY;i2++,j++){
							RevSpielfeldx.SFeld[i2][j].setState(eigenerStein);
							
						}
					i=-1;
					}	
					else if(RevSpielfeldx.SFeld[laufvariableX2][i].getState()==2){
					i=-1;
					}
					
					
				
				}
			}
			
						
		}
		
		public static void dreheSteineUmNachLinksUnten(int x,int y,int gegnerischerStein,int eigenerStein){
			//Nach linksunten bedeutet x+1 und y-1
			
			if((x+2<Höhe)&&(y-2>=0)&&(RevSpielfeldx.SFeld[x+1][y-1].getState()==gegnerischerStein)){
				int bisX=x+1;
				int bisY=y-1;
				//System.out.println(bisX);
				//System.out.println(bisY);
				int laufvariableX=bisX+1;
				for(int laufvariableX2=laufvariableX,i=bisY-1;laufvariableX2<Höhe&&i>=0;laufvariableX2++,i--){
					if((laufvariableX2<Höhe)&&(i>=0)&&(RevSpielfeldx.SFeld[laufvariableX2][i].getState()==eigenerStein)){
						//System.out.println("Eigener Stein gefunden");
						//System.out.println(laufvariableX2);
						//System.out.println(i);
						//System.out.println("--------------");
						for(int i2=laufvariableX2-1,j=i+1;i2>=bisX&&j<=bisY;i2--,j++){
							RevSpielfeldx.SFeld[i2][j].setState(eigenerStein);
							
						}
					i=-1;
					}	
					else if((laufvariableX2<Höhe)&&(RevSpielfeldx.SFeld[laufvariableX2][i].getState()==2)){
					i=-1;
					}
					
					
				
				}
			}
			
			
		
		}
		
		public static void dreheSteineUmNachRechtsOben(int x,int y,int gegnerischerStein,int eigenerStein){
			//Nach rechtsoben bedeutet x-1 und y+1
			
			if((x-2>=0)&&(y+2<Breite)&&(RevSpielfeldx.SFeld[x-1][y+1].getState()==gegnerischerStein)){
				int bisX=x-1;
				int bisY=y+1;
				//System.out.println("Rechtsoben");
				//System.out.println(bisX);
				//System.out.println(bisY);
				int laufvariableX=bisX-1;
				for(int laufvariableX2=laufvariableX,i=bisY+1;laufvariableX2>=0&&i<Breite;laufvariableX2--,i++){
					if((laufvariableX2>=0)&&(RevSpielfeldx.SFeld[laufvariableX2][i].getState()==eigenerStein)){
						//System.out.println("Eigener Stein gefunden");
						//System.out.println(laufvariableX2);
						//System.out.println(i);
						
						for(int i2=laufvariableX2+1,j=i-1;i2<=bisX&&j>=bisY;i2++,j--){
							RevSpielfeldx.SFeld[i2][j].setState(eigenerStein);
							
						}
					return;
					}	
					else if(RevSpielfeldx.SFeld[laufvariableX2][i].getState()==2){
					return;
					}
					
					
				
				}
			}
			
			
		
		}
		
		public static void dreheSteineUmNachRechtsUnten(int x,int y,int gegnerischerStein,int eigenerStein){
			//Nach rechtsunten bedeutet x+1 und y+1
			
			if((x+2<Höhe)&&(y+2<Breite)&&(RevSpielfeldx.SFeld[x+1][y+1].getState()==gegnerischerStein)){
				int bisX=x+1;
				int bisY=y+1;
				System.out.println("Rechtsunten");
				//System.out.println(bisX);
				//System.out.println(bisY);
				int laufvariableX=bisX+1;
				for(int laufvariableX2=laufvariableX,i=bisY+1;laufvariableX2<Höhe&&i<Breite;laufvariableX2++,i++){
					if((laufvariableX2>=0)&&(RevSpielfeldx.SFeld[laufvariableX2][i].getState()==eigenerStein)){
						//System.out.println("Eigener Stein gefunden");
						//System.out.println(laufvariableX2);
						//System.out.println(i);
						
						for(int i2=laufvariableX2-1,j=i-1;i2>=bisX&&j>=bisY;i2--,j--){
							RevSpielfeldx.SFeld[i2][j].setState(eigenerStein);
							
						}
					return;
					}	
					else if(RevSpielfeldx.SFeld[laufvariableX2][i].getState()==2){
					return;
					}
					
					
				
				}
			}
			
			
		}	
	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;
	
	
	}
		
}

Gruß

Gaston

L-ectron-X hat erst mal den Titel angepasst.

 

[messi]

Trenne dich zuerst einmal von all den "static"s.

 

[timomeinen]

mann merkt dass ich wenig erfharung habe

Ich schlage vor du suchst dir bessere Titel für den Thread aus, konkretisierst deine Frage und gibst nur den nötigen Codeteil an. Das ist ja unlesbar so.

 

[Gaston]

Kann ich nicht weil diese Variablen auch von anderen Programmteilen benutzt werden sprich anderen Klassen. Und damit die anderen Klassen auf diese zugreifen können, müssen die static sein. oder irre ich mich hier?

 

[Gaston]

zu timomeinen: meine frage bezieht sich in der regekl darauf wie ich es schafefn soll, dass bei jeder Neuinstanzierung von RevSpielfeldx() eine neue Instanz von Spiellogik() aufgerufen werden soll, und während des Programmablaufs soll jede RevSpielfeldx() mit "ihrer" eigenen Spiellogik() Instanz kommunizieren können. Bei RevSpielfeldx() und Spiellogik() handelt es sich um Klassen.

 

[Sky]

Kann ich nicht weil diese Variablen auch von anderen Programmteilen benutzt werden sprich anderen Klassen. Und damit die anderen Klassen auf diese zugreifen können, müssen die static sein. oder irre ich mich hier?

Normalerweise sind solche Variablen private und haben entsprechende getter (und bei Bedarf setter)-Methoden

 

[Gaston]

ja sky80 das ist die elgeantere variante, aber kann das dann mein problem lösen?

 

[Wildcard]

ja sky80 das ist die elgeantere variante, aber kann das dann mein problem lösen?

Ja, denn das static ist dein Problem.
Ich kann dir nur den Tipp geben das Wörtchen "static" komplett aus deinem Wortschatz zu streichen bis du mehr Erfahrung mit OOP gesammelt hast. Du wirst sonst immer wieder über solche Probleme stolpern.

 

[messi]

Kann ich nicht weil diese Variablen auch von anderen Programmteilen benutzt werden sprich anderen Klassen. Und damit die anderen Klassen auf diese zugreifen können, müssen die static sein. oder irre ich mich hier?

Einerseits sagst du, daß du keine Erfahrung hast, und andererseits läßt du dich trotzdem nicht belehren.
Ich sag's nochmal: Trenne dich von all den "static"s bei den Objekt-Eigenschaften und dann auch bei all den statischen Methoden, die dann auf nicht-statische Eigenschaften zugreifen.

Das ist sehr simpel ausgedrückt. Besser ist, du schaust nochmal ins Buch zum Thema "static".

 

[Gaston]

Also ich mache jetzt die static raus und melde mich dann wieder

 

[Gaston]

jetzt hat sich in dem zusammenhand mit dem abschaffen der static methoden ein neues problem ergben. ich habe in RevSpielfeldx.java eine public Methode die einfach die Höhe ausgibt. Nun möchte ich aber aus dieser Methode aus Spiellogik mit RevSpielfeldx.gebeHöheAus() zugreifen. Das geht nicht da diese nicht mehr static ist. Laut Krüger kann man auf ne public Methode aus ner anderen Klasse zugreifen kann, solange sie in dem selben Paket sind, was hier der Fall ist. Also wie kann ich diese public methode zugreifen?

 

[Wildcard]

In dem du eine Referenz auf das Objekt mit der entsprechenden Methode benutzt.

 

[Gaston]

habe ich : in in RevSpielfeldx eine public variable Zähler und eine public Methode gebeZählerAus(). Und in der Spiellogik Klasse habe ich: public int zähler = RevSpielfeldx.gebeZählerAus() und das klappt nicht obwohl es meiner Meinung nach klappen sollte- Bitte um einen Tipp

 

[messi]

habe ich : in in RevSpielfeldx eine public variable Zähler und eine public Methode gebeZählerAus(). Und in der Spiellogik Klasse habe ich: public int zähler = RevSpielfeldx.gebeZählerAus() und das klappt nicht obwohl es meiner Meinung nach klappen sollte- Bitte um einen Tipp

gebeZählerAus() ist jetzt (richtigerweise) eine Objekt-Methode und kann auch nur so benutzt werden:

RevSpielfeldx feld = new RevSpielfeldx();

zähler = feld.gebeZählerAus();

 

[Gaston]

oh super danke

 

[bygones]

wähle bitte einen besseren Titel für deine Threads... sowas ist einfach unsinnig !!

 

[L-ectron-X]

Genau! Ich war dann mal so frei. Warum macht das eigentlich nicht auch mal anderer Mod? Bin ich hier der Thread-Umbenenner? :?