AWT Mühlespiel funktioniert... Neustartproblem

Status
Nicht offen für weitere Antworten.

Nachbar

Mitglied
hallo leutz,

wir haben es geschafft eine Offlinevariante des Brettspiels Mühle zu proggen...nun sollen wir es noch hier und da verfeinern und ein Onlinespiel (Server-Client) basteln...ich denke mal das bekommen wir hin...

unsere Problem ist derzeit aber, das Spiel neu zu starten ,also innerhalb des Applets.
Was wir haben ist zwar ein Spielneustart ( neues Applet) aber kein Spielabbruch des alten.Ich hoffe das versteht jemand das Problem...wir sind keine Javameister, angehende Lehrer, das wird wohl unsere letztes Projekt sein und danach , so Gott will, unterrichten wir Struktogramme und eventuell lassen wir mal nen Progrämmchen proggen zur Berechnung der Fakultät....

man wird wohl den Spielzustand auf Null oder Anfang setzen müssen...die Methode initialisieren sorgt ja dafür...aber halt nur für den start eines neuen Spiels und nicht zum start im Spiel ... !!!????

hier der Code der Klasse Mühle:
Java:
import java.awt.BorderLayout;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.util.Random;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JPanel;

public class Mühle extends MouseAdapter implements ActionListener {
	
	int Pos1;
	int Pos2;
	
	int AktSpieler;
	String[] SpielZustand;
	int[] SteineAufBrett;
	int[] SteineImPool;
	
	String Regel;
	boolean SpielBeendet;
	boolean SpielGestartet;
	boolean weiter;
	
	static JFrame f;
	static Spielbrett SB;
	static Steinpool SP;
	static JPanel pnlMain;
	static JPanel pnlLinks;
	static JPanel pnlRechts;
	static JLabel lPlayer;
	static JLabel lAktion;
	static JMenuBar MB;
	static JMenu MSpiel;
	static JMenu MOptionen;
	static JMenuItem MINeu;
	static JMenuItem MIExit;
	
	public Mühle(){
		while(true){	
			initialisieren();
			berechneZustand();
			while(SpielBeendet==false){
				if(weiter==true){
					berechneZustand();
					RegelnPrüfen();
					wechsleSpieler();
					weiter=false;
				}
				f.repaint();
				f.pack();
			}
			if(SpielBeendet==true)break;
		}
	}
	
	public void initialisieren(){
		Pos1=26;
		Pos2=26;
		Regel="keine";
		SpielGestartet=true;
		weiter=false;
		SpielZustand=new String[3];
		SteineAufBrett=new int[3];
		SteineImPool=new int[3];
		
		SB=new Spielbrett(300,300);
		SP=new Steinpool(300,100);
		
		lPlayer=new JLabel("",0);
		lAktion=new JLabel("",0);
		MB=new JMenuBar();
		MSpiel=new JMenu("Spiel");
		MOptionen=new JMenu("Optionen");
		MINeu=new JMenuItem("Neues Spiel");
		MIExit=new JMenuItem("Spiel Beenden");
		MSpiel.add(MINeu);
		MSpiel.add(MIExit);
		MB.add(MSpiel);
		MB.add(MOptionen);
		MIExit.addActionListener(this);
		MINeu.addActionListener(this);
		
		Random rnd=new Random();
		
		AktSpieler=rnd.nextInt(2)+1;
		if(AktSpieler==1){
			SpielZustand[1]="SteineSetzen";
			SpielZustand[2]="SteineSetzen";
			SpielBeendet=false;
			lPlayer.setText("Spieler 1 ist dran.");
			SteineAufBrett[1]=0;
			SteineImPool[1]=9;
			SteineAufBrett[2]=0;
			SteineImPool[2]=9;
			SB.Spieler=1;
			lAktion.setText(SpielZustand[1]);
		}
		else{
			SpielZustand[2]="SteineSetzen";
			SpielZustand[1]="SteineSetzen";
			SpielBeendet=false;
			lPlayer.setText("Spieler 2 ist dran.");
			SteineAufBrett[2]=0;
			SteineImPool[2]=9;
			SteineAufBrett[1]=0;
			SteineImPool[1]=9;
			SB.Spieler=2;
			lAktion.setText(SpielZustand[2]);
		}
		f=new JFrame();
		f.addWindowListener(new WindowAdapter(){

			@Override
			public void windowClosing(WindowEvent arg0) {
				System.exit(0);	
			}
		});
		pnlMain=new JPanel();
		pnlLinks=new JPanel();
		pnlRechts=new JPanel();
		
		pnlMain.setLayout(new BorderLayout());
		pnlLinks.setLayout(new BorderLayout());
		pnlRechts.setLayout(new GridLayout(2,0));
		
		SB.addMouseListener(this);
		pnlLinks.add("North",SB);
		pnlLinks.add("South",SP);
		
		pnlRechts.add(lPlayer);
		pnlRechts.add(lAktion);
		
		pnlMain.add("Center",pnlLinks);
		pnlMain.add("East",pnlRechts);
		pnlMain.add("North",MB);
		
		f.add(pnlMain);
		f.pack();
		f.setVisible(true);
	}
	public void berechneZustand(){
		if(SteineImPool[AktSpieler]==0){
			if(SteineAufBrett[AktSpieler]>3){
				SpielZustand[AktSpieler]="SteineSchieben";
				if(!SB.kannNochBewegen(AktSpieler)){
					SpielZustand[AktSpieler]="verloren";
				}
			}
			else if(SteineAufBrett[AktSpieler]==3){
				SpielZustand[AktSpieler]="SteineSpringen";
			}
			else{
				SpielZustand[AktSpieler]="verloren";
			}
		}
		else if(SteineImPool[AktSpieler]>0){
			
			SpielZustand[AktSpieler]="SteineSetzen";
		}
		
		if(SteineImPool[AndererSpieler()]==0){
			if(SteineAufBrett[AndererSpieler()]>3){
				SpielZustand[AndererSpieler()]="SteineSchieben";
				if(!SB.kannNochBewegen(AndererSpieler())){
					SpielZustand[AndererSpieler()]="verloren";
				}
			}
			else if(SteineAufBrett[AndererSpieler()]==3){
				SpielZustand[AndererSpieler()]="SteineSpringen";
			}
			else{
				SpielZustand[AndererSpieler()]="verloren";
			}
		}
		else if(SteineImPool[AndererSpieler()]>0){
			
			SpielZustand[AndererSpieler()]="SteineSetzen";
		}
	}
	public void RegelnPrüfen(){	
	}
	public void wechsleSpieler(){
		if(AktSpieler==1){
			AktSpieler=2;
			SB.Spieler=2;
			lPlayer.setText("Schwarz ist am Zug");
			lAktion.setText(SpielZustand[2]);
		}
		else{
			AktSpieler=1;
			SB.Spieler=1;
			lPlayer.setText("Weiss ist am Zug.");
			lAktion.setText(SpielZustand[1]);
		}
	}
	public int andererSpieler(){
		if(AktSpieler==1)return 2;
		else return 1;
	}
	public static void main(String[] args) {
		@SuppressWarnings("unused")
		Mühle m=new Mühle();
	}
	@Override
	public void mouseClicked(MouseEvent m) {
		if(SpielGestartet){
			if(SpielZustand[AktSpieler].equals("SteineSetzen")){
				if(SB.getBelegung(SB.AufWelcherPos(m.getX(), m.getY())).equals("frei")){
					SB.SteinSetzen(SB.AufWelcherPos(m.getX(), m.getY()));
					if(AktSpieler==1)SP.entnehme("weiß");
					else SP.entnehme("schwarz");
					SteineAufBrett[AktSpieler]+=1;
					SteineImPool[AktSpieler]-=1;
					if(SB.mühleGebildet(AktSpieler,SB.AufWelcherPos(m.getX(), m.getY()))){
						Regel="MühleGebaut";
					}
					else weiter=true;
				}
			}
			else if(SpielZustand[AktSpieler].equals("SteineSchieben")){
				String Farbe="weiß";
				if(AktSpieler==2)Farbe="schwarz";
				if(Pos1>23){
					if(SB.getBelegung(SB.AufWelcherPos(m.getX(), m.getY())).equals(Farbe) && SB.kannSteinBewegen(SB.AufWelcherPos(m.getX(), m.getY()), AktSpieler)){
						Pos1=SB.AufWelcherPos(m.getX(), m.getY());
					}
				}
				else if(Pos2>23){
					
					if(!SB.getBelegung(SB.AufWelcherPos(m.getX(), m.getY())).equals("frei")){
					}
					if(!SB.istNachbarVon(Pos1,Pos2)){
					}
					
					if(SB.getBelegung(SB.AufWelcherPos(m.getX(), m.getY())).equals("frei") && SB.istNachbarVon(Pos1,SB.AufWelcherPos(m.getX(), m.getY()))){
						Pos2=SB.AufWelcherPos(m.getX(), m.getY());
					}
				}
				if(Pos1<=23&Pos2<=23){
					SB.bewege(Pos1,Pos2);
					if(SB.mühleGebildet(AktSpieler,Pos2)){
						Regel="MühleGebaut";
					}
					else weiter=true;
					
					Pos1=26;
					Pos2=26;
				}
			}
			else if(SpielZustand[AktSpieler].equals("SteineSpringen")){
				String Farbe="weiß";
				if(AktSpieler==2)Farbe="schwarz";
				if(Pos1>23){
					if(SB.getBelegung(SB.AufWelcherPos(m.getX(), m.getY())).equals(Farbe)){
						Pos1=SB.AufWelcherPos(m.getX(), m.getY());
					}
				}
				else if(Pos2>23){
					
					if(!SB.getBelegung(SB.AufWelcherPos(m.getX(), m.getY())).equals("frei")){
					}
					
					if(SB.getBelegung(SB.AufWelcherPos(m.getX(), m.getY())).equals("frei")){
						Pos2=SB.AufWelcherPos(m.getX(), m.getY());
					}
				}
				if(Pos1<=23&Pos2<=23){
					SB.bewege(Pos1,Pos2);
					if(SB.mühleGebildet(AktSpieler,Pos2)){
						Regel="MühleGebaut";
					}
					else weiter=true;
					
					Pos1=26;
					Pos2=26;
				}
			}
			else if(SpielZustand[AktSpieler].equals("verloren")){	
			}
			if(Regel.equals("MühleGebaut")){
				SpielZustand[AktSpieler]="";
				String Farbe="";
				if(AktSpieler==1)Farbe="schwarz";
				else Farbe="weiß";
				lAktion.setText("MÜHLE!!! Lösche einen Stein!");
				f.repaint();
				f.pack();
					if(SB.getBelegung(SB.AufWelcherPos(m.getX(), m.getY())).equals(Farbe)&& !SB.mühleGebildet(andererSpieler(), SB.AufWelcherPos(m.getX(), m.getY()))){
						
						SB.SteinLöschen(SB.AufWelcherPos(m.getX(), m.getY()));
						SteineAufBrett[andererSpieler()]-=1;
						Regel="";
						weiter=true;
						berechneZustand();
					}
					else if(SB.getBelegung(SB.AufWelcherPos(m.getX(), m.getY())).equals(Farbe)&& SB.alleInMühle(andererSpieler())){
						SB.SteinLöschen(SB.AufWelcherPos(m.getX(), m.getY()));
						SteineAufBrett[andererSpieler()]-=1;
						Regel="";
						weiter=true;
						berechneZustand();
					}
			}
		}
			if(Regel.equals("verloren")){	
			}
		SB.repaint();
		SP.repaint();
	}
	public int AndererSpieler(){
		if(AktSpieler==1)return 2;
		return 1;
	}
	@Override
	public void mousePressed(MouseEvent arg0) {}
	@Override
	public void mouseReleased(MouseEvent arg0) {}
	public void mouseEntered(MouseEvent e) {}
	public void mouseExited(MouseEvent e) {}
	@Override
	public void actionPerformed(ActionEvent a) {
		Object obj=a.getSource();
		if(obj==MIExit){
			System.exit(0);
		}
		if(obj==MINeu){
			initialisieren(); //hier wird wohl der Hund begraben sein 
		}
	}
}
 
Versuch'a mal so:
Java:
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import javax.swing.*;

public class Muehle extends MouseAdapter implements ActionListener {

    private int pos1, pos2;
    private int aktSpieler;
    private String[] spielZustand;
    private int[] steineAufBrett, steineImPool;
    private String regel;
    private boolean spielGestartet;
    private final JFrame frame;
    private final Spielbrett brett;
    private final Steinpool pool;
    private final JPanel pnlMain, pnlLinks, pnlRechts;
    private final JLabel lPlayer, lAktion;
    private final JMenuBar menubar;
    private final JMenu mSpiel, mOptionen;
    private final JMenuItem miNeu, miExit;

    public Muehle() {
        frame = new JFrame("Mühle");
        frame.addWindowListener(new WindowAdapter() {

            @Override
            public void windowClosing(WindowEvent arg0) {
                System.exit(0);
            }
        });
        brett = new Spielbrett(300, 300);
        pool = new Steinpool(300, 100);
        lPlayer = new JLabel("", 0);
        lAktion = new JLabel("", 0);
        menubar = new JMenuBar();
        mSpiel = new JMenu("Spiel");
        mOptionen = new JMenu("Optionen");
        miNeu = new JMenuItem("Neues Spiel");
        miExit = new JMenuItem("Spiel Beenden");
        mSpiel.add(miNeu);
        mSpiel.add(miExit);
        menubar.add(mSpiel);
        menubar.add(mOptionen);
        miExit.addActionListener(this);
        miNeu.addActionListener(this);
        pnlMain = new JPanel(new BorderLayout());
        pnlLinks = new JPanel(new BorderLayout());
        pnlRechts = new JPanel(new GridLayout(0, 1));
        brett.addMouseListener(this);
        pnlLinks.add(brett, BorderLayout.NORTH);
        pnlLinks.add(pool, BorderLayout.SOUTH);
        pnlRechts.add(lPlayer);
        pnlRechts.add(lAktion);
        pnlMain.add(pnlLinks, BorderLayout.WEST);
        pnlMain.add(pnlRechts, BorderLayout.EAST);
        pnlRechts.setPreferredSize(new Dimension(200, 0));
        frame.add(pnlMain);
        frame.setJMenuBar(menubar);
        frame.pack();
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
        initialisieren();
    }

    public void initialisieren() {
        pos1 = 26;
        pos2 = 26;
        regel = "keine";
        spielGestartet = true;
        spielZustand = new String[3];
        steineAufBrett = new int[3];
        steineImPool = new int[3];
        Random rnd = new Random();
        aktSpieler = rnd.nextInt(2) + 1;
        if (aktSpieler == 1) {
            spielZustand[1] = "SteineSetzen";
            spielZustand[2] = "SteineSetzen";
            lPlayer.setText("Spieler 1 ist dran.");
            steineAufBrett[1] = 0;
            steineImPool[1] = 9;
            steineAufBrett[2] = 0;
            steineImPool[2] = 9;
            brett.spieler = 1;
            lAktion.setText(spielZustand[1]);
        } else {
            spielZustand[2] = "SteineSetzen";
            spielZustand[1] = "SteineSetzen";
            lPlayer.setText("Spieler 2 ist dran.");
            steineAufBrett[2] = 0;
            steineImPool[2] = 9;
            steineAufBrett[1] = 0;
            steineImPool[1] = 9;
            brett.spieler = 2;
            lAktion.setText(spielZustand[2]);
        }
    }

    public void berechneZustand() {
        if (steineImPool[aktSpieler] == 0) {
            if (steineAufBrett[aktSpieler] > 3) {
                spielZustand[aktSpieler] = "SteineSchieben";
                if (!brett.kannNochBewegen(aktSpieler)) {
                    spielZustand[aktSpieler] = "verloren";
                }
            } else if (steineAufBrett[aktSpieler] == 3) {
                spielZustand[aktSpieler] = "SteineSpringen";
            } else {
                spielZustand[aktSpieler] = "verloren";
            }
        } else if (steineImPool[aktSpieler] > 0) {
            spielZustand[aktSpieler] = "SteineSetzen";
        }
        if (steineImPool[andererSpieler()] == 0) {
            if (steineAufBrett[andererSpieler()] > 3) {
                spielZustand[andererSpieler()] = "SteineSchieben";
                if (!brett.kannNochBewegen(andererSpieler())) {
                    spielZustand[andererSpieler()] = "verloren";
                }
            } else if (steineAufBrett[andererSpieler()] == 3) {
                spielZustand[andererSpieler()] = "SteineSpringen";
            } else {
                spielZustand[andererSpieler()] = "verloren";
            }
        } else if (steineImPool[andererSpieler()] > 0) {
            spielZustand[andererSpieler()] = "SteineSetzen";
        }
    }

    public void regelnPrüfen() {
    }

    public void wechsleSpieler() {
        if (aktSpieler == 1) {
            aktSpieler = 2;
            brett.spieler = 2;
            lPlayer.setText("Schwarz ist am Zug");
            lAktion.setText(spielZustand[2]);
        } else {
            aktSpieler = 1;
            brett.spieler = 1;
            lPlayer.setText("Weiss ist am Zug.");
            lAktion.setText(spielZustand[1]);
        }
    }

    @Override
    public void mouseClicked(final MouseEvent m) {
        if (spielGestartet) {
            if (spielZustand[aktSpieler].equals("SteineSetzen")) {
                if (brett.getBelegung(brett.aufWelcherPos(m.getX(), m.getY())).equals("frei")) {
                    brett.steinSetzen(brett.aufWelcherPos(m.getX(), m.getY()));
                    if (aktSpieler == 1) {
                        pool.entnehme("weiß");
                    } else {
                        pool.entnehme("schwarz");
                    }
                    steineAufBrett[aktSpieler] += 1;
                    steineImPool[aktSpieler] -= 1;
                    if (brett.mühleGebildet(aktSpieler, brett.aufWelcherPos(m.getX(), m.getY()))) {
                        regel = "MühleGebaut";
                    }
                }
            } else if (spielZustand[aktSpieler].equals("SteineSchieben")) {
                String Farbe = "weiß";
                if (aktSpieler == 2) {
                    Farbe = "schwarz";
                }
                if (pos1 > 23) {
                    if (brett.getBelegung(brett.aufWelcherPos(m.getX(), m.getY())).equals(Farbe) && brett.kannSteinBewegen(brett.aufWelcherPos(m.getX(), m.getY()), aktSpieler)) {
                        pos1 = brett.aufWelcherPos(m.getX(), m.getY());
                    }
                } else if (pos2 > 23) {
                    if (!brett.getBelegung(brett.aufWelcherPos(m.getX(), m.getY())).equals("frei")) {
                    }
                    if (!brett.istNachbarVon(pos1, pos2)) {
                    }
                    if (brett.getBelegung(brett.aufWelcherPos(m.getX(), m.getY())).equals("frei") && brett.istNachbarVon(pos1, brett.aufWelcherPos(m.getX(), m.getY()))) {
                        pos2 = brett.aufWelcherPos(m.getX(), m.getY());
                    }
                }
                if (pos1 <= 23 & pos2 <= 23) {
                    brett.bewege(pos1, pos2);
                    if (brett.mühleGebildet(aktSpieler, pos2)) {
                        regel = "MühleGebaut";
                    }
                    pos1 = 26;
                    pos2 = 26;
                }
            } else if (spielZustand[aktSpieler].equals("SteineSpringen")) {
                String Farbe = "weiß";
                if (aktSpieler == 2) {
                    Farbe = "schwarz";
                }
                if (pos1 > 23) {
                    if (brett.getBelegung(brett.aufWelcherPos(m.getX(), m.getY())).equals(Farbe)) {
                        pos1 = brett.aufWelcherPos(m.getX(), m.getY());
                    }
                } else if (pos2 > 23) {
                    if (!brett.getBelegung(brett.aufWelcherPos(m.getX(), m.getY())).equals("frei")) {
                    }
                    if (brett.getBelegung(brett.aufWelcherPos(m.getX(), m.getY())).equals("frei")) {
                        pos2 = brett.aufWelcherPos(m.getX(), m.getY());
                    }
                }
                if (pos1 <= 23 & pos2 <= 23) {
                    brett.bewege(pos1, pos2);
                    if (brett.mühleGebildet(aktSpieler, pos2)) {
                        regel = "MühleGebaut";
                    }
                    pos1 = 26;
                    pos2 = 26;
                }
            } else if (spielZustand[aktSpieler].equals("verloren")) {
            }
            if (regel.equals("MühleGebaut")) {
                spielZustand[aktSpieler] = "";
                String Farbe = "";
                if (aktSpieler == 1) {
                    Farbe = "schwarz";
                } else {
                    Farbe = "weiß";
                }
                lAktion.setText("MÜHLE!!! Lösche einen Stein!");
                if (brett.getBelegung(brett.aufWelcherPos(m.getX(), m.getY())).equals(Farbe) && !brett.mühleGebildet(andererSpieler(), brett.aufWelcherPos(m.getX(), m.getY()))) {
                    brett.steinLöschen(brett.aufWelcherPos(m.getX(), m.getY()));
                    steineAufBrett[andererSpieler()] -= 1;
                    regel = "";
                    berechneZustand();
                } else if (brett.getBelegung(brett.aufWelcherPos(m.getX(), m.getY())).equals(Farbe) && brett.alleInMühle(andererSpieler())) {
                    brett.steinLöschen(brett.aufWelcherPos(m.getX(), m.getY()));
                    steineAufBrett[andererSpieler()] -= 1;
                    regel = "";
                    berechneZustand();
                }
            }
        }
        if (regel.equals("verloren")) {
        }
        brett.repaint();
        pool.repaint();
    }

    public int andererSpieler() {
        if (aktSpieler == 1) {
            return 2;
        } else {
            return 1;
        }
    }

    @Override
    public void mousePressed(final MouseEvent m) {
    }

    @Override
    public void mouseReleased(final MouseEvent m) {
    }

    @Override
    public void mouseEntered(final MouseEvent m) {
    }

    @Override
    public void mouseExited(final MouseEvent m) {
    }

    @Override
    public void actionPerformed(final ActionEvent a) {
        Object obj = a.getSource();
        if (obj == miExit) {
            System.exit(0);
        }
        if (obj == miNeu) {
            initialisieren(); //hier wird wohl der Hund begraben sein
        }
    }

    public static void main(final String[] args) {
        Runnable gui = new Runnable() {

            @Override
            public void run() {
                new Muehle();
            }
        };
        //GUI must start on EventDispatchThread:
        SwingUtilities.invokeLater(gui);
    }
}

class Spielbrett extends JPanel {

    protected int spieler;

    public Spielbrett(final int w, final int h) {
        setBorder(BorderFactory.createLineBorder(Color.BLACK));
        setPreferredSize(new Dimension(w, h));
    }

    public boolean kannNochBewegen(final int aktSpieler) {
        return true;
    }

    public int aufWelcherPos(final int x, final int y) {
        return 0;
    }

    public String getBelegung(final int aufWelcherPos) {
        return "frei";
    }

    public void steinSetzen(final int aufWelcherPos) {
    }

    public boolean mühleGebildet(final int aktSpieler, final int aufWelcherPos) {
        return true;
    }

    public boolean kannSteinBewegen(final int aufWelcherPos, final int aktSpieler) {
        return true;
    }

    public boolean istNachbarVon(final int pos1, final int pos2) {
        return true;
    }

    public void bewege(final int pos1, final int pos2) {
    }

    public void steinLöschen(final int aufWelcherPos) {
    }

    public boolean alleInMühle(final int andererSpieler) {
        return true;
    }
}

class Steinpool extends JPanel {

    public Steinpool(final int w, final int h) {
        setBorder(BorderFactory.createLineBorder(Color.BLACK));
        setPreferredSize(new Dimension(w, h));
    }

    public void entnehme(final String string) {
    }
}
 
ersteinmal riesen dank, für die mühe...ABER

ich hab da jetzt einige Zeit investiert...ich komm da auf keinen grünen zweig...dein code is zweifellos richtig (also startet neu, war ja genau mein problem) die leeren Methoden usw sollte ich ja nur noch ergänzen...hmm...da liegt dann wohl das nächste problem, abgesehen von deinem sauberen Stil, besseren bezeichnern und final variablen usw. liegt es wohl an meiner Unfähigkeit , gerade die methoden mit unseren Berechnungen zu ergänzen..

1. gibt es nicht irgendwas, was man einfach irgendwo hinschreibt, damit es neu startet, ohne Mühle, Spielbrett und Steinpool zu verändern

2. ich poste mal mein spielbrett und mein steinpool...meine vermutung ist ähm, ein krasse verwechlung vom aktspieler und spieler , d.h. es findet kein spielerwechsel statt und normalerweise sollte das ja funktionieren, die methoden mit unseren "berechnungen" zu ergänzen, und dann Neustarten zu können, das funzt leider auch nich...es kann nur daran liegen, wie oben erwähnt, das ich den überblick verliere, wenn ich die methoden anpassen möchte

Java:
import java.awt.Dimension;
import java.util.ArrayList;

public class Spielbrett extends BilderPanel{
	
	private static final long serialVersionUID = 2711657626614164167L;

	int Spieler;
	boolean beendet;
	int Abstand;
	
	Dimension[] Positionen;
	String[] Belegungen;
	
	
	public Spielbrett(int width,int height){
		super();
		preferredWidth=width;
		preferredHeight=height;
		Spieler=1;
		beendet=false;
		Abstand=17;
		Bilder=new ArrayList<Bild>();
		
		Bilder.add(new Bild("pics/Brett3.png",0,0));
		
		Positionen=new Dimension[24];
		Belegungen=new String[24];
		
		Positionen[0]=new Dimension(30,30);
		Positionen[1]=new Dimension(150,30);
		Positionen[2]=new Dimension(270,30);
		//zweite Zeile
		Positionen[3]=new Dimension(60,60);
		Positionen[4]=new Dimension(150,60);
		Positionen[5]=new Dimension(240,60);
		//dritte Zeile
		Positionen[6]=new Dimension(90,90);
		Positionen[7]=new Dimension(150,90);
		Positionen[8]=new Dimension(210,90);
		//Mittlere zeile
		Positionen[9]=new Dimension(30,150);
		Positionen[10]=new Dimension(60,150);
		Positionen[11]=new Dimension(90,150);
		Positionen[12]=new Dimension(210,150);
		Positionen[13]=new Dimension(240,150);
		Positionen[14]=new Dimension(270,150);
		//5.Zeile
		Positionen[15]=new Dimension(90,210);
		Positionen[16]=new Dimension(150,210);
		Positionen[17]=new Dimension(210,210);
		//6.Zeile
		Positionen[18]=new Dimension(60,240);
		Positionen[19]=new Dimension(150,240);
		Positionen[20]=new Dimension(240,240);
		//7.Zeile
		Positionen[21]=new Dimension(30,270);
		Positionen[22]=new Dimension(150,270);
		Positionen[23]=new Dimension(270,270);
		
		for(int n=0;n<24;n++){
			Belegungen[n]="frei";
			Bilder.add(new Bild("pics/SteinLeer.png",(int)Positionen[n].getWidth()-30,(int)Positionen[n].getHeight()-30));
		}
	}
	public boolean kannSteinBewegen(int pos,int Spieler){
		if((pos >= 0) && (pos<24)){
			String Farbe="";
			if(Spieler==1){
				Farbe="weiß";
				}
			else{
				Farbe="schwarz";
				}
			if( Belegungen[pos].equals(Farbe)){
				switch(pos){
					case 0:{if(Belegungen[1].equals("frei")||Belegungen[9].equals("frei")){return true;}break;}
					case 1:{if(Belegungen[0].equals("frei")||Belegungen[2].equals("frei")||Belegungen[4].equals("frei")){return true;}break;}
					case 2:{if(Belegungen[1].equals("frei")||Belegungen[14].equals("frei")){return true;}break;}
					case 3:{if(Belegungen[4].equals("frei")||Belegungen[10].equals("frei")){return true;}break;}
					case 4:{if(Belegungen[1].equals("frei")||Belegungen[5].equals("frei")||Belegungen[3].equals("frei")||Belegungen[7].equals("frei")){return true;}break;}
					case 5:{if(Belegungen[5].equals("frei")||Belegungen[13].equals("frei")){return true;}break;}
					case 6:{if(Belegungen[7].equals("frei")||Belegungen[11].equals("frei")){return true;}break;}
					case 7:{if(Belegungen[6].equals("frei")||Belegungen[8].equals("frei")||Belegungen[4].equals("frei")){return true;}break;}
					case 8:{if(Belegungen[7].equals("frei")||Belegungen[12].equals("frei")){return true;}break;}
					case 9:{if(Belegungen[0].equals("frei")||Belegungen[21].equals("frei")||Belegungen[10].equals("frei")){return true;}break;}
					case 10:{if(Belegungen[9].equals("frei")||Belegungen[3].equals("frei")||Belegungen[18].equals("frei")||Belegungen[11].equals("frei")){return true;}break;}
					case 11:{if(Belegungen[6].equals("frei")||Belegungen[15].equals("frei")||Belegungen[10].equals("frei")){return true;}break;}
					case 12:{if(Belegungen[8].equals("frei")||Belegungen[17].equals("frei")||Belegungen[13].equals("frei")){return true;}break;}
					case 13:{if(Belegungen[5].equals("frei")||Belegungen[20].equals("frei")||Belegungen[14].equals("frei")||Belegungen[12].equals("frei")){return true;}break;}
					case 14:{if(Belegungen[2].equals("frei")||Belegungen[23].equals("frei")||Belegungen[13].equals("frei")){return true;}break;}
					case 15:{if(Belegungen[11].equals("frei")||Belegungen[16].equals("frei")){return true;}break;}
					case 16:{if(Belegungen[15].equals("frei")||Belegungen[17].equals("frei")||Belegungen[19].equals("frei")){return true;}break;}
					case 17:{if(Belegungen[12].equals("frei")||Belegungen[16].equals("frei")){return true;}break;}
					case 18:{if(Belegungen[10].equals("frei")||Belegungen[19].equals("frei")){return true;}break;}
					case 19:{if(Belegungen[18].equals("frei")||Belegungen[20].equals("frei")||Belegungen[16].equals("frei")||Belegungen[22].equals("frei")){return true;}break;}
					case 20:{if(Belegungen[13].equals("frei")||Belegungen[19].equals("frei")){return true;}break;}
					case 21:{if(Belegungen[9].equals("frei")||Belegungen[22].equals("frei")){return true;}break;}
					case 22:{if(Belegungen[21].equals("frei")||Belegungen[19].equals("frei")||Belegungen[23].equals("frei")){return true;}break;}
					case 23:{if(Belegungen[14].equals("frei")||Belegungen[22].equals("frei")){return true;}break;}
				}
			}
		}
		return false;	
	}
	public boolean kannNochBewegen(int Spieler){
		for(int pos=0;pos<24;pos++){
			if(kannSteinBewegen(pos,Spieler)==true)return true;
		}
		return false;
	}
	public boolean istInMühle(int Spieler,int pos){
		return mühleGebildet(Spieler,pos);
	}
	public boolean alleInMühle(int Spieler){
		String Farbe="weiß";
		if(Spieler==2)Farbe="schwarz";
		for(int pos=0;pos<24;pos++){
			if(Belegungen[pos].equals(Farbe)){
				if(!istInMühle(Spieler,pos))return false;
			}
		}
		return true;
	}
	public boolean istNachbarVon(int a, int b){
		switch(a){
		case 0: {if(b==1||b==9){return true;}break;}
		case 1: {if(b==0||b==2||b==4){return true;}break;}
		case 2: {if(b==1||b==14){return true;}break;}
		case 3: {if(b==4||b==10){return true;}break;}
		case 4: {if(b==1||b==3||b==5||b==7){return true;}break;}
		case 5: {if(b==4||b==13){return true;}break;}
		case 6: {if(b==7||b==11){return true;}break;}
		case 7: {if(b==6||b==8||b==4){return true;}break;}
		case 8: {if(b==7||b==12){return true;}break;}
		case 9: {if(b==0||b==21||b==10){return true;}break;}
		case 10: {if(b==9||b==3||b==18||b==11){return true;}break;}
		case 11: {if(b==6||b==15||b==10){return true;}break;}
		case 12: {if(b==8||b==17||b==13){return true;}break;}
		case 13: {if(b==5||b==20||b==12||b==14){return true;}break;}
		case 14: {if(b==2||b==23||b==13){return true;}break;}
		case 15: {if(b==11||b==16){return true;}break;}
		case 16: {if(b==15||b==17||b==19){return true;}break;}
		case 17: {if(b==16||b==12){return true;}break;}
		case 18: {if(b==10||b==19){return true;}break;}
		case 19: {if(b==18||b==20||b==16||b==22){return true;}break;}
		case 20: {if(b==19||b==13){return true;}break;}
		case 21: {if(b==9||b==22){return true;}break;}
		case 22: {if(b==21||b==19||b==23){return true;}break;}
		case 23: {if(b==22||b==14){return true;}break;}
		}
		return false;
	}
	public void SteinSetzen(int pos){
		String Pfad="";
		String Farbe="frei";
		if(Spieler==1){
			Pfad="pics/stein_weiss.png";
			Farbe="weiß";
			}
		else{
			Pfad="pics/stein_schwarz.png";
			Farbe="schwarz";
			}
		if(getBelegung(pos).equals("frei")){
			Bilder.remove(pos+1);
			Bilder.add(pos+1, (new Bild(Pfad,(int)Positionen[pos].getWidth()-15,(int)Positionen[pos].getHeight()-15)));
			Belegungen[pos]=Farbe;
						
			repaint();
		}
		else System.out.println("Das Feld ist belegt!");
		repaint();
	}
	public void SteinLöschen(int pos){
		if(!getBelegung(pos).equals("frei")&& pos<=23){
			Bilder.remove(pos+1);
			Bilder.add(pos+1,new Bild("pics/SteinLeer.png",(int)Positionen[pos].getWidth()-15,(int)Positionen[pos].getHeight()-15));
			Belegungen[pos]="frei";
			repaint();
		}
		else System.out.println("Das Feld ist nicht belegt oder garkein Feld!");
	}
	public int AufWelcherPos(int x,int y){
		for(int i=0;i<24;i++){
			if(x > (Positionen[i].getWidth()-Abstand)&& x <(Positionen[i].getWidth()+Abstand)
					&& y > Positionen[i].getHeight()-Abstand && y <(Positionen[i].getHeight()+Abstand)){
				return i;
			}
		}
		return 26;
	}
	public String getBelegung(int pos){
		if(pos>=0 & pos<=23){
			return Belegungen[pos];
		}
		else return "Feld";
	}
	public void bewege(int von,int nach){
		SteinLöschen(von);
		SteinSetzen(nach);
	}
	public boolean mühleGebildet(int spieler,int pos){
		String Farbe="";
		if(spieler==1){Farbe="weiß";}
		else{Farbe="schwarz";}
		
		switch(pos){
		case 0: {
			if((Belegungen[0].equals(Farbe)&& Belegungen[1].equals(Farbe) && Belegungen[2].equals(Farbe))
					||(Belegungen[0].equals(Farbe)&& Belegungen[9].equals(Farbe) && Belegungen[21].equals(Farbe))){
				return true;
			}
			break;
			}
		case 1: {
			if((Belegungen[1].equals(Farbe)&& Belegungen[0].equals(Farbe) && Belegungen[2].equals(Farbe))
					||(Belegungen[1].equals(Farbe)&& Belegungen[4].equals(Farbe) && Belegungen[7].equals(Farbe))){
				return true;
			}
			break;
			}
		case 2: {
			if((Belegungen[2].equals(Farbe)&& Belegungen[0].equals(Farbe) && Belegungen[1].equals(Farbe))
					||(Belegungen[2].equals(Farbe)&& Belegungen[14].equals(Farbe) && Belegungen[23].equals(Farbe))){
				return true;
			}
			break;
			}
		case 3: {
			if((Belegungen[3].equals(Farbe)&& Belegungen[4].equals(Farbe) && Belegungen[5].equals(Farbe))
					||(Belegungen[3].equals(Farbe)&& Belegungen[10].equals(Farbe) && Belegungen[18].equals(Farbe))){
				return true;
			}
			break;
			}
		case 4: {
			if((Belegungen[4].equals(Farbe)&& Belegungen[3].equals(Farbe) && Belegungen[5].equals(Farbe))
					||(Belegungen[4].equals(Farbe)&& Belegungen[1].equals(Farbe) && Belegungen[7].equals(Farbe))){
				return true;
			}
			break;
			}
		case 5: {
			if((Belegungen[5].equals(Farbe)&& Belegungen[3].equals(Farbe) && Belegungen[4].equals(Farbe))
					||(Belegungen[5].equals(Farbe)&& Belegungen[13].equals(Farbe) && Belegungen[20].equals(Farbe))){
				return true;
			}
			break;
			}
		case 6: {
			if((Belegungen[6].equals(Farbe)&& Belegungen[7].equals(Farbe) && Belegungen[8].equals(Farbe))
					||(Belegungen[6].equals(Farbe)&& Belegungen[11].equals(Farbe) && Belegungen[15].equals(Farbe))){
				return true;
			}
			break;
			}
		case 7: {
			if((Belegungen[7].equals(Farbe)&& Belegungen[6].equals(Farbe) && Belegungen[8].equals(Farbe))
					||(Belegungen[7].equals(Farbe)&& Belegungen[1].equals(Farbe) && Belegungen[4].equals(Farbe))){
				return true;
			}
			break;
			}
		case 8: {
			if((Belegungen[8].equals(Farbe)&& Belegungen[6].equals(Farbe) && Belegungen[7].equals(Farbe))
					||(Belegungen[8].equals(Farbe)&& Belegungen[12].equals(Farbe) && Belegungen[17].equals(Farbe))){
				return true;
			}
			break;
			}
		case 9: {
			if((Belegungen[9].equals(Farbe)&& Belegungen[0].equals(Farbe) && Belegungen[21].equals(Farbe))
					||(Belegungen[9].equals(Farbe)&& Belegungen[10].equals(Farbe) && Belegungen[11].equals(Farbe))){
				return true;
			}
			break;
			}
		case 10: {
			if((Belegungen[10].equals(Farbe)&& Belegungen[9].equals(Farbe) && Belegungen[11].equals(Farbe))
					||(Belegungen[10].equals(Farbe)&& Belegungen[3].equals(Farbe) && Belegungen[18].equals(Farbe))){
				return true;
			}
			break;
			}
		case 11: {
			if((Belegungen[11].equals(Farbe)&& Belegungen[6].equals(Farbe) && Belegungen[15].equals(Farbe))
					||(Belegungen[11].equals(Farbe)&& Belegungen[9].equals(Farbe) && Belegungen[10].equals(Farbe))){
				return true;
			}
			break;
			}
		case 12: {
			if((Belegungen[12].equals(Farbe)&& Belegungen[8].equals(Farbe) && Belegungen[17].equals(Farbe))
					||(Belegungen[12].equals(Farbe)&& Belegungen[13].equals(Farbe) && Belegungen[14].equals(Farbe))){
				return true;
			}
			break;
			}
		case 13: {
			if((Belegungen[13].equals(Farbe)&& Belegungen[5].equals(Farbe) && Belegungen[20].equals(Farbe))
					||(Belegungen[13].equals(Farbe)&& Belegungen[12].equals(Farbe) && Belegungen[14].equals(Farbe))){
				return true;
			}
			break;
			}
		case 14: {
			if((Belegungen[14].equals(Farbe)&& Belegungen[2].equals(Farbe) && Belegungen[23].equals(Farbe))
					||(Belegungen[14].equals(Farbe)&& Belegungen[12].equals(Farbe) && Belegungen[13].equals(Farbe))){
				return true;
			}
			break;
			}
		case 15: {
			if((Belegungen[15].equals(Farbe)&& Belegungen[6].equals(Farbe) && Belegungen[11].equals(Farbe))
					||(Belegungen[15].equals(Farbe)&& Belegungen[16].equals(Farbe) && Belegungen[17].equals(Farbe))){
				return true;
			}
			break;
			}
		case 16: {
			if((Belegungen[16].equals(Farbe)&& Belegungen[19].equals(Farbe) && Belegungen[22].equals(Farbe))
					||(Belegungen[16].equals(Farbe)&& Belegungen[15].equals(Farbe) && Belegungen[17].equals(Farbe))){
				return true;
			}
			break;
			}
		case 17: {
			if((Belegungen[17].equals(Farbe)&& Belegungen[8].equals(Farbe) && Belegungen[12].equals(Farbe))
					||(Belegungen[17].equals(Farbe)&& Belegungen[15].equals(Farbe) && Belegungen[16].equals(Farbe))){
				return true;
			}
			break;
			}
		case 18: {
			if((Belegungen[18].equals(Farbe)&& Belegungen[3].equals(Farbe) && Belegungen[10].equals(Farbe))
					||(Belegungen[18].equals(Farbe)&& Belegungen[19].equals(Farbe) && Belegungen[20].equals(Farbe))){
				return true;
			}
			break;
			}
		case 19: {
			if((Belegungen[19].equals(Farbe)&& Belegungen[18].equals(Farbe) && Belegungen[20].equals(Farbe))
					||(Belegungen[19].equals(Farbe)&& Belegungen[16].equals(Farbe) && Belegungen[22].equals(Farbe))){
				return true;
			}
			break;
			}
		case 20: {
			if((Belegungen[20].equals(Farbe)&& Belegungen[5].equals(Farbe) && Belegungen[13].equals(Farbe))
					||(Belegungen[20].equals(Farbe)&& Belegungen[18].equals(Farbe) && Belegungen[19].equals(Farbe))){
				return true;
			}
			break;
			}
		case 21: {
			if((Belegungen[21].equals(Farbe)&& Belegungen[0].equals(Farbe) && Belegungen[9].equals(Farbe))
					||(Belegungen[21].equals(Farbe)&& Belegungen[22].equals(Farbe) && Belegungen[23].equals(Farbe))){
				return true;
			}
			break;
			}
		case 22: {
			if((Belegungen[22].equals(Farbe)&& Belegungen[16].equals(Farbe) && Belegungen[19].equals(Farbe))
					||(Belegungen[22].equals(Farbe)&& Belegungen[21].equals(Farbe) && Belegungen[23].equals(Farbe))){
				return true;
			}
			break;
			}
		case 23: {
			if((Belegungen[23].equals(Farbe)&& Belegungen[2].equals(Farbe) && Belegungen[14].equals(Farbe))
					||(Belegungen[23].equals(Farbe)&& Belegungen[21].equals(Farbe) && Belegungen[22].equals(Farbe))){
				return true;
			}
			break;
			}
		}
		return false;
	}
}

Java:
// steinpool wird erstellt, und methode für steine entnehmen....

public class Steinpool extends BilderPanel{
	
	private static final long serialVersionUID = 4109240906359222049L;
	
	int AnzahlWeißeSteine;
	int AnzahlSchwarzeSteine;
	
	public Steinpool(int w,int h){
		AnzahlWeißeSteine=9;
		AnzahlSchwarzeSteine=9;
		preferredWidth=w;
		preferredHeight=h;
		
		Bilder.add(new Bild("pics/SteinPool2.png",0,0));
		for(int i=0;i<9;i++){
			Bilder.add(new Bild("pics/stein_weiss.png",10+i*30,25-15));	
		}
		for(int i=0;i<9;i++){
			Bilder.add(new Bild("pics/stein_schwarz.png",10+i*30,75-15));
		}
	}
	public void entnehme(String Farbe){
		if(Farbe.equals("schwarz")){
			Bilder.remove(AnzahlWeißeSteine+AnzahlSchwarzeSteine);
			AnzahlSchwarzeSteine-=1;
		}
		else if(Farbe.equals("weiß")){
			Bilder.remove(AnzahlWeißeSteine);
			AnzahlWeißeSteine-=1;
		}
		repaint();
	}
}
 
also zu meinem Punkt eins, ich meine, es müsste doch Befehle geben, die den Neustart erzwingen und zwar bei folgenden Fragmenten
Java:
frame.addWindowListener(new WindowAdapter(){

			@Override
			public void windowClosing(WindowEvent arg0) {
				System.exit(0);
			}
			/*
			public void windowNeustarting(WindowEvent e){
				scherzhaft gemeint, ab so ungefähr
			}
			*/
		});

Java:
public void actionPerformed(ActionEvent a) {
		
		Object obj=a.getSource();
		if(obj==miExit){
			System.exit(0);
		}
		if(obj==miNeu){
			// hier irgendwas 
		}
 
Es geht um die Methode "initialisieren": da gehört alles hinein, was erforderlich ist, um ein neues Spiel sauber starten zu können. Alle einmaligen Sachen sollen da raus bleiben, wie Frame, Panels, Menüs erzeugen und zusammenbauen: das kommt in den Konstruktor. Die while-Schleifen und if-Abfragen, die du im Konstruktor hast, sollen verschwinden.
 
aja, da denk ich morgen in Ruhe nochmal drüber nach, komm gerad von Arbeit und brauche erstma ne Mütze voll Schlaf...

was mir gerad so ( früh um 6) durch den Kopf geht... meine whileSchleifen im Konstruktor sorgen wohl dafür , das immer ein neues Applet gestartet wird, anstatt das "alte auf null zu setzen"...ok...wie gesagt , das versuche ich morgen mal, zu durchdenken, hab ja auch noch 2 Gruppenmember, die da mitmachen...

danke dir nochmal !!!!!!!!!!!!!!!!!!!!!!!!!!!
 
so , da bin ich mal wieder oder besser wir...
also wir können es drehen und wenden wie wir wollen,
wir haben 2 wege versucht:

1. unsere methoden an deine leeren methoden anpassen und dabei konstruktor und initialisieren von dir beibehalten

2. einfach nur deinen konstruktor und die methode initialisieren über unser projekt drübergebügelt

Fazit: es ändert sich nichts an unserem problem...entweder wechselt der spieler nicht, nur nach betätigen von "neustart" oder "neustart" funzt nicht...das krasse ist immernoch, das deine "leeren methoden" von dir ,also wenn man das mal so ausprobiert hinhauen...

wir hatten noch ne schöne idee gehabt, die aber leider nicht klappte, vielleicht is diese noch ausbaufähig...und zwar eine zweite methode initialisieren implementieren (initial2) und unten bei der methode actionperformed bei (if==miNeu) einfach initial2 aufrufen...

ich werd bald ein wenig gaga...hab zwei semester java "überlebt".... wir haben eine offlinevariante Mühle und wollen nun deinen vorschlag zum "neustart" umsetzen....bekommen das aber nicht hin...woran kann denn das noch alles liegen

gruß
 
ah ok...öhm ja, da poste ich ma die anderen Klassen

Java:
import java.awt.Dimension;
import java.awt.Graphics;
import java.util.ArrayList;
import java.util.List;
import javax.swing.JPanel;

public class BilderPanel extends JPanel{
	
	private static final long serialVersionUID = 9129285947394680278L;
	int preferredWidth;
	int preferredHeight;
	List<Bild> Bilder;
	
	public BilderPanel(List<Bild> Bilder,int width,int height){
		preferredWidth=width;
		preferredHeight=height;
		this.Bilder=Bilder;
	}
	public BilderPanel(){
		this(new ArrayList<Bild>(),50,50);
	}
	@Override public Dimension getPreferredSize(){
		return new Dimension(preferredWidth,preferredHeight);
	}
	@Override public void paint(Graphics g){
		for(int i=0;i<Bilder.size();i++){
			g.drawImage(Bilder.get(i).img,Bilder.get(i).getPosX(),Bilder.get(i).getPosY(),this);
		}
	}
}
Java:
public class Bilddaten {
	private String Pfad;
	private Dimension Pos;
	
	public Bilddaten(String Pfad,Dimension Pos){
		this.Pfad=Pfad;
		this.Pos=Pos;
	}
	public Bilddaten(){
		this("",new Dimension(0,0));
	}
	public Bilddaten(String Pfad,int x,int y){
		this(Pfad,new Dimension(x,y));
	}
	public void setPfad(String Pfad){this.Pfad=Pfad;}
	public void setPos(Dimension Pos){this.Pos=Pos;}
	public void setPos(int x,int y){setPos(new Dimension(x,y));}
	
	public String getPfad(){return Pfad;}
	public Dimension getPos(){return Pos;}
	public int getPosX(){return (int)Pos.getWidth();}
	public int getPosY(){return (int)Pos.getHeight();}
}
Java:
import java.awt.Dimension;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.net.URL;
import javax.imageio.ImageIO;

public class Bild extends Bilddaten{
	BufferedImage img;
	public Bild(){
		img=null;
	}
	public Bild(BufferedImage img){
		super();
		this.img=img;
	}
	public Bild(String Pfad,Dimension Pos,BufferedImage img){
		super(Pfad,Pos);
		this.img=img;
	}
	public Bild(String Pfad,int x,int y,BufferedImage img){
		super(Pfad,new Dimension(x,y));
		this.img=img;
	}
	public Bild(String Pfad){
		super(Pfad,0,0);
		Laden(Pfad);
	}
	public Bild(String Pfad,Dimension Pos){
		super(Pfad,Pos);
		Laden(Pfad);
	}
	public Bild(String Pfad,int x,int y){
		super(Pfad,x,y);
		Laden(Pfad);
	}
	public void Laden(String Pfad){
		img= null;
		URL pic_url = getClass().getClassLoader().getResource(Pfad);
		try {
			img = ImageIO.read(pic_url);
		} catch (IOException e) {}
	}
}
 
so wie es aussieht, ist das ganze wohl doch nicht so einfach...oder es ist zu einfach, und wir gucken wie das Sch*** ins Uhrwerk... mmh
 
nochmal wir;

wir sind uns einig, dass wir die Schleifen trotzdem brauchen....im main hatte das eben nicht viel Sinn, da mussten wir alles als static definieren...wo soll sie also hin, oder wie muss sie eventuell anders aussehen...ohne schleife geht es garantiert , da kein spielerwechsel stattfindet...

grüße
 
wir sind uns einig, dass wir die Schleifen trotzdem brauchen ... da kein spielerwechsel stattfindet
Die Schleifen müssen verschwinden!!!
Wo ist das Problem? Ihr braucht doch nur eure Methode "wechsleSpieler()" aufzurufen, sobald der Gegner dran ist 😀
Java:
@Override
public void mouseClicked(final MouseEvent m) {
    if (spielGestartet) {
        if (spielZustand[aktSpieler].equals("SteineSetzen")) {
            if (brett.getBelegung(brett.aufWelcherPos(m.getX(), m.getY())).equals("frei")) {
                brett.steinSetzen(brett.aufWelcherPos(m.getX(), m.getY()));
                if (aktSpieler == 1) {
                    pool.entnehme("weiß");
                } else {
                    pool.entnehme("schwarz");
                }
                steineAufBrett[aktSpieler] += 1;
                steineImPool[aktSpieler] -= 1;
                if (brett.mühleGebildet(aktSpieler, brett.aufWelcherPos(m.getX(), m.getY()))) {
                    regel = "MühleGebaut";
                }else{
                    wechsleSpieler();
                }
            }
        } else if (spielZustand[aktSpieler].equals("SteineSchieben")) {
            String Farbe = "weiß";
            if (aktSpieler == 2) {
                Farbe = "schwarz";
            }
            if (pos1 > 23) {
                if (brett.getBelegung(brett.aufWelcherPos(m.getX(), m.getY())).equals(Farbe) &&
                        brett.kannSteinBewegen(brett.aufWelcherPos(m.getX(), m.getY()), aktSpieler)) {
                    pos1 = brett.aufWelcherPos(m.getX(), m.getY());
                }
            } else if (pos2 > 23) {
                if (!brett.getBelegung(brett.aufWelcherPos(m.getX(), m.getY())).equals("frei")) {
                }
                if (!brett.istNachbarVon(pos1, pos2)) {
                }
                if (brett.getBelegung(brett.aufWelcherPos(m.getX(), m.getY())).equals("frei") &&
                        brett.istNachbarVon(pos1, brett.aufWelcherPos(m.getX(), m.getY()))) {
                    pos2 = brett.aufWelcherPos(m.getX(), m.getY());
                }
            }
            if (pos1 <= 23 & pos2 <= 23) {
                brett.bewege(pos1, pos2);
                if (brett.mühleGebildet(aktSpieler, pos2)) {
                    regel = "MühleGebaut";
                }else{
                    wechsleSpieler();
                }
                pos1 = 26;
                pos2 = 26;
            }
        } else if (spielZustand[aktSpieler].equals("SteineSpringen")) {
            String Farbe = "weiß";
            if (aktSpieler == 2) {
                Farbe = "schwarz";
            }
            if (pos1 > 23) {
                if (brett.getBelegung(brett.aufWelcherPos(m.getX(), m.getY())).equals(Farbe)) {
                    pos1 = brett.aufWelcherPos(m.getX(), m.getY());
                }
            } else if (pos2 > 23) {
                if (!brett.getBelegung(brett.aufWelcherPos(m.getX(), m.getY())).equals("frei")) {
                }
                if (brett.getBelegung(brett.aufWelcherPos(m.getX(), m.getY())).equals("frei")) {
                    pos2 = brett.aufWelcherPos(m.getX(), m.getY());
                }
            }
            if (pos1 <= 23 & pos2 <= 23) {
                brett.bewege(pos1, pos2);
                if (brett.mühleGebildet(aktSpieler, pos2)) {
                    regel = "MühleGebaut";
                }else{
                    wechsleSpieler();
                }
                pos1 = 26;
                pos2 = 26;
            }
        } else if (spielZustand[aktSpieler].equals("verloren")) {
        }
        if (regel.equals("MühleGebaut")) {
            spielZustand[aktSpieler] = "";
            String Farbe = "";
            if (aktSpieler == 1) {
                Farbe = "schwarz";
            } else {
                Farbe = "weiß";
            }
            lAktion.setText("MÜHLE!!! Lösche einen Stein!");
            if (brett.getBelegung(brett.aufWelcherPos(m.getX(), m.getY())).equals(Farbe) && !brett.mühleGebildet(andererSpieler(), brett.aufWelcherPos(m.getX(), m.getY()))) {
                brett.steinLöschen(brett.aufWelcherPos(m.getX(), m.getY()));
                steineAufBrett[andererSpieler()] -= 1;
                regel = "";
                wechsleSpieler();
            } else if (brett.getBelegung(brett.aufWelcherPos(m.getX(), m.getY())).equals(Farbe) && brett.alleInMühle(andererSpieler())) {
                brett.steinLöschen(brett.aufWelcherPos(m.getX(), m.getY()));
                steineAufBrett[andererSpieler()] -= 1;
                regel = "";
                wechsleSpieler();
            }
        }
        berechneZustand();
    }
    if (regel.equals("verloren")) {
    }
    brett.repaint();
    pool.repaint();
}
 
ach, wenn alles immer so einfach wäre...aber das Problem besteht immer, wenn manche sich anstellen wie sonstwas, verstehen die anderen , die es können nicht....das merke ich wenn ich Nachhilfe gebe und werde es merken, wenn ich mal Lehrer sein werde...oh gott welche worte am frühen morgen...

ja äh, hab das mal eben copy&print mäßig übernommen, warte warte gedanke...äh weil nämlich der neustart trotzdem nich funzt...muss man dann...ne muss man nicht, weil man das nix mit exit in der methode mouseclicked hat....nagut

muss erstma zu Wahrscheinlichkeitsrechnung...

danke dir mal wieder !!!!!!!!!!!!!!!!!!! auch im Namen der Gruppe versteht sich !!!!!!!!!!!!!!!!!
 
weil man das nix mit exit in der methode mouseclicked hat.....

ohne nix und dafür mit ....auch nicht hat

Für ein neues Spiel müsst ihr noch die Methode "initialisieren" anpassen, damit sie die noch gesetzten Figuren vom Brett wegnimmt (einfach mit der Methode "steinLöschen" in einer for-Schleife alle Figuren löschen) und den Steinpool auffüllt. Für letzteres macht sich auch gut eine init-Methode in der Klasse Steinpool, etwa so:
Java:
public Steinpool(int w, int h) {
    preferredWidth = w;
    preferredHeight = h;
    init();
}
public void init() {
    bilder.clear();
    anzahlWeißeSteine = 9;
    anzahlSchwarzeSteine = 9;
    bilder.add(new Bild("pics/SteinPool2.jpg", 0, 0));
    for (int i = 0; i < 9; i++) {
        bilder.add(new Bild("pics/stein_weiss.jpg", 10 + i * 30, 25 - 15));
    }
    for (int i = 0; i < 9; i++) {
        bilder.add(new Bild("pics/stein_schwarz.jpg", 10 + i * 30, 75 - 15));
    }
    repaint();
}
Die könnt ihr dann in der Methode "initialisieren" aufrufen:
Java:
pool.init();
Für das Brett sowas:
Java:
brett.init();
in der Klasse Spielbrett:
Java:
public void init() {
    for (int i = 0; i < 24; i++) {
        steinLöschen(i);
    }
    repaint();
}
 
nach reichlichem "Probieren" klappt das mit dem Steinpool nicht, Spielbrett ist kein Problem mehr, das funzt... folgende Fehlermeldungen tauchen auf, die wir nicht beheben können...
Exception in thread "AWT-EventQueue-0" java.lang.IllegalArgumentException: input == null!
at javax.imageio.ImageIO.read(Unknown Source) //vorher hat das doch geklappt und nun nicht mehr, so wie alles eigentlich
at Bild.Laden(Bild.java:44)
at Bild.<init>(Bild.java:36)
at Steinpool.init(Steinpool.java:23)
at Steinpool.<init>(Steinpool.java:16)
at Mühle.<init>(Mühle.java:33)
at Mühle$2.run(Mühle.java:301)
at java.awt.event.InvocationEvent.dispatch(Unknown Source)
at java.awt.EventQueue.dispatchEvent(Unknown Source)
at java.awt.EventDispatchThread.pumpOneEventForFilters(Unknown Source)
at java.awt.EventDispatchThread.pumpEventsForFilter(Unknown Source)
at java.awt.EventDispatchThread.pumpEventsForHierarchy(Unknown Source)
at java.awt.EventDispatchThread.pumpEvents(Unknown Source)
at java.awt.EventDispatchThread.pumpEvents(Unknown Source)
at java.awt.EventDispatchThread.run(Unknown Source)
 
or nee, das gibts doch nicht...das ist echt hart...ne einfache Dateiendung...oh man...danke dir schon wieder 1000-fach im Namen aller...

da werden wir uns nun "endlich" dem Themea Socketprogrammierung widmen, bin gespannt, wie sich das gestalten wird...unser Prof meinte, das wäre das einfachste...

da hab ich gleich mal ne Frage...also ganz rustikal natürlich, wie immer *g*, muss 2 neue Klassen programmieren, das steht in nem Buch...die Frage ist gleich mal am frühen Morgen...bei meiner Klasse Mühle, muss ich doch den Konstruktor ändern und oder die Methode initialisieren, denn ich schicke ja dem der mitspielen will ein Paket an Daten, mit nem zweiten Konstrukuor (dem ich nen Port und ne Internetadresse übergebe), spielt der andere Spieler und "wirft" alles wieder zu mir, also doch die Methode initialisieren so lassen und den Konstruktor der Mühle abändern...hab da sowas in der Art gelesen ??? geht das in die richtige Richtung ???
 
Status
Nicht offen für weitere Antworten.

Zurück
Oben